ralentir la JVM

Version imprimable

31/03/2009, 18h59
casertap

ralentir la JVM

voila tout est dit.

Je veux que la JVM exécute les instructions beaucoup plus lentement.
Car je veux faire une analyse dynamique de ce qu'il se passe à l'exécution d'un programme.

Je pensais à une option à mettre avec la commande >java -...

Merci pour votre aide.
31/03/2009, 19h20
Uther
Si tu veux une analyse dynamique de ton programme, utiliser un debuggeur ne serait pas plus simple?

Sinon si tu as une boucle générale, tu peux y mettre dans une bout de code du genre pour faire une pause de 500 ms par tour de boucle :
Code:

1 2 long startTime = System.currentTimeMillis(); while (System.currentTimeMillis() - startTime < 500)
31/03/2009, 20h16
casertap

ok merci

mais non il faut vraiment que je ralentisse l'exécution de la JVM.
Je suis presque sure que ca doit etre possible
31/03/2009, 20h23
tchize_

bien sur

tu va dans ton bios et tu ralentit le processeur. La JVM n'est pas comme un émulateur de console, qui créer une fausse horloge destinée à cadencer le code. La jvm traduit le code java en code natif à la volée ou l'interprète suivant les cas de figure, mais fait tout au plus vite.

+1 pour l'utilisation d'un debuggeur pas à pas si tu veux voir ce qui se passe.
31/03/2009, 20h43
casertap

ok merci

merci pour l'idée de ralentir le proc.

Si quelqu'un d'autre a une idée je suis preneur.

Je reste persuader qu'il doit exister une commande pour ralentir la JVM lors de l'exec.
01/04/2009, 11h09
Djobird

Tu peux diminuer la mémoire allouée, mais je doute fort qu'on puisse diminuer la vitesse.
Quand tu dis vouloir faire une analyse dynamique de ce qui se passe à l'exécution, tui penses à quoi ? Enfin qu'est ce qu'un débugger ne peut pas faire ?
01/04/2009, 11h29
dinobogan

Citation:

Envoyé par casertap

Je reste persuader qu'il doit exister une commande pour ralentir la JVM lors de l'exec.

Non, c'est impossible.
01/04/2009, 12h08
wax78

Et si tu utilises BCEL afin de faire des insertion de Sleep entre chaques instruction d'une classe ? (plus facile a dire qu'a faire, ne sachant pas non plus ton but precis).

