Synchronization via scheduling

Abstract

Shared state access conflicts are one of the greatest sources of error for fine grained parallelism in any domain. Notoriously hard to debug, these conflicts reduce reliability and increase development time. The standard task graph model dictates that tasks with potential conflicting accesses to shared state must be linked by a dependency, even if there is no explicit logical ordering on their execution. In cases where it is difficult to understand if such implicit dependencies exist, the programmer often creates more dependencies than needed, which results in constrained graphs with large monolithic tasks and limited parallelism.We propose a new technique, Synchronization via Scheduling (SvS), that uses the results of static and dynamic code analysis to manage potential shared state conflicts by exposing the data accesses of each task to the scheduler. We present an in-depth performance analysis of SvS via examples from video games, our target domain, and show that SvS performs well in comparison to software transactional memory (TM) and fine grained mutexes.

Atomic dataflow model

“…We omit the details of the Node class and refer the reader to Intel TBB documentation [Intel (2007-)] for the details of the multifunction node, the join node and the continue msg classes. strategies require discipline in acquiring the locks, which was demonstrated by previous research [Abdelkhalek & Bilas (2004), Best et al (2011)] and also in Section 5.2.…”

“…Without the loss of generality, in this work we use the QuakeSquad game engine benchmark [Best et al (2011)] to describe the problems related to the game engine parallelization that apply to many MMOG games, especially first-person shooters, role playing games and real-time strategies. We show that hybrid dataflow models decrease the complexity of the parallel game engine implementation by eliminating or restructuring the explicit synchronization that is necessary in shared memory implementations.…”

“…Due to its complexity, the Quake game engine was substituted as a research application by its derivatives, such as the SynQuake benchmark [Lupei et al (2010)] and the QuakeSquad benchmark [Best et al (2011)]. These benchmarks capture the essential computational patterns and data structures found in commercial video games, such as Quake, while remaining simple enough for meaningful testing.…”

“…A more practical solution is to employ coarse-grained locking. For example, the approach proposed in [Best et al (2011)] associates a single lock for each grid cell and processes all objects in a given grid cell by first acquiring the locks of all adjacent cells. Note that this approach requires a programmer to adopt a predetermined order of acquiring the locks to guarantee a deadlock-free execution.…”

“…Hence, these are work-sharing implementations and variants of the region-based locking proposed in [Abdelkhalek & Bilas (2004)]. Instead of a complex finegrained locking scheme, we implement the coarse-grained locking of grid cells, in accordance with the lock-based implementation used in [Best et al (2011)]. Specifically, we associate a dedicated lock for each grid cell and apply a predefined order of locking to avoid deadlocks: each cell task first tries to acquire its own lock, and then the locks of adjacent grid cells, starting from the upper-left neighbor and moving clockwise.…”