151 research outputs found
Data Structures for Task-based Priority Scheduling
Many task-parallel applications can benefit from attempting to execute tasks
in a specific order, as for instance indicated by priorities associated with
the tasks. We present three lock-free data structures for priority scheduling
with different trade-offs on scalability and ordering guarantees. First we
propose a basic extension to work-stealing that provides good scalability, but
cannot provide any guarantees for task-ordering in-between threads. Next, we
present a centralized priority data structure based on -fifo queues, which
provides strong (but still relaxed with regard to a sequential specification)
guarantees. The parameter allows to dynamically configure the trade-off
between scalability and the required ordering guarantee. Third, and finally, we
combine both data structures into a hybrid, -priority data structure, which
provides scalability similar to the work-stealing based approach for larger
, while giving strong ordering guarantees for smaller . We argue for
using the hybrid data structure as the best compromise for generic,
priority-based task-scheduling.
We analyze the behavior and trade-offs of our data structures in the context
of a simple parallelization of Dijkstra's single-source shortest path
algorithm. Our theoretical analysis and simulations show that both the
centralized and the hybrid -priority based data structures can give strong
guarantees on the useful work performed by the parallel Dijkstra algorithm. We
support our results with experimental evidence on an 80-core Intel Xeon system
Efficient and Reasonable Object-Oriented Concurrency
Making threaded programs safe and easy to reason about is one of the chief
difficulties in modern programming. This work provides an efficient execution
model for SCOOP, a concurrency approach that provides not only data race
freedom but also pre/postcondition reasoning guarantees between threads. The
extensions we propose influence both the underlying semantics to increase the
amount of concurrent execution that is possible, exclude certain classes of
deadlocks, and enable greater performance. These extensions are used as the
basis an efficient runtime and optimization pass that improve performance 15x
over a baseline implementation. This new implementation of SCOOP is also 2x
faster than other well-known safe concurrent languages. The measurements are
based on both coordination-intensive and data-manipulation-intensive benchmarks
designed to offer a mixture of workloads.Comment: Proceedings of the 10th Joint Meeting of the European Software
Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of
Software Engineering (ESEC/FSE '15). ACM, 201
Reducing the burden of parallel loop schedulers for many-core processors
Funder: FP7 People: MarieâCurie Actions; Id: http://dx.doi.org/10.13039/100011264; Grant(s): 327744Summary: As core counts in processors increases, it becomes harder to schedule and distribute work in a timely and scalable manner. This article enhances the scalability of parallel loop schedulers by specializing schedulers for fineâgrain loops. We propose a lowâoverhead work distribution mechanism for a static scheduler that uses no atomic operations. We integrate our static scheduler with the Intel OpenMP and Cilkplus parallel task schedulers to build hybrid schedulers. Compiler support enables efficient reductions for Cilk, without changing the programming interface of Cilk reducers. Detailed, quantitative measurements demonstrate that our techniques achieve scalable performance on a 48âcore machine and the scheduling overhead is 43% lower than Intel OpenMP and 12.1Ă lower than Cilk. We demonstrate consistent performance improvements on a range of HPC and data analytics codes. Performance gains are more important as loops become finerâgrain and thread counts increase. We observe consistently 16%â30% speedup on 48 threads, with a peak of 2.8Ă speedup
Programming models for parallel computing
Mit dem Auftauchen von Multicore Prozessoren beginnt parallele Programmierung den Massenmarkt zu erobern. Derzeit ist der Parallelismus noch relativ eingeschrĂ€nkt, da aktuelle Prozessoren nur ĂŒber eine geringe Anzahl an Kernen verfĂŒgen, doch schon bald wird der Schritt zu Prozessoren mit Hunderten an Kernen vollzogen sein.
WĂ€hrend sich die Hardware unaufhaltsam in Richtung Parallelismus weiterentwickelt, ist es fĂŒr Softwareentwickler schwierig, mit diesen Entwicklungen Schritt zu halten. Parallele Programmierung erfordert neue AnsĂ€tze gegenĂŒber den bisher verwendeten sequentiellen Programmiermodellen. In der Vergangenheit war es ausreichend, die nĂ€chste Prozessorgeneration abzuwarten, um Computerprogramme zu beschleunigen. Heute jedoch kann ein sequentielles Programm mit einem neuen Prozessor sogar langsamer werden, da die Geschwindigkeit eines einzelnen Prozessorkerns nun oft zugunsten einer gröĂeren Gesamtzahl an Kernen in einem Prozessor reduziert wird. Angesichts dieser Tatsache wird es in der Softwareentwicklung in Zukunft notwendig sein, Parallelismus explizit auszunutzen, um weiterhin performante Programme zu entwickeln, die auch auf zukĂŒnftigen Prozessorgenerationen skalieren.
Die Problematik liegt dabei darin, dass aktuelle Programmiermodelle weiterhin auf dem sogenannten "Assembler der parallelen Programmierung", d.h. auf Multithreading fĂŒr Shared-Memory- sowie auf Message Passing fĂŒr Distributed-Memory Architekturen basieren, was zu einer geringen ProduktivitĂ€t und einer hohen FehleranfĂ€lligkeit fĂŒhrt. Um dies zu Ă€ndern, wird an neuen Programmiermodellen, -sprachen und -werkzeugen, die Parallelismus auf einer höheren Abstraktionsebene als bisherige Programmiermodelle zu behandeln versprechen, geforscht. Auch wenn bereits einige Teilerfolge erzielt wurden und es gute, performante Lösungen fĂŒr bestimmte Bereiche gibt, konnte bis jetzt noch kein allgemeingĂŒltiges paralleles Programmiermodell entwickelt werden - viele bezweifeln, dass das ĂŒberhaupt möglich ist.
Das Ziel dieser Arbeit ist es, einen Ăberblick ĂŒber aktuelle Entwicklungen bei parallelen Programmiermodellen zu geben. Da homogenen Multi- und Manycore Prozessoren in nĂ€chster Zukunft die meiste Bedeutung zukommen wird, wird das Hauptaugenmerk darauf gelegt, inwieweit die behandelten Programmiermodelle fĂŒr diese Plattformen nĂŒtzlich sind. Durch den Vergleich unterschiedlicher, auch experimenteller AnsĂ€tze soll erkennbar werden, wohin die Entwicklung geht und welche Werkzeuge aktuell verwendet werden können.With the emergence of multi-core processors in the consumer market, parallel computing is moving to the mainstream. Currently parallelism is still very restricted as modern consumer computers only contain a small number of cores. Nonetheless, the number is constantly increasing, and the time will come when we move to hundreds of cores.
For software developers it is becoming more difficult to keep up with these new developments. Parallel programming requires a new way of thinking. No longer will a new processor generation accelerate every existing program. On the contrary, some programs might even get slower because good single-thread performance of a processor is traded in for a higher level of parallelism. For that reason, it becomes necessary to exploit parallelism explicitly and to make sure that the program scales well.
Unfortunately, parallelism in current programming models is mostly based on the "assembler of parallel programming", namely low level threading for shared multiprocessors and message passing for distributed multiprocessors. This leads to low programmer productivity and erroneous programs. Because of this, a lot of effort is put into developing new high level programming models, languages and tools that should help parallel programming to keep up with hardware development. Although there have been successes in different areas, no good all-round solution has emerged until now, and there are doubts that there ever will be one.
The aim of this work is to give an overview of current developments in the area of parallel programming models. The focus is put onto programming models for multi- and many-core architectures as this is the area most relevant for the near future. Through the comparison of different approaches, including experimental ones, the reader will be able to see which existing programming models can be used for which tasks and to anticipate future developments
Memory abstractions for parallel programming
Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2012.Cataloged from PDF version of thesis.Includes bibliographical references (p. 156-163).A memory abstraction is an abstraction layer between the program execution and the memory that provides a different "view" of a memory location depending on the execution context in which the memory access is made. Properly designed memory abstractions help ease the task of parallel programming by mitigating the complexity of synchronization or admitting more efficient use of resources. This dissertation describes five memory abstractions for parallel programming: (i) cactus stacks that interoperate with linear stacks, (ii) efficient reducers, (iii) reducer arrays, (iv) ownershipaware transactions, and (v) location-based memory fences. To demonstrate the utility of memory abstractions, my collaborators and I developed Cilk-M, a dynamically multithreaded concurrency platform which embodies the first three memory abstractions. Many dynamic multithreaded concurrency platforms incorporate cactus stacks to support multiple stack views for all the active children simultaneously. The use of cactus stacks, albeit essential, forces concurrency platforms to trade off between performance, memory consumption, and interoperability with serial code due to its incompatibility with linear stacks. This dissertation proposes a new strategy to build a cactus stack using thread-local memory mapping (or TLMM), which enables Cilk-M to satisfy all three criteria simultaneously. A reducer hyperobject allows different branches of a dynamic multithreaded program to maintain coordinated local views of the same nonlocal variable. With reducers, one can use nonlocal variables in a parallel computation without restructuring the code or introducing races. This dissertation introduces memory-mapped reducers, which admits a much more efficient access compared to existing implementations. When used in large quantity, reducers incur unnecessarily high overhead in execution time and space consumption. This dissertation describes support for reducer arrays, which offers the same functionality as an array of reducers with significantly less overhead. Transactional memory is a high-level synchronization mechanism, designed to be easier to use and more composable than fine-grain locking. This dissertation presents ownership-aware transactions, the first transactional memory design that provides provable safety guarantees for "opennested" transactions. On architectures that implement memory models weaker than sequential consistency, programs communicating via shared memory must employ memory-fences to ensure correct execution. This dissertation examines the concept of location-based memoryfences, which unlike traditional memory fences, incurs latency only when synchronization is necessary.by I-Ting Angelina Lee.Ph.D
Hyposubjects
The time of hypersubjects is ending. Their desert-apocalypse-fire-and-death cults arenât going to save them this time. Meanwhile the time of hyposubjects is just beginning. This text is an exercise in chaotic and flimsy thinking that will possibly waste your time. But it is the sincere effort of two reform-minded hypersubjects to decenter themselves and to help nurture hyposubjective humanity. Here are some of the things we say in this book: 1) Hyposubjects are the native species of the Anthropocene and are only just now beginning to discover what they might be and become. 2) Like their hyperobjective environment, hyposubjects are also multiphasic and plural: not-yet, neither here nor there, less than the sum of their parts. They are, in other words, subscendent (moving toward relations) rather than transcendent (rising above relations). They do not pursue or pretend to absolute knowledge or language, let alone power. Instead they play; they care; they adapt; they hurt; they laugh. 3) Hyposubjects are necessarily feminist, colorful, queer, ecological, transhuman, and intrahuman. They do not recognize the rule of androleukoheteropetromodernity and the apex species behavior it epitomizes and reinforces. But they also hold the bliss-horror of extinction fantasies at bay, because hyposubjectsâ befores, nows, and afters are many. 4) Hyposubjects are squatters and bricoleuses. They inhabit the cracks and hollows. They turn things inside out and work miracles with scraps and remains. They unplug from carbon gridlife; they hack and redistribute its stored energies for their own purposes. 5) Hyposubjects make revolutions where technomodern radars canât glimpse them. They patiently ignore expert advice that they do not or cannot exist. They are skeptical of efforts to summarize them, including everything we have just said
Future as medium
FUTURE AS MEDIUM through critical examination develops a working premise for advancing designed visualizations of the future. In an effort to build new models of practice that consciously work towards the future, I undertake a set of delicate negotiations rooted in critical inquiry as well as creative production, all expressed across three temporal contingencies: yesterday, today and tomorrow.
I work the terrain of the past as an assembled archive of speculative worlds created by architects, designers, and artists, and problematize the mediation of futures through a close reading of their world-building tools. I use this archive to make sense of my overall visions and methodology, always looking to the future.
In the present, I measure these accounts against the ideological and systemic biases of designers and the complex world we inhabit, allowing opportunities for nuance, true plurality, and the incorporation of diversity for effective social engagement.
Tomorrow explores adaptive models for an alternative pedagogical framework and the invention of new visualization strategies. Behaving like an âologistâ, taking a somewhat scientific and ethnographic approach to understanding my subject matter and intended audience, I finally ask (and attempt to answer) these questions: Are there ways for us to build multiple yet collective futures? Can we use the future as medium
- âŠ