Si ce que je disais tantot te semble bien, voici un exemple qui te permet de modifier un fichier class pour ajouter dans toutes les methodes sauf le main, une instruction (ici un println avec l'instruction "bytecode", que tu dois remplacer par un sleep) entre chaque instructions (instruction au sens atomique si je puis dire) des methodes.

Il faudrait bien entendu etendre ceci a toutes les class de ton projet en ajoutant une petite couche par dessus :

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
68
69
70
71
 
import java.io.File;
import java.io.IOException;
 
import org.apache.bcel.classfile.ClassFormatException;
import org.apache.bcel.classfile.ClassParser;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.generic.ClassGen;
import org.apache.bcel.generic.ConstantPoolGen;
import org.apache.bcel.generic.InstructionFactory;
import org.apache.bcel.generic.InstructionList;
import org.apache.bcel.generic.MethodGen;
 
public class Sleeper {
 
	/**
         * @param args
         * @throws IOException
         * @throws ClassFormatException
         */
	public static void main(String[] args) throws ClassFormatException, IOException {
		String TargetclassFile = "bin\\Tosleep.class";
		String SaveTargetclassFile = "Tosleep.class";
 
		File f = new File(TargetclassFile);
		if (f.exists() == true) {
 
			JavaClass jclas = new ClassParser(TargetclassFile).parse();
			ClassGen cg = new ClassGen(jclas);
 
			ConstantPoolGen cp = new ConstantPoolGen(jclas.getConstantPool());
			// Recupere les methode de la classe.
			org.apache.bcel.classfile.Method[] methods = jclas.getMethods();
 
			for (int i = 0; i < methods.length; i++) {
				org.apache.bcel.classfile.Method m = methods[i];
				// Ne touche pas au main.
				if (m.getName().contains("main") == true) continue;
				// Recupere la "methode" i de la classe
				MethodGen mg = new MethodGen(methods[i], jclas.getClassName(),cp);
				MethodGen mg2 = new MethodGen(methods[i], jclas.getClassName(),cp);
				// Recupere la liste de la methode i
				InstructionList il = mg.getInstructionList();
				// Cree une liste d'instruction
				InstructionList il2 = new InstructionList();// mg2.getInstructionList();
				InstructionFactory fM = new InstructionFactory(cg);
				// Recopie les instruction en ajoutant les instructions entre les instructions.
				org.apache.bcel.generic.Instruction[] ins = il.getInstructions();
				for (int j = 0; j < ins.length; j++) {
					org.apache.bcel.generic.Instruction instruct = ins[j];
					il2.append(instruct);
					// ICI TU DOIS CHANGER POUR AVOIR TON SLEEP;
					il2.append(fM.createPrintln("["+instruct.toString()+"]"));
				}
				mg2.setInstructionList(il2);
				mg2.setMaxStack(cp.getSize()); //? setMaxStack(); -> nullpointer.
 
				// Remplace la methode.
				cg.removeMethod(mg.getMethod());
				cg.addMethod(mg2.getMethod());
			}
			// Sauve
			try {
				cg.getJavaClass().dump(SaveTargetclassFile);
			} catch (java.io.IOException e) {
				System.err.println(e);
			}
		}
	}
 
}

Voici aussi le bete exemple qui va avec (juste pour tester que ca marche dans ce cas ci) :

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
 
 
public class Tosleep
{
 
	/**
         * @param args
         */
	public static void main(String[] args)
	{
		Tosleep t = new Tosleep();
		t.faitqlqchose();
	}
 
	public Tosleep()
	{
 
	}
 
	private void faitqlqchose()
	{
		System.err.println("instruction 1");
		System.err.println("instruction 2");
		System.err.println("instruction 3");
		System.err.println("instruction 4");
		System.err.println("instruction 5");
		System.err.println("instruction 6");
	}
 
}

Bonne chance.

PS : Je ne suis pas dutout expert avec cette lib, d'ailleurs ca ne marche qu'avec des cas simples (comme l'exemple fournis) car il manque surement des trucs. :( (problemes avec les If_, goto, ...)

05/06/2009, 14h43
Celeborn

Mais ça va te servir à quoi au final de ralentir ton bidule ? Si ton prog se base sur sa vitesse de fonctionnement c'est qu'il a un problème. Est ce pour un besoin graphique de visualisation ?
05/06/2009, 14h50
oneagaindoguys

Si tu veux faire des temporisations, utilise les threads
05/06/2009, 16h24
wax78

Citation:

Envoyé par oneagaindoguys

Si tu veux faire des temporisations, utilise les threads

Oui mais s'il veut ralentir TOUT le programme il va mettre des Thread.sleep a la main partout ? :) (Mais je rejoinds ton idée, en rajoutant des sleep entre chaque intstruction avec BCEL, automatiquement)

(Tu parlais bien de Thread sleep en disant thread ou alors je t'ai mal compris)
05/06/2009, 18h34
Djakisback

Mettre des sleep() ne ralentira pas la JVM mais seulement le Thread il me semble ?
Il y a cpukiller pour ralentir le proc, ce qui n'est pas sans danger je crois.
Sinon tu peux peut-être passer la JVM en very low priority ?
05/06/2009, 18h59
tchize_

ou démarrer une vieille bécane :D
ou underclocker to cpu :p
06/06/2009, 09h32
millie

Pourquoi un débuggeur (pas à pas) n'est pas suffisant ?
06/06/2009, 10h02
Celeborn

Citation:

Envoyé par casertap

voila tout est dit.

Je veux que la JVM exécute les instructions beaucoup plus lentement.
Car je veux faire une analyse dynamique de ce qu'il se passe à l'exécution d'un programme.

Un debugeur te permetra de stopper l'execution de ton prog, et d'avancer à ton rythme dans son exécution, tu pourra aussi apprendre tout plein d'info sur son état à chaque instant. J'ai bien l'impression que c'est ce que t'appelle une analyse dynamique ! De plus tu n'aura pas à modifier ton source avant et après.