Synchronization Constraints Research Articles

Scheduling flexible flow shops with sequence-dependent setup effects

This paper presents a Lagrangian relaxation-based approach for production scheduling of flexible flow shops (PSFFS) where sequence-dependent setup effects are significant. PSPFS is first formulated as a separable integer programming problem with synchronization constraints between production and machine usage. Lagrangian relaxation is then applied, and the scheduling is decomposed into part production and machine scheduling. In these subproblems, there are network flow structures in the equality constraints describing machine status change and production flow balance. Our iterative algorithm applies a minimum cost network flow algorithm to individual subproblems and adopts an efficient surrogate subgradient method to optimize Lagrangian multipliers. A machine availability-searching heuristic finally adjusts the solution to satisfy all synchronization constraints by exploiting the network structure, economic interpretation of Lagrangian multipliers, and the slack time policy. Numerical results of 16 cases, each having 20 test problems, demonstrate that differences between the schedules obtained by our approach and the true optima are on average within 15%, CPU times spent are all less than 17 min on a Pentium-II personal computer. Among the problem dimension factors, the number of part types has the most significant effect on both optimality and computation efficiency. Application of the methodology to daily scheduling of a realistic integrated circuit testing facility of 30 machines takes about 6 min of CPU time to generate a near-optimal solution.

Fleet assignment and routing with schedule synchronization constraints

This paper introduces a new type of constraints, related to schedule synchronization, in the problem formulation of aircraft fleet assignment and routing problems and it proposes an optimal solution approach. This approach is based on Dantzig–Wolfe decomposition/column generation. The resulting master problem consists of flight covering constraints, as in usual applications, and of schedule synchronization constraints. The corresponding subproblem is a shortest path problem with time windows and linear costs on the time variables and it is solved by an optimal dynamic programming algorithm. This column generation procedure is embedded into a branch and bound scheme to obtain integer solutions. A dedicated branching scheme was devised in this paper where the branching decisions are imposed on the time variables. Computational experiments were conducted using weekly fleet routing and scheduling problem data coming from an European airline. The test problems are solved to optimality. A detailed result analysis highlights the advantages of this approach: an extremely short subproblem solution time and, after several improvements, a very efficient master problem solution time.

Synchronization languages

Synchronization expressions introduced in [7] within the framework of the ParC project are a high-level construct which allow a programmer to express minimal synchronization constraints of a program in a distributed context. The study and the implementation of these expressions are based on their associated synchronization languages. Synchronization languages have been introduced in [9, 10]. They give a way to implement synchronization expressions and specify their semantic. These languages represent distributed systems whose behaviour respects synchronization constraints expressed by the programmer with synchronization expressions. So these languages describe all the correct executions of a program. In [9, 10] Guo, Salomaa and Yu propose a characterization of synchronization languages based on a rewriting system named R which generalizes partial commutations. This system gives a way to rewrite a word representing a parallel execution into a word with a lower or equal degree of parallelism. Guo et al. show that every synchronization language is closed under the system R and they conjecture that it is sufficient for a regular language to be closed under R to be a synchronization language. We show that the conjecture is true in the particular case of languages expressing the synchronization between two distinct actions. We also show that the conjecture is false in the general case.

Towards reusable real-time objects

Large and complex realdtime systems can benefit significantly from a componentdbased development approach where new systems are constructed by composing reusable, documented and previously tested concurrent objects. However, reusing objects which execute under realdtime constraints is problematic because application specific time and synchronization constraints are often embedded in the internals of these objects. The tight coupling of functionality and realdtime constraints makes objects interdependent, and as a result difficult to reuse in another system. We propose a model which facilitates separate and modular specification of realdtime constraints, and show how separation of realdtime constraints and functional behavior is possible. We present our ideas using the Actor model to represent untimed objects, and the Realdtime Synchronizers language to express realdtime and synchronization constraints. We discuss specific mechanisms by which Realdtime Synchronizers can govern the interaction and execution of untimed objects. We treat our model formally, and succinctly define what effect realdtime constraints have on a set of concurrent objects. We briefly discuss how a middleware scheduling and eventddispatching service can use the synchronizers to execute the system.

