Discussion :

[jhon_milou]

Bonjour,
je me demande comment on peut envoyer un tableau de byte (sa taille est de l'ordre de 350000) par socket UDP en java d'un seul coup.
ma solution était la suivante:j'ai découpé mon tableau en petit tableau de taille(1024 ou 512) je l'envoi l'un aprés l'autre aprés avoir envoyé la taille de tableau initial ou le nombre de packets à envoyer.

ma question est: est ce qu'il y'a une autre solution autre que la mienne pour envoyer un tableau de grande taille par socket UDP en java?

mon probleme c'est le traitement des tableaux qui consomme beaucoup de calcul CPU et de la memoire, donc je dois les optimiser.
Merci

[adiGuba]

Salut,

mon probleme c'est le traitement des tableaux qui consomme beaucoup de calcul CPU et de la memoire, donc je dois les optimiser.

On pourrait voir ton code ???

a++

[jhon_milou]

voici mon code au niveau de la reception:donc ici je reçois chaque packet, en extraire le tableau et l'ajouter au tableau final.
voici la methode

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
 
  public byte[] RecevoirTabUDP(int taille_tab_final)
		{	
			int size_max_packet=1024;
			byte[] tab_src=new byte[taille_tab_final];
			byte[] tableauPacket=new byte[taille_tab_final];
			int nbr_packet=(int)(taille_tab_final/size_max_packet);
			int taille_tab_reste=taille_tab_final-size_max_packet*nbr_packet;
			DatagramPacket packetUDP;
 
			try
			{			
				//socketSrvUDP.setSoTimeout(5000);
				for(int i=0;i<nbr_packet;i++)
				{			
				        packetUDP = new DatagramPacket(tableauPacket, tableauPacket.length);
					socketSrvUDP.receive(packetUDP);
					for(int j=0;j<size_max_packet;j++)
					{
				          tab_src[i*size_max_packet+j]=tableauPacket[j];		
					}
 
					packetUDP=null;
//System.arraycopy(tableauPacket,0 , tab_src, i*size_max_packet, size_max_packet);
 
				}
				if((taille_tab_final % size_max_packet) !=0)
				{
//Reception du dernier packet qui va contenir un nombre de byte < 1024
					byte[] tableauPacket_reste=new byte[taille_tab_reste];
					packetUDP = new DatagramPacket(tableauPacket_reste, tableauPacket_reste.length);
					socketSrvUDP.receive(packetUDP);
					for(int k=0;k<taille_tab_reste;k++)
					{
						tab_src[nbr_packet*size_max_packet+k]=tableauPacket_reste[k];
					}
					packetUDP=null;
//System.arraycopy(tableauPacket_reste, 0, tab_src, nbr_packet*size_max_packet, taille_tab_reste);
 
				}
			}
			catch(Exception e)
			{
				e.printStackTrace();
			}
 
		return tab_src;
		}

[adiGuba]

Pourquoi ne pas utiliser un seul DatagramPacket de la taille totale de ton tableau ?

a++

[jhon_milou]

je ne peux pas envoyer un tableau de taille de l'ordre de 350000 dans un seul DatagramPacket parce que d'aprés mes recherches il y'a un taille maximal du tableau (65508) à envoyer dans le DatagramPacket. Donc, je suis obligé de le découper en petit tableau non?
a+

[adiGuba]

Mais d'après la doc l'ordre d'arrivée des DatagramPacket n'est pas garantit (donc ce que tu envois pourrait être très différent de ce que tu reçois).

Sinon tu pourrais simplifier ton code en évitant une copie inutile et une tableau temporaire supplémentaire, par exemple :

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
	public byte[] RecevoirTabUDP(int taille_tab_final) {
		int size_max_packet = 1024; // Taille max des pacquets
		int readCount = 0; // Nom d'élément recu
 
		// Buffer de données :
		byte[] tableauPacket = new byte[taille_tab_final];
 
		try {
			while (readCount<taille_tab_final) {
				int length = Math.min(size_max_packet, taille_tab_final-readCount);
				DatagramPacket packetUDP = new DatagramPacket(
						tableauPacket, readCount, length);
				socketSrvUDP.receive(packetUDP);
				readCount += length;
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
 
		return tableauPacket;
	}

a++

PS : Et attention à cette gestion des exceptions : en cas d'erreur tu retournes quand même le tableau