Solving Inheritance Anomaly with OMNets

This paper presents a concurrent object-oriented modeling language based on Petri nets:OMNets,which hepls greatly to avoid the inheritance anomaly problem appeared in concurrent OO languages.OMNets separates th functional part and the synchroniztion part of objects and uses Petri nets to describe the synchronization part.Both parts are reusable through inheritance.     

An application of artificial intelligence to object-orientedperformance design for real-time systems

The paper describes an application of artificial intelligence technology to the implementation of a rapid prototyping method in object-oriented performance design (OOPD) for real-time systems. OOPD consists of two prototyping phases for real-time systems. Each of these phases consists of three steps: prototype construction, prototype execution, and prototype evaluation. We present artificial intelligence based methods and tools to be applied to the individual steps. In the prototype construction step, a rapid construction mechanism using reusable software components is implemented based on planning. In the prototype execution step, a hybrid inference mechanism is used to execute the constructed prototype described in declarative knowledge representation. MENDEL, which is a Prolog based concurrent object-oriented language, can be used as a prototype construction tool and a prototype execution tool. In the prototype evaluation step, an expert system which is based on qualitative reasoning is implemented to detect and diagnose bottlenecks and generate an improvement plan for them     

基于Petri网结构的多处理机实时操作系统

多处理机环境下的实时系统具有并发事件驱动性质,其软件结构展现了多重同步点以及生产者与消费者之间的关系,这导致了复杂的控制结构.对于此类系统软件的开发缺少标准的方法和工具,造成了软件低效、程序结构不清晰、开发成本高、维护困难的现象的出现.根据Petri网易于描述并行/并发现象的特点,采用它来解决多处理机软件的描述问题,介绍了一种以Petri网图形方式在多处理机系统环境下进行程序设计的方法.该方法基于两种程序设计级别:任务级和作业级.前者负责描述基本操作,由单一控制线程完成;后者用于并行/并发程序建模,由整个多处理机系统来执行.在作业级程序设计中,用户采用面向对象Petri网来描述并行程序结构,以建立系统模型.该方法以一种接近于程序员的思维方式去设计并发软件,提供了一种可靠的并行结构的程序.阐述了支持此种程序设计方法的操作系统结构及其实现原理.     

A formal method for building concurrent real-time software

Developing concurrent real-time programs is one of computer science's greatest challenges. Not only is such software expensive to manufacture, but its role in safety-critical systems demands that it be correct. Formal methods of program specification and refinement could strengthen the mathematical precision used to develop such software. Nevertheless, formalisms that embrace both real-time and concurrency requirements are only just emerging. The Quartz method treats time and functional behavior with equal importance in the development process. The authors argue that by modeling program development in a unified framework, we can increase our confidence in the correctness of real-time concurrent code     

面向国产平台的程序并发性能分析技术

随着国产处理器和国产操作系统的逐步推广应用,越来越多的开发人员在国产平台下开发多线程程序.目前国产平台普遍采用的Qt Creator工具中缺乏可视化的并发性能分析工具,使得优化由于多线程同步/互斥和资源竞争带来的性能问题变得特别困难.设计一种Qt Creator下的并发性能分析方案,通过实时监控程序并发事件,采集程序运行过程中的并发性能数据,分析程序并发性能瓶颈和死锁原因,并以插件形式进行多视图数据显示.通过实验表明,该并发性能分析方案可以方便、快捷地辅助用户开发多线程并发程序,提高软件开发效率.     

Documentation driven development for complex real-time systems

This work presents a novel approach for development of complex real-time systems, called the documentation-driven development (DDD) approach. This approach can enhance integration of computer aided software development activities, which encompass the entire life cycle. DDD will provide a mechanism to monitor and quickly respond to changes in requirements and provide a friendly communication and collaboration environment to enable different stakeholders to be easily involved in development processes and, therefore, significantly improve the agility of software development for complex real-time systems. DDD will also support automated software generation based on a computational model and some relevant techniques. DDD includes two main parts: a documentation management system (DMS) and a process measurement system (PMS). DMS will create, organize, monitor, analyze, and transform all documentation associated with the software development process. PMS will monitor the frequent changes in requirements and assess the effort and success possibility of development. A case study was conducted by a tool set that realized part of the proposed approach.     

