Search

Defining performance models associated with the application structure has been proven a useful strategy for implementing dynamic tuning tools. However, for extending this strategy to more complex applications (those composed by different structures) it must integrate a policy for the distribution of the resources among the different application components. Consequently, we propose to take advantage of the knowledge of these models and combine them with a resource management policy for obtaining a global model. In this sense, this work constitutes the ongoing effort in the development of performance models for dynamic tuning.

Programs for parallel distributed memory computers are difficult to write, understand, evaluate and debug. The design and performance evaluation of such algorithms is much more complex than for the conventional sequential ones. In such complex systems, the performance is highly influenced by factors such as the interconnection scheme, granularity, computing/communication ratio, algorithm topology, parallel languages, and operating system policies. Interaction between these factors is not easy to understand and is often unpredictable. This paper presents an overview of PSEE (Parallel System Evaluation Environment), which is an interactive graphics environment, as well as several enhancements to increase the goodness of this tool. PSEE is an easy-to-use environment that enables parallel systems programmers to take decisions about the behaviour of parallel programs and parallel computers in terms such as scalability, tuning and performance. >

The STMDS (Self-Tuning-Machines Development System) has been designed, with the aim of verifying strategies for structures of computers, which gradually increase their speed during the actual program execution. The system incorporates the functions of development and of dynamically changing the microprogrammed interpreter, as well as a complete environment of experience.

Parallel/distributed application development is a very difficult task for non-expert programmers, and therefore support tools are needed for all phases of this kind of application development cycle. This means that developing applications using predefined programming structures (frameworks) should be easier than doing it from scratch. We propose to take advantage of the knowledge about the structure of the application in order to develop a dynamic and automatic tuning tool. In this sense, we have designed POETRIES, which is a dynamic performance tuning tool based on the idea that a performance model could be associated to the high-level structure of the application. This way, the tool could efficiently make better tuning decisions. Specifically, we focus this work on the definition of the performance model associated to applications developed with the master-worker framework.

Parallel systems are wellknown solutions to satisfy the demand of computing capabilities, but parallel computer design involves difficult hardware/software tradeoffs. Standard general purpose parallel architectures don't exist, only some particular architectures are used to solve specific problems. In such complex systems the performance measurement is important to evaluate several situations for existing architectures or for systems in designing phase. This performance is highly influenced by factors as interconnection scheme, granularity, computing/communication ratio, algorithm topology and operating system policies. Interaction between these factors is not easy to understand and often unpredictable. Simulation has proved to be useful as a tool for system design and performance evaluation, allowing a simple way to compare different alternatives. In this paper, an integrated simulation environment for the design and evaluation of parallel computing systems is presented. It has been designed for a large-grain data flow programming model, which we call Weighted Behavioral Graph (WBG). This formalism allows the representation of both the static and dynamic properties of the program graph. The simulation environment provides facilities for the program and interconnection graph's specification, as well as the scheduler and router policy's selection. An icon based, multiwindow graphic front end allows for a friendly man-machine interface, thus reducing the model's development cycle.

We have developed a set of tools for software engineering in parallel processing (EU-funded project). The aims of the project are to develop methodologies and tools for parallel software engineering. The main tool corresponds to an event-driven simulator that uses synthetic descriptions of a parallel programme and a parallel architecture. This work deals with the model verification, the data collection and the simulator validation.

Currently, performance analysis support tools are required to exploit the potential performance of large-scale computers. However, in this context, scalability becomes a major problem for this kind of tools. Nowadays, there are automatic performance analysis tools, such as Scalasca [1] or Periscope [2], capable of scaling and looking for performance problems of parallel applications. Nevertheless, if the behaviour of a parallel application varies during the execution according to the data evolution, then dynamic analysis and tuning of the application during its execution, such as that performed by MATE [3] tool, is necessary.

Our objective is to show a parallel system development method within the educational area based on the Parallel System Development Environment (PSEE). To do so, first we define the development cycle proposed by PSEE, and the theoretical model underlying it. Secondly, we use an example (matrix multiplication algorithm) to illustrate all the method steps, which are: Algorithm Choice-Criteria, Problem Presentation (how to present the problem to the student), Modelling the algorithm (using the theoretical model), Programming (using an appropriate parallel language), Functional Simulation of the program, Behavioral Simulation (algorithm and architecture), and Trace Visualization and Evaluation. This paper gives a description of the parallel systems development method, based on our own experience with PSEE (Parallel System Evaluation Environment) [1].

The Master/Worker paradigm is one of the most commonly used by parallel/distributed application developers. This paradigm is easy to understand and is fairly close to the abstract concept of a wide range of applications. However, to obtain adequate performance indexes, such a paradigm must be managed in a very precise way. There are certain features, such as data distribution or the number of workers, that must be tuned properly in order to obtain such performance indexes, and in most cases they cannot be tuned statically since they depend on the particular conditions of each execution. In this context, dynamic tuning seems to be a highly promising approach since it provides the capability to change the parameters during the execution of the application to improve performance. In this paper, we demonstrate the usage of a dynamic tuning environment that allows for adaptation of the number of workers based on a theoretical model of Master/Worker behavior. The results show that such an approach significantly improves the execution time when the application modifies its behavior during execution.

