[Topic unique] JR (Java extension)

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : [Topic unique] JR (Java extension)

jagstang

Pa Capona ಠ_ಠ

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?

Publicité

jagstang

Pa Capona ಠ_ಠ

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 :

import edu.ucdavis.jr.JR;
public class ptrfunc {
private static op int f(int x) { return 2*x ; }
private static op int g(int x) { return x-1 ; }
public static void main(String []args) {
cap int (int) ptr ;
ptr = f ;
System.out.println(ptr(3)) ;
ptr = g ;
System.out.println(ptr(3)) ;
}
}

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?

jagstang

Pa Capona ಠ_ಠ

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 :

import edu.ucdavis.jr.JR;
public class GeneralForm {
private static final int S=10 ; // # of sessions
private static final int N=6 ; // # of processes
// run N static processes
private static process p( (int i=0 ; i<N ; i++) )
{
for (int s=1 ; s<=S ; s++)
{
System.out.println(i +" : " + p) ;
}
}
// Quiescence
private static op void done() { System.out.println("done" ) ; }
public static void main(String []args)
{
try
{
JR.registerQuiescenceAction(done) ;
}
catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
{
e.printStackTrace() ;
}
}
}

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?

jagstang

Pa Capona ಠ_ಠ

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 :

import edu.ucdavis.jr.JR;
// This is an example of a CS problem
public class GeneralForm {
private static final int S=10 ; // # of sessions
private static final int N=6 ; // # of processes
private static int x=0 ; // critical section
private static sem mutex = 1 ; // provide mutual exlusion
// run N static processes
private static process p( (int i=0 ; i<N ; i++) )
{
for (int s=1 ; s<=S ; s++)
{
// non CS...
// ...
// CS : entry protocol
P(mutex) ;
System.out.println(i + " is in CS" ) ;
x+=3 ;
// Non CS : exit protocol
V(mutex) ;
}
}
// method to display x when done
private static op void done() { System.out.println("done : x=" + x) ; }
public static void main(String []args)
{
try
{
JR.registerQuiescenceAction(done) ;
}
catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
{
e.printStackTrace() ;
}
}
}

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

jagstang

Pa Capona ಠ_ಠ

implémentation producteurs / consommateurs avec sémaphores

Code :

import edu.ucdavis.jr.JR;
// This is an example of Producers / Consumer problem with buffer
public class ProdCons {
private static final int S=20 ; // # of sessions
private static final int N=5 ; // # of processes
private static final int BUFFS = 10 ; // buffer size
private static int []buffer = new int[BUFFS]; // buffer
private static int itp = 0 ; // prod iterator
private static int itc = 0 ; // cons iterator
private static sem consumers = 0 ; // sem as counter, initial : buffer is empty
private static sem producers = BUFFS ; // sem as counter, initial : buffer is empty
private static sem mutex_c = 1 ; // sem as mutex
private static sem mutex_p = 1 ; // sem as counter
// run producers pocesses
private static process prod( (int i=0 ; i<N ; i++) )
{
int m ;
for (int s=1 ; s<=S ; s++)
{
// non CS...
// ...
// CS : entry protocol
P(producers) ; // stop when buffer is full
P(mutex_p) ; // get exclusive access (multiple producers)
m = s*(i+1) ;
buffer[itp] = m ;
itp = (itp+1)%BUFFS ; // circular buffer
System.out.println("PROD : " + m) ;
// Non CS : exit protocol
V(mutex_p) ;
V(consumers) ; // one message more
// Non CS : exit protocol
}
}
// run consumers pocesses
private static process cons( (int i=0 ; i<N ; i++) )
{
int m ;
for (int s=1 ; s<=S ; s++)
{
// non CS...
// ...
// CS : entry protocol
P(consumers) ; // stop when buffer is empty
P(mutex_c) ; // get exclusive access (multiple consumers)
m = buffer[itc] ;
itc = (itc+1)%BUFFS ; // circular buffer
System.out.println("CONS : " + m) ;
// Non CS : exit protocol
V(mutex_c) ;
V(producers) ; // one less message
// Non CS : exit protocol
}
}
// method to display x when done
private static op void done() { System.out.println("done..." ) ; }
public static void main(String []args)
{
try
{
JR.registerQuiescenceAction(done) ;
}
catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
{
e.printStackTrace() ;
}
}
}

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

jagstang

Pa Capona ಠ_ಠ

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 :