Rollback overhead reduction methods for time warp distributed simulation

Parallel discrete event simulation is a useful technique to improve performance of sequential discrete event simulation. We consider the time warp algorithm for asynchronous distributed discrete event simulation. Time warp is an optimistic synchronization mechanism for asynchronous distributed systems that allows a system to violate the synchronization constraint and, in this case, make the system rollback to a correct state. We focus on the kernel of the time warp algorithm, that is the rollback operation, and we propose some techniques to reduce the overhead due to this operation. In particular, we propose a method to reduce the overhead involved in state saving operation, two methods to reduce the overhead of a single rollback operation and a method to reduce the overall number of rollbacks. These methods have been implemented in a distributed simulation environment on a distributed memory system. Some experimental results show the effectiveness of the proposed techniques.

An efficient and flexible C++ library for concurrent programming

A major problem for the integration of concurrency in object-oriented languages is the so-called inheritance anomaly, i.e. the conflicts between inheritance and concurrency that often cause the need to redefine inherited methods in order to maintain the integrity of objects. Several solutions have been proposed for resolving these conflicts. However, some of them are incomplete, and do not solve all types of inheritance anomaly; others make the definition of classes complex and/or their implementation inefficient. This paper describes a C++ library for concurrent programming that provides a comprehensive framework particularly suitable for coarse-grained distributed applications. This library copes with the inheritance anomaly problem, presenting a solution that minimizes the redefinition of inherited methods without increasing the complexity to write them. This solution is based on the use of a special set of methods, called interface methods, composed of a body and two sets of synchronization constraints. These two sets of synchronization constraints are respectively used to enable the execution of their method body and to disable the methods that cannot be executed after their method. © 1998 John Wiley & Sons, Ltd.

Synchronization expressions with extended join operation

Synchronization expressions are high level constructs used for specifying minimal synchronization constraints of parallel processes. Their semantics is defined by the corresponding synchronization language. The original definition of synchronization expressions [12, 13] forces the languages to be closed under rewriting rules that, for instance, do not preserve regularity. Here we propose an extension of the syntactic definition of synchronization expressions, and an appropriate modification of their semantics. The extended definition has the advantage that it allows us to eliminate the less well motivated transformations (rewriting rules) describing properties of synchronization languages. We show that the modified rewriting rules preserve regularity of the languages. Also, we obtain a characterization of finite synchronization languages as the family consisting of languages satisfying the start-termination property and closed under three types of simple rewriting rules.

Towards Re-usable Real-Time Objects

Large and complex real-time systems can benefit significantly<br />from a component-based development approach where new systems are constructed by composing reusable, documented and previously tested concurrent objects. However, reusing objects which execute under real-time constraints is problematic because application specific time and synchronization constraints are often embedded in the internals of these objects. The tight coupling of functionality and real-time constraints makes objects interdependent, and as a result difficult to reuse in another system. We propose a model which facilitates separate and modular specification of real-time constraints, and show how separation of real-time constraints and functional behavior is possible. We present our ideas using the Actor model to represent untimed objects, and the Real-time Synchronizers language to express real-time and synchronization constraints. We discuss specific mechanisms by which Real-time Synchronizers can govern the interaction and execution of untimed objects.<br />We treat our model formally, and succinctly define what effect<br />real-time constraints have on a set of concurrent objects. We<br />briefly discuss how a middleware scheduling and event-dispatching service can use the synchronizers to execute the system.

Distributed Safety Controllers for Web Services

We show how to use high-level synchronization constraints, written<br />in a version of monadic second-order logic on finite strings, to synthesize safety controllers for interactive web services. We improve on the naïve runtime model to avoid state-space explosions and to increase the flow capacities of services.

Stochastic bounds for parallel program execution times with processor constraints

A parallel program can be modeled as an acyclic directed graph, where a node represents a task, which is the smallest grain of computation to be assigned to a processor, and arcs stand for precedence (synchronization) constraints among the tasks. Due to different input data and unpredictable dynamic run time environments, the execution times of tasks as well as the entire program can be treated as random variables. In this paper, we develop some stochastic lower and upper bounds for parallel program execution times when there are limited processors. Such analysis can provide important information for job scheduling and resource allocation. For several typical classes of parallel programs, we derive very accurate closed form approximations for the bounds. Examples are also given to demonstrate the quality of the bounds derived.

