Search

A system utilizing reconfigurable hardware of 1 million gates and two CMOS cameras is used in an image analysis system. The system is a part of a sensor system for a robot, and can deliver data about the robots position as well as relative distances of other objects in real time. [ABSTRACT FROM AUTHOR]

The positive experiences from the usage of Ada in a safety critical flight control system are described in this paper. It states that preemptive scheduling implemented with tasking, can be combined with high requirements on reliability and a deterministic behaviour. How data consistency has been obtained between the periodic tasks is outlined. Also the exception handling in the system is mentioned. [ABSTRACT FROM AUTHOR]

In this paper we discuss our guidance on the suitability of Ada95 for high integrity systems. [ABSTRACT FROM AUTHOR]

The Ravenscar profile defines a simple subset of the tasking features of Ada in order to support efficient, high integrity applications that need to be analysed for their timing properties. This paper describes the Profile and gives the motivations for the features it does (and does not) include. An implementation of the profile is then described in terms of development practice and requirements, run-time characteristics, certification, size, testing and scheduling analysis. Support tools are discussed as are the means by which the timing characteristics of the run-time can be obtained. The important issue of enforcing the restrictions imposed by the Ravenscar profile is also addressed. [ABSTRACT FROM AUTHOR]

This paper presents a process for the refinement of safety-critical source code into a more tractable representation. For large software-intensive information systems, the safety engineering view of the system reveals a "long thin slice" of hazard-related software involving a number of different software components. The hazard-related software is documented in the system "safety verification case" which provides a rigorous argument for the safety of the source code. The refinement process creates a representation of the source code which isolates the relevant source code details. A hypothetical chemical factory information system is examined to illustrate aspects of this process and its significance. [ABSTRACT FROM AUTHOR]

A data-flow framework for symbolic symbolic reaching definitions analysis is presented. It produces a more accurate solution of the reaching definitions problem than can be achieved with "classic" data-flow analysis, which is very important for safety-related applications. [ABSTRACT FROM AUTHOR]

This paper is devoted to study the use, in the Simple_Com system, of several mechanisms provided by the Ada programming language (type extension, dynamic dispatching, encapsulation, generics, etc.). The Simple_Com system is a toolbox for building protocols of different qualities of service (both unicast and multicast). It is flexible, extensible, portable, and provides clean and simple interfaces. Many of its features are possible thanks to the extensive use of those Ada mechanisms. The Simple_Com system is useful for building distributed applications (using the protocols already provided), or to design and test new protocols (either combining some of the pieces provided, or building new ones). [ABSTRACT FROM AUTHOR]

Generic architectures for specific domains can provide significant gains in productivity and quality for real-time systems development. In order to choose among different architectural features, a variety of qualitative criteria have been proposed in the literature. However, real-time systems require a more exact characterization based on quantitative evaluation of some architectural features related to timing properties, such as scalability. In this paper we explore a possible way of using Rate Monotonic Analysis to get a measure of scalability between alternative architectures. The technique is illustrated with a case study in a well-known real-time domain, data acquisition systems. The results show clear differences in scalability for different architectures, giving a clear indication of which one is better from this point of view. We believe that the approach can be used on other properties and domain architectures, thus opening new possibilities for quantitative evaluation of software architectures. [ABSTRACT FROM AUTHOR]

We ported an Architecture Description Language (ADL), MetaH, for automating the specification, analysis and building of Avionics/high reliability systems on top of Ada 95 and the Distributed Systems Annex (DSA). Our purpose was to explore the requirements for the DSA in such applications and to assess portability benefits. The problem domain of modern avionics will increasingly require strong partitioning of software with multilevel safety and reliability analysis to build highly complex, large, multiprocessor, predominately hard real-time software systems. This paper covers changes in the requirement driving the problem domain, the solution approach using an ADL, MetaH, on top of the DSA, and requirements for a usable DSA implementation. [ABSTRACT FROM AUTHOR]

