Section: PARSEC Benchmark Suite (7)
Updated: December 2008
Index Return to Main Contents


PARSEC - The Princeton Application Repository for Shared-Memory Computers  


PARSEC is a benchmark suite composed of multithreaded programs. The suite focuses on emerging workloads and was designed to be representative of next-generation shared-memory programs for chip-multiprocessors.

PARSEC differs from other benchmark suites in the following ways:

While serial programs are abundant, they are of limited use for evaluation of multiprocessor machines. PARSEC is one of few benchmark suites that are parallel.
Emerging Workloads
The suite includes emerging workloads which are likely to become important applications in the near future but which are currently not commonly used. Our goal was to provide a collection of applications as might be typical in a few years.
PARSEC does not try to explore a single application domain in detail, as was done by several previous benchmark suites. The selection of included programs is wide and tries to be as representative as possible.
Not HPC-Focused
Computationally intensive, parallel programs are very common in the domain of High-Performance Computing (HPC), but HPC programs are just a small subset of the whole application space. In the future, parallelization techniques will become increasingly popular in other areas as well. The PARSEC suite anticipates this development and tries to avoid a program selection which is skewed towards HPC. It focuses on programs from all domains, such as desktop and server applications.
The suite is primarily intended for research. It can also be used for performance measurements of real machines, but its original purpose is insight, not numbers. Benchmark suites intended for research usually go beyond pure scoring systems and provide infrastructure to instrument and manipulate included programs in an efficient manner.

The PARSEC suite can be interpreted as a high-level problem specification: It is composed of programs for which there is high user demand but which do not run sufficiently fast on current machines. The suite is thus suitable to enable application-driven research. This form of research differs from the conventional approach, which uses benchmarks only as a form of validation at the end of the work, by putting the emphasis on user demand at the beginning of the thought process.  


PARSEC contains the following 13 workloads:
Option pricing kernel that uses the Black-Scholes partial differential equation (PDE).
Body tracking application that is able to locate and follow a marker-less person.
Simulated cache-aware annealing kernel which optimizes the routing cost of a chip design.
Next-generation compression kernel which employs data deduplication.
This application simulates the motions of a human face for animation purposes.
This application is a content similarity search server.
Fluid dynamics application that simulates physics for animation purposes with the Smoothed Particle Hydrodynamics (SPH) method.
A frequent itemset mining application which uses an array-based version of the FP-growth (Frequent Pattern-growth) method.
A real-time raytracing application.
An online clustering kernel.
Application which prices a portfolio of swaptions with the Heath-Jarrow-Morton (HJM) framework.
An image processing application.
An H.264 video encoding application.

PARSEC furthermore offers standardized input sets which are support by each workload. An input set consists of all the arguments expected by the workload as well as any input files necessary. Each workload has the following 6 predefined inputs:

Minimal input to verify that programs are executable. Execution time less than 1 second.
Very small input which causes code execution comparable to a typical input for this program. Intended for microarchitectural simulator development. Execution time less than 1 second.
Small input for performance measurements with microarchitectural simulators. Execution time about 1 second.
Medium-sized input for performance measurements with microarchitectural simulators. Execution time about 3 to 5 seconds.
Large-sized input for performance measurements with microarchitectural simulators. Execution time about 10 to 20 seconds.
Very large input intended for large-scale experiments on real machines. Execution time about 10 to 30 minutes.


The easiest and most common way to use the PARSEC distribution is with the parsecmgmt tool. parsecmgmt allows to build, run and manage the workloads of the PARSEC distribution using a centralized, coherent interface.

It is possible to use PARSEC without parsecmgmt. This requires the manual execution of all the steps that parsecmgmt performs as specified by the configuration files. More details can be found in the section about the configuration files and in the documentation of parsecmgmt.

Workload instrumentation can be facilitated by the PARSEC Hooks Instrumentation API. All workloads call PARSEC hook functions at certain points during their execution if PARSEC hook support has been enabled. By providing a suitable function implementation any type of functionality can be inserted at once into all workloads at build time. An implementation of the PARSEC hook functions is provided by the hooks library that is part of the PARSEC distribution. The specification of the hooks API and details about the use of the hook functions can be found in the documentation of the hooks library.  


