Optimistic Execution Research Articles

Virtual Time III, Part 3: Throttling and Message Cancellation

This is Part 3 of a trio of papers that unify in a natural way the two historically distinct parallel discrete event synchronization paradigms, optimistic and conservative, combining the best properties of both into a single framework called Unified Virtual Time (UVT) . In this part we survey the synchronization effects that can be achieved by restricting to corner cases the relationships permitted among the control variables, GVT , CVT , TVT , and LVT , which were defined in Part 1 . We also survey various throttling policies from the literature and describe how they can be implemented in UVT by controlling the value of TVT , including policies that can take advantage of rollback in addition to LP blocking. A significant result is a new category of efficient and higher precision throttling algorithms for optimistic execution that are based on optimistic lookahead , defined in a way that is symmetric to what we now call the conservative lookahead information that is traditionally used for conservative synchronization. Finally, we present a novel algorithm allowing the choice between lazy and aggressive cancellation to be made on a message-by-message basis using either external logic expressed in the model code, or policy code internal to the simulator, or a mixture of both.

An Axiomatic Theory for Reversible Computation

Undoing computations of a concurrent system is beneficial in many situations, such as in reversible debugging of multi-threaded programs and in recovery from errors due to optimistic execution in parallel discrete event simulation. A number of approaches have been proposed for how to reverse formal models of concurrent computation, including process calculi such as CCS, languages like Erlang, and abstract models such as prime event structures and occurrence nets. However, it has not been settled as to what properties a reversible system should enjoy, nor how the various properties that have been suggested, such as the parabolic lemma and the causal-consistency property, are related. We contribute to a solution to these issues by using a generic labelled transition system equipped with a relation capturing whether transitions are independent to explore the implications between various reversibility properties. In particular, we show how all properties we consider are derivable from a set of axioms. Our intention is that when establishing properties of some formalism, it will be easier to verify the axioms rather than proving properties such as the parabolic lemma directly. We also introduce two new properties related to causal-consistent reversibility, namely causal liveness and causal safety, stating, respectively, that an action can be undone if (causal liveness) and only if (causal safety) it is independent from all of the following actions. These properties come in three flavours: defined in terms of independent transitions, independent events, or via an ordering on events. Both causal liveness and causal safety are derivable from our axioms.

Fast intensive validation on blockchain with scale-out dispute resolution

Blockchain heralds the dawn of decentralized applications that coordinate proper computations without requiring prior trust. Existing blockchain solutions, however, are incapable of dealing with intensive validation. Duplicated execution results in limited throughput and unacceptably high costs. Furthermore, the absence of secure incentive mechanisms derives undesired dilemmas among rational verifiers.In this work, we present Lever-FS, a practical blockchain validation framework that makes intensive validation cost-efficient and incentive-compatible among rational verifiers. It is faster than previous constructions since full-fledged scalability is achieved over optimistic execution, dispute resolution, and backbone confirmation of every potential workload. Lever-FS first curtails the scale of each validation to a single node and introduces novel challenge-response games between potential adversaries and rational participants, optimistically optimizing validation redundancy according to the practical adversarial capability confronted. When there is a rich and stubborn adversary, the backstop protocol is then activated to resolve intricate disputes via a threshold voting supported by concurrent redundant executions. Throughout the game, compelling incentive design efficiently transfers the adversary’s budget to proliferated task rewards for subsequent executions, therefore allowing the user to lever sufficient endorsements for the correct verdict with minimum expense. In addition, fair incentive distribution mechanisms are designed to circumvent the well-known Verifier’s Dilemma. Finally, we accelerate Lever-FS with sharding to enable scale-out backbone confirmation, seamless workload balancing, and optimized unanimous assertion across multiple independent validation instances.Experiments reveal that Lever-FS significantly improves the throughput while lowering expenses of intensive validation with a slight tradeoff in latency. Compared to state-of-the-art alternatives, it removes their brittle reliance on altruism, dense interactions, or massive computational power. It is also robust to conceivable attacks on validation and performs distinguishable ability to purify Byzantine participants.