Certifying Low-Level Programs with Hardware Interrupts and Preemptive Threads

Hardware interrupts are widely used in the world’s critical software systems to support preemptive threads, device drivers, operating system kernels, and hypervisors. Handling interrupts properly is an essential component of low-level system programming. Unfortunately, interrupts are also extremely hard to reason about: they dramatically alter the program control flow and complicate the invariants in low-level concurrent code (e.g., implementation of synchronization primitives). Existing formal verification techniques—including Hoare logic, typed assembly language, concurrent separation logic, and the assume-guarantee method—have consistently ignored the issues of interrupts; this severely limits the applicability and power of today’s program verification systems. In this paper we present a novel Hoare-logic-like framework for certifying low-level system programs involving both hardware interrupts and preemptive threads. We show that enabling and disabling interrupts can be formalized precisely using simple ownership-transfer semantics, and the same technique also extends to the concurrent setting. By carefully reasoning about the interaction among interrupt handlers, context switching, and synchronization libraries, we are able to—for the first time—successfully certify a preemptive thread implementation and a large number of common synchronization primitives. Our work provides a foundation for reasoning about interrupt-based kernel programs and makes an important advance toward building fully certified operating system kernels and hypervisors.     

Using flat concurrent Prolog in system modeling

The flat concurrent Prolog (FCP) language, which enables the implementation of synchronization through data flow, communication through shared variables, parallelism through the reduction of the AND components in the clause's body, and indeterminacy through guarded commands, is discussed. It is shown that FCP, used in conjunction with Petri net methods, forms a powerful tool in the modeling of parallel systems that involve concurrency. The simulation of systems represented by various types of Petri nets is achieved using the reduction process of FCP. AND parallelism supports free competition among conflicting enabled transitions. A structural analysis of systems is provided using the metaprogramming technique     

Implementation of tabled evaluation with delaying in Prolog

Unlike SLD resolution as implemented in Prolog, tabled evaluation with delaying guarantees termination for function free logic programs, avoids repeated computation of identical subqueries, and handles recursion through negation. It is often used in query processing and nonmonotonic reasoning where termination is required. The paper presents a new technique for incorporating tabled evaluation into existing Prolog systems. It requires neither time consuming modifications of a Prolog engine nor metainterpretation that can enormously slow down program execution. Instead, using a program transformation approach, the technique allows effective use of the advanced Prolog technology. The transformed program uses tabling primitives implemented externally in C that provide direct control over the search strategies. This brings efficiency as well as portability across Prolog systems. Experiences with a prototype implementation indicate that the approach results in a flexible and pragmatic method for query processing and nonmonotonic reasoning on top of Prolog. Performance measurements show that the method is efficient for practical applications     

An integrated manufacturing planning assistant — IMPA

In this paper, we describe our development of a fully integrated manufacturing planning assistant (IMPA) system, which is able to: (1) interpret the finished part requirements directly from the designer's CAD systems or solid modelers without user intervention or special feature coding; (2) check the machinability of a designed part; (3) automatically generate a process plan, a tool path and an NC (numerically controlled) code, and (4) support interactive user modification of the resulting plans, tool paths and NC code. A demonstration version of the system was designed to provide automated assistance for the planning of machining processes on three-axes NC machine tools. The underlying architectural concepts and reasoning algorithms can be extended to more complex machines such as four-or-more-axes NC machines. CAD, CAE, and CAM including robotic, FMS (flexible manufacturing system) and NC machines are widely used in industry today. There is increasing interest in automation of factory control software Merchant, (1988); this includes automating the generation of the control programs — that is, in developing systems which will automatically produce the NC code for machining the part, given a model of the part, the shape of the raw material, and the machine specifications. With such systems, there are several difficulties in the manual preparation of an NC program code such as, long and tedious calculations, high risk of error in data preparation, etc., which need to be eliminated. This is a critical step toward the integration of CAD and CAM into a truly concurrent engineering and manufacturing environment.     

