Showing papers on "Multiple dispatch published in 2007"

A multiple dispatch and partial backup hypercube queuing model to analyze emergency medical systems on highways

Abstract: The hypercube is a spatially distributed queuing model based on Markovian analysis approximations, used to analyze the configuration and operation of server-to-customer emergency systems. In the present study we adapted the model to analyze emergency medical systems (EMS) on highways, which operate within particular dispatching policies. The study takes into consideration that: the emergency calls are of different types; the servers are distinct (e.g., rescue ambulances, medical vehicles); only certain servers in the system can service calls in a given region (partial backup); and, depending on the type of call, one or more identical or distinct servers are immediately dispatched to service such calls (multiple dispatch). We also consider that the arriving calls take place either along the highway or at the home location of a server – in which case the server does not need to travel to the call location. Finally, we analyzed the computational results of applying such an approach to the case study of an EMS operating on Brazilian highways.

Compiler and Runtime for Heterogeneous Multiprocessor Systems

Abstract: Presented are embodiments of methods and systems for library-based compilation and dispatch to automatically spread computations of a program across heterogeneous cores in a processing system. The source program contains a parallel-programming keyword, such as mapreduce, from a high-level, library-oriented parallel programming language. The compiler inserts one or more calls for a generic function, associated with the parallel-programming keyword, into the compiled code. A runtime library provides a predicate-based library system that includes multiple hardware specific implementations (“variants”) of the generic function. A runtime dispatch engine dynamically selects the best-available (e.g., most specific) variant, from a bundle of hardware-specific variants, for a given input and machine configuration. That is, the dispatch engine may take into account run-time availability of processing elements, choose one of them, and then select for dispatch an appropriate variant to be executed on the selected processing element. Other embodiments are also described and claimed.

Dependent classes

Abstract: Virtual classes allow nested classes to be refined in subclasses. In this way nested classes can be seen as dependent abstractions of the objects of the enclosing classes. Expressing dependency via nesting, however, has two limitations: Abstractions that depend on more than one object cannot be modeled and a class must know all classes that depend on its objects. This paper presents dependent classes, a generalization of virtual classes that expresses similar semantics by parameterization rather than by nesting. This increases expressivity of class variations as well as the flexibility of their modularization. Besides, dependent classes complement multimethods in scenarios where multi-dispatched abstractions rather than multi-dispatched methods are needed. They can also be used to express more precise signatures of multimethods and even extend their dispatch semantics. We present a formal semantics of dependent classes and a machine-checked type soundness proof in Isabelle/HOL [29], the first of this kind for a language with virtual classes and path-dependent types.

Highly dynamic behaviour adaptability through prototypes with subjective multimethods

Abstract: With the advent of ambient intelligence and advances in mobile hardware technology, the next generation of software systems will require the ability to gracefully and dynamically adapt to changes in their surrounding environment. Contemporary languages provide no dedicated support to this end, thus requiring software developers to achieve this run-time adaptability through the use of specific design patterns and architectural solutions. As a consequence, all possible variability points of mobile systems need to be anticipated up front. Instead, we aim at solving the problem at the language level. We propose a new programming language called Ambience that provides dedicated language mechanisms to manage changing contexts and deal with run-time adaptation of mobile applications to those contexts. The language abstractions we propose are based on a prototype-based programming model that features multimethods and subjective object behaviour. We illustrate and motivate our approach by means of two running examples that were implemented in our language.

Open multi-methods for c++

Abstract: Multiple dispatch - the selection of a function to be invoked based on the dynamic type of two or more arguments - is a solution to several classical problems in object-oriented programming. Open multi-methods generalize multiple dispatch towards open-class extensions, which improve separation of concerns and provisions for retroactive design. We present the rationale, design, implementation, and performance of a language feature, called open multi-methods, for C++. Our open multi-methods support both repeated and virtual inheritance. Our call resolution rules generalize both virtual function dispatch and overload resolution semantics. After using all information from argument types, these rules can resolve further ambiguities by using covariant return types. Great care was taken to integrate open multi-methods with existing C++ language features and rules. We describe a model implementation and compare its performance and space requirements to existing open multi-method extensions and workaround techniques for C++. Compared to these techniques, our approach is simpler to use, catches more user mistakes, and resolves more ambiguities through link-time analysis, runs significantly faster, and requires less memory. In particular, the runtime cost of calling an open multi method is constant and less than the cost of a double dispatch (two virtual function calls). Finally, we provide a sketch of a design for open multi-methods in the presence of dynamic loading and linking of libraries.

