1 / 18

Memory-Aware Scheduling in Charm++: Enhancing Performance with Adaptive Techniques

This study explores memory-aware scheduling in LU programs within a Charm++ runtime system, focusing on adaptive techniques to optimize memory usage. The presented technique dynamically schedules tasks based on memory usage, with minimal overhead impact. By prioritizing tasks that reduce memory consumption, the scheduler effectively enhances program performance. The research showcases a timeline analysis illustrating the benefits of memory-aware scheduling, particularly for small matrices. Additionally, the study proposes a Balanced Snake Mapping approach to improve load balance and memory efficiency. Overall, the findings highlight the potential of memory-aware scheduling in improving program efficiency, with implications for future work in adaptive runtime systems.

keaton-austin
Download Presentation

Memory-Aware Scheduling in Charm++: Enhancing Performance with Adaptive Techniques

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Memory-Aware Scheduling for LU in Charm++ Isaac Dooley, Chao Mei, Jonathan Lifflander, Laxmikant V. Kale

  2. Problem • Unrestricted parallelism may lead to a continuous increase of memory usage on a node • e.g. LU lookahead • Previous solutions • Statically restricting concurrency (HPL) • Dynamically restrict, but also restrict some tasks (to eliminate deadlock) (Husbands and Yelick)

  3. A timeline view, colored by memory usage, of an LU program run on 64 processors of BG/P using a Block-Cyclic Mapping for a N = 32768 sized matrix with 512 x 512 sized blocks. The traditional block-cyclic mapping suffers from limited concurrency at the end (the right portion of this plot). This is most problematic in small matrices.

  4. Goal • Language runtime system should provide a mechanism to schedule for memory usage • Adaptive runtime systems (RTS) are the future • Memory-aware scheduling is a case-study of one of the adaptive techniques that could be exploited in RTS • Use Charm++ RTS as the framework to study such technique

  5. Charm++ Essentials • Computation: expressed as a collection of objects that intreractvia asynchronous method invocations • RTS controls the mapping objects to PEs • Adaptive techniques are naturally introduced • AMPI provides the same functions for MPI apps • Schedulers in Charm++ RTS • Queues with priorities

  6. Memory-Aware Scheduling • In parallel interface file • Tag entry method known to decrease memory with[memcritical] • At runtime set a memory threshold • Scheduler • When the threshold is reached: • Perform linear scan of priority queues • Schedule the first task known to reduce memory usage • Repeat until the memory usage is below the threshold

  7. Memory-Aware Scheduling • Overhead • In LU program with N = 32768 x 32768 matrix, and 512 x 512 block size, average time spent in scheduler code is 0.0239 seconds • LU factorization takes 168.4 seconds • Negligible overhead of 0.014%

  8. LU in Charm++ • LU solve on diagonal • Broadcast of L and U across the row and column • Triangular solve for L and U in the row and column • Trailing updates for submatrix

  9. Mapping Blocks to Processors • Block-cyclic mapping reduces concurrency at the end • However, it decreases the cost of communication (by limiting the number of processors for each multicast across the row and column) • For smaller matrices, another mapping scheme may perform better, due to better load balance (even if it involves more processors in the multicast)

  10. Balanced Snake Mapping • Traverse in roughly decreasing amount of work • As the diagram shows • Assign to processor which has been assigned the smallest amount of work so far • Keep alist of processors and the amount of work each has been assigned

  11. Balanced Snake Mapping

  12. Memory Increase in LU • Trailing updates may be delayed • Only needed for next diagonal and the next set of triangular solves (which may also be delayed) • These are scheduled using priorities • Trailing updates accumulate in the queue (because of the relatively low priority), increasing memory usage • Override priority and schedule immediately if memory threshold is reached

  13. With Memory-Aware Scheduling

  14. Without Memory-Aware Scheduling

  15. Memory-Aware Scheduling

  16. Performance

  17. Future work • Make the scheduler automatically detect which entry method will be marked memory critical • Respect priorities within messages marked memory critical in the scheduler • Allow other messages to be marked as increasing memory, or having no effect on memory

  18. Conclusion • A general memory-aware scheduling technique is demonstrated • Could be used in other RTS • Using Charm++ as a case study • A new LU block mapping in a message-driven system • Performs better for small matrices

More Related