Virtual Time III, Part 1: Unified Virtual Time Synchronization for Parallel Discrete Event Simulation

Algorithms for synchronization of parallel discrete event simulation have historically been divided between conservative methods that require lookahead but not rollback, and optimistic methods that require rollback but not lookahead. In this paper we present a new approach in the form of a framework called Unified Virtual Time (UVT) that unifies the two approaches, combining the advantages of both within a single synchronization theory. Whenever timely lookahead information is available, a logical process (LP) executes conservatively using an irreversible event handler. When lookahead information is not available the LP does not block, as it would in a classical conservative execution, but instead executes optimistically using a reversible event handler. The switch from conservative to optimistic synchronization and back is decided on an event-by-event basis by the simulator, transparently to the model code. UVT treats conservative synchronization algorithms as optional accelerators for an underlying optimistic synchronization algorithm, enabling the speed of conservative execution whenever it is applicable, but otherwise falling back on the generality of optimistic execution. We describe UVT in a novel way, based on fundamental invariants, monotonicity requirements, and synchronization rules. UVT permits zero-delay messages and pays careful attention to tie-handling using superposition. We prove that under fairly general conditions a UVT simulation always makes progress in virtual time. This is Part 1 of a trio of papers describing the UVT framework for PDES, mixing conservative and optimistic synchronization and integrating throttling control.

Graphical Analysis of Rollback Process in Ad Hoc Distributed Traffic Simulation

Recent advancements in sensor, mobile computing, and wireless communication technologies is creating new opportunities to effectively exploit real-time traffic data. Onboard vehicles collect, process, simulate traffic states in a distributed fashion and a local transportation management center coordinates the overall simulation with an optimistic execution technique. Such a distributed approach can provide more up-to-date and robust estimates with decreased communication bandwidth requirements and increased computing capacity. This paper proposes an online ad hoc distributed simulation. The physical operating platform for the model including operating system, communicational middleware, and traffic simulation model are described. Also, this paper investigates the analytical background of rollback process of the proposed ad hoc distributed simulation model. Flow rate diagram and cumulative number of vehicle diagram show that the overall system simulation speed and estimate accuracy may differ significantly as a function of the selected threshold.

A novel view on bounding execution demand under mixed-criticality EDF

In this paper, we are concerned with scheduling a mix of high-criticality (HI) and low-criticality (LO) tasks under Earliest Deadline First (EDF) on one processor. To this end, the system implements two operation modes, LO and HI mode. In LO mode, HI tasks execute for no longer than their optimistic execution budgets and are scheduled together with the LO tasks. The system switches to HI mode, where all LO tasks are prevented from running, when one or more HI tasks run for longer than expected. Since these mode changes may happen at arbitrary points in time, it is difficult to find an accurate bound on carry-over jobs, i.e., those HI jobs that were released before, but did not finish executing at the point of the transition. To overcome this problem, we propose a technique that works around the computation of carry-over execution demand. Basically, the proposed technique separates the schedulability analysis of the transition between LO and HI mode from that of stable HI mode. We prove that a transition from LO to HI mode is feasible, if an equivalent task set derived from the original is schedulable under plain EDF. On this basis, we can apply approximation techniques such as, e.g., the well-known Devi’s test to derive further tests that trade off accuracy versus complexity/runtime. Finally, we perform a detailed comparison with respect to weighted schedulability on synthetic data illustrating benefits by the proposed technique.

FireLedger

