Self-optimizing skeleton execution using events

This thesis presents a novel way to introduce self-configuration and self-optimization autonomic characteristics to Algorithmic Skeletons using Event-Driven Programming (EDP) techniques. Due to the use of event driven programming, the approach proposed in this thesis contributes to the current solutions as follows: • It is not related to a specific application architecture, like the component architecture. Thus, it has a broader scope, and is independent of the architecture used to implement skeletons. • It allows the introduction of structural changes during execution time. Therefore, it provides a higher level of adaptability compared with other solutions that only allows to introduce structural changes during compilation. • The estimates of expected future work can be calculated on-the-fly, and it is not limited to pre-calculated estimates. This thesis focuses mainly on guaranteeing a given execution time for a skeleton, by optimizing the number of threads allocated to execute an skeleton. The QoSs (Quality of Services) autonomically managed to be self-configured and self-optimized are: (1) Execution Wall Clock Time, and (2) Level of Parallelism. Other contributions are: • Design and implementation of a novel skeleton’s separation-of-concerns based on event driven programing. This novel approach allows the introduction of non-functional concerns to skeletons without lowering its higher-level programming. • Evaluation of different estimation strategies of future work was done. As result, a recommendation is presented to answer the question: Which strategy produces better estimates under which circumstances?.

[1]  Thierry Coupaye,et al.  The FRACTAL component model and its support in Java , 2006, Softw. Pract. Exp..

[2]  Bruce P. Douglass,et al.  Doing hard time: developing real-time systems with uml , 1999 .

[3]  Marco Danelutto,et al.  Autonomic QoS in ASSIST grid-aware components , 2006, 14th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP'06).

[4]  Mario Leyton,et al.  Tackling Algorithmic Skeleton's Inversion of Control , 2012, 2012 20th Euromicro International Conference on Parallel, Distributed and Network-based Processing.

[5]  Miro Samek,et al.  Practical UML Statecharts in C/C++: Event-Driven Programming for Embedded Systems , 2002 .

[6]  Cédric Fournet,et al.  The reflexive CHAM and the join-calculus , 1996, POPL '96.

[7]  Françoise Baude,et al.  Using components to provide a flexible adaptation loop to component-based SOA applications , 2012 .

[8]  Mira Mezini,et al.  EScala: modular event-driven object interactions in scala , 2011, AOSD '11.

[9]  Mario Leyton,et al.  Skandium: Multi-core Programming with Algorithmic Skeletons , 2010, 2010 18th Euromicro Conference on Parallel, Distributed and Network-based Processing.

[10]  Murray Cole,et al.  Algorithmic Skeletons: Structured Management of Parallel Computation , 1989 .

[11]  Peter Kilpatrick,et al.  The ParaPhrase Project: Parallel Patterns for Adaptive Heterogeneous Multicore Systems , 2011, FMCO.

[12]  Mira Mezini,et al.  JEScala: modular coordination with declarative events and joins , 2014, MODULARITY.

[13]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[14]  Rita Loogen,et al.  Estimating parallel performance , 2013, J. Parallel Distributed Comput..

[15]  Christoph W. Kessler,et al.  Auto-tuning SkePU: a multi-backend skeleton programming framework for multi-GPU systems , 2011, IWMSE '11.

[16]  Hugh Leather,et al.  Auto-Tuning Parallel Skeletons , 2012, Parallel Process. Lett..

[17]  Denis Caromel,et al.  Fine Tuning Algorithmic Skeletons , 2007, Euro-Par.

[18]  Petr Jan Horn,et al.  Autonomic Computing: IBM's Perspective on the State of Information Technology , 2001 .

[19]  Mario Leyton,et al.  Advanced features for algorithmic skeleton programming , 2008 .

[20]  Map , 1994, Imagining the Sacred Past.

[21]  Ludovic Henrio,et al.  A component platform for experimenting with autonomic composition , 2007, AUTONOMICS 2007.

[22]  Horacio González-Vélez,et al.  Adaptive structured parallelism for distributed heterogeneous architectures: a methodological approach with pipelines and farms , 2010, Concurr. Comput. Pract. Exp..

[23]  Jeffrey O. Kephart,et al.  The Vision of Autonomic Computing , 2003, Computer.

[24]  Denis Caromel,et al.  GCM: a grid extension to Fractal for autonomous distributed components , 2009, Ann. des Télécommunications.

[25]  Horacio González-Vélez,et al.  A survey of algorithmic skeleton frameworks: high‐level structured parallel programming enablers , 2010, Softw. Pract. Exp..

[26]  David Patterson The trouble with multi-core , 2010, IEEE Spectrum.

[27]  Marco Danelutto,et al.  Securing skeletal systems with limited performance penalty: The muskel , 2008, J. Syst. Archit..

[28]  José M. Troya,et al.  Adding Aspect-Oriented Concepts to the High-Performance Component Model of SBASCO , 2009, 2009 17th Euromicro International Conference on Parallel, Distributed and Network-based Processing.

[29]  Peter Kilpatrick,et al.  Managing Adaptivity in Parallel Systems , 2011, FMCO.

[30]  Peter Kilpatrick,et al.  Autonomic management of non-functional concerns in distributed & parallel application programming , 2009, 2009 IEEE International Symposium on Parallel & Distributed Processing.

[31]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[32]  Murray Cole,et al.  Bringing skeletons out of the closet: a pragmatic manifesto for skeletal parallel programming , 2004, Parallel Comput..

[33]  Thomas Ledoux,et al.  An Aspect-Oriented Approach for Developing Self-Adaptive Fractal Components , 2006, SC@ETAPS.