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

[jhon_milou]

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).

Oui je sais c'est l'inconvénient du UDP. En fait ce que je vais faire c'est une étude comparative entre l'envoi d'image avec Socket TCP et UDP et à la fin je vais utiliser les deux protocoles dans mon application (TCP pour l'envoi de mes commandes et UDP pour envoyer du tableau de byte de l'image)

Merci pour l'optimisation de mon code,
je vais tester ça
a+

[jhon_milou]

Merci adiGuba
ça améliore les le traitement.

Une autre question si vous me permettez:avec UDP parfois je reçoit la totalité du tableau de l'image et je peux l'afficher aprés (l'image est correcte et claire) et la majorité de fois ca reste bloquer au niveau de la reception en attente de packet.(packet perdu :c'est le protocole UDP comme on sait) là je doit faire masocket.setReceiveBufferSize(5000) pour ca reste pas bloqué infinement. dans ce cas je vais sortir avec un tableau incomplet ==> l'image va être incomplete et pas clair et meme n'est plus lisible.

Donc pour résoudre ce probleme je dois ajouter une couche de controle je pense ?j'ai réflechi à pas mal de solution mais je tombe toujours dans le meme problem

Ma question est: quels sont les controles à faire et comment on va les faire sachant que je veux pas utiliser TCP?

Merci pour votre aide
a+

[Rayndell]

Si tu donnes à ton serveur le nombre de paquets à recevoir, il est normal qu'il reste en attente si l'un des ces paquets est perdu. Le mieux à faire est de mettre en place un timer qui débloque le serveur au bout d'un certain temps s'il ne reçoit plus rien. Un setSoTimeOut() devrait marcher je pense. Cette méthode bloque la méthode receive() du socket jusqu'à réception où jusqu'à ce que le timeout soit atteint.