Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
2985 connectés 

  FORUM HardWare.fr
  Programmation
  Divers

  [Topic unique] JR (Java extension)

 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

[Topic unique] JR (Java extension)

n°1396953
jagstang
Pa Capona ಠ_ಠ
Posté le 28-06-2006 à 23:42:53  profilanswer
 

Il s'agit d'un langage de programmation concurrent qui étend Java, au détail près que les mécanismes concurrents sont beaucoup plus simple à implémenter qu'en Java.  
 
L'idéal pour se familiariser avec les sémaphores, les messages asynchrones, les RPC, rendezvous, pointeurs de fonction (en java!)
 
page officielle : http://www.cs.ucdavis.edu/~olsson/research/jr/
 

Citation :


The JR programming language extends Java to provide a rich concurrency model, based on that of the  SR concurrent programming language. JR provides dynamic remote virtual machine creation, dynamic remote object creation, remote method invocation, asynchronous communication, rendezvous, and dynamic process creation.  JR takes a novel object-oriented approach to synchronization, which leads to more flexible programming of concurrent applications like servers.  JR can, depending on one's particular definitions, also be considered a distributed programming language or a parallel programming language.
 
JR programs are written in an extended Java and then translated into standard Java programs.  The JR run-time support system is also written in standard Java.  JR runs on UNIX-based systems (Linux, Solaris, Mac OS X) and Windows.
 
The JR_distribution includes the JR translator; the JR virtual machine (JRVM); the JR verification tool and test suite (jrv, for checking proper functioning of the JR implementation); documentation; numerous JR example programs; and preprocessors that convert other concurrency notations (CCRs, monitors, and CSP) into JR.



---------------
What if I were smiling and running into your arms? Would you see then what I see now?  
mood
Publicité
Posté le 28-06-2006 à 23:42:53  profilanswer
 

n°1396957
jagstang
Pa Capona ಠ_ಠ
Posté le 28-06-2006 à 23:51:30  profilanswer
 

1er exemple : les pointeurs de fonctions (en java!)
 
en JR, le mot clé op signifie que c'est une méthode JR (sinon c'est une méthode "normale" traité par le complilateur java)
 
le mot clé cap permet de référencer une méthode (plus précisément un op)
 

Code :
  1. import edu.ucdavis.jr.JR;
  2. public class ptrfunc {
  3.    private static op int f(int x) { return 2*x ; }
  4.    private static op int g(int x) { return x-1 ; }   
  5.    public static void main(String []args) {
  6.    cap int (int) ptr ;
  7.    ptr = f ;
  8.    System.out.println(ptr(3)) ;
  9.    ptr = g ;
  10.    System.out.println(ptr(3)) ; 
  11.    }
  12. }


output :  


6
2


Message édité par jagstang le 28-06-2006 à 23:52:05

---------------
What if I were smiling and running into your arms? Would you see then what I see now?  
n°1396963
jagstang
Pa Capona ಠ_ಠ
Posté le 28-06-2006 à 23:57:21  profilanswer
 

JR et threads
 
Voyons comme il est simple d'implémenter des processus en JR (par rapport à Java)
 
N processes sont lancés et sont S boucles.  
 
QuiescenceAction est appelé lorsque tout les processus sont inactifs
 

Code :
  1. import edu.ucdavis.jr.JR;
  2. public class GeneralForm {
  3.    private static final int S=10 ;  // # of sessions
  4.    private static final int N=6 ;   // # of processes
  5.    // run N static processes
  6.    private static process p( (int i=0 ; i<N ; i++) ) 
  7.    {
  8.       for (int s=1 ; s<=S ; s++) 
  9.       {
  10.       System.out.println(i +" : " + p) ;
  11.       }
  12.    }
  13.    // Quiescence
  14.    private static op void done() { System.out.println("done" )  ; }
  15.    public static void main(String []args)
  16.    {
  17.       try
  18.       {
  19.       JR.registerQuiescenceAction(done) ;
  20.       }
  21.       catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
  22.       {
  23.       e.printStackTrace() ;
  24.       }
  25.    }
  26. }

Message cité 1 fois
Message édité par jagstang le 29-06-2006 à 00:11:21

---------------
What if I were smiling and running into your arms? Would you see then what I see now?  
n°1396965
jagstang
Pa Capona ಠ_ಠ
Posté le 29-06-2006 à 00:06:07  profilanswer
 

Même exemple, mais avec la modification d'une variable partagée. L'accès exclusif à cette variable est assuré à l'aide des semaphores mot clé sem
 
L'opération P() est bloquante tant qu'un process n'y est pas sorti par V()
 

