Compiler du java en natif & Optimisation serveur socket

Version imprimable

28/12/2005, 01h10
Skreo

Compiler du java en natif & Optimisation serveur socket

Bonjour :D

Pour des raisons d'optimisation (processus et ram), j'aimerais pouvoir compiler mon serveur xmlsocket en executable pour linux (red hat) pour l'executer directement par la suite sans avoir besoin de la JVM.
Je le dis pour certain : ne riez pas, j'ai très bien réussi à le faire sous Windows avec Excelsior JET. (mais celui-ci est payant et je n'ai pas réussi à l'installer sous linux).

Si vous savez comment faire merci de me le faire savoir ;-)
28/12/2005, 10h30
FreshVic

Moi perso j'ai jamais généré d'exe , mais tout les commentaires que j'ai pu lire sur ce sujet disent que sans JVM l'exe ne fonctionne pas !!

Ceci dit optimiser en generant un exe n'est peut etre pas la meilleur solution:
Voici des arguments difficilement discutable :
http://blog.developpez.com/index.php...&c=1&tb=1&pb=1

A+
28/12/2005, 11h03
lunatix

sous linux, tu peux essayer GCJ/gnu-classpath, mais ca ne supporte pas tout
28/12/2005, 11h09
billou77

moi je dis "attention", pour deux raisons :

- tu casses la logique java (compile once, run everywhere) (je suis un puriste java :D )
- rien ne te dis que ton executable sera plus performant qu'en JIT. les performances de ton executable vont dependre de la facon dont ton compilateur linux convertit les fonctionnalités critique java (garbage collection, threads, exceptions) en code natif executable linux.

si ca t'amuse de comparer :lol: du bytecode et du native executable, voila quelques compileurs natifs :

http://gcc.gnu.org/java/
(Free) The Java GNU Compiler (GCJ) is part of GCC. GCJ can compile Java source or Java bytecodes to either native code or Java class files.

http://www.excelsior-usa.com/jet.html
(Commercial) JET is an optimizing Java to native code compiler that statically compiles Java bytecodes directly into native code, just like traditional C, C++ compilers.

http://www.naturalbridge.com/bullettrain.html
(Commercial) NaturalBridge BulletTrain Java to native code compiler

http://www.windriver.com/products/html/fastj_compiler.html
(Commercial) Wind River Systems Diab FastJ Java to native code compiler

http://www.metrowerks.com/desktop/java/?features
(Commercial) Metroworks Codewarrior for Java, Java to native code compiler.

http://www.cs.vu.nl/manta/
(Free) Manta compiler with Fast RMI.
28/12/2005, 14h42
Skreo

Merci :D
Bon c'est vrai que c'est peut-être pas très utile que je compile en natif ^^''
Et pour éviter de relancer un nouveau topic, je relance une question en rapport avec mon serveur :
J'ai en moyenne dans les 90 connectés sur le serveur xmlsocket, et au bout de quelques heures (5 à 10 heures) il plante : les utilisateurs connectés restent connnectés mais ne peuvent plus ni recevoir ni envoyer de données, et personne ne peux plus se connecter ni se déconnecter.
Je l'ai fais avec pour code de départ celui de Blablaserv ( http://defaut.developpez.com/tutorie...r/multithread/ ), que j'ai beaucoup enrichi (connexion mysql, requêtes perso...).
De plus quand je lance le serveur, il utilise une dizaine de processus, je ne sais pas pourquoi, et à chaque fois qu'un utilisateur se connecte ça créé un nouveau processus. Donc 100 processus pour un serveur c'est ptètre pas top... surtout que le tout prend pas mal de ram : dans les 55 Mo (en ce moment même chaque processus indique 448172 kB !!)

Si quelqu'un pouvait m'aider sur au moins un de ces problème ça serait super car je suis obligé de le surveiller en permanence ...
28/12/2005, 14h46
billou77

c'est une nouvelle question que tu poses, et ca n'a rien à voir avec le sujet "Compiler du java en natif". ca ne serait pas mieux de faire un autre tropic ? :?:
28/12/2005, 14h59
billou77

