Proposal (More) Flexible RMA Synchronization for MPI-3 Hubert Ritzdorf NEC–IT Research Division

Slides:



Advertisements
Similar presentations
Operating Systems Semaphores II
Advertisements

Read Modify Write for MPI Howard Pritchard (Cray) Galen Shipman (ORNL)
RMA Working Group Update. Status Three proposals submitted over They will be discussed in the working group meeting on Wednesday,
MPI3 RMA William Gropp Rajeev Thakur. 2 MPI-3 RMA Presented an overview of some of the issues and constraints at last meeting Homework - read Bonachea's.
Generalized Requests. The current definition They are defined in MPI 2 under the hood of the chapter 8 (External Interfaces) Page 166 line 16 The objective.
Processes and Threads Chapter 3 and 4 Operating Systems: Internals and Design Principles, 6/E William Stallings Patricia Roy Manatee Community College,
RMA Considerations for MPI-3.1 (or MPI-3 Errata)
Chapter 3 Basic Input/Output
Marc Snir Ticket 313 Ticket 310 Ticket 311. TICKET 313 – INIT/FINALIZE 2.
Chapter 4 Threads Patricia Roy Manatee Community College, Venice, FL ©2008, Prentice Hall Operating Systems: Internals and Design Principles, 6/E William.
Threads, SMP, and Microkernels
MPI Message Passing Interface
More on Processes Chapter 3. Process image _the physical representation of a process in the OS _an address space consisting of code, data and stack segments.
Enabling MPI Interoperability Through Flexible Communication Endpoints
1 Non-Blocking Communications. 2 #include int main(int argc, char **argv) { int my_rank, ncpus; int left_neighbor, right_neighbor; int data_received=-1;
Introduction to Memory Management. 2 General Structure of Run-Time Memory.
HW/Study Guide. Synchronization Make sure you understand the HW problems!
1 Implementations: User-level Kernel-level User-level threads package each u.process defines its own thread policies! flexible mgt, scheduling etc…kernel.
EEE 435 Principles of Operating Systems Interprocess Communication Pt II (Modern Operating Systems 2.3)
Process Synchronization. Module 6: Process Synchronization Background The Critical-Section Problem Peterson’s Solution Synchronization Hardware Semaphores.
5.6 Semaphores Semaphores –Software construct that can be used to enforce mutual exclusion –Contains a protected variable Can be accessed only via wait.
Tao Yang, UCSB CS 240B’03 Unix Scheduling Multilevel feedback queues –128 priority queues (value: 0-127) –Round Robin per priority queue Every scheduling.
5.6.2 Thread Synchronization with Semaphores Semaphores can be used to notify other threads that events have occurred –Producer-consumer relationship Producer.
Memory Allocation and Garbage Collection. Why Dynamic Memory? We cannot know memory requirements in advance when the program is written. We cannot know.
1 Chapter 4 Threads Threads: Resource ownership and execution.
Persistent Collectives Comments on feedback. Waiting for optimisation phase [15] MPI_ _INIT(…, &request) – Usage: INIT -> (START -> WAIT)* -> FREE [2]
A. Frank - P. Weisberg Operating Systems Introduction to Cooperating Processes.
© 2004, D. J. Foreman 2-1 Concurrency, Processes and Threads.
A Parallel, Real-Time Garbage Collector Author: Perry Cheng, Guy E. Blelloch Presenter: Jun Tao.
1 Race Conditions/Mutual Exclusion Segment of code of a process where a shared resource is accessed (changing global variables, writing files etc) is called.
Chapter 8 Windows Outline Programming Windows 2000 System structure Processes and threads in Windows 2000 Memory management The Windows 2000 file.
Channel Interface Takeshi Nanri (Kyushu Univ., Japan) and Shinji Sumimoto (Fujitsu Ltd.) Dec Advanced Communication for Exa (ACE) project supported.
Nachos Phase 1 Code -Hints and Comments
RFC: Breaking Free from the Collective Requirement for HDF5 Metadata Operations.
Recall: Three I/O Methods Synchronous: Wait for I/O operation to complete. Asynchronous: Post I/O request and switch to other work. DMA (Direct Memory.
Synchronization with shared memory AMANO, Hideharu Textbook pp
Jeremy Denham April 7,  Motivation  Background / Previous work  Experimentation  Results  Questions.
Aaron Nathan CS6464 Final Project vapor_disk. Idea Provide a “real time” backup that is widely and easily available Simple to use Works in Windows.
Memory Consistency Models. Outline Review of multi-threaded program execution on uniprocessor Need for memory consistency models Sequential consistency.
Implementing SRC in MPI Ishai Rabinovitz 19/7/07.
Porting processes to threads with MPC instead of forking Some slides from Marc Tchiboukdjian (IPDPS’12) : Hierarchical Local Storage Exploiting Flexible.
Operating System Concepts
Interrupts and Exception Handling. Execution We are quite aware of the Fetch, Execute process of the control unit of the CPU –Fetch and instruction as.
Communication thread core thread Spawn N negotiation threads... negotiation threads active inactive Initialize An Agent and Its Threads execution thread.
Martin Kruliš by Martin Kruliš (v1.1)1.
Process Synchronization. Concurrency Definition: Two or more processes execute concurrently when they execute different activities on different devices.
HPX-5 ParalleX in Action
Operating Systems CMPSC 473
PROCESS MANAGEMENT IN MACH
Scheduler activations
Memory Consistency Models
Concurrency, Processes and Threads
Memory Consistency Models
Overview of the Lab 3 Assignment: Kernel Module Concurrent Memory Use
Request ordering for FI_MSG and FI_RDM endpoints
MPI-Message Passing Interface
Synchronization Issues
Threading And Parallel Programming Constructs
Critical section problem
Threads and Concurrency
CSE451 - Section 10.
Overall Kernel Module Design
Concurrency, Processes and Threads
CSE 153 Design of Operating Systems Winter 19
NT Executive Resources
Chapter 6: Synchronization Tools
CSE451 - Section 10.
Concurrency, Processes and Threads
Implementing Processes and Threads
Contact Information Office: 225 Neville Hall Office Hours: Monday and Wednesday 12:00-1:00 and by appointment. Phone:
Presentation transcript:

Proposal (More) Flexible RMA Synchronization for MPI-3 Hubert Ritzdorf NEC–IT Research Division

© NEC Europe Ltd 2008 The Problem Process (I)Process J MPI_Puts MPI_Gets How can Process J decide that Process (I) has finished RMA transfer so that Process J can access/change the data ? and others Shared Memory: Atomic counters, ready flags, semaphores, … Its not necessarily defined, which process provides the data, decrements the counter, sets the flag, … MPI-2: Collective approach (Fence, Complete/Wait) on Windows The group has to be clear in advance; not very flexible New Proposal

© NEC Europe Ltd 2008 Idea Window: Large amount of (shared) memory Atomic counter (synchronization counters): To independently handle parts of the (shared) memory New MPI Type MPI_Sync: MPI Synchronization counter Special Allocate: MPI_Win_Sync_alloc_objects (n_sync, sync_counters, win, info) MPI_Win_Sync_free_objects (n_sync, sync_counters, win) to be performed by the owner of the window win

© NEC Europe Ltd 2008 Problem How to transfer the info on MPI_Sync counters Every process (in win comm) should be able to get access Access to counter may change in run-time Processes must have required info to ``attach to the counter Idea: New MPI Datatype MPI_Handle_sync Transfer data via MPI pt2pt and collectives Possible alternative : Create n_sync counters in MPI_Win_create Pro: User doesnt see them; Contra: libraries, less flexibility, scalability

© NEC Europe Ltd 2008 Usage MPI_Win_sync_ops_init (target_rank, sync_mode, sync_counter, win, info, req) Init wait for completion of RMA operations corresponding to sync_mode : Bit vector or of MPI_MODE_WIN_PUT, MPI_MODE_WIN_GET, MPI_MODE_WIN_ACCUMULATE increment/decrement counter sync_counter on process target_rank On processes which perform RMA operations

© NEC Europe Ltd 2008 Usage MPI_Win_sync_object_init (sync_counter, count, win, info, req) On process where counter is located Init wait for count completions (atomic increments) of requests created by MPI_Win_sync_ops_init Designed as persistent request for frequent re-use All possibilities of MPI Test/Wait functions Works on cache coherent and non cache coherent systems Can be implemented by pt2pt functions

© NEC Europe Ltd 2008 Example MPI_Win_sync_object_init (sync_counter, 8, win, info, req); MPI_Start (req) MPI_Win_sync_ops_init (target_rank MPI_MODE_PUT, sync_counter, win, info, req); MPI_Start (req) 8 neighboursTarget MPI_Put (target, …) MPI_Wait (req, …)

© NEC Europe Ltd 2008 Wait for completion of which RMA ops ? With current MPI-2 Interface: Wait for completion of all RMA requests since last synchronization Additional functions for MPI-3 interface (useful for threads and several synchronization counters) Add synchronization counter request to RMA functions for example: MPI_Iput (…, win, req), MPI_Iget (…, win, req), … Not really save programming style. Difficult for threads or several counters

© NEC Europe Ltd 2008 Window as Shared Memory More dynamic usage of window required (for example for dynamic process spawning) MPI_Win_change_comm (new_comm, peer_rank, win) Allow processes to join or leave an already existing window.

© NEC Europe Ltd 2008 Possible Extensions Synchronization counters == atomic counters Wait/Test that counter completed on remote node Change final counter value (increment, decrement) Automatic restart of request if final counter value is reached and test/wait function was executed