Modèle de jointure

En Erlang , la synchronisation de plusieurs processus n'est pas simple. C'est pourquoi JErlang , une extension d' Erlang , a été créée. Le J signifie « Join ». En effet, pour pallier cette limitation, JErlang a été implémentée : il s'agit d'une extension d' Erlang inspirée du calcul de jointure . Les caractéristiques de ce langage sont les suivantes :

• Les jointures permettent la première sémantique de correspondance et la possibilité d'avoir plusieurs modèles tout en préservant l'ordre des messages.

opération () -> recevoir { ok , somme } et { val , X } et { val , Y } -> { somme , X + Y }; { ok , multiplicateur } et { val , X } et { val , Y } -> { multiplicateur , X * Y }; { ok , sous- } et { val , X } et { val , Y } -> { sous- , X - Y }; fin fin

• Guards offre un filtrage supplémentaire qui ne s'exprime pas en termes de modèles. Nombre limité d'expressions sans effets secondaires.

Il s'agit d'une bibliothèque de modèles de jointure déclarative, facile à utiliser et évolutive. Contrairement à la bibliothèque Russo , elle ne comporte pas de verrou global. En effet, elle fonctionne avec un système CAS de comparaison et d'échange et un système de messages atomiques. La bibliothèque utilise trois améliorations pour le modèle de jointure :

• Vol de messages pour les ressources inutilisées (autorisation de détournement) ;
• La file d'attente paresseuse permet de réaliser des économies à la fois sur l'allocation et potentiellement sur la communication interprocesseur en évitant l'allocation ou l'enfilement avec un chemin rapide optimiste ;
• Le statut « RÉVEILLÉ » garantit qu’un appelant synchrone bloqué n’est réveillé qu’une seule fois.

JoCaml est le premier langage où le modèle de jointure a été implémenté. En effet, à l'origine, toutes les implémentations étaient compilées avec le compilateur JoCaml. Le langage JoCaml est une extension du langage OCaml . Il étend OCaml en y ajoutant la prise en charge de la concurrence et de la synchronisation, l'exécution distribuée des programmes et le déplacement dynamique des fragments de programme actifs pendant l'exécution.

pièces de monnaie = Nickel | Dime et boissons = Café | Thé et boutons = BCoffee | BTea | BCancel ;;(* def définit une clause d'ensemble de modèles de jointure * "&" à gauche du = signifie jointure (synchronisation des canaux) * "&" à droite signifie : traitement parallèle * synchronous_reply :== "reply" [x] "to" channel_name * Les canaux synchrones ont des types de type fonction (`a -> `b) * Les canaux asynchrones ont des types (`a Join.chan) * Seule la dernière instruction d'une expression de modèle à droite peut être un message asynchrone * 0 à la position d'un message asynchrone signifie STOP (« aucun message envoyé » dans la terminologie CSP).  *)def put ( s ) = print_endline s ; 0 (* STOP *) ; (* put: string Join.chan *)def serve ( drink ) = match drink with Coffee- > put ( "Coffee" ) | Tea- > put ( "Tea" ) ;; (* serve: drinks Join.chan *)def refund ( v ) = let s = Printf.sprintf "Remboursement %d" v in put(s) ;; ( * refund : int Join.chan *)let new_vending serve refund = let vend ( cost : int ) ( credit : int ) = if credit >= cost then ( true , credit - cost ) else ( false , credit ) in def coin ( Nickel ) & value ( v ) = value ( v + 5 ) & reply () to coin or coin ( Dime ) & value ( v ) = value ( v + 10 ) & reply () to coinou bouton ( BCoffee ) & valeur ( v ) = soit devrait_servir , reste = vendre 10 v dans ( si devrait_servir alors servir ( Café ) sinon 0 (* STOP *) ) & valeur ( reste ) & répondre () au boutonou bouton ( BTea ) & valeur ( v ) = soit devrait_servir , reste = vendre 5 v dans ( si devrait_servir alors servir ( Thé ) sinon 0 (* STOP *) ) & valeur ( reste ) & réponse () au boutonou bouton ( BCancel ) & valeur ( v ) = remboursement ( v ) & valeur ( 0 ) & réponse () au bouton dans spawn valeur ( 0 ) ; pièce , bouton (* pièce, bouton : int -> unité *) ;; (* nouveau_distributeur : boisson Join.chan -> int Join.chan -> (int->unité)*(int->unité) *)let ccoin , cbutton = new_vending serve refund in ccoin ( Nickel ); ccoin ( Nickel ); ccoin ( Dime ); Unix . sleep ( 1 ); cbutton ( BCoffee ); Unix . sleep ( 1 ); cbutton ( BTea ); Unix . sleep ( 1 ); cbutton ( BCancel ); Unix . sleep ( 1 ) (* laisser le dernier message s'afficher *) ;;

