Discussion :

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

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

Merci pour votre aide.

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
long startTime = System.currentTimeMillis(); 
while (System.currentTimeMillis() - startTime < 500)

[casertap]

mais non il faut vraiment que je ralentisse l'exécution de la JVM.
Je suis presque sure que ca doit etre possible

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

[casertap]

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.

[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 ?

[dinobogan]

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

Non, c'est impossible.

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

[wax78]

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 :

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
 
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 :

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

[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 ?

[oneagaindoguys]

Si tu veux faire des temporisations, utilise les threads

[wax78]

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)

[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 ?

[tchize_]

ou démarrer une vieille bécane
ou underclocker to cpu :p

[millie]

Pourquoi un débuggeur (pas à pas) n'est pas suffisant ?

[Celeborn]

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.