Mirror‐based reflection in AmbientTalk

This paper introduces a novel mechanism to perform intercession (a form of reflection) in an object‐oriented programming language with the goal of making the language extensible from within itself. The proposed mechanism builds upon a mirror‐based architecture, leading to a reusable reflective application programming interface that cleanly separates interface from implementation details. However, support for intercession has been limited in contemporary mirror‐based architectures. This is due to the fact that mirror‐based architectures only support reflection explicitly triggered by metaprograms, while intercession requires reflection implicitly triggered by the language interpreter. This work reconciles mirrors with intercession in the context of an actor‐based, object‐oriented programming language named AmbientTalk. We describe this language's full reflective architecture, highlighting its novel mirror‐based approach to reflect upon both objects and concurrently executing actors. Subsequently, we apply AmbientTalk's mirror‐based reflection to implement two language features, which crucially depend on intercession, to wit future‐type message passing and leased object references. Copyright © 2008 John Wiley & Sons, Ltd.     

A formally verified application-level framework for real-time scheduling on POSIX real-time operating systems

We present a framework, called meta scheduler, for implementing real-time scheduling algorithms. The meta scheduler is a portable middleware layer component designed for implementations over POSIX-compliant operating systems. It accommodates pluggable real-time scheduling algorithms while offering the flexibility of platform independence - the singular underlying OS requirement is the now nearly ubiquitous POSIX compliance. The versatility of pluggable schedulers positions the meta scheduler for deployment in an interoperable heterogeneous real-time environment. We present the design of the meta scheduler and outline its implementation. Furthermore, we present a mechanized correctness verification using the UPPAAL model checker. Prototype implementation of the meta scheduler over QNX Neutrino real-time operating system demonstrates high performance and a small footprint.     

Automatic synthesis and verification of real-time embedded software for mobile and ubiquitous systems

Currently available application frameworks that target the automatic design of real-time embedded software are poor in integrating functional and non-functional requirements for mobile and ubiquitous systems. In this work, we present the internal architecture and design flow of a newly proposed framework called Verifiable Embedded Real-Time Application Framework (VERTAF), which integrates three techniques namely software component-based reuse, formal synthesis, and formal verification. Component reuse is based on a formal unified modeling language (UML) real-time embedded object model. Formal synthesis employs quasi-static and quasi-dynamic scheduling with multi-layer portable efficient code generation, which can output either real-time operating systems (RTOS)-specific application code or automatically generated real-time executive with application code. Formal verification integrates a model checker kernel from state graph manipulators (SGM), by adapting it for embedded software. The proposed architecture for VERTAF is component-based which allows plug-and-play for the scheduler and the verifier. The architecture is also easily extensible because reusable hardware and software design components can be added. Application examples developed using VERTAF demonstrate significantly reduced relative design effort as compared to design without VERTAF, which also shows how high-level reuse of software components combined with automatic synthesis and verification increases design productivity.     

APIs for real-time distributed object programming

Ideally, according to the author, a real-time distributed programming method should be based on a general high-level style that could be easily accommodated by application programmers using C++ and Java. If such a method were to exist, these programmers could specify the interactions among distributed components and the timing requirements of various actions without expending much effort. Facilitating high-level, high precision, real-time object programming by establishing some form of language tools has consequently become a subject of great interest to the embedded systems community. This article focuses on application programming interfaces (APIs) that take the form of C++ and Java class libraries and support high-level, high precision, real-time object programming without requiring new language translators. These APIs wrap the services of the real-time object execution engines, which consist of hardware, node OSs, and middleware; they enable convenient high-level programming almost to the extent that a new real-time object language can. The author explains the API's fundamental features, how they interact among real-time objects, and how multicast channels and real-time multicast APIs contribute     

一个可构造的反演状态模式

