1 / 27

Linear Type Systems for Concurrent Languages

This paper compares the merit and demerit of concurrent languages with sequential languages, showcasing examples of complications in ML and CML. It proposes an approach to identify deterministic and deadlock-free parts using a static type system. The paper presents the benefits of enriching Channel Types with Linear Channels and Time Tags to enhance efficiency and correctness in process calculi.

mohammad-freeman
Télécharger la présentation

Linear Type Systems for Concurrent Languages

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Linear Type Systemsfor Concurrent Languages Eijiro SumiiNaoki Kobayashi University of Tokyo

  2. Merit and Demerit of Concurrent Languages Compared with sequential languages • Merit: more expressive power • Inherently concurrent application (e.g. GUI) • Parallel/distributed computation • Demerit: more complicated behavior • Non-determinism(possibility of various results) • Deadlock(failure of due communication) • Errors & Inefficiencies

  3. Example of Complication (1) In ML:r:int ref├(r:=3; r:=7; !r) (* evaluates to 7 *) In CML [Reppy 91]:c:int chan├(spawn(fn()=>send(c, 3)); spawn(fn()=>send(c, 7));recv(c)) (* evaluates to either 3 or 7 *)

  4. Example of Complication (2) In ML:let val r:int ref = ref 3in !r + !r + !rend (* evaluates to 9 *) In CML:let val c:int chan = channel() val _ = spawn(fn()=>send(c, 3))in recv(c) + recv(c) + recv(c))end (* evaluation gets stuck! *)

  5. Example of Complication (3) In ML:let val r1:bool ref = ref false val r2:bool ref = ref truein !r2 andalso !r1end (* evaluates to false *) In CML:

  6. Example of Complication (3) In ML: In CML:let val c1:bool chan = channel () val c2:bool chan = channel () val _ = spawn(fn()=> (send(c1, false);send(c2, true)))in recv(c2) andalso recv(c1)end (* evaluation gets stuck! *)

  7. Our Approach Identify deterministic/deadlock-free partsby a static type system Enrich Channel Types with Information of • “In what way a channel is used” Linear Channels, Usage Annotations • “In what order channels are used” Time Tags Rationale:Type systems are usually compositional & tractable (unlike model checking, abstract interpretation, etc.)

  8. Outline • Introduction • Basic Ideas • Linear Channels [Kobayashi et al. 96] • Time Tags [Kobayashi 97] • Formalization in process calculi • Extension by Usage Annotations [Sumii & Kobayashi 98] • Conclusion

  9. Basic Ideas (1): Linear Channels c : pm chan p (polarity) ::=  (output) |  (input) |  (both) |  (none) “In which directionc can be used” m (multiplicity) ::= 1(exactly once) | (any times) “How many timesccan be used” • c:1 int chan├ send(c, 3):unit • c:1 int chan├ recv(c):int

  10. Basic Ideas (1): Linear Channels c : pm chan p (polarity) ::=  (output) |  (input) |  (both) |  (none) “In which directionc can be used” m (multiplicity) ::= 1(exactly once) | (any times) “How many timesccan be used” • c:1 int chan├ send(c, 3):unit • c:1 int chan├ (send(c, 3);send(c, 7)):unit

  11. Basic Ideas (1): Linear Channels c:1 int chan├ send(c, 3):unit c:1 int chan├ recv(c):int ──────────────────── c:1 int chan├ (spawn(fn()=>send(c, 3));recv(c)):int

  12. Basic Ideas (2): Time Tags • c:s1 bool chan, d:t1 bool chan; st├ (recv(c) andalso recv(d)):bool • c:s1 bool chan, d:t1 bool chan; st├ (recv(d) andalso recv(c)):bool

  13. Basic Ideas (2): Time Tags • c:s1 bool chan, d:t1 bool chan; st├(spawn(fn()=>(send(c, true);send(d, false)));recv(d) andalso recv(c)):bool • c:s1 bool chan, d:t1 bool chan; ts├(spawn(fn()=>(send(c, true);send(d, false)));recv(d) andalso recv(c)):bool

  14. Basic Ideas (2): Time Tags • c:s1 bool chan, d:t1 bool chan; st, ts├(spawn(fn()=>(send(c, true);send(d, false)));recv(d) andalso recv(c)):bool

  15. Outline • Introduction • Basic Ideas • Linear Channels [Kobayashi et al. 96] • Time Tags [Kobayashi 97] • Formalization in process calculi • Extension by Usage Annotations [Sumii & Kobayashi 98] • Conclusion

  16. Type Judgment in the Type System ; ├ P  : type environment (mapping from variables to types)  : time tag ordering (binary relation on time tags) • P uses channels according to • the usage specified by  • the order specified by 

  17. Correctness of the Type System • Subject Reduction: ”Reduction preserves well-typedness" , c:t1 int chan; ├ (spawn(fn()=>send(c, 3)); let v = recv(c) in )  , c:t1 int chan; ├ let v = 3 in 

  18. Correctness of the Type System • Partial Confluence: ”Communication on linear channelswon't cause non-determinism" ; ├ PandQ 1P Q'  Q * R * Q'for someR

  19. Correctness of the Type System • Partial Deadlock-Freedom: ”Non-cycliccommunication on linear channelswon't cause deadlock" ; ├ P  P Qfor someQ Unless P is trying to receive/send a valuefrom/to some channel typed asptm chanwhere eitherm 1,t+t,p =or

  20. Outline • Introduction • Basic Ideas • Linear Channels [Kobayashi et al. 96] • Time Tags [Kobayashi 97] • Formalization in process calculi • Extension by Usage Annotations [Sumii & Kobayashi 98] • Conclusion

  21. Generalize Linear Channels by Usage Annotations U (usage) ::= O (output) | I.U (input & sequential execution) | U|V (concurrent execution) | !U (replication) | - (none) • c:(O|O|I.I.-)t int chan; ├ (spawn(fn()=>send(c, 3)); spawn(fn()=>send(c, 7)); let v = recv(c) w = recv(c) in )

  22. Generalize Linear Channels by Usage Annotations Annotate I’s and O’s with • Capability (c)“The input/output will succeed (if it is performed)” • Obligation (o)“The input/output must be performed (though it won’t succeed)” • "Deadlock" if these assumptions don't hold

  23. Generalize Linear Channels by Usage Annotations “For every I/O with capability,a corresponding O/I with obligation” • c:(Oo|Ic.-)t int chan; ├ (spawn(fn()=>send(c, 3)); let v = recv(c) in ) • c:(Oo|Ic.-)t int chan; ├ let v = recv(c) in 

  24. Generalize Linear Channels by Usage Annotations We can uniformly express usage of • Linear Channels Oco|(Ico.-) • “Semaphore” Channels Oo|!(Ic.Oo) • “Client-Server” Channels !Oc|!(Io.-) etc.

  25. Usage as LL-Formula [| _ |] : Usage LLFormula [| Oco|] = m [|Ico.U|] = m [| U |] [| Oc|] = m 1 [| Ic.U|] = (m [| U |]) 1 [| Oo|] = m& 1 [| Io.U|] = (m [| U |])& 1 [| O|] = (m& 1) 1[| I.U|] = ((m [| U |])& 1) 1 [|U|V|] ＝ [| U |]  [| V |] [|-|] ＝ 1 [|!U|] ≒! [| U |]

  26. Usage as LL-Formula U is a “reliable” usage i.e., For every I/O with capability,a corresponding O/I with obligation exists  [| U |] always reduces to1 i.e., no unexpected garbage (producer/consumer) remains e.g.[| Oo|Ic.- |] 1  (m& 1) ((m1) 1)1

  27. Conclusion Summary:“Resource- & order-conscious” type system with linear channels & time tags Future Work • Type Inference Algorithm for Usage Annotations (Cf. for time tag ordering [Kobayashi 97], for linear channels [Igarashi & Kobayashi 97]) • Aggressive Optimization by the Type Information • Semantics of Time Tag Ordering • Linear Logic with Sequencing Operator?

More Related