Code :
  1. import edu.ucdavis.jr.JR;
  2. // This is an example of a CS problem
  3. public class GeneralForm {
  4.    private static final int S=10 ;  // # of sessions
  5.    private static final int N=6 ;   // # of processes
  6.    private static int x=0 ;         // critical section
  7.    private static sem mutex = 1 ;   // provide mutual exlusion
  8.    // run N static processes
  9.    private static process p( (int i=0 ; i<N ; i++) ) 
  10.    {
  11.       for (int s=1 ; s<=S ; s++) 
  12.       {
  13.       // non CS...  
  14.       // ...
  15.       // CS : entry protocol
  16.       P(mutex) ;
  17.       System.out.println(i + " is in CS" ) ;
  18.       x+=3 ;
  19.       // Non CS : exit protocol
  20.       V(mutex) ;     
  21.       }
  22.    }
  23.    // method to display x when done
  24.    private static op void done() { System.out.println("done : x=" + x) ; }
  25.    public static void main(String []args)
  26.    {
  27.       try
  28.       {
  29.       JR.registerQuiescenceAction(done) ;
  30.       }
  31.       catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
  32.       {
  33.       e.printStackTrace() ;
  34.       }
  35.    }
  36. }


---------------
What if I were smiling and running into your arms? Would you see then what I see now?  
n°1446035
jagstang
Pa Capona ಠ_ಠ
Posté le 22-09-2006 à 00:04:17  profilanswer
 

implémentation producteurs / consommateurs avec sémaphores
 

Code :
  1. import edu.ucdavis.jr.JR;
  2. // This is an example of Producers / Consumer problem with buffer
  3. public class ProdCons {
  4.    private static final int S=20 ;                // # of sessions
  5.    private static final int N=5 ;                 // # of processes
  6.    private static final int BUFFS = 10 ;          // buffer size
  7.    private static int []buffer = new int[BUFFS];  // buffer
  8.    private static int itp = 0 ;                   // prod iterator
  9.    private static int itc = 0 ;                   // cons iterator
  10.    private static sem consumers = 0 ;             // sem as counter, initial : buffer is empty
  11.    private static sem producers = BUFFS ;         // sem as counter, initial : buffer is empty
  12.    private static sem mutex_c = 1 ;               // sem as mutex
  13.    private static sem mutex_p = 1 ;               // sem as counter
  14.  
  15.    // run producers pocesses
  16.    private static process prod( (int i=0 ; i<N ; i++) )
  17.    {
  18.       int m ;
  19.  
  20.       for (int s=1 ; s<=S ; s++)
  21.       {
  22.       // non CS...  
  23.       // ...
  24.       // CS : entry protocol
  25.       P(producers) ;    // stop when buffer is full
  26.       P(mutex_p) ;      // get exclusive access (multiple producers)
  27.       m = s*(i+1) ;
  28.       buffer[itp] = m ;
  29.       itp = (itp+1)%BUFFS ;  // circular buffer
  30.       System.out.println("PROD : " + m) ;
  31.      
  32.       // Non CS : exit protocol
  33.       V(mutex_p) ;     
  34.       V(consumers) ;     // one message more
  35.       // Non CS : exit protocol
  36.       }
  37.    }
  38.    // run consumers pocesses
  39.    private static process cons( (int i=0 ; i<N ; i++) )
  40.    {
  41.       int m ;
  42.  
  43.       for (int s=1 ; s<=S ; s++)
  44.       {
  45.       // non CS...  
  46.       // ...
  47.       // CS : entry protocol
  48.       P(consumers) ;    // stop when buffer is empty
  49.       P(mutex_c) ;      // get exclusive access (multiple consumers)
  50.       m = buffer[itc] ;
  51.       itc = (itc+1)%BUFFS ;  // circular buffer
  52.       System.out.println("CONS : " + m) ;
  53.      
  54.       // Non CS : exit protocol
  55.       V(mutex_c) ;
  56.       V(producers) ;    // one less message
  57.       // Non CS : exit protocol
  58.       }
  59.    }
  60.    // method to display x when done
  61.    private static op void done() { System.out.println("done..." ) ; }
  62.    public static void main(String []args)
  63.    {
  64.       try
  65.       {
  66.       JR.registerQuiescenceAction(done) ;
  67.       }
  68.       catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
  69.       {
  70.       e.printStackTrace() ;
  71.       }
  72.    }
  73. }


---------------
What if I were smiling and running into your arms? Would you see then what I see now?  
n°1446036
jagstang
Pa Capona ಠ_ಠ
Posté le 22-09-2006 à 00:07:54  profilanswer
 

Même problème, résolu bien plus élégamment avec les Rendez-vous (inni)
 
le mot clé st (such that) permet de déterminer si la méthode peut-être appelé ou non. Si ça n'est pas le cas, le message est mis en attente
 
 

