Session Types in ATS (NEPLS 15)

Session types offer a type-based discipline for enforcing that communication protocols be correctly followed in distributed programming. In essence, a session type can be assigned to a channel that encodes the protocol in use for communication on the channel and any code that uses the channel must follow the protocol precisely for otherwise the code cannot pass type checking.

Session type originates from Honda, Vasconcelos and Kubo back in 1998, and has since then been further extended and developed by a lot researchers around the world, including but not limited to Caires, Gay, Pfenning, Wadler, Yoshida, etc.

In this talk, we are to show that session types can be readily implemented in ATS, a statically typed programming language equipped with dependent types (of DML-style) and linear types. One particular implementation of session types in ATS translates (session-typed) ATS programs into Erlang code, benefiting directly from Erlang's extensive support for distributed programming. Interesting examples will be given to demonstrate certain usage and benefits of session types.

Transcript

1. Session Types in ATS Hongwei Xi, Hanwen Wu Boston University Nov 2015, NEPLS
2. Overview • Session Types enforce correct implementation of communication protocols in distributed programming. Global progress is guaranteed. • Session Types originates from Honda, Vasconcelos, and Kubo in 1998. Since then, it is further extended and developed by a variety of researchers including Caires, Gay, Pfenning, Wadler, Yoshida, etc. • ATS is a statically typed functional language with DML-style dependent types and linear types. • Session types can be readily implemented in ATS.
3. Introduction Idea: assign proper types to communication channels that conform to the protocol. an example channel’s type (has been simplified): chsnd(int) :: chrcv(bool) :: nil It will be, and can only be used for first sending an integer, then receiving a boolean, and finally terminating communication.
4. Introduction Idea: provided functions will use channels and update their types to conform to protocol. an example function type (has been simplified): fun send {a:vt@ype} {ss:type} (!chan(chsnd(a)::ss) >> chan(ss), a): void a channel’s type before function call (has been simplified): chsnd(int) :: chrcv(bool) :: nil the channel’s type after function call (has been simplified): chrcv(bool) :: nil
5. Session Types in ATS Types of some built-in functions provided by ATS. fun channeg_create {ss:type} (chanpos(ss) -<lincloptr1> void): channeg(ss) fun chanpos_send {a:vt@ype} {ss:type} (!chanpos(chsnd(a)::ss) >> chanpos(ss), a): void fun chanpos_recv {a:vt@ype} {ss:type} (!chanpos(chrcv(a)::ss) >> chanpos(ss)): a fun channeg_nil_close (channeg(chnil)): void Note: • Positive channels are endpoints held by the server side. • Negative channels are endpoints held by the client side.
6. Session Types in ATS Types for some functions in the demo. fun counter (int): channeg (rpt int) fun c_loop (chanpos (rpt int), int): void fun filter (channeg (rpt int), int): channeg (rpt int) fun f_loop (chanpos (rpt int), channeg (rpt int), int): void Note: • rpt int means “the server side repeatedly send integers”.
7. Demo: Prime Number Generator pseudo code: counter_loop(counter, N): send(counter, N) counter_loop(counter, N+1) filter_loop(in, out, P): N = recv(in) if N % P != 0 then send(out, N) else filter_loop(in, out, P) filter(in, P): mod_n = new channel spawn filter_loop(in, mod_n, P) return mod_n primes_loop(in, primes): N = recv(in) send(primes, N) filter_n = filter(in, P) sieve_loop(filter_n, primes)
8. Demo Explained • Demo 1: • Channel is untyped, ConcurrentML style. Its usage is completely unrestricted. • Cons: prone to incorrect usage of channel, which usually causes deadlock, and it is hard to debug. • Demo 2: • Channel is session typed for sending/receiving infinite number of integers. • Pros: channel usage is forced to be correct, e.g. programmers can’t mistakenly use a sending channel for receiving, etc. • Cons: session doesn’t terminate • Demo 3: • Channel is session typed for either continuing to send/receive or terminating. • Pros: channel is forced to be closed after all intended usages. e.g. programmer is forced to close the channel in the end.
9. Demo http://steinwaywhw.github.io/nepls-15-demo/ requires ATS/Erlang/Elixir to be installed
10. Advantages • Global progress (deadlock-free) is guaranteed. • Session protocol is strictly enforced through type checking. • Resource leaking is prevented through linear typed channels. • Extensive support of distributed computing through compiling into Erlang. • ATS co-programming with Erlang. • Asynchronous session. • Session type is part of the language instead of an embedding. Utilizing everything provided by ATS, e.g. dependent type (DML- style), linear type, and proofs.
11. Q&A Thanks! for more info http://steinwaywhw.github.io/nepls-15-demo/
12. Backup • Session types in ATS supports: • dependent types, linear types • high-order sessions (mobile sessions) • dyadic session for now • Implementation details • Sessions are not symmetric. two endpoints are denoted negative(client) and positive(server) respectively. Though symmetric can be implemented in ATS, too. • Global progress is proved based on a formalization of multi- threaded linear lambda calculus extended with channels. • A channel is a process in Erlang.