PARSECSs

Abstract

In this work, we show how parallel applications can be implemented efficiently using task parallelism. We also evaluate the benefits of such parallel paradigm with respect to other approaches. We use the PARSEC benchmark suite as our test bed, which includes applications representative of a wide range of domains from HPC to desktop and server applications. We adopt different parallelization techniques, tailored to the needs of each application, to fully exploit the task-based model. Our evaluation shows that task parallelism achieves better performance than thread-based parallelization models, such as Pthreads. Our experimental results show that we can obtain scalability improvements up to 42% on a 16-core system and code size reductions up to 81%. Such reductions are achieved by removing from the source code application specific schedulers or thread pooling systems and transferring these responsibilities to the runtime system software.

Bringing Parallel Patterns Out of the Corner

“…In the analysis, we focus both on the programming effort and the performance achieved. The comparison is made with the parallel versions already available in PARSEC (Table 1) and with the task-based implementations written in OmpSs and presented in Chasapis et al [17]. 4 Their work covers most of the PARSEC applications, except Raytrace and Vips.…”

“…One of the most interesting aspects of this benchmark suite is that it covers a wide set of application domains, such as streaming, scientific computing, computer vision, and data compression. For this reason, the PARSEC suite has been recently used to assess the expressive power of emerging parallel programming frameworks [17].…”

“…In addition to the programmability advantage, a focal aspect is to precisely assess which is the flexibility and performance gap observed when using high-level methodologies. An interesting work that tries to provide a first answer for task-based programming models is presented in Chasapis et al [17]. The authors showed that the OmpSs porting of a significant subset of the PARSEC benchmark suite [6] does not provide substantial performance degradation with respect to native Pthreads implementations while reducing the programming effort measured in terms of LOCs.…”

“…Despite that a shorter code does not necessarily imply a simpler or better code, evaluating the programming effort in an objective way is a difficult task and no existing metric is universally accepted. We decided to use LOC and code churn since they are often used in several research works as proxy metrics to evaluate programmability [17,51,58]. The patterned implementations achieve an average LOC reduction of 26% (in both FastFlow and SkePU) compared to the native Pthreads implementation (and up to a maximum of 87% for some specific benchmarks).…”

“…The patterned implementations achieve an average LOC reduction of 26% (in both FastFlow and SkePU) compared to the native Pthreads implementation (and up to a maximum of 87% for some specific benchmarks). We also compared such metrics with those of the OpenMP and TBB implementations provided by PARSEC and with the OmpSs implementations described in Chasapis et al [17]. • On three different multicore systems we compare performance of the pattern-based implementations to the one of native Pthreads implementations, with OpenMP and TBB versions provided by PARSEC (when available) and with OmpSs task-based parallelizations.…”