Schedule (computer science)

Abstract: A method and device for using a computer to facilitate a transaction of secondary market shares of an investment company such as a mutual fund between a buyer and a seller, having the steps of: a customer determining the mutual fund to be traded receiving a schedule of fees from the central controller, the customer selecting the class of shares and inputting the quantity to be traded, the customer selecting the order type and adding any special instructions. The customer then submits the order to the central controller. The central controller will match buyers and sellers and determine which orders were executed. For all executions, the central controller will provide the seller with payments and the buyer with shares in the selected mutual fund.

Abstract: In this paper we consider an optimization problem that arises in the execution of parallel programs on shared-memory multiple-instruction-stream, multiple-data-stream (MIMD) computers A program on such machines consists of many sequential program segments, each executed by a single processor These segments interact as they access shared variables Access to memory is asynchronous, and memory accesses are not necessarily executed in the order they were issued An execution is correct if it is sequentially consistent: It should seem as if all the instructions were executed sequentially, in an order obtained by interleaving the instruction streams of the processors Sequential consistency can be enforced by delaying each access to shared memory until the previous access of the same processor has terminated For performance reasons, however, we want to allow several accesses by the same processor to proceed concurrently Our analysis finds a minimal set of delays that enforces sequential consistency The analysis extends to interprocessor synchronization constraints and to code where blocks of operations have to execute atomically We use a conflict graph similar to that used to schedule transactions in distributed databases Our graph incorporates the order on operations given by the program text, enabling us to do without locks even when database conflict graphs would suggest that locks are necessary Our work has implications for the design of multiprocessors; it offers new compiler optimization techniques for parallel languages that support shared variables

Abstract: A database system optimized for in-memory storage can support much higher transaction rates than current systems. However, standard concurrency control methods used today do not scale to the high transaction rates achievable by such systems. In this paper we introduce two efficient concurrency control methods specifically designed for main-memory databases. Both use multiversioning to isolate read-only transactions from updates but differ in how atomicity is ensured: one is optimistic and one is pessimistic. To avoid expensive context switching, transactions never block during normal processing but they may have to wait before commit to ensure correct serialization ordering. We also implemented a main-memory optimized version of single-version locking. Experimental results show that while single-version locking works well when transactions are short and contention is low performance degrades under more demanding conditions. The multiversion schemes have higher overhead but are much less sensitive to hotspots and the presence of long-running transactions.

Abstract: Multi-Version Concurrency Control (MVCC) is a widely employed concurrency control mechanism, as it allows for execution modes where readers never block writers. However, most systems implement only snapshot isolation (SI) instead of full serializability. Adding serializability guarantees to existing SI implementations tends to be prohibitively expensive. We present a novel MVCC implementation for main-memory database systems that has very little overhead compared to serial execution with single-version concurrency control, even when maintaining serializability guarantees. Updating data in-place and storing versions as before-image deltas in undo buffers not only allows us to retain the high scan performance of single-version systems but also forms the basis of our cheap and fine-grained serializability validation mechanism. The novel idea is based on an adaptation of precision locking and verifies that the (extensional) writes of recently committed transactions do not intersect with the (intensional) read predicate space of a committing transaction. We experimentally show that our MVCC model allows very fast processing of transactions with point accesses as well as read-heavy transactions and that there is little need to prefer SI over full serializability any longer.