donne

Hume  est un langage fonctionnel strict et fortement typé pour les plateformes aux ressources limitées, avec une concurrence basée sur le passage de messages asynchrones, la programmation de flux de données et une syntaxe de type Haskell .
Hume ne propose pas de messagerie synchrone.
Il encapsule un ensemble de modèles de jointure ayant un canal en commun sous forme de boîte , listant tous les canaux dans un tuple d'entrée et spécifiant toutes les sorties possibles dans un tuple de sortie .
Chaque modèle de jointure de l'ensemble doit se conformer au type de tuple d'entrée de la boîte , en spécifiant un '*' pour les canaux non requis, donnant une expression dont le type se conforme au tuple de sortie, en marquant '*' les sorties non alimentées.
Une clause de câblage spécifie
un tuple d'origines ou de sources d'entrée correspondantes et, éventuellement, de valeurs de départ
un tuple de destinations de sortie, étant des canaux ou des récepteurs (stdout, ..).
Une boîte peut spécifier des gestionnaires d'exceptions avec des expressions conformes au tuple de sortie.
 ( *, v + 5, *) | ( Dime, *, v) -> ( *, v + 10, *) | ( *, BCoffee, v) -> vend Coffee 10 v | ( *, BTea, v) -> vend Tea 5 v | ( *, BCancel, v) -> let refund u = \"Refund \" ++ show u ++ \"\ \" in ( *, 0, refund v) ; vend drink cost credit = if credit >= cost then ( serve drink, credit - cost, *) else ( *, credit, *); serve drink = case drink of Coffee -> \"Cofee\ \" Tea -> \"Tea\ \" ; box control in (c :: char) out (coin :: Coins, button:: Buttons) match 'n' -> (Nickel, *) | 'd' -> (Dime, *) | 'c' -> (*, BCoffee) | 't' -> (*, BTea) | 'x' -> (*, BCancel) | _ -> (*, *) ; stream console_outp to \"std_out\" ; stream console_inp from \"std_in\" ; -- dataflow wiring wire cofee -- inputs (channel origins) (control.coin, control.button, coffee.value’ initially 0) -- outputs destinations (console_outp, coffee.value, console_outp) ; wire control (console_inp) (coffee.coin, coffee.button) ; " 
données Pièces = Nickel | Dime ; données Boissons = Café | Thé ; données Boutons = BCoffee | BTea | BCancel ;type Int = int 32 ; type String = chaîne ; afficher u = u comme chaîne ;boîte café en ( pièce :: Pièces , bouton :: Boutons , valeur :: Entier ) -- canaux d'entrée sortie ( sortie_boisson :: Chaîne , valeur ' :: Entier , sortie_remboursement :: Chaîne ) -- sorties nomméesmatch -- * caractères génériques pour les sorties non remplies et les entrées non consommées ( Nickel , * , v ) -> ( * , v + 5 , * ) | ( Dime , * , v ) -> ( * , v + 10 , * ) | ( * , BCoffee , v ) -> vendre du café 10 v | ( * , BTea , v ) -> vendre du thé 5 v | ( * , BCancel , v ) -> laisser le remboursement u = "Remboursement " ++ afficher u ++ " " dans ( * , 0 , remboursement v ) ;vendre la boisson coût crédit = si crédit >= coût alors ( servir la boisson , crédit - coût , * ) sinon ( * , crédit , * );servir une boisson = cas boisson de Café -> "Café " Thé -> "Thé " ;boîte de contrôle en ( c :: char ) sortie ( coin :: Coins , button :: Buttons ) correspondance 'n' -> ( Nickel , * ) | 'd' -> ( Dime , * ) | 'c' -> ( * , BCoffee ) | 't' -> ( * , BTea ) | 'x' -> ( * , BCancel ) | _ -> ( * , * ) ;Diffuser la sortie console vers "std_out" ; diffuser l'entrée console depuis "std_in" ;-- câblage de flux de donnéesfil café -- entrées (origines des canaux) ( contrôle . pièce , contrôle . bouton , café . valeur ' initialement 0 ) -- sorties destinations ( console_outp , café . valeur , console_outp ) ;contrôle filaire ( console_inp ) ( café . pièce , café . bouton ) ;