The circulating processor model of parallel systems

This paper introduces the circulating processor model for parallel computer systems. Models of parallel systems tend to be computationally complex due to synchronization constraints such as task forking and joining. However, product form queuing network models remain computationally efficient as the size of the system grows by calculating only the mean performance metrics of the system. The circulating processor model is a product form queuing network model that differs from more traditional models in that the processors circulate among the parallel applications. In traditional models, the tasks of the parallel application circulate among the processors. Behaviors such as forking and joining of tasks and barrier synchronizations are better captured using this new approach. The circulating processor model may be load-dependent or load-independent. For systems that contain a single parallel application, the load-dependent circulating processor model is exact, while the load-independent model is not. In the latter case, an exact error can be calculated. For systems that contain multiple parallel applications, the load-dependent circulating processor model is a good approximation to the actual system, while the load-independent model is not. A case study using Parallel Virtual Machine (PVM) on a network of workstations illustrates the applicability of the circulating processor model.

A Reflective Model for Real-Time Applications in Open Distributed Systems

This paper presents a model for distributed applications with real-time constraints in open systems. The RTR model uses the reflective paradigm, providing realtime scheduling, control of time and synchronization constraints, and exception handling. The model adopts the CORBA standard for open systems to provide remote method calls, and handles timing constraints by using timeouts and deadlines. Therefore, the model ensures an efficient treatment of best-effort policies. Also, a prototype implemented using RTR model is described and a multimedia application is used in the prototype to express the model potentialities for real-time programming. Finally, the main characteristics of the RTR model are compared with other approaches adopted to real-time distributed applications.

Analysis of synchronization constraints and associated errors in collective work environments

This paper presents a framework of analysis of the requirements of synchronization and the associated errors in collective work environments. It proposes a formalism for describing the temporal relations that synchronization constraints take on in a work situation, giving special attention to the temporal information strategies used by the operators. A relational conception of time helps in understanding how the operators perceive, retain and utilize information to temporally co-ordinate their behaviours. An example application of the framework of analysis is developed for a situation of concrete work -anaesthesia- in the final section which concludes with the analysis of two cases of errors related to synchronization.

Quality of service (QoS) metrics for continuous media

This paper presents quality of service (QoS) metrics for continuity and synchronization specifications in continuous media (CM). Proposed metrics specify continuity and synchronization, with tolerable limits on average and bursty defaults from perfect continuity, timing and synchronization constraints. These metrics can be used in a distributed environment for resource allocation. Continuity specification of a CM stream consists of its sequencing, display rate and drift profiles. The sequencing profile of a CM stream consists of tolerable aggregate and consecutive frame miss ratios. Rate profiles specify the average rendition rate and its variation. Given a rate profile, the ideal time unit for frame display is determined as an offset from the beginning of the stream. Drift profile specifies the average and bursty deviation of schedules for frames from such fixed points in time. Synchronization requirements of a collection of CM streams are specified by mixing, rate and synchronization drift profiles. Mixing profiles specify vectors of frames that can be displayed simultaneously. They consist of average and bursty losses of synchronization. Rate profiles consist of average rates and permissible deviations thereof. Synchronization drift profiles specify permissible aggregate and bursty time drifts between schedules of simultaneously displayable frames. It is shown that rate profiles of a collection of synchronized streams is definable in terms of rate profiles of its component streams. It is also shown that mixing and drift profiles of a collection of streams are non-definable in terms of sequencing and drift profiles of its constituents. An important consequence of the mutual independence of synchronization and continuity specification is that, in a general purpose platform with limited resources, synchronized display of CM streams may require QoS tradeoffs. An algorithm that makes such tradeoffs is presented as a proof of applicability of our metrics in a realistic environment.

Synchronous Kahn networks

