We propose a new operational model for shared variable concurrency, in the context of a concurrent, higher-order imperative language àla ML. In our model the scheduling of threads is cooperative, and a non-terminating process suspends itself on each recursive call. A property to ensure in such a model is fairness, that is, any thread should yield the scheduler after some finite computation. To this end, we follow and adapt the classical method for proving termination in typed formalisms, namely the realizability technique. There is a specific difficulty with higher-order state, which is that one cannot define a realizability interpretation simply by induction on types, because applying a function may have side-effects at types not smaller than the type of the function. Moreover, such higher-order side-effects may give rise to computations that diverge without resorting to explicit recursion. We overcome these difficulties by introducing a type and effect system for our language that enforces a stratification of the memory. The stratification prevents the circularities in the memory that may cause divergence, and allows us to define a realizability interpretation of the types and effects, which we then use to prove the intended termination property. © Springer-Verlag Berlin Heidelberg 2007.
CITATION STYLE
Boudol, G. (2007). Fair cooperative multithreading. In Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics) (Vol. 4703 LNCS, pp. 272–286). Springer Verlag. https://doi.org/10.1007/978-3-540-74407-8_19
Mendeley helps you to discover research relevant for your work.