est-ce que ces Mo ne sont vraiment pas utilisés par ton appli ? ce sont peut etre des données utilisées par ton appli, non ?

- quand un client se deconnecte, tu kill bien sa thread coté serveur ? (ou tu reutilises ce thread pour une nouvelle connection cliente ?)
- tu fermes bien le statement/preparedstatement apres chaque usage ?
- tu utilises un pool de connection sql ou non ?
- tu fais des trucs genre String tata="machin"+"toto"+"bidule"? tu utilises les + pour concatener les chaines de caracteres ?
28/12/2005, 17h37
Skreo

Alors...
- le thread se termine comme dans Blablaserv avec la fermeture du socket (je sais pas si c'est idéal
- J'utilise une seule connection mysql continue avec un seul Statement jamais fermé et pas de Preparedstatement
- un pool ? c'est quoi ? ^^''''
- oui je fais des trucs genre String tata="machin"+"toto"+"bidule"
c'est pas top je sais ^^

Comment je pourrais optimisé tout ça ?
28/12/2005, 17h58
billou77

- il faut fermer, apres chaque utilisation, ton statement

- un pool de connections, c'est un ensemble de connections pretes à etre utilisées. quand tu as besoin d'une connection, tu en prends une dans ce tas de connections, et tu le remets, apres son utilisation, dans ce tas.
http://webdevelopersjournal.com/columns/connection_pool.html
http://www.javaworld.com/jw-06-1998/jw-06-object-pool.html
http://www.theserverside.com/articles/article.tss?l=Prepared-Statments

- ton augmentation de mémoire utilisée pourrait s'expliquer par le fait que tu utilises des "machin"+"bidule". il faudrait que tu remplaces ca par un stringbuffer.

si tu as des questions n'hesite pas 8O

Merci ^^
comment on fait exactement avec un stringbuffer et en quoi c'est mieux pour la mémoire ?
Je vais essayer de voir les pool de connexion mysql.

Et sinon les threads correspondant à chaque client finissent comme ça (dans la fonction run):
Code:

1 2 3 4 5 6 7 }finally { try { System.out.println("Le client no "+_numClient+" s'est deconnecte"); _serv.delClient(_numClient); // on supprime le client de la liste _s.close(); // fermeture du socket si il ne l'a pas déjà été }catch (IOException e){ } }
Je ne sais pas si ça kill bien le thread

28/12/2005, 20h30
Pill_S

pour moi: une seule réponse ;)

refais tout en utilisant java.nio et 1 seul thread, ce sera bien plus performant. Ici, tu auras de quoi débuter dans cette techno: http://www.onjava.com/pub/a/onjava/2002/09/04/nio.html?page=2

pour la mémoire: utilise des StringBuffer/StringBuilder si tu dois faire de gros et fréquents traitements de chaînes, sinon laisse tomber ce genre de petites optimisations... surtout que le compilo java en fait certaines automatiquement sans te demander ton avis

et en dernier recours: affecte "null" à tes références dès qu'elles ne sont plus utilisées, pour forcer la libération d'un maximum de mémoire par le GC à chacun de ses passages

ps: 448172 KB c'est plus proche de 500Mo que de 55 ;)
28/12/2005, 21h13
Skreo

Ok je vais voir ça merci ^^
avec un seul thread on peux faire du multi-utilisateur ?

PS : je sais pas si c'est en kilobits ou kilobytes... mais sous windows ça me prend moins de 10 Mo le serveur donc ....
28/12/2005, 21h36
nic58

Citation:

Envoyé par Skreo

avec un seul thread on peux faire du multi-utilisateur ?

Oui.
Je te conseil d'ailleurs de jeter un oeil sur Mina qui est plus pratique à utiliser que le package java.nio directement.
29/12/2005, 20h13
Skreo

J'ai essayer le truc avec java.nio mais j'ai un problème : je ne vois pas comment :
- envoyer un message d'un utilisateur à un autre
- avoir une liste des utilisateurs et pouvoir accéder au socket de chacun d'entre eux par cette liste (avec un id pour chaque)
- gérer les déconnexion des utilisateurs
29/12/2005, 20h39
Pill_S
Hello,

je pense pouvoir répondre à tes questions:

Citation:

Envoyé par Skreo

envoyer un message d'un utilisateur à un autre

tu peux faire comme ceci:
Code:

1 2 ((SocketChannel) aSelectionKey.channel()).write("Salut toto".getBytes());
Citation:

Envoyé par Skreo

avoir une liste des utilisateurs et pouvoir accéder au socket de chacun d'entre eux par cette liste (avec un id pour chaque)

il suffit de stocker les "SelectionKey" associée à chacun des clients (le "Selector" doit normalement permettre de récupérer des ensembles de SelectionKey, avec "selector.keys()" )

Citation:

Envoyé par Skreo

gérer les déconnexion des utilisateurs

tout simple ;):

Code:

aSelectionKey.cancel();

il sera supprimé du selector lors de la prochaine sélection
29/12/2005, 23h41
Mister Nono

J'ai eu le même genre de problèmes pour une appli qui devait rester toujours en fonctionnement.

La mémoire se remplissait lentement mais sûrement.

Après de multiples recherches et tests :

Fermeture des sockets dès qu'ils ne servaient plus (ou à intervalles réguliers avec ré-initialisation), déconnexion de la base de donnée dès qu'une requête était réalisée, vidage ou destruction des buffers in et out régulièrement.

Depuis, l'appli fonctionne très bien.

Salut. :wink:

oki
Mais quand je dit gérer les déconnection des utilisateurs, c'est pas les faire se déconnecter ^^, c'est plutôt savoir quand ils se déconnectent et executer une fonction pour sauvegarder leurs données (c'est pour un jeu : http://www.murties.com)
Pour la liste des utilisateurs et les envois entre utilisateurs, je pense faire un ArrayList contenant les références des SocketChannel des utilisateurs, et les clés de ce tableau sera leurs id.

Pour l'instant voici la boucle (je ne sais pas si c'est bien) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 server = ServerSocketChannel.open(); server.configureBlocking(false); server.socket().bind(new java.net.InetSocketAddress(port)); Selector selector = Selector.open(); SelectionKey acceptKey = server.register(selector, SelectionKey.OP_ACCEPT); while (it.hasNext( )) { SelectionKey key = (SelectionKey) it.next(); it.remove(); if (key.isAcceptable()) { SocketChannel client = server.accept(); client.configureBlocking(false); client.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE); System.out.println("Client Connected Successfully!"); continue; } if (key.isReadable()) { SocketChannel client = (SocketChannel) key.channel(); readMessage(client); // Fonction qui lit le buffer du client } }
Une ptite question finale ^^ : quand on fait flush() sur un buffer, ça libère sa mémoire ?

30/12/2005, 23h57
Skreo

up
31/12/2005, 18h50
Pill_S

Citation:

Envoyé par Skreo

gérer les déconnection des utilisateurs, c'est pas les faire se déconnecter ^^, c'est plutôt savoir quand ils se déconnectent et executer une fonction pour sauvegarder leurs données

je viens de tomber la dessus:

http://javaalmanac.com/egs/java.nio/DetectClosed.html?l=rel

:wink:

Merci ^^

Hum je viens de reprogrammer mon serveur, mais j'ai l'impression que c'est pire : avant avec 100 connectés le serveur prennait moins de 1% du processeur, et là, même avec aucun connecté, ça prend entre 25 et 50% du processeur !! (avec 1 connecté c'est pareil)

Comment faire SVP ?? :?

Voici le code de la fonction de démarrage du ServerSocketChannel :

Code:

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 static void startServer() throws Exception {
        logErreur("Démarrage serveur");
        // Create the server socket channel
        server = ServerSocketChannel.open();
        // nonblocking I/O
        server.configureBlocking(false);
        server.socket().bind(new java.net.InetSocketAddress(port));
        // Create the selector
        Selector selector = Selector.open();
        SelectionKey acceptKey = server.register(selector, SelectionKey.OP_ACCEPT);
 
        while (true) {
            try {
                // Wait for an event
                selector.select();
            } catch (IOException e) {
                // Handle error with selector
                break;
            }
            // Get keys
            Set readyKeys = selector.selectedKeys();
            // iterate over the set of selected keys:
            Iterator it = readyKeys.iterator();
 
            // Look at each key in the selected set:
            while (it.hasNext()) {
                SelectionKey key = (SelectionKey) it.next();
                it.remove();
 
                if (key.isAcceptable()) {
                    SocketChannel client = server.accept();// get client socket channel
                    client.configureBlocking(false); // Non Blocking I/O
                    client.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE); // recording to the selector (reading & writing)
                    int idClient=addClient(client, key);
                    continue;
                }
 
                if (key.isReadable()) {
                    SocketChannel client = (SocketChannel) key.channel();
                    try {
                        readMessage(client);
                    }catch(Exception e){
                        System.out.println("ERROR in Server readMessage() " + e);
                    }
                }
            }
        }
    }

14/01/2006, 18h33
Pill_S
ajoute une instruction du genre
Code:

1 2 try {Thread.sleep(20);} catch(Throwable t){}
en fin de boucle ;)

d'après moi c'est le thread qui s'affole

en fait lorsque tu enregistres un channel, il ne faut pas l'enregistrer en lecture/écriture, mais en lecture seule. Il faut ajouter l'intérêt pour l'écriture à la selectionkey uniquement lorsque tu as besoin d'écrire

Sinon, tous les canaux seront sélectionnés instantanément à chaque fois, puisqu'ils seront probablement tous prêt à l'écriture ;)
15/01/2006, 01h09
Skreo

Super !
ça marche impec, merci encore Pill_S !

Maintenant je vais tester avec plus de 50 users pour voir si ça tient ^^
21/01/2006, 21h44
Skreo

Bon alors ça marche bien, mais le serveur plante 2 fois par jour....
Je pense que c'est à cause de mon système mysql...
Maintenant je n'utilise pas de Pool de connexions, mais une seule connexion mysql qui se reconnecte toutes les 2 minutes, et les Statement et ResultSet sont fermés après chaque requète.
S'il y a une erreur mysql, le Statement et le ResultSet sont fermés et je lance une Exception pour l"user, et si la connexion mysql est perdue, elle est relancée (avec à chaque fois une boucle d'attente si une requète est demandée par un user).

En gros dans ma classe ConnexionMysql, j'ai fait une fonction query(String requete) qui retourne un ResultSet, un fonction flush() pour clore le Statement et le ResultSet et définir la connexion ocmme libre (variable inuse), et une fonction update(String requete) pour les DELETE, INSERT INTO et UPDATE, elle renvoi ce que renvoi stmt.executeUpdate() et ferme tout seul le Statement (pas besoin de flush pour update()).

Donc tout ceci marche très bien pendant quelques heures, mais ça finit par planter : la connexion est définie comme occupée, et si je libère ou relance la connexion mysql (par une commande de mon serveur, avec la classe Commandes), j'obtient une erreur Java qui me cite tous les noms de fonctions de ma classe principale.
Pourtant j'ai mis des try partout, et j'ai bien libéré la connexion après chaque utilisation, je comprend vraiment pas.

Merci à ceux qui ont eu le courage de lire tout ça, et ça serait super sympa de m'aider ;-)
21/01/2006, 21h52
adiGuba

Salut,

Quel est la trace complète de l'exception que tu obtiens ?
Sinon pourquoi est-ce que tu utilises une seule connection ? Il serait plus propre de la fermer après chaque utilisation... non ?
Enfin est-ce que tu fermes bien tout tes éléments dans un bloc finally ?

a++
22/01/2006, 00h06
Skreo

Non je ne ferme pas la connexion mysql à chaque fois car elle est très souvent utilisée (il y a en moyenne dans les 70 connectés au serveur xmlsocket, donc 4 requètes à l'identification, plus quelques requètes de temps en temps pour certaines actions).

J'ai au total 5 classes, dont la principale (MurtiesServ) et une en threads.
Le thread est la classe Commandes qui n'est jamais stoppée.
Donc je ne vois pas à quoi servirais un finally

L'erreur que j'obtiens termine par ça : (je n'ai pas le début car ça prend toute la place dans la fenètre de commandes)
at MurtiesServ.sendAll(MurtiesServ.java:367)
at MurtiesServ.delClient(MurtiesServ.java:511)
at MurtiesServ.sendMessage(MurtiesServ.java:192)
at MurtiesServ.sendAll(MurtiesServ.java:357)
at MurtiesServ.sendAll(MurtiesServ.java:367)
at MurtiesServ.delClient(MurtiesServ.java:511)
at MurtiesServ.sendMessage(MurtiesServ.java:192)
at MurtiesServ.sendAll(MurtiesServ.java:357)
at MurtiesServ.sendAll(MurtiesServ.java:367)
at MurtiesServ.delClient(MurtiesServ.java:511)
at MurtiesServ.sendMessage(MurtiesServ.java:192)
at MurtiesServ.sendAll(MurtiesServ.java:357)
at MurtiesServ.sendAll(MurtiesServ.java:367)

Cette erreur me signale donc des erreurs dans les fonctiosn d'envoi de messages au users connectés (par SocketChannel), mais la connexion mysql semble également bloquée.
Je n'arrive pas à faire le rapprochement ^^'''
22/01/2006, 11h09
adiGuba

Citation:

Envoyé par Skreo

Donc je ne vois pas à quoi servirais un finally

A être sûr que tu fermes bien ton ResultSet et ton Statement dans tous les cas...
Si tu te retrouves dans un cas particulier où tu ne fermes pas correctement ton Statement/ResulSet, cela peut finir par te poser des problèmes...

Citation:

Envoyé par Skreo

L'erreur que j'obtiens termine par ça : (je n'ai pas le début car ça prend toute la place dans la fenètre de commandes)

Il faudrait au moins le début avec la description de l'exception... et eventuellement le code de la méthode sendAll() avec les numéro de ligne...

a++

En fait je ne comprend pas très bien l'interêt du finally.
J'ai trouvé ça sur internet :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class WithFinally {
  static Switch sw = new Switch();
  public static void main(String[] args) {
    try {
      sw.on();
      // Code that can throw exceptions...
      OnOffSwitch.f();
    } catch(OnOffException1 e) {
      System.err.println("OnOffException1");
    } catch(OnOffException2 e) {
      System.err.println("OnOffException2");
    } finally {
      sw.off();
    }
  }
}

pourquoi ne pas faire tout simplement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class WithFinally {
  static Switch sw = new Switch();
  public static void main(String[] args) {
    try {
      sw.on();
      // Code that can throw exceptions...
      OnOffSwitch.f();
    } catch(OnOffException1 e) {
      System.err.println("OnOffException1");
    } catch(OnOffException2 e) {
      System.err.println("OnOffException2");
    }
    sw.off();
  }
}

Qu'est ce que ça change ?

A partir du moment où tu rentres dans le try, le bloc finally sera toujours exécuté quoi qu'il arrive dans le bloc try ou les blocs catch, même s'il y a une instruction return ou une exception de propager...

Dans ce code :
Code:

1 2 3 4 5 6 7 8 9 10 try { sw.on(); // Code that can throw exceptions... OnOffSwitch.f(); } catch(OnOffException1 e) { System.err.println("OnOffException1"); } catch(OnOffException2 e) { System.err.println("OnOffException2"); } sw.off();
Si l'instruction OnOffSwitch.f() renvoit une exception différente de OnOffException1 et OnOffException2 (ce qui est possible si la méthode déclare renvoyer une exception, ou bien s'il s'agit d'une RuntimeException), elle ne sera pas attrapée par les catch, et donc remonté à la méthode appellante...

Du coup ton instruction sw.off() n'est pas appellé... alors qu'elle le serait avec un bloc finally...

Bien sûr dans certain cas cela n'est pas bien grave... mais lorsqu'il s'agit d'une connection réseau ou d'un fichier cela peut poser des problèmes (on peut atteindre des limites du systèmes, en particulier dans le cas d'un serveur).

