[Topic unique] JR (Java extension)

JR (Java extension) [Topic unique] - Divers - Programmation

Marsh Posté le 28-06-2006 à 23:42:53    

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

Marsh Posté le 28-06-2006 à 23:42:53   

Reply

Marsh Posté le 28-06-2006 à 23:51:30    

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;
  3. public class ptrfunc {
  5.    private static op int f(int x) { return 2*x ; }
  6.    private static op int g(int x) { return x-1 ; }   
  8.    public static void main(String []args) {
  10.    cap int (int) ptr ;
  12.    ptr = f ;
  13.    System.out.println(ptr(3)) ;
  14.    ptr = g ;
  15.    System.out.println(ptr(3)) ; 
  16.    }
  18. }


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

Marsh Posté le 28-06-2006 à 23:57:21    

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;
  3. public class GeneralForm {
  5.    private static final int S=10 ;  // # of sessions
  6.    private static final int N=6 ;   // # of processes
  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.       System.out.println(i +" : " + p) ;
  14.       }
  15.    }
  17.    // Quiescence
  18.    private static op void done() { System.out.println("done" )  ; }
  20.    public static void main(String []args)
  21.    {
  22.       try
  23.       {
  24.       JR.registerQuiescenceAction(done) ;
  25.       }
  26.       catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
  27.       {
  28.       e.printStackTrace() ;
  29.       }
  30.    }
  32. }

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

Marsh Posté le 29-06-2006 à 00:06:07    

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


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

Marsh Posté le 22-09-2006 à 00:04:17    

implémentation producteurs / consommateurs avec sémaphores
 

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


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

Marsh Posté le 22-09-2006 à 00:07:54    

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


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

Marsh Posté le 22-09-2006 à 00:13:07    

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


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

Marsh Posté le 22-09-2006 à 00:23:02    

jagstang a écrit :


Code :
  1. import edu.ucdavis.jr.JR;
  3. public class GeneralForm {
  5.    private static final int S=10 ;  // # of sessions
  6.    private static final int N=6 ;   // # of processes
  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.       System.out.println(i +" : " + p) ;
  14.       }
  15.    }
  17.    // Quiescence
  18.    private static op void done() { System.out.println("done" )  ; }
  20.    public static void main(String []args)
  21.    {
  22.       try
  23.       {
  24.       JR.registerQuiescenceAction(done) ;
  25.       }
  26.       catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
  27.       {
  28.       e.printStackTrace() ;
  29.       }
  30.    }
  32. }



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

Reply

Marsh Posté le 22-09-2006 à 00:24:00    

les process sont lancés avant le main

Message cité 1 fois

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

Marsh Posté le 22-09-2006 à 00:24:21    

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

Reply

Marsh Posté le 22-09-2006 à 00:24:21   

Reply

Marsh Posté le 22-09-2006 à 00:24:49    

jagstang a écrit :

les process sont lancés avant le main


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

Reply

Marsh Posté le 22-09-2006 à 00:26:04    

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

Marsh Posté le 22-09-2006 à 00:28:22    

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
Reply

Marsh Posté le 22-09-2006 à 00:29:32    

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

Marsh Posté le 22-09-2006 à 00:30:39    

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

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed