PARA++ : C++ Bindings for Message Passing Libraries

Transcription

1 PARA++ : C++ Bindings for Message Passing Libraries O. Coulaud, E. Dillon {Olivier.Coulaud, Eric.Dillon}@loria.fr INRIA-lorraine BP101, VILLERS-les-NANCY, FRANCE Abstract The aim of Para++ is to provide a user-level C++ interface to message passing libraries, by encapsulating the notions of processes and inter-processes communications into specific C++ objects and streams. Actually, this abstraction level allows to implement Para++ with any kind of message passing library. Para++ s main idea is to add new C++ io-streams allowing inter-tasks communications. These streams support all generic scalar datatype (int, float, double,), plus some mathematical datatypes(vectors, Matrix,). Para++ has been implemented on top of PVM [1] and MPI [2]. 1 Introduction In this paper, we present a new abstraction level for message passing parallelism. The model of communications between tasks still remains unchanged but is simplified by a new C++ interface. This idea was first proposed in [3], but our approach changes on several points. All kind of message passing libraries are always based on identical sequences of primitive calls like : an init function : to call before anything else. some point to point or collective communication functions : to allow processes to exchange data. an end function : to call before stopping the process. Para++ does not change this model at all, but only provides a new way of exchanging data by using C++ streams instead of communication functions. Indeed, in Para++, inter-tasks communications are just another kind of I/O. That means, we provide new streams called pin and pout (for parallel-in and parallel-out ), which work just like cin and cout, by overloading the standard insertion operator << and >> for C++ input/ouput (see [4]).

2 Consequently, this approachsimplifies all message passing functions, task management, by manipulating C++ objects only. The paper is organised as follows: section 2 presents the C++ objects proposed to manage co-operating tasks. In section 3 we define the syntax and the semantic of both the pin and pout streams. Some collective primitives provided in Para++ are presented in section 4. 2 Task model Para++ allows to use SPMD and MPMD parallelism: both cases will be treated in the following subsections. The was first implemented in [5]. 2.1 within Para++ The main entity in message passing parallelism is the task. In all libraries they are represented as UNIX processes. Within Para++, you do not have a mapping between a UNIX process and a kind of task object. In the, each task must instantiate a ParaProcess object. For example, to compute the value by integration with five processes, the Para++ code could be: #include "Para++" main(int argc, char ** argv) { ParaProcess p("pi", argc, argv); p.init(5); // end of SPMD initialisation // computation on 1 interval // merge of all local results value_reduction(parasum, pi); p.end(); } listing 1 That means, by running this program, the first instantiation of p will set up things in order to be able to spawn 4 other tasks. Actually, the spawn operation is performed by the init(5) method. This method will spawn 4 other tasks within the master task and will have no effect within others. Before leaving the init(5) method, all the five tasks synchronise. Afterwards, the five co-operating tasks will share the same informations in their p object, and will execute the same code (which executable s name is pi ). This initialisation phase ensures integrity of all informations shared (number of task, identifiers of all tasks,) in p. Finally that means, a ParaProcess object represents a set of tasks running the same code. Moreover, the ParaProcess objects include all informations about the cooperating tasks. In particular, a ParaProcess instantiation contains a Vector

3 of all the tasks identifiers. That means, to access task number 4, the programmer may write : int task4 = p.tasks(4); Afterwards, this identifier may be used to send or receive data to or from task number MPMD model within Para++ In order to support MPMD programming model, the new object ParaSlave has been added to Para++. The concept of MPMD programming is to allow one or more master tasks to start slave tasks that will not share the same executable code. That means, whereas master tasks will instantiate a ParaProcess object, slave tasks will instantiate a ParaSlave object. In fact, we group all master tasks by a shared ParaProcess instantiation, and all the identical slaves by a shared ParaSlave instantiation see Figure 1. ParaProcess T1 Tn ParaSlave S1 S1 S2 S1 S2 S3 ParaSlave Sn ParaSlave Figure 1: The MPMD model For example, imagine an application designed to compute the temperaturerepartition in an area. This application might be composed of three sets of tasks : a master task : the interface with the user. some computing tasks : to perform all computation operations. some drawing tasks : to print the results given by the computing tasks. In this example, the master task will instantiate a ParaProcess object, and will call the startslave() method twice: once to spawn the computing group of slaves. once to spawn the printing group of slaves.

