bonjour,

j'ai fait un petit programme pour tester la charge max que peut supporter mon réseau en envoyant des paquets UDP :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
public class UDPTransciever implements Runnable {
 
	private InetAddress pAddressTX; // adresse du noeud distant
	private int pPortTX; // port d'emission
	private int pPacketSizeTX; // taille des paquets émis
 
	private int pGapTimeTX; // temps entre l'envoie de deux paquets (en ms)
	private int pGapTimeTXnano; // temps entre l'envoie de deux paquets (en ns)
	// => il faut ajouter les deux variables pour avoir le temps total
 
	private DatagramSocket pSocket;
 
	private DatagramPacket packet;	
	private byte[] buffer;
 
 
	public UDPTransciever(InetAddress addressTX, int portTX, int packetSizeTX, int gapTimeTX, int gapTimeTXnano){
		pPortTX = portTX;
		pAddressTX = addressTX;
		pPacketSizeTX = packetSizeTX;
		pGapTimeTX = gapTimeTX;
		pGapTimeTXnano = gapTimeTXnano;
 
 
		buffer = new byte[pPacketSizeTX];
		// remplissage du tableau
		for(int i=8; i<pPacketSizeTX; i++){
			buffer[i] = (byte)i;
		}
 
		packet = new DatagramPacket(buffer, buffer.length, pAddressTX, pPortTX);	
 
		try {
			pSocket = new DatagramSocket();
 
			if (addressTX.getAddress()[0] == 255){
				pSocket.setBroadcast(true); // => adresse MAC de destination FF:FF:FF:FF:FF:FF
			}
 
			//pSocket = new DatagramSocket(pPortRX);
		} catch (SocketException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
 
 
 
	}
 
 
 
 
 
	@Override
	public void run() {
 
 
 
		//pPacketSizeTX = 1472; // taille max des paquets
 
		int val = 0;
		byte valTmp;
 
		while(!Thread.currentThread().isInterrupted()){
 
			buffer[7] = (byte) (val >> (8*0));
			buffer[6] = (byte) (val >> (8*1));
			buffer[5] = (byte) (val >> (8*2));
			buffer[4] = (byte) (val >> (8*3));
			buffer[3] = (byte) (val >> (8*4));
			buffer[2] = (byte) (val >> (8*5));
			buffer[1] = (byte) (val >> (8*6));
			buffer[0] = (byte) (val >> (8*7));
			val++;
 
			valTmp = buffer[7];
 
			packet.setData(buffer);
 
			// envoie des données
			try {
				pSocket.send(packet);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
 
 
			// pause 
			if ((pGapTimeTX != 0) || (pGapTimeTXnano != 0)){
				try {
					Thread.sleep(pGapTimeTX, pGapTimeTXnano);
					//System.out.println("UDPTransciever : Sleep");
 
				} catch (InterruptedException e) {
 
					// TODO Auto-generated catch block
					//e.printStackTrace();
 
					// le traitement de l'interruption remet le flag de .isInterrupted() à false
					// => il faut donc le réactiver pour sortir de la boucle
					// => on pourrait aussi faire un break; pour sortir de la boucle
					Thread.currentThread().interrupt();
				}
			}
		}
 
 
		pSocket.close();
		System.out.println("UDPTransciever : Arret du Thread");
 
	}
 
 
}
=> je n'arrive pas à controller mon débit : si pGapTimeTX et pGapTimeTX nano valent 0, j'ai bien un débit max d'un peu moins de 100Mb
=> par contre si pGapTimeTX = 0 et pGapTimeTX = 1 (ou plus), le débit s'effondre

Ce que je veux faire, c'est simplement envoyer des paquets toues les x nanosecondes sans que ça freeze l'interface graphique de mon programme Java

PS : est-ce que quelqu'un sait quels est le temps minimal possible entre l'envoie de deux paquets ? ça dépend du PC ou de la norme Ethernet ?