1,721,314 research outputs found
Feasibility of automatic adaptation of structured parallel programs
No full textWhen executing highly demanding parallel/distributed applications on grids or non-dedicated parallel architectures, several important issues have to be taken into account to achieve efficiency. These issues can be neglected when more traditional parallel machines are used, instead. In particular, applications should be programmed in such a way they adapt their behavior to the dynamically varying features of the target architecture (node load and availability, node and network link faults, etc). Recently, autonomic control strategies have been proposed to implement adaptation code, cyclically alternating monitoring, analysis, planning and execution phases. The monitoring phase triggers misbehaviors and in the analysis phase an adaptation strategy is figured out whose execution is subsequently planned and executed. In case traditional parallel programming environments are used, the task of transforming a plain parallel/distributed application into an adaptive one is completely in charge to the application programmers. The programming of adaptation code is not a trivial task, however. Monitoring activities should be set up as further, independent, concurrent activities with respect to normal application workflow. The analysis phase triggered by relevant monitoring events should be carefully programmed to exploit the existing knowledge on parallelism exploitation techniques as well as any kind of clever, effective heuristics available. Planning of the decisions taken at the end of the analysis phase requires to understand and exploit the parallel structure of the application, in particular to devise which are the "synchronization points" to be awaited to safely perform the adaptation actions. Planning and execution phases require a deep knowledge of the underlying grid/cluster middleware, to achieve efficiency in the adaptation process. We claim that when structured parallel programming models are considered, the transformation of plain application code into adaptive code can be fully automatized, instead. Structured parallel programming models provide programmers with a (possibly restricted) set of pre-defined parallelism exploitation patterns that can be instantiated and composed to model the full parallel structure of the application at hand. The predefined parallelism exploitation patterns are implemented using some combination of non-trivial compiler and run time tools. The whole responsibility of parallelism exploitation being in charge of the support tools, rather than of the application programmers, an adaptation manager can be easily added to the support tools once and for all, exploiting the autonomic control strategy mentioned above. In particular, monitoring activities can be implemented in the support tools in the very same way all the other activities needed to efficiently implement the support tools are programmed. The analysis phase may exploit the same knowledge exploited to efficiently implement the predefined parallelism exploitation patterns provided to the programmers. Eventually, planning and execution phases may capitalize on the knowledge used in the support tools related to the efficient usage of the underlying grid middleware. Within the GRID.it three-year Italian national research project (http://www.grid.it), we developed a structured parallel programming environment that actually provides grid application programmers with autonomic adaptation capabilities. The ASSIST (http://www.di.unipi.it/Assist.html) programming environment (released as open source under the GNU license) both provides a high level, structured coordination language and a "manager" tool and concept. The coordination language can be used to develop efficient parallel applications running on top of Globus grids as well as on top of plain POSIX TCP/IP workstation networks. The ASSIST manager can be invoked providing a "performance contract". It automatically controls the behavior of ASSIST applications in such a way they adapt, without any kind of programmer intervention, to the varying grid features while trying to satisfy (best effort) the user supplied performance contract. Recent results show how automatic adaptation of ASSIST PARMODs (the generic, parametric PARallel MODule parallelism exploitation pattern provided to programmers by ASSIST) can be achieved. It has also been demonstrated how automatic adaptation can be achieved in ASSIST super components (super components are components taking other components as parameters and modeling common parallelism exploitation patterns out of them). These results are currently being exploited in the framework of the CoreGRID (http://www.coregrid.net) EU Network of Excellence. Within CoreGRID, the Programming model Institute is defining GCM, the Grid Component Model, a component based programming model suitable for programming high performance grid applications. Within GCM, autonomic managers have been recognized as a key concept to succeed delivering the "non trivial qualities of service" advocated by Ian Foster in his three-point checklist defining grids
Extending the VLIW approach to fine grain parallelism exploitation beyond single control unit machines
No full textIrregularity handling via structured parallel programming
No full textIrregularity arises in different contexts and causes different problems in parallel computing. We discuss some typical irregularity sources and we show how the related problems can be automatically solved by adopting high-level structured parallel programming techniques. In particular, by adopting those programming models only requiring the programmer to express the qualitative parallel behaviour of the application, and then automatically taking care of irregularity in the compiler or in the runtime support. Experimental results are presented, using either dedicated, homogeneous workstation clusters or undedicated, heterogeneous workstation networks, to demonstrate the effectiveness of the proposed approach
Programmazione parallela: Evoluzione e nuove sfide [Parallel programming: Evolution and new challenges]
No full textRecent advances in digital components provided faster and more powerful computing devices that open new challenges to the programming tools. Classical programming tools require quite a programming effort in all those cases where the advanced features of these new components must be exploited. In this work, we discuss some recent advances in the field of the structured parallel programming models that support the rapid development of efficient parallel applications suitable to exploit all the new features available
HPC the easy way: new technologies for high performance applications deployment
No full textWith the increase of both computing power available and computer application size and complexity, existing programming methodologies and technologies for parallel and distributed computing demonstrated their inadequacy. New techniques have therefore been designed and are currently being developed that aim at providing the user/programmer with higher level programming methodologies, environments and run time supports. In this work, we take into account some of these new technologies and we discuss their features, both positive and negative. Eventually, exploiting our experience in structured parallel programming environment design, we try to summarize which features have to be included in the programming environments of the near future, those answering (or trying to answer) the pressures and urgencies of current days claiming for new, efficient, easy to use high performance programming environments
QoS in parallel programming through application managers
No full textWe present an evolution of the Lithium parallel
programming environment (the muskel Java
package) that implements new features suitable for
handling problems arising in typical dynamic
environments such as the grid ones. In particular, our
environment provides a prototype application manager
that takes completely care of maintaining a given
quality of service. The first version of muskel we
discuss here is able to ensure a constant number of
active processing elements assigned to computations in
presence of failures of different types. The application
manager embedded in muskel represents a prototype
experience. It demonstrates the feasibility of a run time
support controlled quality of service approach. In
particular, it shows that a user supplied “performance
contract” can be automatically ensured
Adaptive Task Farm Implementation Strategies
No full textTask farm parallelism exploitation pattern is used in a wide range of parallel
applications. Due to the independence of the computations relative to the
different tasks, efficient methods have been developed that can be used to
implement task farms on both SMP/MPP and on homogeneous, static network/clusters
of workstations. In this work we discuss a new implementation strategy for task
farm computations that takes into account dynamicity and heterogeneity in the
availability of computing resources as well as fault tolerance. The proposed
implementation schema suitably addresses classical situations relative to both
peer-to-peer and GRID worlds
- …