Je ne sais pas si je suis bien clair ?

a++

PS : quel est le message de ton exception au fait ?

22/01/2006, 19h11
Skreo
Merci pour ta réponse :D maintenant j'ai compris ^^
Alala vous êtes sympa ici :p

Si après chaque requète mysql, je fais ça, ça va ? :
Code:

1 2 result.close(); stmt.close();
Est-ce que ça libère bien la mémoire ?
Et faut-il utiliser stmt.cancel() si je veux interrompre une requète par un autre thread ?

Et de même pour les SocketChannel des utilisateurs, avec un simple socketchannel.close(); ça va ?
22/01/2006, 19h37
adiGuba

Oui l'appel à close() suffit pour libérer les resources (c'est fait pour ca d'ailleurs!).
Mais il faut le faire dans tous les cas...

Le meiux c'est que tu nous montre un bout de code de ce que tu fais ;)

a++
27/01/2006, 22h50
Skreo

Merci ^^
J'ai fait des simulations avec un client qui ouvrait des centaines de connexions avec des dizaines de requètes à la seconde, et il n'y a eu aucun problème. Le bug survenait par contre à la déconnexion du client.
J'avais mal géré mes fonctions de déconnexion et les exception.
Ca marche maintenant parfaitement bien ! (entout cas pour le moment ^^)