为了构造可扩充、可配置、可控制的状态模型,提出了一个可构造的反演状态模式.基于体系结构的反演模式和角色对象模式,讨论了状态设计模式中结构和行为的反演方法及其手段;给出了其反演模式体系结构的元级和基本级对象结构;使用MOP(metaobjeotprotoco1)规程给出了元级和基本级的关系,讨论了反演状态模式的元对象反演到基本级对象群的"截取和求精(interception和reification)”机制.此外,还给出了一个应用可构造的反演状态模式的[记账凭证处理型]应用事例.     

中间件的体系结构研究

介绍了一种可配置且具有开放性的中间件体系结构模型、该体系结构模型是一种独立于语言且具有反身映射性的结构模型，它包含有：元空间(每一对象具有一个元空间)、元模型(用元模型去构建元空间)、对象图(用对象图表示组合组件)．通过使用构造元空间的组件框架来实现该结构模型．Open COM结构模型是对Microsoft的分布式组件技术进行了扩展，具有可配置性、开放性、反身映射性，语言独立性、系统独立性等特点．     

Verification of schedulability for real-time programs

Assume that a real-time programP ^T consisting of a number of parallel processes is executed on a system having a setPr of processors which are shared between the processes by a real-time schedulerS ^T. Assume that P^T must meet some timing deadlines. We show that such an implementation ofP ^T can be represented as a transformationL(P ^T) and that the deadlines ofP ^T will be met if they are satisfied by the timing properties of the transformed program. The condition for feasibility of a real-time program executed under a scheduler is formalized and rules are provided for verification. The schedulerS ^T can be specifiedgenerically and applied to different programs, making it unnecessary to introduce low-level operations such as scheduling primitives into the programming language. Thus real-time program specification and Schedulability can be considered in the same framework and the timing properties of a program can be determined at the specification level. By separating the specification of the scheduler from that of the program, the feasibility of an implementation can be proved by considering a scheduling policy rather than its implementation details.     

Client-side straggler-aware I/O scheduler for object-based parallel file systems

Object-based parallel file systems have emerged as promising storage solutions for high-performance computing (HPC) systems. Despite the fact that object storage provides a flexible interface, scheduling highly concurrent I/O requests that access a large number of objects still remains as a challenging problem, especially in the case when stragglers (storage servers that are significantly slower than others) exist in the system. An efficient I/O scheduler needs to avoid possible stragglers to achieve low latency and high throughput. In this paper, we introduce a log-assisted straggler-aware I/O scheduling to mitigate the impact of storage server stragglers. The contribution of this study is threefold. First, we introduce a client-side, log-assisted, straggler-aware I/O scheduler architecture to tackle the storage straggler issue in HPC systems. Second, we present three scheduling algorithms that can make efficient decision for scheduling I/Os while avoiding stragglers based on such an architecture. Third, we evaluate the proposed I/O scheduler using simulations, and the simulation results have confirmed the promise of the newly introduced straggler-aware I/O scheduler.     

A Modular Approach to Programming Distributed Real-Time Systems

Conventional real-time programs associate real-time requirements with individual commands in a program. This approach has three weaknesses. First, it intermixes two different design concerns: functional correctness and temporal correctness. Second, by mixing real-time requirements with program statements it makes it harder, and in some cases infeasible, to specify constraints between objects. Third, it limits the ability to independently modify either the timing constraints or the representations of objects. We describe a new approach that separates real-time constraints from functional aspects of an application; real-time constraints are described by synchronization code between the interfaces of objects. Objects in our system are defined using a real-time variant of the Actor model. We define a high-level programming language construct calledRTsynchronizer, which specifies a collection of temporal constraints between actors. Thus, our approach separates what an object does from when it does it. Such separation also facilitates the ability to dynamically modify real-time constraints. We illustrate the use of RTsynchronizers by a number of examples and then describe a meta-architecture that can be used to implement RTsynchronizers.     

An Open Environment for Real-Time Applications

