Automation of high-performance programs construction is a relevant and challenging problem. Automatic construction of programs that are suitable (e.g. efficient-enough) for practical use within reasonable time critically depends on peculiarities of the target subject domain. Because of this dependency general approaches fail, explaining the diversity of languages, systems and tools developed for automating program construction in specific subject domains. To overcome these limitations, the active knowledge concept, a methodology for automatic program synthesis, proposes employing an active knowledge base—a machine-oriented formal description of a subject domain that captures its peculiarities. Using an active knowledge base significantly reduces the complexity of program construction automation while improving the quality of the resulting programs. Implementation of the active knowledge concept ideas in practice raises a number of technological issues. In the paper we present how we resolve them within the framework of the LuNA system for automatic program construction, which is based on the active knowledge concept.

Didal is a distributed data library that supports development of efficient parallel fragmented programs on distributed memory supercomputers. Fragmented programming is a technology where a parallel program is represented as a collection of pieces of data (data fragments) and computations on these pieces (computation fragments), able to be tuned to the resources of a computing system and automatically provide such facilities as dynamic load balancing. While several tools for fragmented programming exist, Didal aims to get benefits from as being a simple to use C++ library, as being able to produce efficient parallel programs. In this paper we study parallelization with Didal library of RHD3D application for numerical modeling of colliding flows in relativistic hydrodynamics. Results of the parallel program’s efficiency and its comparison with Coarray Fortran implementation are provided.

Nowadays with rapid evolution of high-performance computing systems it’s becoming essential to have tools to simplify development of efficient portable parallel programs for these systems. Fragmented programming is a technology where parallel program is represented as a collection of pieces of data (data fragments) and computations on these pieces (computation fragments), able to be tuned to the resources of a computing system and automatically provide such facilities as dynamic load balancing. Didal is a distributed data library to support development of efficient parallel fragmented programs on distributed memory supercomputers. The library contains facilities for data partitioning, distribution and load balancing. In this paper foundations of the library are explained and applicability of the library is demonstrated with Particle-in-Cell (PIC) method implementation, which shows performance comparable to conventional parallel programming tools.

In the paper an improved trace playback technique is presented. Run-time systems are widely used in parallel programming to provide dynamic properties of programs execution. However, run-time system often cause significant overhead. Trace playback is a technique, oriented to improve parallel program execution by reducing the overhead. It consists in recording a special log (called trace ) while run-time system executes a program. The trace contains enough information on exact actions performed to reproduce the execution without the run-time system. Run-time system overhead is thus eliminated. The technique is usable in such systems as LuNA. The proposed improvement of the technique consists in modification of (“balancing”) the trace before trace playback in order to fit more efficiently into given multicomputer. Particular balancing algorithm, as well as experimental study results are presented in the paper. The improvement showed a significant performance increase.

The LuNA system, which was created in ICMMG SB RAS, follows the approach of fragmented programming. The LuNA-program runs in parallel, but the programmer does not specify the behaviour of individual processes or threads when creating it. Instead, the user defines the content of computational fragments that may have dependencies on each other. Then, during the execution of the LuNA-program, the runtime system allocates independent computational fragments and distributes them to computing nodes and cores of the multicomputer.Some properties of the system play significant role, e.g. LuNA is the single assignment language and the execution order of operators in the subprogram body is undefined in general case. That is why LuNA-programs are characterized by specific errors. They are not peculiar neither to sequential programs, nor to parallel in classical technologies (MPI, OpenMP etc.) The paper contains classification of semantic errors that are specific for fragmented programs. The analysis of the various approaches applicability to automated debugging in the LuNA system is given. The paper also describes the operation principle of the tool created by the authors for detecting some popular fragmented program errors. The work of the tool is shown on the example of a test programs with different errors. Since the debugging tool is based on a “post-mortem” analysis, it is important to evaluate overhead. The evaluation results are also given in the paper. The directions of further work are described.

Automatic construction of high performance distributed numerical simulation programs is used to reduce complexity of distributed parallel programs development and to improve code efficiency as compared to an average manual development. Development of such means, however, is challenging in general case, that’s why a variety of different languages, systems and tools for parallel programs construction exist and evolve. Program tracing (i.e. journaling execution acts of the program) is a valuable source of information, which can be used to optimize efficiency of constructed programs for particular execution conditions and input data peculiarities. One of the optimization techniques is trace playback, which consists in step-by-step reproduction of the trace. This allows reducing run-time overhead, which is relevant for runtime system-based tools. The experimental results demonstrate suitability of the technique for a range of applications.

Dear Colleagues,This special issue of the journal is devoted to Parallel Computing Technologies (PaCT).Today the PaCT is the mainstream research area in parallel computing.Generally, Science of Parallel Computing Technologies studies laws of the combined use of the results obtained in many different research areas: pure and applied mathematics, computer science, hardware architectures and software technologies, subject domains, including results from any disciplines needed for proving a successful application of supercomputers in a certain application area.Contrary to research in a "narrow" area, where usually a pure mathematical theory can be developed, in the PaCT we deal with a wide range of practical problems where it is impossible to operate only with the notions of a high abstraction in the framework of a certain theory suitable for analysis.As a rule, we are forced to operate simultaneously with the notions from different levels of abstraction as well as from the different theories.This demands the development of special approaches to the software development.The basic desirable result here is a certain concrete method helping to understand how to cross a gap between pure ideas via mathematical model and a necessary practical technology.With the use of modern supercomputers it is now possible to develop and to implement on supercomputers different realistic mathematical models of natural phenomena, complex technical devises and human intellectual activities.In the area of mod-

The paper concerns the problem of efficient distributed execution of fragmented programs in LuNA system, which is a automated parallel programs construction system. In LuNA an application algorithm is represented with a high-level programming language, which makes the representation portable, but also causes the complex problem of automatic construction of an efficient distributed program, which implements the algorithm on given hardware and data. The concept of adding supplementary information (recommendations) is employed to direct the process of program construction based on user knowledge. With this approach the user does not have to program complex distributed logic, while the system makes advantage of the user knowledge to optimize program and its execution. Implementation of this concept within LuNA system is concerned. In particular, a conventional compiler is employed to optimize the generated code. Some performance tests are conducted to compare efficiency of the approach with both previous LuNA release and reference hand-coded MPI implementation performance.

The paper concerns the problem of efficient distributed execution of fragmented programs in LuNA system, which is a automated parallel programs construction system. In LuNA an application algorithm is represented with a high-level programming language, which makes the representation portable, but also causes the complex problem of automatic construction of an efficient distributed program, which implements the algorithm on given hardware and data. The concept of adding supplementary information (recommendations) is employed to direct the process of program construction based on user knowledge. With this approach the user does not have to program complex distributed logic, while the system makes advantage of the user knowledge to optimize program and its execution. Implementation of this concept within LuNA system is concerned. In particular, a conventional compiler is employed to optimize the generated code. Some performance tests are conducted to compare efficiency of the approach with both previous LuNA release and reference hand-coded MPI implementation performance.

The paper presents some advanced high performance (HPC) and parallel computing (PC) methodologies for solving a large space complex problem involving the integrated difference research areas. About eight interdisciplinary problems will be accurately solved on multiple computers communicating over the local area network. The mathematical modeling and a large sparse simulation of the interdisciplinary effort involve the area of science, engineering, biomedical, nanotechnology, software engineering, agriculture, image processing and urban planning. The specific methodologies of PC software under consideration include PVM, MPI, LUNA, MDC, OpenMP, CUDA and LINDA integrated with COMSOL and C++/C. There are different communication models of parallel programming, thus some definitions of parallel processing, distributed processing and memory types are explained for understanding the main contribution of this paper. The matching between the methodology of PC and the large sparse application depends on the domain of solution, the dimension of the targeted area, computational and communication pattern, the architecture of distributed parallel computing systems (DPCS), the structure of computational complexity and communication cost. The originality of this paper lies in obtaining the complex numerical model dealing with a large scale partial differential equation (PDE), discretization of finite difference (FDM) or finite element (FEM) methods, numerical simulation, high-performance simulation and performance measurement. The simulation of PDE will perform by sequential and parallel algorithms to visualize the complex model in high-resolution quality. In the context of a mathematical model, various independent and dependent parameters present the complex and real phenomena of the interdisciplinary application. As a model executes, these parameters can be manipulated and changed. As an impact, some chemical or mechanical properties can be predicted based on the observation of parameter changes. The methodologies of parallel programs build on the client-server model, slave-master model and fragmented model. HPC of the communication model for solving the interdisciplinary problems above will be analyzed using a flow of the algorithm, numerical analysis and the comparison of parallel performance evaluations. In conclusion, the integration of HPC, communication model, PC software, performance and numerical analysis happens to be an important approach to fulfill the matching requirement and optimize the solution of complex interdisciplinary problems.

The distributed algorithm Patch with local communications for dynamic data allocation of a distributed multicomputer in the course of an application LuNA fragmented program execution is presented. The objective of the Patch is to decrease the length and as result the volume of communications while the parallel program is executed. Communications include all the internode interactions for data processing, dynamic data allocation, search and balancing. The Patch takes into account the data dependencies and maximally tries to keep the data locality during all the internode interactions.

The concept of active knowledge implementation on the basis of the theory of structural program synthesis, modern technologies and their necessary developments are considered. The theory is proposed for technological description, accumulation, keeping, processing and application of active knowledge. On this basis the notion of literacy for the future is suggested. The concept was implemented in the frame of the LuNA project aimed at elimination of parallel programming from the process of large-scale numerical models development.

The main features of the LuNA system of fragmented programming, aimed at parallel implementation of the large-scale numerical models on the mesh, are considered. The complex application of the Particle-In-Cell method to a large-scale 3D dust-cloud model, developed in LuNA, demonstrates its advantages for providing such dynamic properties of application programs as portability, dynamic load balancing and tunability to all the available resources.

The concept of active knowledge and the model of structural program synthesis are proposed for accumulation, keeping and processing of the active knowledge. On this basis the notion of literacy for the future, based on axiomatic theories, is defined.

Logic programming approach demonstrated technological not implementability of the program realization of an axiomatic theory. Here it is suggested to describe the axiomatic theory partially, in order to overcome the problem of the not implementability. Partially defined axiomatic theory should contain not all the possible decisions/theorems/, but those only, that were already well implemented once.

The peculiarities of the LuNA run-time subsystem implementation are considered. LuNA is the language and system of fragmented programming. The peculiarities are conditioned by the properties of numerical algorithms, to implementation and execution of which the LuNA is mainly oriented.

Organization of high performance execution of fragmented programs met the problem of choice of acceptable way of their execution. The possibilities of execution optimization on the stages of fragmented program development, compilation and execution are considered. The methods and algorithms of optimizations are suggested to be included both in fragmented programming language and in run-time system.

This paper considers and analysis the idea of magic wand as approach to representation new technologies, their implementability, application and use in different object domain. Magic wand approach in its currently implementable form is suggested to be the standard for any new technology representation. How to describe a new technology, how to accumulate and control the active knowledge base constitute the main subject of the paper.

The NumGRID is a middleware for joining geographically distributed computational clusters in order to run large-scale scientific applications that use MPI standards for communication between processes. Intercluster communication system of the NumGRID provides a single communication environment for the processes located on internal nodes of joined clusters. The paper discusses shortcoming of the NumGRID v.1 implementations, suggests new principles for the NumGRID v.2 implementation and presents an experimental evaluation of this principles.

Filmification of methods is an approach to find new formats for program and data/knowledge representation. It is also to create a basis for specifying and developing a new generation of programming environments. Within this approach various algorithms are analyzed and represented as cyberFilms where special visual super-symbols (icons) are introduced for defining meaning of the cyberFilm frames. In this paper, the filmification of methods is applied for particle-in-cells algorithms. Results demonstrate a promising compactness of the program representation, covering technical details of parallel implementation and an effectiveness of an open set of icons.