English (United Kingdom)

https://curated-unify.zendy.io/wp-json/zendy-region/v1/featured_content/oa?rat=en

https://curated-unify.zendy.io/wp-json/zendy-region/v1/highlighted_journal/

Global: Zendy Plus annual

Presents the access of premium content as premium feature

Premium Content

Presents the keyphrase highlighting as premium feature

Keyphrase Highlighting

Presents the summarisation as premium feature

Summarisation

Insights

Presents the pdf analysis as premium feature

PDF Analysis

Presents the zaia usage as premium feature

ZAIA

Global: Zendy Plus monthly

Global: Zendy Tools annual

Global: Zendy Tools monthly

Global: Zendy Free Plan

A number of problems in parallel computing require reasoning about thedependency structure in parallel programs. For example, dynamic race detectionrelies on efficient "on-the-fly" determination of dependencies betweensequential and parallel tasks (e.g. to quickly determine whether or not twomemory accesses occur in parallel). Several solutions to this "parallel ordermaintenance" problem has been proposed, but they all have several drawbacks,including lack of provable bounds, high asymptotic or practical overheads, andpoor support for parallel execution.  In this paper, we present a solution to the parallel order maintenanceproblem that is provably efficient, fully parallel, and practical. Ouralgorithm -- called DePa -- represents a computation as a graph and encodesvertices in the graph with two components: a dag-depth and a fork-path. In thisencoding, each query requires $O(f/\omega)$ work, where $f$ is the minimumdynamic nesting depth of the two vertices compared, and $\omega$ is theword-size. In the common case (where $f$ is small, e.g., less than 100), eachquery requires only a single memory lookup and a small constant number ofbitwise instructions. Furthermore, graph maintenance at forks and joinsrequires only constant work, resulting in no asymptotic impact on overall workand span. DePa is therefore work-efficient and fully parallel.

DePa: Simple, Provably Efficient, and Practical Order Maintenance for Task Parallelism