Modeling advanced manufacturing systems using concurrent logic programming

Modern manufacturing systems are complex systems composed of the following components: numerically controlled manufacturing machines, automated material handling systems, and a computerized control system that supervises the operation of the manufacturing system. In order to operate properly there must be a sophisticated, hierarchical communication layer among the components.It is desirable to have a tool that can capture all aspects of the manufacturing system, thus being able to model, simulate, analyze and even drive it. The modeling of concurrent asynchronous operations of a complex information intensive manufacturing system has today very limited tools.This paper presents a new approach towards modeling of Advanced Manufacturing Systems (AMS). The modeling vehicle is a dialect of concurrent logic programming language called FCP (Flat Concurrent Prolog). This approach, in addition to the more commonly modeled features, enables the modeler to capture the dynamic nature of a system including conflicts, deadlocks, communication protocols, concurrency and information transfer.     

Composing Synchronization and Real-Time Constraints

There have been a number of publications illustrating the successes of object-oriented techniques in creating highly reusable software systems. Several concurrent languages have been proposed for specifying reusable synchronization specifications. Recently, a number of real-time object-oriented languages have been introduced for building object-oriented programs with real-time behavior. Composing and reusing object-oriented programs with both synchronization and real-time constraints has not been addressed adequately, although most real-time systems are concurrent. This paper analyzes the origins of the problems in composing and reusing synchronization and real-time specifications, first as separate concerns, and later as composed behavior. To overcome the so-called inheritance anomaly problems, this paper proposes modular and composable synchronization and real-time specification extensions to the object-oriented model. The applicability of the proposed mechanisms is illustrated through a number of examples.     

An automated reasoning problem associated with proving claims about programs using Floyd-Hoare inductive assertion methods

Proving claims about behavior of software is essential for the qualification of computer-based systems used in the control of nuclear reactors. For this Problem Corner, we select one of the verification conditions for a C program that initializes an array to zero. We add assertions about the initial conditions and state of the program and about the expected behavior of the program in terms of its state. The modeling and specification technique is the inductive assertion technique of Floyd-Hoare. The program with assertions is then transformed by the source-to-source program transformation system TAMPR into a set of separate verification conditions to be proven by the automated reasoning system. Our experience with this program demonstrates the typical automated reasoning problems we have encountered and illustrates how we have approached solutions to the problems.Work supported by the Civilian Reactor Development Program and the Applied Mathematical Sciences Research subprogram of the Office of Energy Research, U.S. Department of Energy, under Contract No. W-31-109-ENG-38.     

An approach for high-yield requirements capture for e-commerce and its application

Web-based e-commerce software is typically real-time, responsive, and distributed software that must meet high quality requirements. Moreover, because of its Internet-based operating environment, e-commerce software must deal with concurrency, synchronization, and non-deterministic issues (such as delays) primarily caused by the heavy usage load and underlying network conditions. In this paper, we introduce a generic, cost-effective approach to optimize requirements capture (and subsequent development and testing) with respect to functional coverage and customer perception of quality. This high-yield approach is presented and illustrated by application to an e-commerce online shopping system and used to explain the principles of use-case requirements captured in the unified modeling language. Published online: 25 July 2001     

Automated reasoning in geometry theorem proving with Prolog

This paper describes automated reasoning in a PROLOG Euclidean geometry theorem-prover. It brings into focus general topics in automated reasoning and the ability of Prolog in coping with them.     

Integrating scientific modeling and supporting dynamic hazard management with a GeoAgent-based representation of human–environment interactions: A drought example in Central Pennsylvania, USA