Providing an effective search/retrieval mechanism is essential for supporting software reuse. Such a tool can help both software designers and developers in finding, understanding and modifying the components most relevant for their requirements. Syntactic matching techniques can provide easy to use, fast and cheap, but not necessarily very accurate, search tools. On the contrary, specification matching can provide accurate results, while it is more difficult to use, slow and expensive (in terms of complexity and resources). In this paper, we propose a hybrid process which combines these two matching methods. At the first level, a user can perform a keyword search based on faceted classification. If results of the first level are not satisfactory, a specification based matching can be conducted among the results of the first match. In this way, the associated costs of specification matching will be dramatically dropped by the restriction of the search space (you'll pay for what you use). The proposed specification match also tries to take advantage of the characteristics of OO class libraries (i.e. inheritance and design by contract principles). We will show how these can improve both performance and accuracy of matching queries with components. [ABSTRACT FROM AUTHOR]

This paper summarizes IABG's experience as an Ada Validation Facility from the last decade. The paper puts an emphasis on the improvement of the validation process by evolving tool support. [ABSTRACT FROM AUTHOR]

This paper describes the project Quality-for-ASIS, aiming at the development of an extensive testing facility for ASIS implementations. First the specific problems and requirements are presented. After a section about the basic concepts of ASIS and after a short introduction to testing, the designs and implementations for testing important subsets of ASIS are described. Finally, adequacy coverage statistics for a test set based on the ACVC compiler validation suite are provided. [ABSTRACT FROM AUTHOR]

This paper describes a software architecture for industrial robots used in manufacturing equipment. In order to achieve software portability, the application software is dissociated from the low-level robot controller software. The interaction between these two pieces of software is achieved by a portable application programming interface (API) for industrial robots. We discuss the requirements for such an API, and propose a design called PINROB. [ABSTRACT FROM AUTHOR]

In the distributed discrete event simulation area, Jefferson's time warp algorithm initiated a lot of research and practical work. We proposed a generalisation, split queue time warp, that allows lazy message reception and thus may reduce rollback frequency. The present paper contains a brief description of our algorithm and then describes an implementation that uses Ada 95 and its capabilities for distributed programming. [ABSTRACT FROM AUTHOR]

Due to a variety of policy errors of the guardians of Ada in the past, the scientific community has never come to appreciate Ada83; Fortran still holds virtually absolute sway over computational (astro)physics. The advent of Ada95 may have changed this unhappy situation. Extensive exploration of the potential of Ada in the field of spectral line synthesis over the past years has revealed its suitability for numerically intensive (astro)physical modelling. Genericity, hierarchical libraries and programming by extension are among the most attractive features, facilitating code maintenance and extension and achieving a high degree of software reuse. In addition, Ada tasking together with protected objects allows straightforward parallelisation with very few modifications to sequential code, yielding linear scaling of performance with the number of processors, and almost perfect load balance, whereas the data-parallel approach of High Performance Fortran turns out to be of little use. Numerous code examples illustrate how easy it becomes to write safe, reusable and massively parallel scientific codes in Ada95 without incurring the "abstraction penalty". [ABSTRACT FROM AUTHOR]

Flexible and adaptive behavior is seen as one of the key characteristics of next generation hard real-time systems. Within the context of fixed priority pre-emptive scheduling, existing approaches deal with optional components and provide kernel mechanisms to schedule effectively such components when spare processor capacity is available. This paper describes a framework that provides a task programming model with optional components, and the appropriate mechanisms for supporting it, by using the main results of existing research in computing spare processor capacity. The paper shows how these ideas can be adapted for being used from an Ada application. The concurrency and real-time programming features of Ada allow an elegant and efficient implementation of a model where hard real-time tasks, optional unbounded components and optional firm tasks coexist. [ABSTRACT FROM AUTHOR]

As software development and maintenance costs rise, providing higher architectural language abstractions is an effective tool. This paper describes a key set of object oriented abstractions developed using the Ada 95 toolset, and discusses their applicability to distributed real-time command and control systems under development at Boeing. The abstraction concepts described build upon each other and eventually become high level tools. This helps to increase the leveraged development of real-time systems, especially as the product and customer configurations vary. This papers particular emphasis is on how to migrate to the new Ada 95 package (purity) categorization rules, and describes their use in the distributed Annex-E. A strongly typed, possibly remote, data subscription concept is described and then shown in it's use of the advanced Ada distributed generics capabilities. Client-server and distributed-object abstractions are also contrasted. [ABSTRACT FROM AUTHOR]

Off-line analysis techniques for hard real-time systems are all based on the assumption that we can estimate the worst-case execution time of the different tasks executing in the system. In the traditional cyclic-executive schedulers, execution time limits were enforced for each task by the scheduler. Unfortunately, in concurrent hard real-time systems such as those using the tasking model defined in Ada, no bound on the execution time of tasks is enforced, which may result in a system timing malfunction not detected by the analysis techniques. In this paper we explore the implementation of execution time clocks within the task scheduler, and we describe methods to detect execution time overruns in the application, and to limit their effects. We also discuss the use of execution time clocks to enhance the performance of sporadic server schedulers implemented at the application level. [ABSTRACT FROM AUTHOR]

We present Transactional Drago a language that implements Group Transactions, a new transaction model we have developed. This model integrates the group communication paradigm with the nested transaction model. Transactional Drago extends Drago, a distributed fault-tolerant extension of Ada implementing the group paradigm. In this paper we describe the linguistic features added to Drago to support group transactions and how they are integrated with the existing mechanisms in Drago, particularly with group communication. [ABSTRACT FROM AUTHOR]

The current Ada revision tries as much as possible to provide the programmer with an easy way to build distributed systems; in many cases, the programmer can easily modify its monolithic application and transform it in a very short amount of time into a distributed one. However, there is a huge amount of work involved in the compiler and in external tools and libraries to build and run a distributed application without loosing Ada semantics and strong type checking. This paper describes how such a task has been achieved in the current implementation of GNAT, the GNU Ada compiler, and in GLADE, GNAT's companion package for building and running distributed programs. [ABSTRACT FROM AUTHOR]

Object-oriented techniques such as inheritance promise great benefits for the specification and design of concurrent systems. To exploit these benefits appropriate techniques for object-oriented programming within a concurrent programming language context are required. Especially a concept how to support the inheritance of synchronization constraints is necessary to avoid what is called the inheritance anomaly. We present a modelling style of Ada which allows the integration of concurrency into object-oriented programming and which offers a solution to the inheritance anomaly. [ABSTRACT FROM AUTHOR]

This paper presents a programming paradigm for synchronizing multiple clients and servers. The solution is flexible and efficient and shows how class-wide types and protected objects can be used to achieve the effect of dispatching on entry calls. [ABSTRACT FROM AUTHOR]

This paper describes an automated approach for generating Ada bindings from Java class files. We start with the set of Java features that require a visible Ada binding, and an Ada compiler's definition of how to interface Ada and Java. We discuss how to obtain the Java definitions from the class file and then translate them into an Ada binding (using the GNAT binding approach). While it is possible to generate a technically complete Ada binding from the information in a Java class file (within the constraints of necessary support from an Ada compiler). However, we show that such a binding has significant limitations from a practical usability perspective. [ABSTRACT FROM AUTHOR]

This paper describes an implementation model for porting the tasking portion of the GNAT Ada 95 Runtime Library to the Java environment, and a proof-of-concept implementation. The latter allows one to run multi-tasking applications that are written in Ada and compiled into native machine code, using the thread support of the Java Virtual Machine. The Java Virtual Machine takes care of scheduling the different threads of control, just like any multi-threaded operating system would. [ABSTRACT FROM AUTHOR]

Based on a fifteen years experience in safety related software design our opinion is that the combination of an efficient formal method and the use of Ada is the best way to reach the total correctness requested by safety. Although these types of methods may appear as grim, they are not very difficult to learn and give finally to their users the satisfaction of producing a high quality work, at the lowest possible cost for this quality. We hope that these methods will find new users for the greatest benefit of the software engineering community. [ABSTRACT FROM AUTHOR]

This is a modest attempt at unveiling forthcoming opportunities in the embedded computing sector. The final talk will also explain how Ada 95 offers a competitive advantage in the new embedded marketplace. [ABSTRACT FROM AUTHOR]