We describe the structure and operational mode of a coprocessor system which, when incorporated in a microprogrammed syetem to carry out Dynamic Vertical Migration, improves execution speed for any program. The coprocessor includes an interconnection mechanism between the machine code and the instruction set microcode. The interconnections (Intermediate instructions) are created in parallel with machine instruction execution and so do not increase normal execution time. This intermediate code is stored dynamically in coprocessor memory, saving the fetching and decoding phases in subsequent executions, speeding up the execution of repetitive machine code.The coprocessor structure is organized around three basic elements: Interconnection Memory, Interconnection Memory Management Unit and Coprocessor Control Unit. A software simulator has been developed to analyse coprocessor behaviour and a theoretical model has been formulated from the results ot these analyses.

Programs for parallel computers of distributed memory are difficult to write, understand, evaluate and debug. The design and performance evaluation of algorithms is much more complex than the conventional sequential one. The technical know/how necessary for the implementation of parallel systems is already available, but a critical problem is in the handling of complexity. In parallel distributed memory systems the performance is highly influenced by factors as interconnection scheme, granularity, computing/communication ratio, algorithm topology, parallel languages, and operating system policies. Interaction between these factors is not easy to understand and often unpredictable. This paper presents the PSEE (Parallel System Evaluation Environment), an interactive graphical environment, which permits to study the behaviour of parallel distributed memory systems, as well as several enhancements to increase the goodness of this tool. PSEE is an easy-to-use environment that enables parallel distributed memory systems programmers take decisions about the behaviour program and parallel computer in terms such as scalability, tuning and performance of the underlying parallel machine.

PSEE (Parallel System Evaluation Environment) is a software tool that provides a multiprocessor system for research into alternative architectural decisions and experimentation, with such issues as selection, design, tuning, scheduling, clustering and routing policies. PSEE facilitates simulation and performance evaluation as well as a prediction environment for the design and tuning of parallel systems. These tasks involve cycles through programming, simulation, measurement, visualization and modification of parallel system parameters. PSEE includes a parallel programming tool, a simulator for link oriented parallel systems, BOLAS, and a performance evaluation tool, GRAPH. These PSEE modules are tools oriented to support the above tasks in user-friendly, interactive and animated graphical form. PSEE provides quantitative information in a graphical tailored form. This numerical/graphical output helps the user make decisions about his/her particular development.

A method for Dynamic Vertical Migration based on the inclusion of a coprocessor is described. It optimally runs without firmware monitoring techniques and can be applied with neither knowledge of loops bounds, nor their microprogrammability. The coprocessor generates, for every instruction, an interconnection between the instruction and its microprogram execution code. This interconnections are stored in a coprocessor memory saving the fetching and decoding phases in subsequent executions. The coprocessor structure is organized around three basic elements. Interconnection Memory, Interconnection Memory Management Unit and Coprocessor Control Unit. The behaviour of the Interconnection Memory Management Unit has been studied for two different replacement algorithms.

Parallel/Distributed application development is an extremely difficult task for non-expert programmers, and support tools are therefore needed for all phases of the development cycle of these kinds of application. This study specifically presents the development of an analytical performance model for pipelined applications. This model is intended to be used in the POETRIES distributed-program development environment, which is aimed at dynamic performance tuning based on frameworks with an associated performance model.

Programs for parallel computers of distributed memory are difficult to write, understand, evaluate and debug. The design and performance evaluation of algorithms is much complex than the conventional sequential one. This short paper describes the PSEE (Parallel System Evaluation Environment), an interactive graphical environment, which permits to study the behaviour of parallel distributed memory systems. PSEE is an easy-to-use environment that enables parallel distributed memory systems programmers take decisions about the behaviour program and parallel computer in terms such as: scalability, tuning and performance of the underlying parallel machine.

Nowadays, there are several features related to node architecture, network topology and programming model that significantly affect the performance of applications. Therefore, the task of adjusting the values of parameters of hybrid parallel applications to achieve the best performance requires a high degree of expertise and a huge effort. Determining a performance model that considers all the system and application features is a very complex task that in most cases produces poor results. In order to simplify this goal and improve the results, we introduce a model-based regression tree technique to improve the accuracy of performance prediction for parallel Master/Worker applications on homogeneous multicore systems. The technique has been used to model the iteration time of the general expression for performance prediction. This approach significantly reduces the effort in getting an accurate prediction model, although it requires a relatively large training data set. The proposed model determines the configuration of the appropriate number of workers and threads of the hybrid application to achieve the best possible performance.