Recent natural disasters indicate that modern technologies for environmental monitoring, modeling, and forecasting are not well integrated with cross-level social responses in many hazard-management systems. This research addresses this problem through a Java-based multi-agent prototype system, GeoAgent-based Knowledge System (GeoAgentKS). This system allows: (1) computer representation of institutional regulations and behavioral rules used by multiple social institutions and individuals in cross-level human–environment interactions, (2) integration of this representation with scientific modeling of dynamic hazard development, and (3) application of automated reasoning that suggests to users the appropriate actions for supporting cooperative social responses. This paper demonstrates the software architecture of GeoAgentKS and presents such an integrated approach by modeling the drought management processes in Central Pennsylvania, USA. The results show that it is possible to use GeoAgentKS to represent multilevel human–environment interactions and to use those interactions as input to decision making in hazard management.     

Observable behavior of distributed systems: Component reasoning for concurrent objects

Distributed and concurrent object-oriented systems are difficult to analyze due to the complexity of their concurrency, communication, and synchronization mechanisms. Rather than performing analysis at the level of code in, e.g., Java or C++, we consider the analysis of such systems at the level of an abstract, executable modeling language. This language, based on concurrent objects communicating by asynchronous method calls, avoids some difficulties of mainstream object-oriented programming languages related to compositionality and aliasing. To facilitate system analysis, compositional verification systems are needed, which allow components to be analyzed independently of their environment. In this paper, a proof system for partial correctness reasoning is established based on communication histories and class invariants. A particular feature of our approach is that the alphabets of different objects are completely disjoint. Compared to related work, this allows the formulation of a much simpler Hoare-style proof system and reduces reasoning complexity by significantly simplifying formulas in terms of the number of needed quantifiers. The soundness and relative completeness of this proof system are shown using a transformational approach from a sequential language with a non-deterministic assignment operator.     

IPTES: A concurrent engineering approach for real-time software development

The constantly increasing concurrency, complexity, and risks associated with the industrial development of real-time embedded computer systems has been approached in different ways in recent years. In Esprit project no. EP5570, called IPTES, a methodology and a supporting environment to support the Boehm's spiral process are being developed. The prototyping environment will enable the specification, development, and verification of executable system models so that different parts of the system may represent different modeling levels and yet can be executed as a total system. Concurrent engineering problems in connection with multi-supplier, distributed software development are also addressed in the IPTES environment. In the IPTES project the concept of heterogeneous prototyping is proposed as a solution. Each of the development teams may use relatively abstract models of the other parts of the systems as a testbed (environment model) for their own part, yet they can proceed developing their own part full speed by means of advancing the maturity of their part to the next abstraction level(s). The IPTES environment provides a set of tools to help in the process of creating, analyzing, and testing distributed heterogeneous prototypes.     

Temporal data representation and reasoning in REAKT

The ability of reasoning about temporal data, representing past, current and expected application states is an important function to be accomplished by Real-Time Knowledge-Based Systems (RTKBS). The application of Knowledge-based systems to real-time problems has to deal with dynamic time-constrained environments and assess two of the most important requirements in real-time systems: the ability to react rapidly to changes in the environment and the guarantee of a bound on the response time. This paper presents a temporal framework for reasoning about the future behaviour of a dynamic time-constrained problem. The proposed mechanism is integrated into a multiagent blackboard architecture and will provide a perspective of the temporal functionalities offered in the REAKT tool     

Modeling distributed real-time systems with MAST 2

Switched networks have an increasingly important role in real-time communications. The IEEE Ethernet standards have defined prioritized traffic (802.1p) and other QoS mechanisms (802.1q). The Avionics Full-Duplex Switched Ethernet (AFDX) standard defines a hard real-time network based on switched Ethernet. Clock synchronization is also an important service in some real-time distributed systems because it allows a global notion of time for event timing and timing requirements. In the process of defining the new MAST 2 model, clock synchronization modeling capabilities have been added, and the network elements have been enhanced to include switches and routers. This paper introduces the schedulability model that will enable an automatic schedulability analysis of a distributed application using switched networks and clock synchronization mechanisms.