Bonjour

Je relance le sujet, car mon serveur fonctionne très bien, sauf qu'un problème de déconnexion mal gérée du client survient parfois.
Je ne sait pas si on peut réparer ça, mais parfois (en général quand la connexion internet du client plante), la connexion est coupée, sauf que ni le client, ni le serveur ne détecte la déconnexion.

Bon j'ai un peu épuré, mais voici la fonction principale du serveur :

Code:

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
public static void startServer(){
	logErreur("Démarrage serveur");
	try {
		// Create the server socket channel
		server = ServerSocketChannel.open();
		// nonblocking I/O
		server.configureBlocking(false);
		server.socket().bind(new java.net.InetSocketAddress(port));
		// Create the selector
		Selector selector = Selector.open();
		SelectionKey acceptKey = server.register(selector, SelectionKey.OP_ACCEPT);
 
		// Attente des connexions...
		while (true) {
			Set readyKeys;
			Iterator it;
			try {
				// Wait for an event
				selector.select();
				// Get keys
				readyKeys = selector.selectedKeys();
				// iterate over the set of selected keys:
				it = readyKeys.iterator();
			} catch (Exception ee) {
				// Handle error with selector
				continue;
			}
			try {
				// Look at each key in the selected set:
				while (it.hasNext()) {
					SelectionKey key = (SelectionKey) it.next();
					it.remove();
					if (key.isAcceptable()) {
						try {
							SocketChannel client = server.accept();// get client socket channel
							client.configureBlocking(false); // Non Blocking I/O
							client.register(selector, SelectionKey.OP_READ); // recording to the selector (reading & writing)
							String ip = client.socket().getInetAddress().getHostAddress();
							// Ajout du client
							addClient(client, ip);
						}catch(Exception eee){
							// Connexion échouée
							logErreur("!! Erreur : startServer() key.isAcceptable()  !!" + eee.getMessage());
						}
						continue;
					}
 
					try {
						if (key.isReadable()) {
							SocketChannel client = (SocketChannel) key.channel();
							ServerThread thread = selectThread(); // Sélection d'un thread libre de traitement des données reçues
							thread.client = client;
							thread.busy = true;
						}
					}catch(Exception eee){
						logErreur("!! Erreur : startServer() key.isReadable()  !!" + eee.getMessage());
					}
				}
				}catch(Exception ee){}
				try {Thread.sleep(50);} catch(Throwable t){}
			}
	} catch (Exception e) {
		logErreur("!! Erreur : startServer() démarrage  !!" + e.getMessage());
		exitServer();
		System.exit(-1);
	}
}

09/07/2006, 16h31
Skreo

Personne ne saurait svp ?