Modular multiple dispatch with multiple inheritance

Abstract: Overloaded functions and methods with multiple dispatch are useful for extending the functionality of existing classes in an object-oriented language. However, such functions introduce the possibility of ambiguous calls that cannot be resolved at run time, and modular static checking that such ambiguity does not exist has proved elusive in the presence of multiple implementation inheritance. We present a core language for defining overloaded functions and methods that supports multiple dispatch and multiple inheritance, together with a set of restrictions on these definitions that can be statically and modularly checked. We have proved that these restrictions guarantee that no undefined nor ambiguous calls occur at run time, while still permitting various kinds of overloading.

OOMatch: pattern matching as dispatch in Java

Abstract: We present an extension to Java, dubbed OOMatch. It allows method parameters to be specified as patterns, which are matched against the arguments to the method call. When matches occur, the method applies; if multiple methods apply, the method with the more specific pattern overrides the others.

Proportional fair scheduling algorithm multi-mode configuration and scheduling method

Abstract: The proportion equity dispatch algorithm (PEDA) possesses multiple dispatch modes of providing multi choices between throughput of sector and service fairness for operation manager. The method includes following steps: (1) determining configuration parameter for each mode of PEDA; (2) saving the said configuration parameters in base station; (3) using far end maintenance platform or near end maintenance platform sends the selected dispatch mode in PEDA to base station; (4) after receiving dispatch mode of modified PEDA, base station makes appointed mode effect instantly or in time.

Static Analysis Based Application Specific Dispatch Table Compaction

Abstract: Object oriented programming languages are increasingly used in software development for embedded systems as they support elegant programming and easier extensibility. Dispatch table is introduced to support message passing mechanism. For a large number of classes and methods the dispatch table is also larger and needs substantial amount of memory space. But memory size is the main constraint in embedded systems. To overcome this bottleneck we have proposed a static analysis based approach for application specific customization of the dispatch table by removing redundant entries. Hence the size of the table is smaller. Our scheme is independent of underlying storage structure of the table. We have tested our proposed approach on real life applications. We have found that our proposed method can safely remove significant number redundant entries during dispatch table construction and hence enhancing the system performance.

An object-oriented calculus with term constraints

Abstract: Safety has become a fundamental requirement in all aspects of computer systems. Object-oriented calculi, such as Castagna's λ&-calculus and its variants (Castagna, 1997) ensure type safety in environments based on the distinguished object-oriented paradigm. Although for safety reasons object invariance and operation specifications are getting widely employed in all stages of the engineering process, they are not supported by these calculi. In this paper, a new calculus is presented which supports term (value) constraints besides the key object-oriented mechanisms (class types, inheritance, overloading with multiple dispatch and late binding). We also show how a type with constraints may realise a role, another useful object-oriented modelling element. The soundness of the type system and the confluence of the notion of reduction of the calculus are considered. The contribution also discusses computability issues partially arising from the use of first-order logic to formalise the constraints.

Making generic functions useable in Smalltalk

Abstract: There have traditionally been two approaches to object orientation with respect to defining code to operate on objects The first and more common one is message passing The other is generic functions which use multiple dispatch (also known as multimethods) While Smalltalk provides one of the simplest implementations of a message passing system, there are some circumstances where generic functions provide a more concise solution to the problem The goals of this project are two-fold: first, to take a look at how to implement generic functions in Smalltalk alongside the existing message passing system, and secondly, to look into how to nicely integrate the infrastructure for creating generic functions into the Squeak programming environment