Actor scheduling for multicore hierarchical memory platforms

Francesquini, Emílio; Goldman, Alfredo; Méhaut, Jean‐François

doi:10.1145/2505305.2505313

Cited by 8 publications

(10 citation statements)

References 13 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Hub capsules are represented using cVector < f alse, nil, •, scatter, •, io>. In the literature, it is known that hub and its affinity capsules must be placed closer to each other to reduce communication overheads [11]. We achieve this by assigning task policy to hub capsules such that the shared thread that is processing the hub capsules also processes the affinity capsules.…”

Section: Hub Heuristicsmentioning

confidence: 99%

See 1 more Smart Citation

Effectively mapping linguistic abstractions for message-passing concurrency to threads on the Java virtual machine

UpadhyayaGanesha

Rajan

2015

SIGPLAN Not.

View full text Add to dashboard Cite

Efficient mapping of message passing concurrency (MPC) abstractions to Java Virtual Machine ( JVM) threads is critical for performance, scalability, and CPU utilization; but tedious and time consuming to perform manually. In general, this mapping cannot be found in polynomial time, but we show that by exploiting the local characteristics of MPC abstractions and their communication patterns this mapping can be determined effectively. We describe our MPC abstraction to thread mapping technique, its realization in two frameworks (Panini and Akka), and its rigorous evaluation using several benchmarks from representative MPC frameworks. We also compare our technique against four default mapping techniques: thread-all, roundrobin-task-all, random-task-all and work-stealing. Our evaluation shows that our mapping technique can improve the performance by 30%-60% over default mapping techniques. These improvements are due to a number of challenges addressed by our technique namely: i) balancing the computations across JVM threads, ii) reducing the communication overheads, iii) utilizing information about cache locality, and iv) mapping MPC abstractions to threads in a way that reduces the contention between JVM threads. AbstractEfficient mapping of message passing concurrency (MPC) abstractions to Java Virtual Machine (JVM) threads is critical for performance, scalability, and CPU utilization; but tedious and time consuming to perform manually. In general, this mapping cannot be found in polynomial time, but we show that by exploiting the local characteristics of MPC abstractions and their communication patterns this mapping can be determined effectively. We describe our MPC abstraction to thread mapping technique, its realization in two frameworks (Panini and Akka), and its rigorous evaluation using several benchmarks from representative MPC frameworks. We also compare our technique against four default mapping techniques: thread-all, round-robin-task-all, random-task-all and work-stealing. Our evaluation shows that our mapping technique can improve the performance by 30%-60% over default mapping techniques. These improvements are due to a number of challenges addressed by our technique namely: i) balancing the computations across JVM threads, ii) reducing the communication overheads, iii) utilizing information about cache locality, and iv) mapping MPC abstractions to threads in a way that reduces the contention between JVM threads.

show abstract

Section: Hub Heuristicsmentioning

confidence: 99%

“…Francesquini et al [11] proposes a technique implemented in Erlang [37] runtime that places Erlang actors on multi-core efficiently. Their technique showed that by placing frequently communicating actors (hub-and-affinity) together, over two times improvement in the application performance can be achieved.…”

Section: Related Workmentioning

confidence: 99%

Effectively mapping linguistic abstractions for message-passing concurrency to threads on the Java virtual machine

UpadhyayaGanesha

Rajan

2015

SIGPLAN Not.

View full text Add to dashboard Cite

show abstract

“…We call NUMA factor the ratio between remote latency and local latency for memory access in these machines. Some machines might display NUMA factors beyond 10 [8], making a correct placement of processes and memory essential to obtain good performances [4].…”

Section: Multicore Multiprocessor and Manycore Platformsmentioning

confidence: 99%

“…In Erlang, for example, each actor has its own heap [8]. This makes it easy to implement an efficient garbage collector since such a collector does not need to "stop the world", inasmuch as it only needs to stop the actor on which it is working.…”

Section: Actor Runtime Environmentsmentioning

confidence: 99%

“…These applications, however, should take the hardware characteristics into consideration, otherwise concurrency for the shared resources may become strong enough to cause important performance degradation. It has been shown that an efficient utilization of these machines by the actor REs can result in performance improvements up to a factor of 2.50 while limiting the slowdown on the worst case by a factor of 1.09 [7,8].…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Improving the performance of actor model runtime environments on multicore and manycore platforms

Francesquini

Goldman

Méhaut

2013

Proceedings of the 2013 Workshop on Programming Based on Actors, Agents, and Decentralized Control

Self Cite

View full text Add to dashboard Cite

The actor model is present in many systems that demand substantial computing resources which are often provided by multicore and multiprocessor platforms such as non-uniform memory access architectures (NUMA) and manycore processors. Yet, no mainstream actor model runtime environment (RE) currently in use takes into account the hierarchical memory characteristics of these platforms. These REs essentially assume a flat-memory space therefore not performing as well as they could. In this paper we present our proposal to improve the performance of these systems. Using knowledge about the general characteristics of actor-based applications and the underlying platform, we propose techniques spanning from memory management to scheduling and load-balancing. Based on previous work, we present our design guidelines for the RE adaptation to the Kalray MPPA-256 manycore processor.

show abstract

Improving the Performance of Actor-Based Programs Using a New Actor to Thread Association Technique

Rahemi

Khamespanah

Khosravi

2018

Distributed Applications and Interoperable Systems

View full text Add to dashboard Cite

Finding the most efficient policy for the association of objects with threads is one of the main challenges in the deployment of concurrently executing objects, including actors. For the case of actor-based programs, libraries, frameworks, and languages provide fine tuning facilities for associating actors with threads. In practice, programmers use the default policy for the initial deployment of actors and the default policy is replaced with some other policies considering runtime behaviors of actors. Although this ad-hoc approach is widely used by programmers, it is tedious and time-consuming for large-scale applications. To reduce the time-consumption of the ad-hoc approach, a set of heuristics is proposed with the aim of balancing computations of actors across threads. This technique results in performance improvement; however, it relies on the static analysis of source codes and actors' behaviors, ends in the inappropriate configuration of systems in distributed environments. In this paper, we illustrate conditions that the proposed heuristics do not work well and propose a new approach based on the runtime profile of actors for better association of actors with threads. We also show how this approach can be extended to a fully self-adaptive approach and illustrated its applicability using a set of case studies.

show abstract

Actor scheduling for multicore hierarchical memory platforms

Cited by 8 publications

References 13 publications

Effectively mapping linguistic abstractions for message-passing concurrency to threads on the Java virtual machine

Effectively mapping linguistic abstractions for message-passing concurrency to threads on the Java virtual machine

Improving the performance of actor model runtime environments on multicore and manycore platforms

Improving the Performance of Actor-Based Programs Using a New Actor to Thread Association Technique

Contact Info

Product

Resources

About