KiloCore: A Fine-Grained 1,000-Processor Array for Task-Parallel Applications

IEEE Micro ◽  
2017 ◽  
Vol 37 (2) ◽  
pp. 63-69 ◽  
Author(s):  
Brent Bohnenstiehl ◽  
Aaron Stillmaker ◽  
Jon Pimentel ◽  
Timothy Andreas ◽  
Bin Liu ◽  
...  
Keyword(s):  
Parallel Applications ◽  
Processor Array ◽  
Fine Grained ◽  
Task Parallel

scholarly journals Scheduling Task-parallel Applications in Dynamically Asymmetric Environments

2020 ◽  
Author(s):  
Jing Chen ◽  
Pirah Noor Soomro ◽  
Mustafa Abduljabbar ◽  
Madhavan Manivannan ◽  
Miquel Pericas
Keyword(s):  
Parallel Applications ◽  
Task Parallel

scholarly journals Characterizing and Mitigating Work Time Inflation in Task Parallel Programs

2013 ◽  
Vol 21 (3-4) ◽  
pp. 123-136 ◽  
Author(s):  
Stephen L. Olivier ◽  
Bronis R. de Supinski ◽  
Martin Schulz ◽  
Jan F. Prins
Keyword(s):  
Poor Performance ◽  
Data Access ◽  
Parallel Applications ◽  
Task Parallelism ◽  
Improve Performance ◽  
Additional Time ◽  
Work Time ◽  
Task Parallel ◽  
Time Required ◽  
Data Access Latency

Task parallelism raises the level of abstraction in shared memory parallel programming to simplify the development of complex applications. However, task parallel applications can exhibit poor performance due to thread idleness, scheduling overheads, andwork time inflation– additional time spent by threads in a multithreaded computation beyond the time required to perform the same work in a sequential computation. We identify the contributions of each factor to lost efficiency in various task parallel OpenMP applications and diagnose the causes of work time inflation in those applications. Increased data access latency can cause significant work time inflation in NUMA systems. Our locality framework for task parallel OpenMP programs mitigates this cause of work time inflation. Our extensions to the Qthreads library demonstrate that locality-aware scheduling can improve performance up to 3X compared to the Intel OpenMP task scheduler.

scholarly journals Scalable energy-efficient parallel sorting on a fine-grained many-core processor array

2020 ◽  
Vol 138 ◽  
pp. 32-47
Author(s):  
Aaron Stillmaker ◽  
Brent Bohnenstiehl ◽  
Lucas Stillmaker ◽  
Bevan Baas
Keyword(s):  
Energy Efficient ◽  
Processor Array ◽  
Parallel Sorting ◽  
Fine Grained ◽  
Many Core

scholarly journals Extreme-scale scripting: Opportunities for large task-parallel applications on petascale computers

2009 ◽  
Vol 180 ◽  
pp. 012046 ◽  
Author(s):  
Michael Wilde ◽  
Ioan Raicu ◽  
Allan Espinosa ◽  
Zhao Zhang ◽  
Ben Clifford ◽  
...  
Keyword(s):  
Parallel Applications ◽  
Task Parallel ◽  
Extreme Scale

scholarly journals Specifying and testing GPU workgroup progress models

2021 ◽  
Vol 5 (OOPSLA) ◽  
pp. 1-30
Author(s):  
Tyler Sorensen ◽  
Lucas F. Salvador ◽  
Harmit Raval ◽  
Hugues Evrard ◽  
John Wickerson ◽  
...  
Keyword(s):  
Parallel Applications ◽  
Gpu Programming ◽  
Concurrent Programs ◽  
Large Set ◽  
Prior Work ◽  
Fine Grained ◽  
Experimental Campaign ◽  
Correct Execution ◽  
Programming Support ◽  
Litmus Test

As GPU availability has increased and programming support has matured, a wider variety of applications are being ported to these platforms. Many parallel applications contain fine-grained synchronization idioms; as such, their correct execution depends on a degree of relative forward progress between threads (or thread groups). Unfortunately, many GPU programming specifications (e.g. Vulkan and Metal) say almost nothing about relative forward progress guarantees between workgroups. Although prior work has proposed a spectrum of plausible progress models for GPUs, cross-vendor specifications have yet to commit to any model. This work is a collection of tools and experimental data to aid specification designers when considering forward progress guarantees in programming frameworks. As a foundation, we formalize a small parallel programming language that captures the essence of fine-grained synchronization. We then provide a means of formally specifying a progress model, and develop a termination oracle that decides whether a given program is guaranteed to eventually terminate with respect to a given progress model. Next, we formalize a set of constraints that describe concurrent programs that require forward progress to terminate. This allows us to synthesize a large set of 483 progress litmus tests. Combined with the termination oracle, we can determine the expected status of each litmus test -- i.e. whether it is guaranteed to eventually terminate -- under various progress models. We present a large experimental campaign running the litmus tests across 8 GPUs from 5 different vendors. Our results highlight that GPUs have significantly different termination behaviors under our test suite. Most notably, we find that Apple and ARM GPUs do not support the linear occupancy-bound model, as was hypothesized by prior work.

Sign in / Sign up

Export Citation Format

Share Document