Blockchains are distributed secure ledgers to which transactions are issued continuously and each block of transactions is tightly coupled to its predecessors. Permissioned blockchains place special emphasis on transactions throughput. In this paper we present FireLedger, which leverages the iterative nature of blockchains in order to improve their throughput in optimistic execution scenarios. FireLedger trades latency for throughput in the sense that in FireLedger the last f + 1 blocks of each node's blockchain are considered tentative, i.e., they may be rescinded in case one of the last f + 1 blocks proposers was Byzantine. Yet, when optimistic assumptions are met, a new block is decided in each communication step, which consists of a proposer that sends only its proposal and all other participants are sending a single bit each. In our performance study FireLedger obtained 20% -- 600% better throughput than state of the art protocols like HotStuff and BFT-SMaRt, depending on the configuration.

Scalable Byzantine Consensus via Hardware-Assisted Secret Sharing

The surging interest in blockchain technology has revitalized the search for effective Byzantine consensus schemes. In particular, the blockchain community has been looking for ways to effectively integrate traditional Byzantine fault-tolerant (BFT) protocols into a blockchain consensus layer allowing various financial institutions to securely agree on the order of transactions. However, existing BFT protocols can only scale to tens of nodes due to their $O(n^2)$ message complexity. In this paper, we propose FastBFT, a fast and scalable BFT protocol. At the heart of FastBFT is a novel message aggregation technique that combines hardware-based trusted execution environments (TEEs) with lightweight secret sharing primitives. Combining this technique with several other optimizations (i.e., optimistic execution, tree topology and failure detection), FastBFT achieves low latency and high throughput even for large scale networks. Via systematic analysis and experiments, we demonstrate that FastBFT has better scalability and performance than previous BFT protocols.

Mobile computing traffic simulation framework

Recent advancements in sensor, mobile computing, and wireless communication technologies have created an opportunity for mobile computing and online traffic simulations. This paper presents a distributed traffic simulation framework where traffic simulation and data processing are performed in a distributed fashion by mobile computing. In this framework, communication middleware and traffic simulation are integrated to manage the distributed network to synchronize traffic predictions among logical processes using a rollback-based optimistic synchronization protocol. The traffic predictions across the multiple logical processes are coordinated by optimistic execution inspired by Time Warp which mitigates the synchronization problem allowing each logical process to execute asynchronously. Invalidated estimates are updated quickly by this mechanism to ensure more robust and reliable estimates. This framework allows each mobile computing based in-vehicle simulation to model a small portion of the overall network and provide detailed traffic state information. Such a system could provide both more up-to-date and robust predictions than that offered by centralized simulations within a single transportation management center. As these systems evolve, the mobile computing online traffic predictions can be used in surface transportation management and travelers will benefit from more accurate and reliable traffic forecast.

Transparent optimistic synchronization in the high-level architecture via time-management conversion

Distributed simulation allows the treatment of large/complex models by having several interacting simulators running concurrently, each one in charge of a portion of the model. In order to effectively manage integration and interoperability aspects, the standard known as High Level Architecture (HLA) has been developed, which is based on a middleware component known as Run-Time-Infrastructure (RTI). One of the main issues faced by such a standard is synchronization, so that HLA supports both conservative and optimistic approaches. However, technical issues, combined with some peculiarities of the optimistic approach, force most simulators to use the conservative approach. In order to tackle these issues, we present the design and implementation of a Time Management Converter (TiMaC) for HLA based simulation systems. TiMaC is a state machine designed to be transparently interposed between the application layer and the underlying RTI, which performs mapping of the conservative HLA synchronization interface onto the optimistic one. Such a mapping allows transparent optimistic execution (and the related benefits) for simulators originally designed to rely on conservative synchronization. This is achieved without the need to modify the RTI services or alter the HLA standard. An experimental evaluation demonstrating the viability and effectiveness of our proposal is also reported, by integrating our TiMaC implementation with the Georgia Tech B-RTI package and running on it both (A) benchmarks relying on traces from simulated demonstration exercises collected using the Joint Semi-Automated Forces (JSAF) simulation program and (B) a self-federated Personal Communication System simulation application.

Circuit design of a dual-versioning L1 data cache