Synchronous data-flow is a programming paradigm which has been successfully applied in reactive systems. In this context, it can be characterized as some class of static bounded memory data-flow networks. In particular, these networks are not recursively defined, and obey some kind of "synchronous" constraints ( clock calculus ). Based on Kahn's relationship between data-flow and stream functions, the synchronous constraints can be related to Wadler's listlessness, and can be seen as sufficient conditions ensuring listless evaluation. As a by-product, those networks enjoy efficient compiling techniques. In this paper, we show that it is possible to extend the class of static synchronous data-flow to higher order and dynamical networks, thus giving sense to a larger class of synchronous data-flow networks.This is done by extending both the synchronous operational semantics, the clock calculus and the compiling technique of static data-flow networks, to these more general networks.

Scripting Interactive Physically‐Based Motions with Relative Paths and Synchronization

AbstractThis paper presents a novel approach for facilitating the use of physically based models by animators. The idea is to let the user guide motion at a high level of control by giving approximate desired trajectories and synchronization constraints between the objects over time, while a simulation module computes the final motion, dealing with collision detection and response, and enhancing realism.The objects, which are either isolated or components of an articulated structure, are guided through the specification of key‐positions and orientations, defined by coordinates that can be fixed or relative to another object. The animation sequence is scripted by specifying a graph of synchronization constraints between objects over time. During the animation, objects automatically regulate their speed in order to meet these constraints.

Synchronization in Specification-based Multimedia Presentations

Several information protocols exist for exchange of multimedia information. The {H}yper{T}ext {T}ransfer {P}rotocol (HTTP) of NCSA combines hypertext techniques with multimedia to provide an intuitive, easy-to-use hypermedia interface. However, HTTP does not provide the means to synchronize different multimedia channels. The NCSA hypermedia browser, Mosaic, has been modified to incorporate synchronization constraints. Platform-independent multimedia authoring programs have been combined in a new synchronization scheme. The {H}yper{T}ext {M}arkup {L}anguage (HTML) has been extended to allow the specification of temporal dependencies between different media channels. This extension allows synchronization in the authoring of hypermedia presentations using Mosaic.

Synchronization in Specification‐based Multimedia Presentations

Several information protocols exist for exchange of multimedia information. The HyperText Transfer Protocol (HTTP) of NCSA combines hypertext techniques with multimedia to provide an intuitive, easy-to-use hypermedia interface. However, HTTP does not provide the means to synchronize different multimedia channels. The NCSA hypermedia browser, Mosaic, has been modified to incorporate synchronization constraints. Platform-independent multimedia authoring programs have been combined in a new synchronization scheme. The HyperText Markup Language (HTML) has been extended to allow the specification of temporal dependencies between different media channels. This extension allows synchronization in the authoring of hypermedia presentations using Mosaic.

An Interpreted Coloured Petri Net Model For Verifying Protocol Specifications

Abstract This paper presents a Petri net model, called the interpreted coloured Petri net, which allows the verification of parallel systems specified with the ISO language Estelle. The main contribution of this model is to take into account parallel behaviours with strong synchronism constraints. Such behaviours are often encountered in real-time systems in which parallel execution is controlled by a clock tip. Our model allows the expression of simultaneous executions as it can be specified in Estelle. Moreover, this model is the basis of a protocol verification tool called Petristelle.

A programming model and system infrastructure for real-time synchronization in distributed multimedia systems

One of the major requirements of distributed multimedia applications is the need to maintain often complex, real-time synchronization constraints. More specifically, it is necessary to be able to manage arbitrary intra- and inter-media synchronization across activities in the distributed environment. Furthermore, it is important that such developments are integrated into emerging object-oriented standards for distributed computing. This paper presents an object-oriented programming model and associated implementation to meet these requirements. The main concepts behind the proposed approach are, firstly, the use of reactive objects for real-time control and synchronization and, secondly, quality of service controlled bindings for predictable communication between objects. The flexibility of the approach is demonstrated by three contrasting examples of real-time synchronization. The implementation extends the real-time capabilities of the Chorus micro-kernel by introducing the concepts of rtports, rthandlers and quality of service controlled connections. The paper demonstrates how reactive objects and bindings are realized on this infrastructure.