We propose a formal definition for (valid) speculative computations, which is independent of any implementation technique. By speculative computations we mean optimization mechanisms that rely on relaxing the flow of execution in a given program, and on guessing the values read from pointers in the memory. Our framework for formalizing these computations is the standard operational one that is used to describe the semantics of programming languages. In particular, we introduce speculation contexts, that generalize classical evaluation contexts, and allow us to deal with out of order computations. Regarding concurrent programs, we show that the standard DRF guarantee, asserting that data race free programs are correctly implemented in a relaxed semantics, fails with speculative computations, but that a similar guarantee holds for programs that are free of data races in the speculative semantics. 1.

Abstract. Futures are a program abstraction that express a simple yet expressive form of fork-join parallelism. The expression future (e) declares that e can be evaluated concurrently with the future’s continuation. The expression touch (p) where p is a placeholder returned by evaluating a future, blocks until the result of evaluating e is known. Safe futures provide additional deterministic guarantees on the concurrent execution of the future with its continuation, ensuring that all data dependencies found in the original (non-future annotated) version are respected. Earlier work on safe futures and related speculative abstractions have considered their semantics in the context of an otherwise sequential program. When safe futures are integrated within an explicitly concurrent program (e.g., to extract additional concurrency from within a sequential thread of control), the safety conditions necessary to guarantee determinacy of their computations are substantially more complex. In this paper, we present a dynamic analysis for enforcing determinism of safe futures in an ML-like language with dynamic thread creation and first-class references. Our analysis tracks the interaction between futures (and their continuations) with other explicitly defined threads of control, and enforces an isolation property that prevents the effects of a continuation from being witnessed by its future, even indirectly through their interactions with other threads. Our analysis is defined via a novel lightweight capability-based dependence tracking mechanism that serves as a compact representation of an effect history. Implementation results support our contention that the cost of enforcing selective isolation of this kind is modest. 1

concurrent higher-order programs