This paper describes an open system architecture that allows independently developed hard real-time applications to run together and supports their reconfiguration at run-time. In the open system, each real-time application is executed by a server. At the lower level, the OS scheduler schedules all the servers on the EDF basis. At the upper level, the server scheduler of each server schedules the ready jobs of the application executed by the server according to the algorithm chosen for the application. The paper describes the two-level CPU scheduling scheme used by the open system and the design and implementation of a uniprocessor open system within the framework of the Windows NT operating system. The implementation consists of three key components: the two-level hierarchical kernel scheduler, common system service providers, and real-time application programming interface.     

基于CAN总线的共享时钟混合调度算法

CAN总线协议已广泛地应用在分布式嵌入式实时系统中,研究表明共享时钟调度算法能够很好地将基于CAN的微处理器和时间触发网络结构结合起来。针对现有共享时钟调度算法大多采用时间触发不可抢占调度机制的不足,结合时间触发混合调度模型,提出了一种共享时钟混合调度算法,并对算法的消息传输时间、错误检测时间和抖动进行了相应分析。使用Matlab下的Truetime工具搭建仿真平台,仿真结果表明,提出的算法能够减少传输时间,降低抖动,增强实时性。     

Linux2．6进程调度策略分析

分析了Linux2．6进程调度密切相关的一些数据结构,详细描述了进程调度的时机、调度的策略和调度的算法上的策略,这些改进使得Linux2．6进程调度程序实现了O（1）调度算法,支持抢占式调度,并且增强了对实时任务和SMP的支持。     

An object-oriented real-time programming language

The real-time object model, an extended object-oriented model for describing real-time systems, is described. The design and implementation of RTC++, a programming language that extends C++ on the basis of the real-time object model, are discussed. The schedulability analysis and specification of rigid timing constraints in systems with active objects are reviewed     

基于Petri网的分布式实时调度模型研究

Petri网作为一种可视化的规格语言,越来越多地用于实时系统的评估和分析。该文提出了一种基于Petri网的分布式实时系统模型,并对该模型中的局部调度器和消息调度器进行了描述。根据该模型可以开发相应的分布式实时调度模拟器,这样就可以在系统的开发初期,利用模拟器来验证在给定的局部调度策略和消息调度策略下,系统任务的时间约束是否能够得到有效的保障。同时该模型还可以很容易地转化为系统的快速原型。     

A hierarchical reliability-driven scheduling algorithm in grid systems

In a Grid computing system, many distributed scientific and engineering applications often require multi-institutional collaboration, large-scale resource sharing, wide-area communication, etc. Applications executing in such systems inevitably encounter different types of failures such as hardware failure, program failure, and storage failure. One way of taking failures into account is to employ a reliable scheduling algorithm. However, most existing Grid scheduling algorithms do not adequately consider the reliability requirements of an application. In recognition of this problem, we design a hierarchical reliability-driven scheduling architecture that includes both a local scheduler and a global scheduler. The local scheduler aims to effectively measure task reliability of an application in a Grid virtual node and incorporate the precedence constrained tasks’ reliability overhead into a heuristic scheduling algorithm. In the global scheduler, we propose a hierarchical reliability-driven scheduling algorithm based on quantitative evaluation of independent application reliability. Our experiments, based on both randomly generated graphs and the graphs of some real applications, show that our hierarchical scheduling algorithm performs much better than the existing scheduling algorithms in terms of system reliability, schedule length, and speedup.     

Supporting lock-free synchronization in Pfair-scheduled real-time systems

