Abstract: The paper is dedicated to an open T-system (OpenTS) — a programming system that supports automatic parallelization of computations for high-performance and distributed applications. In this paper, we describe the system architecture and input programming language as well as system's distinctive features. The paper focuses on the achievements of the last two years of development, including support of distributed, meta-cluster computations.

Abstract: One of the fundamental components of large-scale gene discovery projects is that of clustering of expressed sequence tags (ESTs) from complementary DNA (cDNA) clone libraries. Clustering is used to create non-redundant catalogs and indices of these sequences. In particular, clustering of ESTs is frequently used to estimate the number of genes derived from cDNA-based gene discovery efforts. This paper presents a novel parallel extension to an EST clustering program, UIeluster4, that incorporates alternative splicing information and a new parallelization strategy. The results are compared to other parallelized EST clustering systems in terms of overall processing time and in accuracy of the resulting clustering.

Abstract: The goal of our investigation is to find automatically the best rule for a cell in the cellular automata model. The cells are either of type Obstacle, Empty or Creature. Only Creature can move around in the cell space and can perform one of the four actions: if the path to the next cell is blocked: turn left or right, if the path is free: move ahead and simultaneously turn left or right. The task of the creature is to cross all empty cells with a minimum number of steps. The behavior was modeled using a variable state machine represented by a state table. Input to the state table is the neighbor's state in front of its moving direction. The goal is to find the absolutely best rule in the set of all possible rules. The search space grows exponentially with the number of states. As simulation, testing and evaluating the quality are very time consuming in software, the migration of the problem to a parallel hardware platform is a promising solution. In order to reduce the computation time, the search procedure was (1) implemented in hardware and (2) solutions which are equivalent under state permutations were not generated and (3) solutions which show or expect bad or trivial behavior were excluded as soon as possible in a preselection phase. Exactly six different five-state algorithms could be detected, which allow to cross all empty cells for all the given initial configurations. We described this model in Verilog HDL and in AHDL. A hardware synthesizing tool transforms the description into a configuration file which was loaded into a field programmable gate array (FPGA). Hardware implementation offers a significant speed up of many thousands compared to software.

Abstract: With the advent of hardware technologies, high-performance parallel computers and commodity clusters are becoming affordable. However, complexity of parallel application development remains one of the major obstacles towards the mainstream adoption of parallel computing. As one of the solution techniques, researchers are actively investigating the pattern-based approaches to parallel programming. As re-usable components, patterns are intended to ease the design and development phases of a parallel applications. While using patterns, a developer supplies the application specific code-components whereas the underlying environment generates most of the code for parallelization. PAS (Parallel Architectural Skeleton) is one such pattern-based parallel programming model and tool, which defines the architectural aspects of parallel computational patterns. Like many other pattern-based models and tools, the PAS model was hampered by its lack of extensibility, i.e., lacking of support for the systematic addition of new skeletons to an existing skeleton repository. Lack of extensibility significantly reduces the flexibility and hence the usability of a particular approach. SuperPAS is an extension of PAS that defines a model for systematically designing and implementing PAS skeletons by a skeleton designer. The newly implemented skeletons can subsequently be used by an application developer. SuperPAS model is realized through a Skeleton Description Language (SDL), which assists both a skeleton designer and an application developer. The paper discusses the SuperPAS model through examples that use the SDL. The paper also discusses some of the recent usability and performance studies, which demonstrate that SuperPAS is a practical and usable parallel programming model and tool.

Abstract: Accuracy, stability and computation complexity of fine-grained parallel simulation of spatial dynamics by probabilistic cellular automata (CA), are assessed and experimentally studied. Under investigation are probabilistic CA constructed as a composition of an ordinary CA with a function given in real numbers. The accuracy problem is reduced to approximation error assessment of the transformation of a real spatial function into a Boolean array and addition of cellular arrays with different cell state alphabets: real and Boolean. Some techniques for determining simulation parameters which provide a given accuracy are given. Stability is shown to be dependent only on real function, the CA component of the dynamics having no effect on it. Computation complexity of simulation process is also assessed. Some experimental results supporting the theoretical conclusions are presented.

Abstract: This paper presents JOIN, a Java-based software platform to construct massively parallel grids capable of executing large parallel applications. The system is designed to be scalable by allowing computers in the grid to be separated in independent sets (called groups) which are managed independently and collaborate using a logical interconnection topology. JOIN provides advanced fault tolerance capabilities that allow it to withstand failures both in computers executing parallel tasks and in computers managing the groups. The parallel applications executing in the system are formally specified using a rigorously defined application model. JOIN uses a dynamic, flexible scheduling algorithm that adapts to changes in resource availability and replicates parallel tasks for fault tolerance. The platform provides an authentication/access control mechanism based on roles which is embedded in the inner parts of the system. The software architecture is based on the concept of services, which are independent pieces of software that can be combined in several ways, providing the flexibility needed to adapt to particular environments. JOIN has been successfully used to implement and execute several parallel applications, such as DNA sequencing, Monte Carlo simulations and a version of the Traveling Salesman Problem.

Abstract: This paper proposes the COoperative COntrol Protocol (COCOP), which enables a synchronous cooperative group to interactively control an on-demand server which multicasts time-dependent data streams. Multicast-based streaming on-demand systems such as video on-demand systems, web casters, and networks of real/virtual sensors can beneficially exploit COCOP to provide cooperative control sessions as a mainstream service. In order to improve efficiency and scalability, the protocol relies on a reliable multicast transport layer which can be based either on the IP-multicast or on Application Layer Multicast. Performance evaluation of COCOP was carried out on multicast trees by using a discrete-event simulation framework.

Abstract: Experiments of neural network training procedure parallelization are conducted. Several styles of parallelization are described and compared, estimations of neural network size and training set size that allow speedup on two-processors SMP machine are obtained.

Abstract: As Internet real-time multimedia applications increase, the bandwidth available to TCP connections is stifled by UDP traffic, which results in the performance of overall system to be extremely deteriorated. Therefore, developing a new transmission protocol is necessary. The TCP-friendly algorithm is an example satisfying this necessity. The TCP-Friendly Rate Control (TFRC) is an UDP-based protocol that controls the transmission rate based on the variables such as RTT and PLR. In the conventional data transmission processing, the transmission rate is determined by the RTT and PLR of the previous transmission period. If the one-step ahead predicted values of RTT and PLR are used to determine the transmission rate, the performance of network will be improved significantly. This paper proposes a predictive TFRC protocol with one-step ahead RTT and PLR. A multi-layer perceptron neural network is used as the prediction model, and the Levenberg-Marquardt algorithm is used as a training algorithm. The values of RTT and PLR were collected using UDP protocol in the real system used for NN modeling. The performance of the predictive TFRC was evaluated by the share of Internet bandwidth with various protocols in terms of the packet transmission rate. The extensive experiment of the suggested system in real system was performed and proves its advantages.

Abstract: We use an enhanced operational semantics to infer quantitative measures on systems describing cryptographic protocols. System transitions carry enhanced labels. We assign rates to transitions by only looking at these labels. The rates reflect the distributed architecture running applications and the use of possibly different crypto-systems. We then map transition systems to Markov chains and evaluate performance of systems, using standard tools.

Abstract: The neural network approach for parallel construction of adaptive mesh on two-dimensional area is proposed. The approach is based on unsupervised learning algorithm for Kohonen's Self Organizing Map and enables to obtain an adaptive mesh being isomorphic to a rectangular uniform one. A parallel algorithm for the construction of those meshes based on master-slave programming model is presented. The main feature of the obtained mesh is that their decomposition into subdomains required for parallel simulation on this mesh is reduced to partitioning of a rectangular array of nodes. The way of partitioning may be defined based on parallel simulations on the mesh. The efficiency of the parallel realization of the proposed algorithm is about 90%.

Abstract: Detecting data races or just races is important for debugging OpenMP programs, because races result in unintended nondeterministic executions of the program. The previous tool to detect the races in OpenMP programs monitors a serial execution of the program, but unfortunately cannot guarantee to verify the existence of races even in the programs only with the directives. This paper presents a practical tool which monitors a parallel execution of standard OpenMP program, and not only verifies the existence of races but also detects first races for each shared variable in the programs.

Abstract: A class of fine-grained (FG) parallel models and algorithms is defined as a generalization of Cellular Automata (CA). It comprises all CA-modifications, in which two main CA-properties (locality and parallelism of intercell interaction) are preserved, no constraint being imposed on state alphabets and transition functions. A set of methods for composing a complex FG-algorithm out of a number of simple ones is proposed. To make compatible FG-algorithms with different alphabets, a number of algebraic operations on cellular arrays are introduced. The set of proposed composition methods has a two-level structure: the lower level comprises composition of cell transition functions, while the higher level deals with global operators on cellular arrays. For each type of proposed methods an example is given and the domain of application is determined.

Abstract: Inference of large phylogenetic trees using statistical methods is computationally extremely expensive. Thus, progress is primarily achieved via algorithmic innovation rather than by brute-force allocation of available computational ressources. We describe simple heuristics which yield accurate trees for synthetic (simulated) as well as real data and significantly improve execution time. The heuristics are implemented in a sequential program (RAxML) and a novel non-deterministic distributed algorithm (DRAxML@ home). We implemented an MPI-based and a http-based distributed prototype of this algorithm and used DRAxML@home to infer trees comprising 1000 and 2025 organisms on LINUX PC clusters.

Abstract: The paper presents Situated Cellular Agents (SCA), systems of reactive agents that are heterogeneous and populate a structured environment. The structure of this environment is defined as a non-uniform network of sites in which agents are situated. The behavior of SCA agents (i.e. change of state and position) is influenced by states and types of agents that are situated in adjacent and at-a-distance sites. After an outline of SCA approach and its main applications, the paper introduces an ongoing project to develop a tool to support the development and execution of SCA applications.

Abstract: Generalized resources are defined as multisets of Petri net vertices. Here places represent material resources (designated by tokens residing in these places). Transitions correspond to activity resources represented by transition firings. Two generalized resources are called similar if in any Petri net marking one resource can be replaced by another without changing the observable system's behaviour (modulo bisimulation). In this paper we study some basic properties of generalized resource similarity and prove that, being undecidable, generalized resource similarity is finitely based, and thus can be finitely described. We show also, that similarity of generalized resources allows to express some substantial properties of systems modelled by Petri nets.

Abstract: In this paper, we propose an associative parallel algorithm for updating a minimum spanning tree when a vertex and all its incident edges are deleted from the underlying graph. This algorithm is represented as the corresponding procedure implemented on a model of associative parallel systems of the SIMD type with vertical data processing (the STAR–machine). We justify the correctness of this procedure and evaluate its time complexity.

Abstract: This paper is a short introduction to wait-free computing "Wait-free" means that the progress of a process depends only on it, regardless of the other processes (that can progress slowly or even crash) To illustrate wait-free computing, the paper considers the design of two concurrent objects, namely, a renaming object and a snapshot object A renaming object allows the processes to acquire new names from a smaller name space despite possible process crashes A snapshot object provides the processes with an array-like data structure (with one entry per process) offering two operations The write operation allows a process to update its own entry The snapshot operation allows a process to read all the entries in such a way that the reading of the whole array appears as it is was an atomic operation A renaming protocol by Moir and Anderson and a snapshot protocol by Afek et al are used to illustrate the beauty and subtleties of wait-free computing