This paper proposes a novel L1 data cache design with dual-versioning SRAM cells (dvSRAM) for chip multi-processors that implement optimistic concurrency proposals. In this cache architecture, each dvSRAM cell has two cells, a main cell and a secondary cell, which keep two versions of the same logical data. These values can be accessed, modified, moved back and forth between the main and secondary cells within the access time of the cache. We design and simulate a 32KB dual-versioning L1 data cache and introduce three well-known use cases that make use of optimistic concurrency execution that can benefit from our proposed design.

Coarse-grained transactions

Traditional transactional memory systems suffer from overly conservative conflict detection, yielding so-called false conflicts, because they are based on fine-grained, low-level read/write conflicts. In response, the recent trend has been toward integrating various abstract data-type libraries using ad-hoc methods of high-level conflict detection. These proposals have led to improved performance but a lack of a unified theory has led to confusion in the literature. We clarify these recent proposals by defining a generalization of transactional memory in which a transaction consists of coarse-grained (abstract data-type) operations rather than simple memory read/write operations. We provide semantics for both pessimistic (e.g. transactional boosting) and optimistic (e.g. traditional TMs and recent alternatives) execution. We show that both are included in the standard atomic semantics, yet find that the choice imposes different requirements on the coarse-grained operations: pessimistic requires operations be left-movers, optimistic requires right-movers. Finally, we discuss how the semantics applies to numerous TM implementation details discussed widely in the literature.

Reversible discrete event formulation and optimistic parallel execution of vehicular traffic models

Vehicular traffic simulations are useful in applications such as emergency planning and traffic management, for rapid response and resilience. Here, a parallel traffic simulation approach is presented that reduces the time for simulating emergency vehicular traffic scenarios. We use a reverse computation-based optimistic execution approach to parallel execution of microscopic, vehicular-level models of traffic. The unique aspects of this effort are: exploration of optimistic simulation of vehicular traffic; addressing the related reverse computation challenges; achieving absolute, as opposed to self-relative, speedup. The design, development and performance study of the parallel simulation system is presented, demonstrating excellent sequential and parallel performance. A speed up of nearly 20 on 32 processors is observed on a vehicular network of 65,000 intersections and 13 million vehicles.

Fair multi-party contract signing using private contract signatures

A multi-party contract signing protocol allows a set of participants to exchange messages with each other with a view to arriving in a state in which each of them has a pre-agreed contract text signed by all the others. Garay and Mackenzie (GM) proposed such protocol based on private contract signatures, but it was later shown to be flawed by Chadha, Kremer and Scedrov (CKS); the authors CKS also provided a fix to the GM protocol by revising one of its sub-protocols. We show an attack on the revised GM protocol for any number ( n > 4) of signers. Furthermore, we argue that our attack shows that the message exchange structure of GM’s main protocol is flawed: whatever the trusted party does will result in unfairness for some signer. This means that it is impossible to define a trusted party protocol for Garay and MacKenzie’s main protocol; we call this “resolve-impossibility”. We propose a new optimistic multi-party contract signing protocol, also based on private contract signatures. We present a proof that our protocol satisfies fairness as well as its formal analysis in NuSMV model checker for the case of five signers. The protocol requires n ( n - 1 ) ( ⌈ n / 2 ⌉ + 1 ) messages to be sent in the optimistic execution, which is about half the number of messages required by the state-of-the-art Baum-Waidner and Waidner protocol, and in contrast with Baum-Waidner and Waidner, it does not use a non-standard notion of a signed contract.

Fault-scalable Byzantine fault-tolerant services

A fault-scalable service can be configured to tolerate increasing numbers of faults without significant decreases in performance. The Query/Update (Q/U) protocol is a new tool that enables construction of fault-scalable Byzantine fault-tolerant services. The optimistic quorum-based nature of the Q/U protocol allows it to provide better throughput and fault-scalability than replicated state machines using agreement-based protocols. A prototype service built using the Q/U protocol outperforms the same service built using a popular replicated state machine implementation at all system sizes in experiments that permit an optimistic execution. Moreover, the performance of the Q/U protocol decreases by only 36% as the number of Byzantine faults tolerated increases from one to five, whereas the performance of the replicated state machine decreases by 83%.