PARSEC is composed of packages and the framework. A package typically corresponds to a workload or a library and contains everything that is necessary to build and run the corresponding program. The framework is everything else, such as the PARSEC tools and the documentation. Packages belong to groups and are largely self-contained. The framework provides the mechanisms to make effective use of the packages.

The directory structure of the PARSEC distribution is as follows:

Directory with PARSEC tools
Global configuration files
Log files of builds and runs (dynamically created)
Man pages of the PARSEC distribution
Directory containing all the groups which contain all their packages
PARSEC workloads that are applications
PARSEC workloads that are kernels
Libraries required by other packages
Tools required by other packages
Additional groups that might have been created

Packages have the following directory structure:

Directory with input archives (optional)
Installation directory (dynamically created)
Build directory (dynamically created)
Directory with reference outputs (optional)
Directory with local configuration and other files for the PARSEC framework
Temporary default directory for program execution (dynamically created)
Source code of the package


Files can be global or local. If it is global it logically belongs to the PARSEC framework, if it is local it is associated with a package. It is common that configuration files exist both in a global and local version. In that case the global configuration applies to all packages, and the local configuration is temporarily added to the global configuration to process the package to which it belongs.

There are three fundamental types of configuration files:

System configurations
A system configuration contains all platform-specific information about an operating system. There is exactly one system configuration file for each operating system supported by the framework. They have the suffix .sysconf and exist only in a global version.
Build configurations
A build configuration contains all the information necessary to build packages in a desired way, such as which compiler and what flags to use. Build configuration files have the suffix .bldconf and exist both in a global and a local version. Build configurations can be managed with the bldconfadd and bldconfdel tools.
Run configurations
A run configuration specifies how to execute a workload with a specific input set. There is one run configuration for each supported input set. They have the suffix .runconf and exist both in a global and a local version.

The configuration files are located in the following directories:

Global configuration files
Local configuration files

Besides the general classes of configuration files the following files also exist:
Setup the environment variables of a bash shell to make the PARSEC distribution easier to use. The script has to be sourced to be effective. This step is purely optional.
Central configuration file of the PARSEC benchmark suite that specifies all packages, package groups and aliases.
Hidden dummy file used by the PARSEC tools to recognize that the correct directory has been auto-detected.
A text file containing the version string for the whole benchmark suite.
A text file containing the version string for the package to which it belongs.


PARSEC tools recognize the following environment variables (if applicable):
Path to the root directory of the PARSEC distribution. The tools auto-detect the root directory by using heuristics to search for .parsec-uniquefile, but it is possible to override that behavior with this environment variable.
Unique identifier for the current machine type. The value of this variable is used to separate the build and installation directories for different machine types so they can coexist in a single PARSEC distribution directory. The PARSEC tools automatically determine a value based on the OS and CPU names, but it is possible to override the default value with this environment variable.

If enabled then the PARSEC hooks library adds support for thread affinity to all workloads. By default the mapping of threads to CPUs can then be controlled with the following environment variables:

The maximum number of CPUs to use. Notice that this does not guarantee exclusive access to these CPUs.
The ID of the base CPU to use. The workload will not use any CPUs below that ID. Together with PARSEC_CPU_NUM a logical slice can be defined in which the workload will execute.


Copyright (c) 2006-2009 Princeton University  


parsecmgmt(1), bldconfadd(1), bldconfdel(1), hooks(7)  


C. Bienia, S. Kumar, J. P. Singh, and K. Li. The PARSEC Benchmark Suite: Characterization and Architectural Implications. In Proceedings of the 17th International Conference on Parallel Architectures and Compilation Techniques, October 2008.
C. Bienia, S. Kumar, and K. Li. PARSEC vs. SPLASH-2: A Quantitative Comparison of Two Multithreaded Benchmark Suites on Chip-Multiprocessors. In Proceedings of the 2008 International Symposium on Workload Characterization, September 2008.




This document was created by man2html, using the manual pages.
Time: 04:41:54 GMT, February 24, 2009