Tahany A. Fergany

Performance-based modeling for distributed object-oriented software

Information systems are basically distributed while object oriented brings new issues in software engineering. Pairing distributed systems with object paradigms results in a distributed object model. Choosing the appropriate distributed object model is a multi-criteria decision problem. Performance is a key criterion that makes software developers be able to select the object-oriented system that best fit their requirements. Classical techniques and methodologies of performance analysis are either unsuitable or unnatural to capture performance behavior of object-oriented (OO) systems. In this paper, we present performance-based model for distributed object-oriented software (DOOS) and a methodology to analyze and evaluate its performance. The new model evaluates the overall time cost of DOOS system considering the communication overheads while preserving the OO features such as encapsulations, information hiding, inheritance, etc.

Task clustering & scheduling with duplication using recursive critical path approach (RCPA)

This paper address the problem of static task clustering and scheduling of a parallel program given as a Directed Acyclic Graph(DAG) with duplication. Scheduling of task graphs onto multiprocessors is known to be an NP-complete in most cases leading to solutions based on heuristics [1]. In this paper, a novel task-duplication scheduling heuristic is presented. Our approach differs from other heuristics found in literature since task clustering and scheduling are handled during the same phase. This technique omit the need of the independent clustering and scheduling phases (i.e., creating a cluster for every single task in the given DAG followed by the scheduling process) as in [2–6]. Preliminarily results shows that our algorithm outperforms PY, LWB, PLW, TCSD and LG algorithms in terms of the overall makespan, and total number of processors used.

Dynamic On-Line Allocation of Independent Task onto Heterogeneous Computing Systems to Maximize Load Balancing

Heterogeneous computing (HC) systems use different types of machines, networks, and interfaces to coordinate the execution of various task components which have different computational requirements. This variation in tasks requirements as well as machine capabilities has created a very strong need for developing mapping techniques to decide on which task should be moved to where and when, to optimize some system performance criteria. The existing dynamic heuristics for mapping tasks in HC systems works either on-line (immediate) or in batch mode. In batch mode, tasks are collected into a set that is examined for mapping at prescheduled times called mapping events. On contrast, on-line mode algorithms map a task onto a machine as soon as it arrives at the mapper. In this paper, we propose an on-line mapping algorithm which is called the maximum load balance, or for short the MLB. It tries to minimize the makespan by maximizing the load balancing of the target system. At each task arrival, the MLB algorithm examines all the machines in the HC suite one by one looking for the one that gives the maximum system balance among all possible mappings. In contrast with the opportunistic load balancing (OLB) heuristic; which assigns a task to the machine that becomes ready next, the MLB takes into consideration both the availability of the machine as well as the execution time of the task on that machine.

Mapping Distributed Object-Oriented Software to Architecture with Limited Number of Processors

Over the last few years, designers and engineers utilized the Object-Oriented (OO) approach in developing distributed software systems. One of the most important aspects of the Distributed Object Oriented (DOO) systems is the efficient distribution of software classes among different nodes. The initial design of the DOO application does not necessarily have the best class distribution and may need to be restructured. Previous restructuring techniques have not been considered DOO software. Within the context of DOO systems, it is a challenge to perform class restructuring due to the complexity of interactions between objects. In this paper, we propose a new methodology for efficiently restructuring the DOO software classes on a set of nodes in a distributed system. The proposed methodology consists of two phases. The first phase is partitioning the OO system into subsystems that have low coupling and are more suitable for distribution using a recursive graph bi-partitioning algorithm. The second phase is accomplished by mapping the generated subsystems to a set of available machines in the target distributed architecture. The results obtained from the simulated experiments approved that our approaches outperforms the traditional K-Partitioning algorithm.

A Double K-Clustering Approach for restructuring Distributed Object-Oriented software

There have been a large number of projects based on the Distributed Object Oriented (DOO) approach for solving complex problems in various scientific fields. The Mismatch problem is one of the most important problems facing the DOO system, where the initial design of the DOO application does not give the best class distribution. In such a case, the DOO software may need to be restructured. In this paper, we propose a methodology for efficiently restructuring the DOO software classes to be mapped on a distributed system consisting of a set of nodes. The proposed methodology consists of two phases. The first phase introduces a recursive graph clustering technique to partition the OO system into subsystems with low coupling. The second phase is concerned with mapping the generated partitions to the set of available machines in the target distributed architecture. A simulation evaluation was carried out for a set of randomly generated DOO software designs. Then the results were compared with those of the K-Partitioning algorithm in terms of the overall inter-class communication cost.

Optimizing the time cost of parallel structures by scheduling parallel processes to access the critical section

In a shared-memory parallel processing environment there are a number of inherent hardware and software bottlenecks. One of these bottlenecks is the exclusive accesses that are needed to the shared variables within a critical section. The time cost of synchronization of processes which require access to the critical section can be minimized by using optimal scheduling methods. This paper presents a set of pre-run-time optimal scheduling algorithms for accessing the critical sections by the processes which are spawned at FORK operation and are terminated at the associated JOIN operation.<<ETX>>

Performance Modeling and Analysis of Distributed Object-Oriented Software

Information systems are basically distributed while object oriented brings new issues in software engineering. Pairing distributed systems with object paradigms results in a distributed object model. Choosing the appropriate distributed object model is a multi-criteria decision problem. Performance is a key criterion that makes software developers be able to select the object-oriented system that best fit their requirements. The accuracy of the performance evaluation depends strongly on the ability to model and analyze the features of the target software. Classical techniques and methodologies of performance analysis are either unsuitable or unnatural to capture performance behavior of Object-Oriented (OO) systems. In this paper, we present Performance-Based Model for Distributed Object-Oriented Software (DOOS) and a methodology to analyze and evaluate its performance. The new model evaluates the overall time cost of DOOS system considering the communication overheads while preserving the OO features such as encapsulations, information hiding, inheritance, ... etc.

A Performance-Driven Approach for Restructuring Distributed Object-Oriented Software

Object oriented techniques make applications substantially easier to build by providing a high-level platform for appli-cation development. There have been a large number of projects based on the Distributed Object Oriented approach for solving complex problems in various scientific fields. One important aspect of Distributed Object Oriented systems is the efficient distribution of software classes among different processors. The initial design of the Distributed Object Oriented application does not necessarily have the best class distribution and may require to be restructured. In this paper, we propose a methodology for efficiently restructuring the Distributed Object Oriented software systems to get better performance. We use Distributed Object-Oriented performance (DOOP) model as guidance for our restructuring methodology. The proposed methodology consists of two phases. The first phase introduces a recursive graph clustering technique to partition the OO system into subsystems with low coupling. The second phase is concerned with mapping the generated partitions to the set of available machines in the target distributed architecture.

Optimizing the time cost of the parallel structures with a limited number of processors

We develop an allocation algorithm that, in conjunction with optimal scheduling algorithms, yields the minimum time cost for a parallel structure. We assume a shared memory environment and a limited number of processors that is less than the degree of parallelism of the parallel structure.<<ETX>>

Randomized Algorithms for Mapping Clustered Object-Oriented Software onto Distributed Architectures

Distributed Object Oriented (DOO) applications have been developed for solving complex problems in various scientific fields. One of the most important aspects of the DOO systems is the efficient distribution of software classes among different nodes in order to solve the mismatch problem that may appear when the software structure does not match up the available hardware organization. We have proposed a multistep approach for restructuring DOO software. According to this approach, the OO system is partitioned into clusters that are then merged into larger groups forming what we call Merged Cluster Graph. The last step in this approach is concerned by mapping these merged clusters onto the target distributed architecture. Generally, the mapping problem is intractable thus allowing only for efficient heuristics. This paper presents two algorithms to solve the mapping problem using a randomized approach. The proposed algorithms has proved to be efficient, Simple and easy to understand and implement. Furthermore, the performance of the proposed algorithms was tested against some existing deterministic techniques. The experimental results showed an outstanding performance of the proposed algorithms in minimizing the overall mapping cost of the produced assignments.