4 Each slave will instantiate a ParaSlave object within each group, leading to two shared ParaSlave objects (for the computing group and for the printing group). Actually, we split the world of co-operating processes into three sets : the first with only one task (with the unique ParaProcess object), the second with several tasks (sharing one ParaSlave object) and the third with several tasks (sharing another ParaSlave object). In our model, a slave cannot generate a group of slaves, only ParaProcess object can do it. 3 Inter-tasks streams This section presents a stream-based interface for inter-tasks communication. 3.1 Stream-based data exchanges In C++ language, all I/O operations are performed by specific streams, overloaded by two operators: << and >>. For example, the standard input/output is accessed by cin and cout. To issue the char-string hello world on the standard output, the programmer may write: cout «"hello world" «flush; where cout representsthe target stream, << the flow direction, "hello world" the information flow itself, and flush the flush operation to ensure the string will be printed right now. Since all C++ I/O operations are performed via streams, the idea is to hide send() and recv() operations behind new specific streams that would represent a communication channel between tasks. Para++ provides two specific streams to exchange data with other tasks: pout : to asynchronously send values to another task. pin : to receive values from another task, as a blocking operation. For example, if a task must send the value of n to task t, the programmer may write : pout(t) «n «flush; The syntax is the same as the syntax used with cout. The only difference is the argument passed to pout() in order to specify the target task. 3.2 Matching messages Various possibilities exist to ensure that a >> operation will correctly match a sent message. First, type checking is performed to ensurethat if an integer is put in the pout() stream, only an integer will get it from a pin stream. Secondly, it is possible to tag all messages with an integer. So, to get it from the pin stream you must use the right tag. The syntax remains very simple: pout(t1, 99) «n «flush; sends n s value to task t1 with tag 99. To match it, we use : pin(t2, 99)» n;

5 3.3 Non-blocking receive Finally, Para++ provides a way to performa non-blocking receive. In the pin object the arrived() method can be called to probe the incoming queue before performing the real receive operation with the >> operator. For example, the programmer may write : while (!pin.arrived(t1,tag)) { } pin(t1,tag)» n; In this example, the program will perform actions while waiting for a message from task t1 tagged with tag. When this message has arrived, it is read. 4 Collective Operations Para++ provides several collective operations, they are all presented in the following sections. All these collective operations are only available in the SPMD model either in ParaProcess or in ParaSlave group of tasks. 4.1 Broadcast and multi-cast operations Broadcast and multi-cast operations are supported by Para++, by using particular parameters with the pout stream. That means, to broadcastthe value of n to several tasks, the programmer may write : pout() «n «flush; This function will broadcast the value of n to all tasks within the restricted set of processes defined by the ParaProcess or ParaSlave object. More clearly, if the current task is one of the master tasks (sharing a ParaProcess object), the value will be broadcasted to all the master tasks. On the other side, if the current task is among slave tasks (sharing a particular ParaSlave object), the value will only be broadcasted to the corresponding set of slave tasks. Moreover, Para++ also supports multi-cast operations. To do it, the parameter given to the pout object must be a vector containning all the identifiers of the target tasks. For example, Vector<int> V(5); pout() «n «flush(v); this program will send the value of n to five tasks defined in V.

6 4.2 Synchronisation and Reduction Operations Para++ provides several ways to synchronise tasks. Firstly, the "sync" function allows to synchronise with all the tasks belonging to the same (see Figure 1). Secondly, several methods in ParaProcess and ParaSlave classes allow a ParaProcess object to synchronise with one or all its slaves. Finally, Para++ provides a way to apply a reduction function. The user may call the value_reduction() method to do it. Here again, the scope of the reduction function is limited to set of tasks that the current task is belonging. For example in listing 1 after the value_reduction(parasum, pi) each task has the global value of. In fact we do two operations, first we reduce the value and then we broadcastthis value to all the tasks in the ParaProcess or ParaSlave context. The predefinedoperatorsare ParaSum, ParaProd, ParaMax, ParaMin. 5 Conclusion We have presented new C++ bindings. They are built on top of existing message passing libraries. An implementation has been done on top of PVM and MPI, which allows the use of a unified program with both message passing libraries. Finally, Para++ is not a new C++ extension, but an other way to use, to unify and to simplify all message passing libraries. More details of Para++ and the library are available at coulaud/parapp.html or by anonymous ftp at ftp.loria.fr/pub/loria/numath/para++. References [1] PVM : Parallel Virtual Machine : a users guide and tutorial for networked parallel computing. Al. Geist, A. Beguelin, J. Dongarra, W. Jiang, R. Manchek, V. Sunderam. Mit Press, [2] Using MPI : portable parallel programming with the message- passing interface. W. Gropp, E. Lusk, A. Skjellum. Mit Press, [3] "A Streams-Based Interface in C++ for Programming Heterogeneous Systems", R. Pozo, CRNS-NSF Workshopon Environmentand Tools for Parallel Scientific Computing, September 7-8, 1992, Saint Hilaire du Touvet, France. [4] The C++ programming language, B. Stroustrup, Addison Wesley, [5] Para++ : C++ binding for Message Passing Libraries : User Guide. O. Coulaud and E. Dillon. Rapport Technique INRIA 174, juin 1995.