We consider the use of lock-free techniques for implementing shared objects in real-time Pfair-scheduled multiprocessor systems. Lock-free objects are more economical than locking techniques when implementing relatively simple objects such as buffers, stacks, queues, and lists. However, the use of such objects on real-time multiprocessors is generally considered impractical due to the need for analytical real-time guarantees. In this paper, we explain how the quantum-based nature of Pfair scheduling enables the effective use of such objects on real-time multiprocessors and present analysis specific to Pfair-scheduled systems. In addition, we show that analytical improvements can be obtained by using such objects in conjunction with group-based scheduling techniques. In this approach, a group of tasks is scheduled as a single entity (called a supertask in the Pfair literature). Such grouping prevents tasks from executing simultaneously, and hence from executing in parallel. Consequently, grouping tasks can improve the worst-case scenario with respect to object contention. Grouping also enables the use of less costly uniprocessor algorithms when all tasks sharing an object reside within the same group. We illustrate these optimizations with a case study that focuses on shared queues. Finally, we present and experimentally evaluate a simple heuristic for grouping tasks in order to reduce object contention. Though the analysis presented herein focuses specifically on Pfair-scheduled systems, the observations and techniques should be applicable to other quantum-scheduled systems as well.     

Preference-oriented fixed-priority scheduling for periodic real-time tasks

Traditionally, real-time scheduling algorithms prioritize tasks solely based on their timing parameters and cannot effectively handle tasks that have different execution preferences. In this paper, for a set of periodic real-time tasks running on a single processor, where some tasks are preferably executed as soon as possible (ASAP) and others as late as possible (ALAP), we investigate Preference-Oriented Fixed-Priority (POFP) scheduling techniques. First, based on Audsley’s Optimal Priority Assignment (OPA), we study a Preference Priority Assignment (PPA) scheme that attempts to assign ALAP (ASAP) tasks lower (higher) priorities, whenever possible. Then, by considering the non-work-conserving strategy, we exploit the promotion times of ALAP tasks and devise an online dual-queue based POFP scheduling algorithm. Basically, with the objective of fulfilling the execution preferences of all tasks, the POFP scheduler retains ALAP tasks in the delay queue until their promotion times while putting ASAP tasks into the ready queue right after their arrivals. In addition, to further expedite (delay) the executions of ASAP (ALAP) tasks using system slack, runtime techniques based on dummy and wrapper tasks are investigated. The proposed schemes are evaluated through extensive simulations. The results show that, compared to the classical fixed-priority Rate Monotonic Scheduling (RMS) algorithm, the proposed priority assignment scheme and POFP scheduler can achieve significant improvement in terms of fulfilling the execution preferences of both ASAP and ALAP tasks, which can be further enhanced at runtime with the wrapper-task based slack management technique.     

反射式集成框架的规约描述方法研究

反射式集成框架的规约描述方法,主要研究在分布式实时应用领域基于构件的软件开发模式中集成框架的形式化规约描述问题.这种描述方法通过引入反射技术,除了描述集成框架中组成要素的业务逻辑之外,还对各要素的实时性能约束、运行时状态的变化以及可能具有的需求变更等特征进行形式化规约,从而支持软件在需求分析阶段的演化进程,并以指导与实现实时应用软件开发时业务逻辑与系统非功能性特征的关注分离.     

A model for scheduling of object-based,distributed real-time systems

This paper describes a general model for pre-run-time scheduling of distributed real-time systems that are composed of abstract data types (definable in languages such as Ada, Clu and Modula-2) and abstract data objects (which can be defined in C++, Eiffel and RT Euclid). An architecture model, a programming paradigm, and execution and communication paradigms form the basis for this general model. The model includesabsolute timing constraints to represent periodicity and deadlines,relative timing constraints to model several kinds of timed precedence relations and synchronization requirements,independency constraints to capture non-determinism of conditionals and repetitions, andconsistency constraints to enforce consistent use of resources. In this paper, the model is formalized to obtain a mathematical foundation on which assignment (Verhoosel et al. 1993a, Welch 1992, Welch et al. 1993) and pre-run-time scheduling problems (Verhoosel et al. 1991, Verhoosel 1992, 1993a, 1993c) are defined. Additionally, the model is extended to allow exploitation of parallelism from programs, a technique that can be used during assignment and scheduling for meeting timing constraints.