EEMCS

Home > Publications
Home University of Twente
Education
Research
Prospective Students
Jobs
Publications
Intranet (internal)
 
 Nederlands
 Contact
 Search
 Organisation

EEMCS EPrints Service


24648 Programming models for many-core architectures: a co-design approach
Home Policy Brochure Browse Search User Area Contact Help

Rutgers, J.H. (2014) Programming models for many-core architectures: a co-design approach. PhD thesis, University of Twente. CTIT Ph.D.-thesis series No. 14-292 ISBN 978-90-365-3611-0

Full text available as:

PDF

5932 Kb
Open Access



Official URL: http://dx.doi.org/10.3990/1.9789036536110

Abstract

Common many-core processors contain tens of cores and distributed memory. Compared to a multicore system, which only has a few tightly coupled cores sharing a single bus and memory, several complex problems arise. Notably, many cores require many parallel tasks to fully utilize the cores, and communication happens in a distributed and decentralized way. Therefore, programming such a processor requires the application to exhibit concurrency. In contrast to a single-core application, a concurrent application has to deal with memory state changes with an observable (non-deterministic) intermediate state. The complexity introduced by these problems makes programming a many-core system with a single-core-based programming approach notoriously hard.

The central concept of this thesis is that abstractions, which are related to (many-core) programming, are structured in a single platform model. A platform is a layered view of the hardware, a memory model, a concurrency model, a model of computation, and compile-time and run-time tooling. Then, a programming model is a specific view on this platform, which is used by a programmer. In this view, some details can be hidden from the programmer's perspective, some details cannot. For example, an operating system presents an infinite number of parallel virtual execution units to the application whilst it hides details regarding scheduling. On the other hand, a programmer usually has balance workload among threads by hand.

This thesis presents modifications to different abstraction layers of a many-core architecture, in order to make the system as a whole more efficient, and to reduce the programming complexity. These modifications influence other abstractions in the platform, and especially the programming model. Therefore, this thesis applies co-design on all models. Notably, co-design of the memory model, concurrency model, and model of computation is required for a scalable implementation of lambda-calculus. Moreover, only the combination of requirements of the many-core hardware from one side and the concurrency model from the other leads to a memory model abstraction. Hence, this thesis shows that to cope with the current trends in many-core architectures from a programming perspective, it is essential and feasible to inspect and adapt all abstractions collectively.

Item Type:PhD Thesis
Supervisors:Bekooij, M.J.G. and Smit, G.J.M.
Research Group:EWI-CAES: Computer Architecture for Embedded Systems
Research Program:CTIT-WiSe: Wireless and Sensor Systems
Research Project:NEST: Netherlands Streaming Reconfigurable digital antenna processor, STARS: Sensor Technology Applied in Reconfigurable systems for Sustainable Security
ID Code:24648
Deposited On:26 May 2014
More Information:statistics

Export this item as:

To correct this item please ask your editor

Repository Staff Only: edit this item