Memory-mapping support for reducer hyperobjects

Lee, I-Ting Angelina; Shafi, Aamir; Leiserson, Charles E.

doi:10.1145/2312005.2312056

Cited by 10 publications

(3 citation statements)

References 26 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…MIT's Cilk [4] was the main framework that modernized this old idea and provided some provable properties around it. Since then, many frameworks have sought to optimize work stealing via providing better task queue implementations [8], alternative victim selection strategies [11], efficiently supporting reduction operations across tasks [28], as well as providing architectural support for work stealing in heterogeneous environments [3,10,44]. Nonetheless, server workloads usually employ shared-rather than per-core-queues, since there is no locality or dependency across requests, and the metric of interest is individual requests' response time, rather than throughput or latency of the entire job [34].…”

Section: Related Workmentioning

confidence: 99%

μSteal

Mirhosseini

Wenisch

2021

Proceedings of the ACM International Conference on Supercomputing

View full text Add to dashboard Cite

Modern internet services are moving towards distributed microservice architectures, wherein a complex application is decomposed into numerous discrete microservices to improve programmability, reliability, manageability, and scalability. A key property of microservice-based architectures is that common microservices may be shared by multiple end-to-end cloud services. As an example, a speech-recognition microservice might serve as an early node in the microservice graphs of several end-to-end services. However, given the dissimilarities across microservice graphs and varying end-to-end latency constraints across services, shared microservices may need to operate under differing latency constraints for each service. As a result, in existing systems, most providers either deploy multiple instance pools for each latency constraint, or require all requests to needlessly meet the most stringent constraint.In this paper, we argue that sharing microservice instances across multiple services can reduce significantly the number of instances, especially under highly asymmetric latency constraints. We propose a request scheduling mechanism, called Steal, which leverages preemptive work and resource stealing to schedule the arriving requests to cores within a "mixed-criticality" microservice instance.Steal provisions "core reservations" for each request class based on their latency requirements, but allows a class to steal cores from other classes if they would otherwise remain idle. But, when a class requires its full reservation, Steal preempts stolen cores, returning them to their reserved class. Steal employs a runtime feedback controller augmented by a queuing theory-based analytical model to tune core reservations across classes, seeking to maximize the request throughput within each instance while meeting all classes' latency constraints. We show that Steal reduces required instances for several shared microservice deployments by 1.29× as compared to deploying multiple, segregated instance pools. CCS CONCEPTS• Computer systems organizations → Multi-core architectures; • Network → Cloud computing.

show abstract

Section: Related Workmentioning

confidence: 99%

μSteal

Mirhosseini

Wenisch

2021

Proceedings of the ACM International Conference on Supercomputing

View full text Add to dashboard Cite

show abstract

“…A reducer (hyperobject) [38,68] is a general parallel reduction mechanism provided by Cilk Plus and other dialects of Cilk. A reducer is defined on an arbitrary data type T , called a view type, by defining an IDENTITY operator and a binary REDUCE operator for views of type T .…”

Section: Data-graph Computations That Modify Global Variablesmentioning

confidence: 99%

Executing dynamic data-graph computations deterministically using chromatic scheduling

Kaler¹,

Hasenplaugh²,

Schardl³

et al. 2014

Proceedings of the 26th ACM Symposium on Parallelism in Algorithms and Architectures

Self Cite

View full text Add to dashboard Cite

A data-graph computation -popularized by such programming systems as Galois, Pregel, GraphLab, PowerGraph, and GraphChi -is an algorithm that performs local updates on the vertices of a graph. During each round of a data-graph computation, an update function atomically modifies the data associated with a vertex as a function of the vertex's prior data and that of adjacent vertices. A dynamic data-graph computation updates only an active subset of the vertices during a round, and those updates determine the set of active vertices for the next round.This paper introduces PRISM, a chromatic-scheduling algorithm for executing dynamic data-graph computations. PRISM uses a vertex-coloring of the graph to coordinate updates performed in a round, precluding the need for mutual-exclusion locks or other nondeterministic data synchronization. A multibag data structure is used by PRISM to maintain a dynamic set of active vertices as an unordered set partitioned by color. We analyze PRISM using work-span analysis. Let G = (V, E) be a degree-∆ graph colored with χ colors, and suppose that Q ⊆ V is the set of active vertices in a round. Define size(Q) = |Q| + v∈Q deg(v), which is proportional to the space required to store the vertices of Q using a sparsegraph layout. We show that a P-processor execution of PRISM performs updates in Q using O(χ(lg(Q/χ) + lg ∆) + lg P) span and Θ(size(Q) + χ + P) work. These theoretical guarantees are matched by good empirical performance. We modified GraphLab to incorporate PRISM and studied seven application benchmarks on a 12-core multicore machine. PRISM executes the benchmarks 1.2-2.1 times faster than GraphLab's nondeterministic lock-based scheduler while providing deterministic behavior. This paper also presents PRISM-R, a variation of PRISM that executes dynamic data-graph computations deterministically even when updates modify global variables with associative operations. PRISM-R satisfies the same theoretical bounds as PRISM, but its implementation is more involved, incorporating a multivector data structure to maintain an ordered set of vertices partitioned by color.

show abstract

“…Many modern concurrency platforms provide some form of reduction mechanism [18,22,25,28,34,39,42,45] to support safe parallel updates to shared variables. A reduction mechanism coordinates parallel updates to a shared variable by applying the parallel updates to distinct views of the variable.…”

Section: Introductionmentioning

confidence: 99%

Efficiently Detecting Races in Cilk Programs That Use Reducer Hyperobjects

Lee

Schardl²

2015

Proceedings of the 27th ACM Symposium on Parallelism in Algorithms and Architectures

Self Cite

View full text Add to dashboard Cite

A multithreaded Cilk program that is ostensibly deterministic may nevertheless behave nondeterministically due to programming errors in the code. For a Cilk program that uses reducers, a general reduction mechanism supported in various Cilk dialects, such programming errors are especially challenging to debug, because the errors can expose the nondeterminism in how the Cilk runtime system manages a reducer.We identify two unique types of races that arise from incorrect use of reducers in a Cilk program and present two algorithms to catch them. The first algorithm, called the Peer-Set algorithm, detects view-read races, which occur when the program attempts to retrieve a value out of a reducer when the read may result a nondeterministic value, such as before all previously spawned subcomputations that might update the reducer have necessarily returned. The second algorithm, called the SP+ algorithm, detects determinacy races, instances where a write to a memory location occurs logically in parallel with another access to that location, even when the raced-on memory locations relate to reducers. Both algorithms are provably correct, asymptotically efficient, and can be implemented efficiently in practice. We have implemented both algorithms in our prototype race detector, Rader. When running Peer-Set, Rader incurs a geometric-mean multiplicative overhead of 2.32 over running the benchmark without instrumentation. When running SP+, Rader incurs a geometric-mean multiplicative overhead of 16.76.

show abstract

Memory-mapping support for reducer hyperobjects

Cited by 10 publications

References 26 publications

μSteal

μSteal

Executing dynamic data-graph computations deterministically using chromatic scheduling

Efficiently Detecting Races in Cilk Programs That Use Reducer Hyperobjects

Contact Info

Product

Resources

About