Charm++ parallel programming system

["Galvez Garcia, Juan Jose" <jjgalvez AT illinois.edu>]

Hi Alexandre,

Most centralized load balancing strategies inherit from CentralLB, which is a Charm++ group, meaning that the object that implements the strategy exists on every core. However, traditionally what CentralLB does on every PE is only send the load statistics to a central PE (typically PE 0), and it is CentralLB on PE 0 the one that runs the load balancing strategy (the work method), and after this communicates the decision to the affected chares/cores.

In the latest beta version of Charm++ and the development branch, there is a new mode called "concurrent mode" for CentralLB which, when active, makes PE0 broadcast the load statistics to every PE, and then calls "work" on every PE. I don't think it does exactly what you want, because the individual instances of CentralLB don't communicate with one another to calculate a solution; they independently obtain a solution and only communicate at the end to choose the best solution. But still, you can take a look at it to get an idea of how to implement a parallel strategy. In particular, you can look at the new GreedyRefine strategy which uses "concurrent" mode.

To implement a fully parallel algorithm, you could use the concurrent mode so that every PE receives the load statistics, and when the work method is called implement a parallel algorithm with coordination between the your objects (the ones that implement your strategy) running on every core.

If you need more details or have more questions, feel free to ask.

-Juan

---

From: Alexandre Santana [alexandre.limas.santana AT gmail.com]
Sent: Tuesday, April 18, 2017 1:42 PM
To: charm AT lists.cs.illinois.edu
Subject: [charm] [Charm] Proper way to write parallel centralized load balancers

Hello,

I'm a new user on Charm++. I'm currently trying to write my first load balancers with the framework. Currently, I'm trying to parallelize a centralized dummy load balancer and I would like to know what is the best practice in doing so. As far as I could understand the Load Balancer Framework, centralized balancers would finish their strategy after returning from the work method. Is there a way to reliably divide load balancing computation between local chares without having to commit to a distributed load balance strategy?

Att,

Alexandre Santana