Analytical Modeling of Pipeline Parallelism

Navarro, Ángeles; Asenjo, Rafael; Tabik, Siham; Caşcaval, Călin

doi:10.1109/pact.2009.28

Cited by 76 publications

(52 citation statements)

References 18 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…Pipeline parallelism 1 [6,16,17,25,27,28,31,33,35,37] is a well-known parallel-programming pattern that can be used to parallelize a variety of applications, including streaming applications from the domains of video, audio, and digital signal processing. Many applications, including the ferret, dedup, and x264 benchmarks from the PARSEC benchmark suite [4,5], exhibit parallelism in the form of a linear pipeline, where a linear sequence S = S 0 , .…”

Section: Introductionmentioning

confidence: 99%

On-the-fly pipeline parallelism

Lee¹,

Leiserson²,

Schardl³

et al. 2013

Proceedings of the Twenty-Fifth Annual ACM Symposium on Parallelism in Algorithms and Architectures

View full text Add to dashboard Cite

Pipeline parallelism organizes a parallel program as a linear sequence of s stages. Each stage processes elements of a data stream, passing each processed data element to the next stage, and then taking on a new element before the subsequent stages have necessarily completed their processing. Pipeline parallelism is used especially in streaming applications that perform video, audio, and digital signal processing. Three out of 13 benchmarks in PARSEC, a popular software benchmark suite designed for shared-memory multiprocessors, can be expressed as pipeline parallelism.Whereas most concurrency platforms that support pipeline parallelism use a "construct-and-run" approach, this paper investigates "on-the-fly" pipeline parallelism, where the structure of the pipeline emerges as the program executes rather than being specified a priori. On-the-fly pipeline parallelism allows the number of stages to vary from iteration to iteration and dependencies to be data dependent. We propose simple linguistics for specifying on-the-fly pipeline parallelism and describe a provably efficient scheduling algorithm, the PIPER algorithm, which integrates pipeline parallelism into a work-stealing scheduler, allowing pipeline and fork-join parallelism to be arbitrarily nested. The PIPER algorithm automatically throttles the parallelism, precluding "runaway" pipelines. Given a pipeline computation with T 1 work and T ∞ span (critical-path length), PIPER executes the computation on P processors in T P ≤ T 1 /P + O(T ∞ + lg P) expected time. PIPER also limits stack space, ensuring that it does not grow unboundedly with running time.We have incorporated on-the-fly pipeline parallelism into a Cilkbased work-stealing runtime system. Our prototype Cilk-P implementation exploits optimizations such as lazy enabling and dependency folding. We have ported the three PARSEC benchmarks that exhibit pipeline parallelism to run on Cilk-P. One of these, x264, cannot readily be executed by systems that support only construct-and-run pipeline parallelism. Benchmark results indicate that Cilk-P has low serial overhead and good scalability. On x264, for example, Cilk-P exhibits a speedup of 13.87 over its respective serial counterpart when running on 16 processors.

show abstract

Section: Introductionmentioning

confidence: 99%

On-the-fly pipeline parallelism

Lee¹,

Leiserson²,

Schardl³

et al. 2013

Proceedings of the Twenty-Fifth Annual ACM Symposium on Parallelism in Algorithms and Architectures

View full text Add to dashboard Cite

show abstract

“…CFS periodically runs a complex load-balancing algorithm to keep the runqueues of all cores roughly balanced. It can improve the CPU utilization for applications using the pipeline model which often has load imbalance issue [21]. However, thread migrations between cores can be extremely expensive and may significantly hurt cache locality in some cases [22].…”

Section: Task Scheduling Disciplinesmentioning

confidence: 99%

“…The analysis of scalability for pipeline application is very complex because it is not determined by a single path like fork-join applications [21]. Though, we can still shed some light by breaking down the execution time.…”

Section: Dedupmentioning

confidence: 99%

A Comparative Analysis of RTOS and Linux Scalability on an Embedded Many-core Processor

Matsubara

Takada

2018

Journal of Information Processing

View full text Add to dashboard Cite

Current embedded systems are usually based on real-time operating system (RTOS). In the near future, embedded systems will include parallel applications for tasks like autonomous driving, and adopt many-core processors to satisfy the performance requirements. However, traditional RTOSes are not designed for high performance applications and whether they can scale well on many-core processors remains unclear. Meanwhile, research has shown that Linux can provide good scalability for processors with tens of cores. In this paper, an experiment environment based on a traditional multi-core RTOS (TOPPERS/FMP) and an off-the-shelf 72-core many-core processor (TILE-Gx72) is presented. By a comparative analysis of RTOS based and Linux based runtime systems, several bottlenecks in RTOS are identified and the methods to avoid them are proposed. After that, the PARSEC benchmark suite is used to evaluate the performance of RTOS and Linux. The results show that the optimized RTOS runtime system tends to deliver better scalability than Linux in many cases. Therefore, we believe that traditional RTOS like TOPPERS/FMP can still be a good choice for embedded many-core processors in the near future.

show abstract

“…Navarro et al [6] presented an analytical model to describe such type of applications based on queueing theory. The results of the analysis of these models are then used to optimize the application through collapsing of pipeline stages and dynamic scheduling.…”

Section: Related Workmentioning

confidence: 99%

Modeling pipelined application with Synchronous Data Flow graphs

Lattuada

Ferrandi

2013

2013 International Conference on Embedded Computer Systems: Architectures, Modeling, and Simulation (SAMOS)

View full text Add to dashboard Cite

Abstract-Streaming applications can efficiently exploit multiprocessors architectures by means of pipelined parallelism, but designing this type of applications can be an hard task. Different subproblems have indeed to be solved: partitioning, mapping, scheduling and pipeline stage assignment. For this reason, high level abstraction models are adopted during design flow since they simplify this process by hiding most of the architectural details. Synchronous Data Flow (SDF) graphs, widely adopted to describe streaming applications, naturally model only their partitioning, so they usually have to be integrated with other types of representations.In this paper Pipelined Application Modeling (PAM), a methodology to create a Synchronous Data Flow graph describing all the aspects of a pipelined application, is presented. The methodology starts from the SDF graph describing the partitioning of the application and enriches it with new actors and channels detailing the mapping, the scheduling and the pipeline stage assignment of the considered solution. The obtained SDF graph, describing all the aspects of the solution in a formal and compact way, facilitates the evaluation of different solutions during design space exploration.

show abstract

Analytical Modeling of Pipeline Parallelism

Cited by 76 publications

References 18 publications

On-the-fly pipeline parallelism

On-the-fly pipeline parallelism

A Comparative Analysis of RTOS and Linux Scalability on an Embedded Many-core Processor

Modeling pipelined application with Synchronous Data Flow graphs

Contact Info

Product

Resources

About