Code :
  1. import edu.ucdavis.jr.JR;
  2. // This is an example of Producers / Consumer problem with buffer, RendezVous version
  3. class RdvProdConsBuffer {
  4.    private final int BUFFS = 10 ;                // buffer size
  5.    private Object []buffer = new Object[BUFFS];  // buffer
  6.    private int count=0, tail=0, front=0 ;                       // counter + buffer iterators
  7.    public op void deposit(Object o) ;            // public access
  8.    public op Object fetch() ;                    // fot both methods
  9.  
  10.    // run Buffer pocesse
  11.    private process buf
  12.    {
  13.       while(true)
  14.       {
  15.          inni  void deposit(Object m) st count<BUFFS {
  16.                count++ ; buffer[tail]=m ; tail=(tail+1)%BUFFS ;  }
  17.          []   Object fetch() st count>0 {
  18.                count-- ; Object m=buffer[front] ; front=(front+1)%BUFFS ; return m ; }
  19.       }
  20.    }
  21. }
  22. // producer / consumers and test class
  23. public class RdvProdCons
  24. {
  25.    private final int S=20 ;                      // # of sessions
  26.    private final int N=5 ;                       // # of processes
  27.    private RdvProdConsBuffer b ;
  28.    public RdvProdCons(RdvProdConsBuffer b) {
  29.       this.b = b ;
  30.    }
  31.  
  32.    // run producers pocesses
  33.    private process prod( (int i=0 ; i<N ; i++) )
  34.    {
  35.       Object m ; 
  36.  
  37.       for (int s=1 ; s<=S ; s++)
  38.       {
  39.          m = new Integer(s*i) ;
  40.          b.deposit(m) ;
  41.          System.out.printf("%2d Produce %d %n", i, m) ;       
  42.       }
  43.    } 
  44.    // run consumers pocesses
  45.    private process cons( (int i=0 ; i<N ; i++) )
  46.    {
  47.       Object m ;
  48.  
  49.       for (int s=1 ; s<=S ; s++)
  50.       {
  51.          m = b.fetch() ;     
  52.          System.out.printf("%2d Consume %d %n", i, m) ;
  53.       }
  54.    }
  55.    // method to display x when done
  56.    private static op void done() { System.out.println("done..." ) ; }
  57.    public static void main(String []args)
  58.    {
  59.       RdvProdConsBuffer b = new RdvProdConsBuffer() ;  // instantiate buffer
  60.       new RdvProdCons(b) ;                             // then processes
  61.  
  62.       try
  63.       {
  64.       JR.registerQuiescenceAction(done) ;
  65.       }
  66.       catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
  67.       {
  68.       e.printStackTrace() ;
  69.       }
  70.    }
  71. }


---------------
What if I were smiling and running into your arms? Would you see then what I see now?  
n°1446039
jagstang
Pa Capona ಠ_ಠ
Posté le 22-09-2006 à 00:13:07  profilanswer
 

Calcul numérique de l'aire d'une fonction avec la précision voulu à l'aide de processus travailleurs
 

Code :
  1. import edu.ucdavis.jr.JR ;
  2. import java.util.* ;
  3. // Adaptative Quadrature : calculate area of a function with adaptive steps, using N worker process and 1 administrator
  4. public class AQ
  5. {
  6.    private static final int N = 20 ;  // number of workers  
  7.    private static final op void bag(double, double, double, double) ;
  8.    private static final op void result(double) ;
  9.    private static final double Epsilon = 1e-3 ;
  10.    private static final double f(double x) {
  11.       //return Math.pow(x, 3.0) ;
  12.       return Math.pow(x, 2.0)*Math.sin(20*x)+5*x ;
  13.       //return 3*x*Math.exp(0.1*x) ;   
  14.    }
  15.    private static double area = 0.0 ;
  16.    private static process administrator
  17.    {
  18.       double part ;
  19.       double l = 0.0, r = 4.0 ;
  20.       send bag(l,r,f(l),f(r)) ;
  21.       while (true)
  22.       {
  23.          receive result(part) ;
  24.          area += part ;
  25.       }
  26.    }
  27.    private static process worker( (int i=0 ; i<N ; i++) )
  28.    {
  29.       double a, b, m, fofa, fofb, fofm, larea, rarea, tarea, diff ;
  30.       while (true)
  31.       {
  32.          receive bag(a,b,fofa,fofb) ;
  33.          m = (a+b)/2 ; fofm = f(m) ;
  34.          // compute larea, rarea, tarea using trapezoidal rules
  35.          larea = (m-a) * (fofa + fofm) / 2.0 ;
  36.          rarea = (b-m) * (fofm + fofb) / 2.0 ;
  37.          tarea = (b-a) * (fofa + fofb) / 2.0 ;
  38.          diff = Math.abs(tarea - (larea+rarea)) ;
  39.  
  40.          if (diff <= Epsilon) // diff small enough
  41.          {
  42.             System.out.printf("%2d successful calc [%5f, %5f], diff=%5e %n",i,a,b,diff) ;
  43.             send result(larea + rarea) ;
  44.          }
  45.          else                 // diff > epsilon : diff too large
  46.          {
  47.             System.out.printf("%2d BAG [%5f, %5f, %5f], diff= %5e %n",i,a,m,b,diff) ;
  48.             send bag(a, m, fofa, fofm) ;
  49.             send bag(m, b, fofm, fofb) ;
  50.          }
  51.       }
  52.    }
  53.    public static void main(String args[])
  54.    {
  55.       // register Quiescent operation
  56.       try
  57.       {
  58.       JR.registerQuiescenceAction(done) ;
  59.       }
  60.       catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
  61.       {
  62.       e.printStackTrace() ;
  63.       }
  64.    }
  65.    private static op void done()
  66.    {
  67.       System.out.println("computed area = " + area) ;
  68.    }
  69. }


