Distributed Objects for Parallel Numerical Applications

Francoise Baude; Denis Caromel; David Sagnol

ESAIM: Mathematical Modelling and Numerical Analysis (2010)

  • Volume: 36, Issue: 5, page 837-861
  • ISSN: 0764-583X

Abstract

top
The C++// language (pronounced C++parallel) was designed and implemented with the aim of importing reusability into parallel and concurrent programming, in the framework of a mimd model. From a reduced set of rather simple primitives, comprehensive and versatile libraries are defined. In the absence of any syntactical extension, the C++// user writes standard C++ code. The libraries are themselves extensible by the final users, making C++// an open system. Two specific techniques to improve performances of a distributed object language such as C++// are then presented: Shared-on-Read and Overlapping of Communication and Computation. The appliance of those techniques is guided by the programmer at a very high-level of abstraction, so the additional work to yield those good performance improvements is kept to the minimum.

How to cite

top

Baude, Francoise, Caromel, Denis, and Sagnol, David. "Distributed Objects for Parallel Numerical Applications." ESAIM: Mathematical Modelling and Numerical Analysis 36.5 (2010): 837-861. <http://eudml.org/doc/194129>.

@article{Baude2010,
abstract = { The C++// language (pronounced C++parallel) was designed and implemented with the aim of importing reusability into parallel and concurrent programming, in the framework of a mimd model. From a reduced set of rather simple primitives, comprehensive and versatile libraries are defined. In the absence of any syntactical extension, the C++// user writes standard C++ code. The libraries are themselves extensible by the final users, making C++// an open system. Two specific techniques to improve performances of a distributed object language such as C++// are then presented: Shared-on-Read and Overlapping of Communication and Computation. The appliance of those techniques is guided by the programmer at a very high-level of abstraction, so the additional work to yield those good performance improvements is kept to the minimum. },
author = {Baude, Francoise, Caromel, Denis, Sagnol, David},
journal = {ESAIM: Mathematical Modelling and Numerical Analysis},
keywords = {Concurrency; data-driven synchronization; dynamic binding; inheritance; object-oriented concurrent programming; polymorphism; reusability; software development method; wait-by-necessity; overlap; object sharing.; concurrency; dynamic binding; polymorphism; overlap; object sharing},
language = {eng},
month = {3},
number = {5},
pages = {837-861},
publisher = {EDP Sciences},
title = {Distributed Objects for Parallel Numerical Applications},
url = {http://eudml.org/doc/194129},
volume = {36},
year = {2010},
}

TY - JOUR
AU - Baude, Francoise
AU - Caromel, Denis
AU - Sagnol, David
TI - Distributed Objects for Parallel Numerical Applications
JO - ESAIM: Mathematical Modelling and Numerical Analysis
DA - 2010/3//
PB - EDP Sciences
VL - 36
IS - 5
SP - 837
EP - 861
AB - The C++// language (pronounced C++parallel) was designed and implemented with the aim of importing reusability into parallel and concurrent programming, in the framework of a mimd model. From a reduced set of rather simple primitives, comprehensive and versatile libraries are defined. In the absence of any syntactical extension, the C++// user writes standard C++ code. The libraries are themselves extensible by the final users, making C++// an open system. Two specific techniques to improve performances of a distributed object language such as C++// are then presented: Shared-on-Read and Overlapping of Communication and Computation. The appliance of those techniques is guided by the programmer at a very high-level of abstraction, so the additional work to yield those good performance improvements is kept to the minimum.
LA - eng
KW - Concurrency; data-driven synchronization; dynamic binding; inheritance; object-oriented concurrent programming; polymorphism; reusability; software development method; wait-by-necessity; overlap; object sharing.; concurrency; dynamic binding; polymorphism; overlap; object sharing
UR - http://eudml.org/doc/194129
ER -

References

top
  1. Parallel Virtual Machine: a user's guide and tutorial for networked parallel computing. MIT Press (1994).  Zbl0849.68032
  2. MPI: The Complete Reference. MIT Press (1998).  
  3. G. Agha, Actors: A Model of Concurrent Computation in Distributed Systems. MIT Press (1986).  
  4. I. Attali, D. Caromel and M. Oudshoorn, A Formal Definition of the Dynamic Semantics of the Eiffel Language, in Sixteenth Australian Computer Science Conference (ACSC-16), G. Gupta, G. Mohay and R. Topor Eds., Griffith University, February (1993) 109-120.  
  5. I. Attali, D. Caromel and M. Russo, Graphical Visualization of Java Objects, Threads, and Locks. IEEE Distributed Systems Online 2 (2001).  
  6. H.E. Bal, M.F. Kaashoek, A.S. Tanenbaum and J. Jansen, Replication techniques for speeding up parallel applications on distributed systems. Concurrency Practice & Experience4 (1992) 337-355.  
  7. F. Baude, D. Caromel, N. Furmento and D. Sagnol, Optimizing Metacomputing with Communication-Computation Overlap, in 6th International Conference PaCT 2001, number 2127, V. Malyshkin Ed., LNCS, 190-204.  Zbl0997.68619
  8. A. Birrell, G. Nelson, S. Owicki and E. Wobber, Network Objects. Technical Report SRC-RR-115, DEC Systems Research Center (1995).  
  9. G. Booch, Object-Oriented Development. IEEE Transaction on Software Engineering (1986).  Zbl0746.68017
  10. T. Brandes and F. Desprez, Implementing Pipelined Computation and Communication in an HPF Compiler, in Euro-Par'96, number 1123, LNCS.  
  11. F. Buschmann, K. Kiefer, F. Paulish and M. Stal, The Meta-Information-Protocol: Run-Time Type Information for C++, in Proceedings of the International Workshop on Reflection and Meta-Level Architecture, A. Yonezawa and B.C. Smith Eds. (1992) 82-87.  
  12. D. Caromel, Service, Asynchrony and wait-by-necessity. Journal of Object-Oriented Programming2 (1989) 12-22.  
  13. D. Caromel, Concurrency: an Object Oriented Approach, in Technology of Object-Oriented Languages and Systems (TOOLS'90), J. Bezivin, B. Meyer and J.-M. Nerson Eds., Angkor, June (1990) 183-197.  
  14. D. Caromel, Concurrency and Reusability: From Sequential to Parallel. Journal of Object-Oriented Programming3 (1990) 34-42.  
  15. D. Caromel, Towards a Method of Object-Oriented Concurrent Programming. Communications of the ACM36 (1993) 90-102.  
  16. D. Caromel, F. Belloncle and Y. Roudier, The C++// Language, in Parallel Programming Using C++, MIT Press (1996) 257-296.  
  17. D. Caromel, P. Dzwig, R. Kauffman, H. Liddell, A. McEwan, P. Mussi, J. Poole, M. Rigg and R. Winder, EC++ - EUROPA Parallel C++: A Draft Definition, in Proceedings of High-Performance Computing and Networking (HPCN'96), Vol. 1067, LNCS, 848-857.  
  18. D. Caromel, W. Klauser and J. Vayssiere, Towards Seamless Computing and Metacomputing in Java. Concurrency Practice and Experience (1998).  
  19. D. Caromel, E. Noulard and D. Sagnol, Sharedonread optimization in parallel object-oriented programming, in Computing in Object-Oriented Parallel Environments, Proceedings of ISCOPE'99, LNCS, San Francisco, Dec (1999).  
  20. S. Chiba and T. Masuda, Designing an Extensible Distributed Language with Meta-Level Architecture, in Proceedings of the 7th European Conference on Object-Oriented Programming (ECOOP '93), O. Nierstrasz Ed., Springer-Verlag, Kaiserslautern, Lecture Notes in Computer Science 707 (1993) 482-501.  
  21. J. Choi, J. Dongarra, S. Ostrouchov, A. Petitet, D. Walker and R.C. Whaley, A proposal for a set of parallel basic linear algebra subprograms. Technical Report Lapack Working Note 100, May (1995).  
  22. A. Dave, M. Sefika and R.H. Campbell, Proxies, Application Interfaces and Distributed Systems, in proceedings of the 2nd International Workshop on Object-Orientation in Operating Systems (OOOS), Paris (France), IEEE Computer Society Press, September (1992).  
  23. F. Desprez, P. Ramet and J. Roman, Optimal Grain Size Computation for Pipelined Algorithms, in Euro-Par'96, number 1123, LNCS.  
  24. S. Diwan and D. Gannon, Capabilities Based Communication Model for High-Performance Distributed Applications: The Open HPC++ Approach, in IPPS/SPDP (1999). ftp://ftp.cs.indiana.edu/pub/sdiwan/capab.ps.gz  
  25. I. Foster and C. Kesselman, Globus: A metacomputing infrastructure toolkit. International Journal of Supercomputer Applications11 (1997) 115-128.  
  26. D. Gannon, S. Diwan and E. Johnson, HPC++ and the Europa Call Reification Model. ACM Applied Computing Review 4 (1996).  
  27. N. Gehani, Concurrent Programming in the ADA Language: the Polling Bias. Software-Practice and Experience14 (1984).  Zbl0536.68014
  28. R. Halstead, Multilisp: A Language for Concurrent Symbolic Computation. ACM Transactions on Programming Languages and Systems, October (1985).  Zbl0581.68037
  29. S.B. Hassen and H. Bal, Integrating task and data parallelism using shared objects, in FCRC '96: Conference proceedings of the 1996 International Conference on Supercomputing: Philadelphia, PA, USA, May 25-28, 1996, ACM Ed., ACM Press, New York (1996) 317-324.  
  30. C. Hewitt, Viewing Control Structures as Patterns of Passing Messages. J. Artificial Intelligence Res.8 (1977) 323-64.  
  31. Y. Ishikawa, A. Hori, M. Sato, M. Matsuda, J. Nolte, H. Tezuka, H. Konaka, M. Maeda and K. Kubota, Design and implementation of metalevel architecture in C++ - MPC++ approach, in Reflection'96, April (1996).  
  32. G. Kiczales, J. des Rivières and D.G. Bobrow, The Art of the Metaobject Protocol. MIT Press (1991).  
  33. H. Lieberman, Concurrent Object-Oriented Programming in Act 1, in Object-Oriented Concurrent Programming, A. Yonezawa and M. Tokoro Eds., MIT Press (1987).  
  34. P. Madany, N. Islam, P. Kougiouris and R.H. Campbell, Practical Examples of Reification and Reflection in C++, in Proceedings of the International Workshop on Reflection and Meta-Level Architecture, A. Yonezawa and B.C. Smith Eds. (1992) 76-81.  
  35. B. Meyer, Object-Oriented Software Construction. Prentice-Hall (1988).  Zbl0719.68012
  36. E. Noulard, N. Emad and L. Flandrin, Calcul numérique parallèle et technologies objet. Technical Report Rapport PRISM 1998/003, ADULIS/PRiSM, Juillet (1997). Révision du 30/01/98.  
  37. R. Rashid, R. Baron, A. Forin, D. Golub, M. Jones, D. Orr and R. Sanzi, Mach: a foundation for open systems (operating systems), in Workstation Operating Systems: Proceedings of the Second Workshop on Workstation Operating Systems (WWOS-II), Pacific Grove, CA, USA, September 27-29, 1989, IEEE Ed., IEEE Computer Society Presspages (1989) 109-113.  
  38. Y. Saad, Iterative Methods for Sparse Linear Systems. PWS Publishing Company, New York (1996).  Zbl1031.65047
  39. M. Shapiro, Structure and Encapsulation in Distributed Systems: the Proxy Principle, in Proceedings of the 6th International Conference on Distributed Computing Systems, Cambridge, MA, USA, IEEE, May (1986) 198-204.  
  40. C.W. Tseng, An Optimizing Fortran D Compiler for MIMD Distributed-Memory Machines. Ph.D. thesis, Rice University (1993).  
  41. G. Wilson and P. Lu Eds., Parallel Programming Using C++. MIT Press (1996).  
  42. Y. Yokote and M. Tokoro, Concurrent Programming in ConcurrentSmalltalk, in Object-Oriented Concurrent Programming, A. Yonezawa and M. Tokoro Eds., MIT Press (1987).  
  43. A. Yonezawa, E. Shibayama, T. Takada and Y. Honda, Modelling and Programming in an Object-Oriented Concurrent Language ABCL/1, in Object-Oriented Concurrent Programming, A. Yonezawa and M. Tokoro Eds., MIT Press (1987).  

NotesEmbed ?

top

You must be logged in to post comments.

To embed these notes on your page include the following JavaScript code on your page where you want the notes to appear.

Only the controls for the widget will be shown in your chosen language. Notes will be shown in their authored language.

Tells the widget how many notes to show per page. You can cycle through additional notes using the next and previous controls.

    
                

Note: Best practice suggests putting the JavaScript code just before the closing </body> tag.