import edu.ucdavis.jr.JR;
// This is an example of Producers / Consumer problem with buffer, RendezVous version
class RdvProdConsBuffer {
private final int BUFFS = 10 ; // buffer size
private Object []buffer = new Object[BUFFS]; // buffer
private int count=0, tail=0, front=0 ; // counter + buffer iterators
public op void deposit(Object o) ; // public access
public op Object fetch() ; // fot both methods
// run Buffer pocesse
private process buf
{
while(true)
{
inni void deposit(Object m) st count<BUFFS {
count++ ; buffer[tail]=m ; tail=(tail+1)%BUFFS ; }
[] Object fetch() st count>0 {
count-- ; Object m=buffer[front] ; front=(front+1)%BUFFS ; return m ; }
}
}
}
// producer / consumers and test class
public class RdvProdCons
{
private final int S=20 ; // # of sessions
private final int N=5 ; // # of processes
private RdvProdConsBuffer b ;
public RdvProdCons(RdvProdConsBuffer b) {
this.b = b ;
}
// run producers pocesses
private process prod( (int i=0 ; i<N ; i++) )
{
Object m ;
for (int s=1 ; s<=S ; s++)
{
m = new Integer(s*i) ;
b.deposit(m) ;
System.out.printf("%2d Produce %d %n", i, m) ;
}
}
// run consumers pocesses
private process cons( (int i=0 ; i<N ; i++) )
{
Object m ;
for (int s=1 ; s<=S ; s++)
{
m = b.fetch() ;
System.out.printf("%2d Consume %d %n", i, m) ;
}
}
// method to display x when done
private static op void done() { System.out.println("done..." ) ; }
public static void main(String []args)
{
RdvProdConsBuffer b = new RdvProdConsBuffer() ; // instantiate buffer
new RdvProdCons(b) ; // then processes
try
{
JR.registerQuiescenceAction(done) ;
}
catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
{
e.printStackTrace() ;
}
}
}

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

jagstang

Pa Capona ಠ_ಠ

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

Code :

import edu.ucdavis.jr.JR ;
import java.util.* ;
// Adaptative Quadrature : calculate area of a function with adaptive steps, using N worker process and 1 administrator
public class AQ
{
private static final int N = 20 ; // number of workers
private static final op void bag(double, double, double, double) ;
private static final op void result(double) ;
private static final double Epsilon = 1e-3 ;
private static final double f(double x) {
//return Math.pow(x, 3.0) ;
return Math.pow(x, 2.0)*Math.sin(20*x)+5*x ;
//return 3*x*Math.exp(0.1*x) ;
}
private static double area = 0.0 ;
private static process administrator
{
double part ;
double l = 0.0, r = 4.0 ;
send bag(l,r,f(l),f(r)) ;
while (true)
{
receive result(part) ;
area += part ;
}
}
private static process worker( (int i=0 ; i<N ; i++) )
{
double a, b, m, fofa, fofb, fofm, larea, rarea, tarea, diff ;
while (true)
{
receive bag(a,b,fofa,fofb) ;
m = (a+b)/2 ; fofm = f(m) ;
// compute larea, rarea, tarea using trapezoidal rules
larea = (m-a) * (fofa + fofm) / 2.0 ;
rarea = (b-m) * (fofm + fofb) / 2.0 ;
tarea = (b-a) * (fofa + fofb) / 2.0 ;
diff = Math.abs(tarea - (larea+rarea)) ;
if (diff <= Epsilon) // diff small enough
{
System.out.printf("%2d successful calc [%5f, %5f], diff=%5e %n",i,a,b,diff) ;
send result(larea + rarea) ;
}
else // diff > epsilon : diff too large
{
System.out.printf("%2d BAG [%5f, %5f, %5f], diff= %5e %n",i,a,m,b,diff) ;
send bag(a, m, fofa, fofm) ;
send bag(m, b, fofm, fofb) ;
}
}
}
public static void main(String args[])
{
// register Quiescent operation
try
{
JR.registerQuiescenceAction(done) ;
}
catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
{
e.printStackTrace() ;
}
}
private static op void done()
{
System.out.println("computed area = " + area) ;
}
}

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

benou

jagstang a écrit :

Code :

import edu.ucdavis.jr.JR;
public class GeneralForm {
private static final int S=10 ; // # of sessions
private static final int N=6 ; // # of processes
// run N static processes
private static process p( (int i=0 ; i<N ; i++) )
{
for (int s=1 ; s<=S ; s++)
{
System.out.println(i +" : " + p) ;
}
}
// Quiescence
private static op void done() { System.out.println("done" ) ; }
public static void main(String []args)
{
try
{
JR.registerQuiescenceAction(done) ;
}
catch(edu.ucdavis.jr.QuiescenceRegistrationException e)
{
e.printStackTrace() ;
}
}
}

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

jagstang

Pa Capona ಠ_ಠ

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?

benou

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

Publicité

benou

jagstang a écrit :

les process sont lancés avant le main

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

jagstang

Pa Capona ಠ_ಠ

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?

benou

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

jagstang

Pa Capona ಠ_ಠ

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?

jagstang

Pa Capona ಠ_ಠ

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?

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 simple	Appli java et outils proprios
probléme pour éxécuter un fichier java	Récupération d'applet java ?
Problème avec une petite application RMI en java	Problème d’é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)

Page générée en 0.158 secondes