thread java et échange MPI avec un programme C
Bonjour,
Je dispose d'une classe Java (développée avec JNI) qui me permet d'utiliser depuis un programme Java, les fonctions C de MPI (un 'wrapper' en quelque sorte).
Ca fonctionne et j'ai pu vérifier que je pouvais faire des SEND depuis un programme java, en correspondance avec des RECEIVE dans un programme C.
Maintenant, je cherche à introduire ce mécanisme dans une petite appli java constituée d'un Slider et d'un listener sur le changement de valeur du Slider.
Le programme C consiste simplement en une boucle avec un seul RECEIVE placé au début de cette boucle.
L'appli Java doit donc faire le SEND vers le programme C depuis une boucle aussi car le SEND et le RECEIVE sont synchrones.
J'ai placé la boucle qui doit faire le SEND de la valeur du Slider dans un Thread Java.
Mon problème est le suivant : le thread java envoie la valeur initiale du slider mais il ignore les changements de valeur par déplacement du Slider.
En revanche, si j'ajoute un délai dans boucle (avec un TimeUnit.SECONDS.sleep(2); ) ça fonctionne et la valeur envoyée est actualisée !
Sauriez-vous m'éclairer sur ce qui se passe, car ce "remède" n'est pas très satisfaisant, et le résultat n'est pas robuste du tout...
Ci dessous le code de l'appli du Slider (vous verrez que le main() ne fait que créer un nouveau thread pour exécuter la fameuse boucle).
Et juste après, le code du Thread qui exécute la boucle avec le SEND
Merci d'avance pour votre aide...
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
|
package power;
import java.awt.GridLayout;
import java.util.Hashtable;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
public class Widget extends JPanel {
static public double value;
public static void main(String[] args) throws InterruptedException {
// Create and set up a frame window
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Slider with change listener");
frame.setSize(500, 500);
frame.setLayout(new GridLayout(3, 1));
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel panel1 = new JPanel();
JPanel panel2 = new JPanel();
final JLabel status = new JLabel("Slide the slider and you can get its value", JLabel.CENTER);
// Set the slider
JSlider slider = new JSlider();
slider.setMinorTickSpacing(10);
slider.setPaintTicks(true);
// Set the labels to be painted on the slider
slider.setPaintLabels(true);
// Add positions label in the slider
Hashtable<Integer, JLabel> position = new Hashtable<>();
position.put(0, new JLabel("0"));
position.put(50, new JLabel("50"));
position.put(100, new JLabel("100"));
// Set the label to be drawn
slider.setLabelTable(position);
// Add change listener to the slider
slider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
status.setText("Value of the slider is: " + ((JSlider)e.getSource()).getValue());
Widget.value=1.0*((JSlider)e.getSource()).getValue();
}
});
// Add the slider to the panel
panel1.add(slider);
// Set the window to be visible as the default to be false
frame.add(panel1);
frame.add(status);
frame.add(panel2);
frame.pack();
frame.setVisible(true);
// Boucle pour les envois MPI
loop l = new loop();
l.start();
}
} |
Ci-dessous le thread qui exécute la boucle pour faire le SEND :
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
|
import fr.moi.jnimpi.MPIInterface;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author pierre
*/
public class loop extends Thread{
@Override
public void run() {
MPIInterface.begin();
int size = MPIInterface.size();
int rank = MPIInterface.rank();
String name = MPIInterface.processorName();
System.out.printf("Java Process %d on %s out of %d \n", rank, name, size);
int time=0;
double[] sentData = {Widget.value};
while(time<100)
{
time +=1;
sentData[0]=Widget.value;
MPIInterface.send(1, sentData);
// try {
// TimeUnit.SECONDS.sleep(2);
// } catch (InterruptedException ex) {
// Logger.getLogger(loop.class.getName()).log(Level.SEVERE, null, ex);
// }
}
MPIInterface.end();
}
} |
