2016-08-31 CERIAS - Towards Safe In-memory Transactions скачать в хорошем качестве

2016-08-31 CERIAS - Towards Safe In-memory Transactions

Recorded: 08/31/2016 CERIAS Security Seminar at Purdue UniversityTowards Safe In-memory TransactionsSrivatsan Ravi, Purdue UniversityCurrent general-purpose CPUs are multicores, offering multiple computing units within a single chip. The performance of programs on these architectures, however, does not necessarily increase proportionally with the number of cores. Designing concurrent programs to exploit these multicores emphasizes the need for achieving efficient synchronization among threads of computation. When there are several threads that conflict on the same data, the threads will need to coordinate their actions for ensuring correct program behaviour. Traditional techniques for synchronization are based on locking that provides threads with exclusive access to shared data. Coarse-grained locking typically forces threads to access large amounts of data sequentially and, thus, does not fully exploit hardware concurrency. Program-specific fine-grained locking or non-blocking \(i.e., not using locks\) synchronization, on the other hand, is a dark art to most programmers and trusted to the wisdom of a few computing experts. Thus, it is appealing to seek a middle ground between these two extremes: a synchronization mechanism that relieves the programmer of the overhead of reasoning about data conflicts that may arise from concurrent operations without severely limiting the programs performance. The Transactional Memory \(TM\) abstraction is proposed as such a mechanism: it intends to combine an easy-to-use programming interface with an efficient utilization of the concurrent-computing abilities provided by multicore architectures. TM allows the programmer to speculatively execute sequences of shared-memory operations as atomic transactions with all-or-nothing semantics: the transaction can either commit, in which case it appears as executed sequentially, or abort, in which case its update operations do not take effect. Thus, the programmer can design software having only sequential semantics in mind and let TM take care, at run-time, of resolving the conflicts in concurrent executions. \?It is important that the intermediate state witnessed by each transaction be \"\;safe\"\;\; if it is not consistent with any sequential execution, then the application may experience a fatal irrecoverable error or enter an infinite loop. In this talk, we focus on implementing safe TM implementations and the inherent complexities associated with them.\?Srivatsan Ravi is a Postdoctoral researcher/Visiting assistant professor at Purdue University. His research interests are in the theory and practice of distributed computing. \(Visit: www.cerias.purdue.edu\)