---------------
What if I were smiling and running into your arms? Would you see then what I see now?  
n°1446043
benou
Posté le 22-09-2006 à 00:23:02  profilanswer
 

jagstang a écrit :


Code :
  1. import edu.ucdavis.jr.JR;
  2. public class GeneralForm {
  3.    private static final int S=10 ;  // # of sessions
  4.    private static final int N=6 ;   // # of processes
  5.    // run N static processes
  6.    private static process p( (int i=0 ; i<N ; i++) ) 
  7.    {
  8.       for (int s=1 ; s<=S ; s++) 
  9.       {
  10.       System.out.println(i +" : " + p) ;
  11.       }
  12.    }
  13.    // Quiescence
  14.    private static op void done() { System.out.println("done" )  ; }
  15.    public static void main(String []args)
  16.    {
  17.       try
  18.       {
  19.       JR.registerQuiescenceAction(done) ;
  20.       }
  21.       catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
  22.       {
  23.       e.printStackTrace() ;
  24.       }
  25.    }
  26. }



il est lancé quand ton beans là ? le main appelle que dalle ...

n°1446044
jagstang
Pa Capona ಠ_ಠ
Posté le 22-09-2006 à 00:24:00  profilanswer
 

les process sont lancés avant le main


---------------
What if I were smiling and running into your arms? Would you see then what I see now?  
n°1446045
benou
Posté le 22-09-2006 à 00:24:21  profilanswer
 

sinon les pointeurs de fonctions ... je vois pas l'intérêt par rapport à une bête interface ...

mood
Publicité
Posté le 22-09-2006 à 00:24:21  profilanswer
 

n°1446046
benou
Posté le 22-09-2006 à 00:24:49  profilanswer
 

jagstang a écrit :

les process sont lancés avant le main


c'est à dire ? à quel moment ? qu'est ce qui délcenche le lancement ?

n°1446048
jagstang
Pa Capona ಠ_ಠ
Posté le 22-09-2006 à 00:26:04  profilanswer
 

les pointeurs de fonction c'est en effet un détail. l'intérêt principal de ce langage réside dans la facilité à créer des programmes concurrents, voir  distribués


---------------
What if I were smiling and running into your arms? Would you see then what I see now?  
n°1446050
benou
Posté le 22-09-2006 à 00:28:22  profilanswer
 

j'ai pas étudié en détail java.util.concurrency de java1.5, mais ca m'a lair de contenir déjà tout ce qu'il faut ... t'as comparé ton JR par rapport à ça ?


Message édité par benou le 22-09-2006 à 00:28:34
n°1446051
jagstang
Pa Capona ಠ_ಠ
Posté le 22-09-2006 à 00:29:32  profilanswer
 

je les ai pas étudié non plus [:jagstang] je peux donc pas te répondre


---------------
What if I were smiling and running into your arms? Would you see then what I see now?  
n°1446052
jagstang
Pa Capona ಠ_ಠ
Posté le 22-09-2006 à 00:30:39  profilanswer
 

ce qui est sûr, c'est que JR génère des fichiers java (une dizaine environ) pour créer l'application. L'intérêt est donc dans la simplicité d'utilisation.  
 
La syntaxe est celle de SR


---------------
What if I were smiling and running into your arms? Would you see then what I see now?  

Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  Divers

  [Topic unique] JR (Java extension)

 

Sujets relatifs
Exécution procédure stockée sur Sybase en Java[java & c++] communication Java ,<=> c++
[java] Mécanisme de timout simpleAppli java et outils proprios
probléme pour éxécuter un fichier javaRécupération d'applet java ?
Problème avec une petite application RMI en javaProblème d&#8217;écriture dans un fichier avec Java (Applet)
chat sous java[java débutant] erreur afficahge Japplet
Plus de sujets relatifs à : [Topic unique] JR (Java extension)


Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR