D. Janaki Ram

Parallel Simulated Annealing Algorithms

Simulated annealing (SA) has been considered a good tool for complex nonlinear optimization problems. The technique has been widely applied to a variety of problems. However, a major disadvantage of the technique is that it is extremely slow and hence not suitable for complex optimization problems such as scheduling. There are many attempts to develop parallel versions of the algorithm. Many of these algorithms are problem dependent in nature. We present, in this paper, two general algorithms for SA. The algorithms have been applied to job shop scheduling problem (JSS) and the traveling salesman problem (TSP) and it has been observed that it is possible to achieve superlinear speedups using the algorithm.

Message filters for object-oriented systems

SUMMARY In the conventionalobject model, encapsulated objects interact by messages that result in method invocations on the destination object. A message is delivered directly at the destination object. As a result of the direct deliveries, the message control code performing intermediate message manipulations cannot be abstracted out separately from the message processing code in the destination object without sacrificing the transparency of the intermediate message control. We propose the filtered delivery model of message passing for object-oriented languages to provide the separation of message control from message processing in a transparent manner. An interclass relationship, called a filter relationship, is introduced. As a consequence, a filter object can intercept and manipulate messages sent to another object called its client via filter member functions. A filter member function in a filter object can intercept a particular member function invocation on its client object. The filtered delivery model supports both upward and downward filtering mechanisms, facilitating interception of an upward message and its return message value. Filter objects can be plugged or unplugged at runtime. Binding of filter member functions to corresponding member functions in the client is selective and dynamic. The filtered delivery model is developed for the C++ object-oriented language; its applications are described and implementation is discussed. ©1997 by John Wiley & Sons, Ltd.

A pattern oriented technique for software design

Design patterns can be considered as elements of complex software systems. Crafting these software systems using design patterns calls for a suitable design methodology or technique. Existing design methodologies do not serve this purpose well. This paper proposes a technique which helps in developing software systems usign design patterns.

An approach for pattern oriented software development based on a design handbook

In many mature engineering disciplines, reuse of available design knowledge is helped by the presence of handbooks. These handbooks record the details of existing system components and help in the process of evaluating design alternatives while building new systems. In recent times, design patterns have been identified as fundamental components of an object oriented design. However, they are presented in a format that may not be best suited for systematic selection and use while evaluating design alternatives. This paper provides a procedure to construct a handbook based on design patterns. This handbook helps designers in methodical selection of design patterns. The construction of the handbook is based on the identification of a set of key attributes of a design pattern and quantification of these attributes using the principles of measurement theory. A new methodology for object oriented design which consults the handbook during the design process is also introduced. The proposed methodology along with the handbook helps in evaluating different design alternatives.

Causal consistency in mobile environment

Causal consistency stipulates that causally dependent writes to data items should be executed in causal order. Traditionally this has been done by causally ordered message delivery using vector clocks. In a vector clock of size N, each element of the vector corresponds to each of the N hosts in the system and hence the message overhead is Θ(N). In a mobile environment the number of hosts can not be fixed because hosts join and leave the system dynamically. Hence traditional vector clocks are not suitable in a mobile environment. Consistency of a system consisting of M data items can be maintained using a vector in which each element corresponds to each data item. We propose a mechanism for maintaining causal consistency whose message overhead is Θ(M). Such a model will be advantageous in a mobile environment, because the message overhead is independent of the number of hosts. Further in applications such as collaboration the number of data items is small. Also, the delivery of a message is never inhibited due to causally overwritten messages.

ShadowObjects: A Programming Model for Service Replication in Distributed Object Systems

With the growing emphasis on distributed applications, sophisticated programming models for handling replication become important. Control replication as an issue has so far been considered in the larger context of distributed systems such as ISIS and Arjuna. We present a programming model called ShadowObjects for programming replicated services to cater to the needs of control replication in distributed object oriented systems. The ShadowObjects model provides primitives for building highly available and redundant services. Replication in ShadowObjects is encapsulated and a replica access control mechanism is provided. Messages accessing the services exported by a server object can be captured on-the-fly, and can be appropriately scheduled on the replicas. The ShadowObjects model can be used to develop applications for distributed systems.

Pattern hybridization: breeding new designs out of pattern interactions

Class or object interactions form the basis of object-oriented design. However, design pattern interaction can be viewed as a higher level of abstraction for system design. The typical interactions among the patterns are a pattern uses another pattern to solve one of its sub problem, and a pattern combines with another pattern for completeness. This paper proposes a mechanism called pattern hybridization for breeding new patterns from the pattern interactions which solve more specialized problems than the original patterns do. Rules for generating hybrid patterns are also mentioned in the paper. This paper also views design pattern interactions for system design.

A data-centric concurrency control mechanism for three tier systems

Concurrency control (CC) algorithms targeted at Web systems need to be different from those of traditional transactional processing systems. In Web systems, transactions could be generated in a burst mode, leading to scalability problems at the server. Transactions may also suffer from network delays due to the unpredictable response time over the Web. This paper proposes a CC mechanism for Web-based three tier systems. In this mechanism, initial validation of the transactions is performed at the application server. The transactions that pass the initial validation are sent to the database server (DB server) for final validation. The serializability criterion is achieved by associating a data-counter with each data-item. This reduces the load on the DB server. Also, in the proposed model, the middle tier contains multiple number of application servers. Apart of the database is dynamically replicated in these servers. The modifications made on the data-items are known immediately to clients and the data-items at the DB server are locked only during the final validation phase and write phase. Consequently, the model is also suitable for transactions that suffer from unpredictable delays between read and write operations. The model is scalable as it can support large number of application servers in the middle tier. Performance studies have been carried out to depict the efficiency of the proposed model over the existing models. The proposed model is simple to implement and it performs extremely well compared to existing models when the transactions are generated in a burst mode.Concurrency control (CC) algorithms targeted at Web systems need to be different from those of traditional transactional processing systems. In Web systems, transactions could be generated in a burst mode, leading to scalability problems at the server. Transactions may also suffer from network delays due to the unpredictable response time over the Web. This paper proposes a CC mechanism for Web-based three tier systems. In this mechanism, initial validation of the transactions is performed at the application server. The transactions that pass the initial validation are sent to the database server (DB server) for final validation. The serializability criterion is achieved by associating a data-counter with each data-item. This reduces the load on the DB server. Also, in the proposed model, the middle tier contains multiple number of application servers. Apart of the database is dynamically replicated in these servers. The modifications made on the data-items are known immediately to clients and the data-items at the DB server are locked only during the final validation phase and write phase. Consequently, the model is also suitable for transactions that suffer from unpredictable delays between read and write operations. The model is scalable as it can support large number of application servers in the middle tier. Performance studies have been carried out to depict the efficiency of the proposed model over the existing models. The proposed model is simple to implement and it performs extremely well compared to existing models when the transactions are generated in a burst mode.

Scalability issues in CORBA

Scalability is recognised as a primary factor to be considered in the design of distributed systems. The scalability of object-oriented middleware CORBA is becoming a major concern as it has emerged as a standard architecture for distributed object computing. In this paper, a systematic scalability analysis of the basic components of the CORBA specification is attempted. From this analysis, the Portable Object Adapter (POA) and the Implementation Repository (IR) are identified to influence the scale of a CORBA-based system. The specification of the POA provides enough feasibility for the application designer to handle scalability. The existing implementations of IR have a tradeoff between scalability and object migration. A scalable design of the IR is proposed which allows individual objects to migrate without compromising scalability. A performance comparison of the proposed model with existing IR designs is made using a simulation study.

A model for parallel programming over CORBA

Existing models for parallel programming over Common Object Request Broker Architecture (CORBA) do not address issues specific to parallel programming over a Network of Workstations (NOWs). This paper presents P-CORBA, a model for parallel programming over CORBA that addresses these issues. Transmission and distribution of computing power of a NOW is facilitated by P-CORBA. The main contribution of the work is to bring a notion of concurrency into CORBA. The model illustrates a method for balancing the load on a CORBA-based distributed system. It also provides a new idea for achieving object migration in CORBA. The paper presents detailed performance studies from a prototype of the model that has been implemented. A detailed performance comparison of the model is made with a widely used parallel programming tool, namely Message Passing Interface (MPI). This paper demonstrates that in spite of its overheads, CORBA can be used for parallel programming over a NOW and significant speedups can be obtained.