Download - Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo
![Page 1: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/1.jpg)
Linear Type Systemsfor Concurrent Languages
Eijiro SumiiNaoki Kobayashi
University of Tokyo
![Page 2: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/2.jpg)
Merit and Demerit of Concurrent Languages
Compared with sequential languagesMerit: 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
![Page 3: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/3.jpg)
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 *)
![Page 4: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/4.jpg)
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! *)
![Page 5: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/5.jpg)
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:
![Page 6: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/6.jpg)
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! *)
![Page 7: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/7.jpg)
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 TagsRationale:
Type systems are usually compositional & tractable(unlike model checking, abstract interpretation, etc.)
![Page 8: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/8.jpg)
Outline
IntroductionBasic Ideas
Linear Channels [Kobayashi et al. 96] Time Tags [Kobayashi 97]
Formalization in process calculiExtension by Usage Annotations
[Sumii & Kobayashi 98]
Conclusion
![Page 9: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/9.jpg)
Basic Ideas (1): Linear Channels
c : pm chanp (polarity) ::= (output) | (input)
| (both) | (none)“In which direction c can be used”
m (multiplicity) ::= 1 (exactly once) | (any times)
“How many times c can be used” c:1 int chan├ send(c, 3):unit c:1 int chan├ recv(c):int
![Page 10: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/10.jpg)
Basic Ideas (1): Linear Channels
c : pm chanp (polarity) ::= (output) | (input)
| (both) | (none)“In which direction c can be used”
m (multiplicity) ::= 1 (exactly once) | (any times)
“How many times c can be used” c:1 int chan├ send(c, 3):unit c:1 int chan├ (send(c, 3); send(c, 7)):unit
![Page 11: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/11.jpg)
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
![Page 12: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/12.jpg)
Basic Ideas (2): Time Tags
c:s1 bool chan,
d:t1 bool chan; st├
(recv(c) andalso recv(d)):bool
c:s1 bool chan,
d:t1 bool chan; st├
(recv(d) andalso recv(c)):bool
![Page 13: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/13.jpg)
Basic Ideas (2): Time Tags
c:s1 bool chan,
d:t1 bool chan; st├
(spawn(fn()=>(send(c, true); send(d, false))); recv(d) andalso recv(c)):bool
c:s1 bool chan,
d:t1 bool chan; ts├
(spawn(fn()=>(send(c, true); send(d, false))); recv(d) andalso recv(c)):bool
![Page 14: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/14.jpg)
Basic Ideas (2): Time Tags
c:s1 bool chan,
d:t1 bool chan; st, ts├
(spawn(fn()=>(send(c, true); send(d, false))); recv(d) andalso recv(c)):bool
![Page 15: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/15.jpg)
Outline
IntroductionBasic Ideas
Linear Channels [Kobayashi et al. 96] Time Tags [Kobayashi 97]
Formalization in process calculiExtension by Usage Annotations
[Sumii & Kobayashi 98]
Conclusion
![Page 16: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/16.jpg)
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
![Page 17: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/17.jpg)
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
![Page 18: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/18.jpg)
Correctness of the Type System
Partial Confluence:”Communication on linear channels
won't cause non-determinism"; ├ P and Q 1 P Q'
Q * R * Q' for some R
![Page 19: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/19.jpg)
Correctness of the Type System
Partial Deadlock-Freedom:”Non-cyclic communication on linear channels
won't cause deadlock"; ├ P
P Q for some Q
Unless P is trying to receive/send a valuefrom/to some channel typed as pt
m chan
where either m 1, tt, p = or
![Page 20: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/20.jpg)
Outline
IntroductionBasic Ideas
Linear Channels [Kobayashi et al. 96] Time Tags [Kobayashi 97]
Formalization in process calculiExtension by Usage Annotations
[Sumii & Kobayashi 98]
Conclusion
![Page 21: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/21.jpg)
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 )
![Page 22: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/22.jpg)
Generalize Linear Channels by Usage Annotations
Annotate I’s and O’s withCapability (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
![Page 23: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/23.jpg)
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
![Page 24: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/24.jpg)
Generalize Linear Channels by Usage Annotations
We can uniformly express usage of Linear Channels
Oco|(Ico.-)
“Semaphore” ChannelsOo|!(Ic.Oo)
“Client-Server” Channels!Oc|!(Io.-)
etc.
![Page 25: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/25.jpg)
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 |]
![Page 26: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/26.jpg)
Usage as LL-Formula
U is a “reliable” usagei.e., For every I/O with capability,
a corresponding O/I with obligation exists
[| U |] always reduces to 1
i.e., no unexpected garbage (producer/consumer) remains
e.g.[| Oo|Ic.- |] 1 (m & 1) ((m 1) 1) 1
![Page 27: Linear Type Systems for Concurrent Languages Eijiro Sumii Naoki Kobayashi University of Tokyo](https://reader030.vdocuments.site/reader030/viewer/2022032414/56649ef15503460f94c019e5/html5/thumbnails/27.jpg)
Conclusion
Summary:“Resource- & order-conscious” type system
with linear channels & time tagsFuture 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?