Using reordering technique for mobile transaction management in broadcast environments

As computer hardware and wireless network technologies are developed to a high degree, there are many research efforts which intend to utilize data broadcasting to a large population of mobile clients through wireless channels. In recent years, different models of data delivery have been explored, particularly the periodic push model where the server repetitively disseminates information without any explicit request. In this paper, we devise new transaction processing algorithms, O-Post for update transactions and O-Pre for read-only transactions, in broadcast environments. Basically, each client executes its transactions in an optimistic manner and does some consistency checks based on periodic invalidation reports. When any kind of conflicts is found, the conflict order is determined according to the notion of reordering and the remaining operations are executed to hold the decision. We also develop a cache algorithm to cope with frequent restarts due to the optimistic execution. Experimental results are given to show the benefits of the proposed algorithms.

Fornax: Web-based distributed discrete event simulation in Java

In this paper we present an environment for the development of Java-based discrete event simulations. An integrated approach is taken that combines discrete event semantics with Java and exceeds the expressiveness of discrete event libraries. The environment supports advanced techniques including distributed evaluation with conservative or optimistic event execution using the Time Warp protocol. We present some performance results and discuss the difficulties encountered with Parallel Discrete Event Simulation. © 1998 John Wiley & Sons, Ltd.

A distributed event processing method for general purpose computation

Previous proposals for the application of discrete event oriented methods to automatic parallelization have been based on the optimistic execution strategy. In this paper we present a new method which avoids optimistic execution. This is motivated by the observation that the control structure of a conventional program constitutes a temporal coordinate system which is exogenous to the program execution. The method employs a logical time mechanism and provides adaptive synchronisation for the distributed execution. Hence Data dependent and/or conditional parallelism is released without the risk of coherency violation. The paper begins with a brief introduction to Parallel Discrete Event Simulation (PDES) paradigm. Efficient coarse grain mapping of conventional programs onto this paradigm is then discussed.

Adaptive flow control in time warp

It is well known that Time Warp may suffer from poor performance due to excessive rollbacks caused by overly optimistic execution. Here we present a simple flow control mechanism using only local information and GVT that limits the number of uncommitted messages generated by a processor, thus throttling overly optimistic TW execution. The flow control scheme is analogous to traditional networking flow control mechanisms. A ``window'' of messages defines the maximum number of uncommitted messages allowed to be scheduled by a process. Committing messages is analogous to acknowledgments in networking flow control. The initial size of the window is calculated using a simple analytical model that estimates the instantaneous number of messages that a process will eventually commit. This window is expanded so that the process may progress up to the next commit point (generally the next fossil collection), and to accommodate optimistic execution. The expansions to the window are based on monitoring TW performance statistics so the window size automatically adapts to changing program behaviors.The flow control technique presented here is simple and fully automatic. No global knowledge or synchronization (other than GVT) is required. We also develop an implementation of the flow control scheme for shared memory multiprocessors that uses dynamically sized pools of free message buffers. Experimental data indicates that the adaptive flow control scheme maintains high performance for "balanced workloads'', and achieves as much as a factor of 7 speedup over unthrottled TW for certain irregular workloads.

Estimating the cost of throttled execution in time warp

Over-optimistic execution has long been identified as a major performance bottleneck in Time Warp based parallel simulation systems. An appropriate throttle or control of optimism can improve performance by reducing the number of rollbacks. However, the design of an appropriate throttle is a difficult task, as correct computations on the critical path may be blocked, thus increasing the overall execution time. In this paper we build a cost model for throttled execution that involves both rollback probability and probability for an event computation being on the critical path. The model can estimate an appropriate size of time window for a throttled execution using statistics collected from the purely optimistic execution. The model is validated by an experimental study with a set of synthetic workloads.