EEMCS

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

EEMCS EPrints Service


24377 Programming a multicore architecture without coherency and atomic operations
Home Policy Brochure Browse Search User Area Contact Help

Rutgers, J.H. and Bekooij, M.J.G. and Smit, G.J.M. (2014) Programming a multicore architecture without coherency and atomic operations. In: Proceedings of the International Workshop on Programming Models and Applications for Multicores and Manycores (PMAM 2014), 15-19 Feb 2014, Orlando, FL, USA. pp. 29-38. ACM. ISBN 978-1-4503-2655-1

Full text available as:

PDF

344 Kb
Open Access



Official URL: http://dx.doi.org/10.1145/2560683.2560697

Exported to Metis

Abstract

It is hard to reason about the state of a multicore system-on-chip, because operations on memory need multiple cycles to complete, since cores communicate via an interconnect like a network-on-chip. To simplify programming, atomicity is required, by means of atomic read-modify-write (RMW) operations, a strong memory model, and hardware cache coherency. As a result, multicore architectures are very complex, but this stems from the fact that they are designed with an imperative programming paradigm in mind, i.e. based on threads that communicate via shared memory.

In this paper, we show the impact on a multicore architecture, when the programming paradigm is changed and a lambda-calculus-based (functional) language is used instead. Ordering requirements of memory operations are more relaxed and synchronization is simplified, because lambda-calculus does not have a notion of state or memory, and therefore does not impose ordering requirements on the platform. We implemented a functional language for multicores with a weak memory model, without the need of hardware cache coherency, any atomic RMW operation, or mutex--the execution is atomic-free. Experiments show that even on a system with (transparently applied) software cache coherency, execution scales properly up to 32 cores. This shows that concurrent hardware complexity can be reduced by making different choices in the software layers on top.

Item Type:Conference or Workshop Paper (Full Paper, Talk)
Research Group:EWI-CAES: Computer Architecture for Embedded Systems
Research Program:CTIT-WiSe: Wireless and Sensor Systems
Research Project:STARS: Sensor Technology Applied in Reconfigurable systems for Sustainable Security
ID Code:24377
Status:Published
Deposited On:14 February 2014
Refereed:Yes
International:Yes
More Information:statisticsmetis

Export this item as:

To correct this item please ask your editor

Repository Staff Only: edit this item