Runtime Engine Research Articles

Model-driven specification and enforcement of RBAC break-glass policies for process-aware information systems

ContextIn many organizational environments critical tasks exist which – in exceptional cases such as an emergency – must be performed by a subject although he/she is usually not authorized to perform these tasks. Break-glass policies have been introduced as a sophisticated exception handling mechanism to resolve such situations. They enable certain subjects to break or override the standard access control policies of an information system in a controlled manner. ObjectiveIn the context of business process modeling a number of approaches exist that allow for the formal specification and modeling of process-related access control concepts. However, corresponding support for break-glass policies is still missing. In this paper, we aim at specifying a break-glass extension for process-related role-based access control (RBAC) models. MethodWe use model-driven development (MDD) techniques to provide an integrated, tool-supported approach for the definition and enforcement of break-glass policies in process-aware information systems. In particular, we provide modeling support on the computation independent model (CIM) layer as well as on the platform independent model (PIM) and platform specific model (PSM) layers. ResultsOur approach is generic in the sense that it can be used to extend process-aware information systems or process modeling languages with support for process-related RBAC and corresponding break-glass policies. Based on the formal CIM layer metamodel, we present a UML extension on the PIM layer that allows for the integrated modeling of processes and process-related break-glass policies via extended UML Activity diagrams. We evaluated our approach in a case study on real-world processes. Moreover, we implemented our approach at the PSM layer as an extension to the BusinessActivity library and runtime engine. ConclusionOur integrated modeling approach for process-related break-glass policies allows for specifying break-glass rules in process-aware information systems.

A knowledge-based architecture for the management of patient-focused care pathways

There is need for software systems in order to coordinate the activities of healthcare professionals involved in the treatment of a patient, aligning the care delivery around already existing Clinical Practice Guidelines (CPGs). This is being carried out in care organizations by implementing integrated Care Pathways (CPs). Nonetheless, the generation of these care pathways is not trivial, and multiple barriers exist for their development and enactment. In this paper, a knowledge-based architecture is presented that, by means of Knowledge Engineering methods and Artificial Intelligence Planning and Scheduling (AI P&S) techniques, is able to automatically generate these care pathways from a computer-interpretable representation of CPGs, tackling some of these barriers. Firstly, these techniques consider the patient profile, the care organization details as well as the temporal and resource constraints, implicit in a care process, in order to generate a patient-focused care pathway. Moreover, they also allow the enactment of personalized care plans in a web-based format, powered by a workflow runtime engine, thus providing an ubiquitous and interactive execution to healthcare professionals. Finally, the architecture also includes monitoring and replanning techniques in order to check the current health status of patients and adapt care plans when they do not progress as expected. For the experimental evaluation of the architecture, several tests have been carried out in order to simulate a clinical environment where different care plans were automatically executed, monitored and adapted regarding the health conditions of patients as well as the recommendations specified in a real, CPG of the paediatric oncology area. As conclusion, the proposed architecture seems to be an adequate infrastructure for supporting the automated generation as well as the interactive execution and monitoring of patient-focused care pathways.

Improving performance of adaptive component-based dataflow middleware

Making the best use of modern computational resources for distributed applications requires expert knowledge of low-level programming tools, or a productive high-level and high-performance programming framework. Unfortunately, even state-of-the-art high-level frameworks still require the developer to conduct a tedious manual tuning step to find the work partitioning which gives the best application execution performance. Here, we present a novel framework, with which developers can easily create high-performance dataflow applications, without the tedious tuning process. We compare the performance of our approach to that of three distributed programming frameworks which differ significantly in their programming paradigm, their support for multi-core CPUs and accelerators, and their load-balancing approach. These three frameworks are DataCutter, a component-based dataflow framework, KAAPI, a framework using asynchronous function calls, and MR-MPI, a MapReduce implementation. By highly optimizing the implementations of three applications on the four frameworks and comparing the execution time performance of the runtime engines, we show their strengths and weaknesses. We show that our approach achieves good performance for a wide range of applications, with a much-reduced development cost.

Case for dynamic deployment in a grid-based distributed query processor

Grid computing enables users to perform computationally expensive applications on distributed resources acquired dynamically. Users are allowed to combine structured data and analysis components into new applications from distributed sites into new applications. Distributed query processing offers an established way of structuring such computations, and well-known tools like OGSA-DAI and OGSA-DQP provide respectively a common interface to heterogeneous databases, and a way of exploiting distributed resources. Such significant benefits are however often undermined by high communication costs due to the need to move data between distributed resources. This paper describes an approach that addresses this by dynamically deploying query processing engines, analysis services and databases within virtual machines, on an internet-scale, so as to reduce communication costs. Results of internet-scale experiments are presented to demonstrate the performance benefits. Further, the use of dynamic deployment features based on requirements allows the creation of an ad-hoc runtime engine and thus opens up the possibility of creating a virtual marketplace for software and hardware resources.

Modeling process-related RBAC models with extended UML activity models

ContextBusiness processes are an important source for the engineering of customized software systems and are constantly gaining attention in the area of software engineering as well as in the area of information and system security. While the need to integrate processes and role-based access control (RBAC) models has been repeatedly identified in research and practice, standard process modeling languages do not provide corresponding language elements. ObjectiveIn this paper, we are concerned with the definition of an integrated approach for modeling processes and process-related RBAC models – including roles, role hierarchies, statically and dynamically mutual exclusive tasks, as well as binding of duty constraints on tasks. MethodWe specify a formal metamodel for process-related RBAC models. Based on this formal model, we define a domain-specific extension for a standard modeling language. ResultsOur formal metamodel is generic and can be used to extend arbitrary process modeling languages. To demonstrate our approach, we present a corresponding extension for UML2 activity models. The name of our extension is Business Activities. Moreover, we implemented a library and runtime engine that can manage Business Activity runtime models and enforce the different policies and constraints in a software system. ConclusionThe definition of process-related RBAC models at the modeling-level is an important prerequisite for the thorough implementation and enforcement of corresponding policies and constraints in a software system. We identified the need for modeling support of process-related RBAC models from our experience in real-world role engineering projects and case studies. The Business Activities approach presented in this paper is successfully applied in role engineering projects.

Adaptable dialog architecture and runtime engine (AdaRTE): A framework for rapid prototyping of health dialog systems

Spoken dialog systems have been increasingly employed to provide ubiquitous access via telephone to information and services for the non-Internet-connected public. They have been successfully applied in the health care context; however, speech technology requires a considerable development investment. The advent of VoiceXML reduced the proliferation of incompatible dialog formalisms, at the expense of adding even more complexity. This paper introduces a novel architecture for dialogue representation and interpretation, AdaRTE, which allows developers to lay out dialog interactions through a high-level formalism, offering both declarative and procedural features. AdaRTE's aim is to provide a ground for deploying complex and adaptable dialogs whilst allowing experimentation and incremental adoption of innovative speech technologies. It enhances augmented transition networks with dynamic behavior, and drives multiple back-end realizers, including VoiceXML. It has been especially targeted to the health care context, because of the great scale and the need for reducing the barrier to a widespread adoption of dialog systems.

Evita raced

Declarative languages have recently been proposed for many new applications outside of traditional data management. Since these are relatively early research efforts, it is important that the architectures of these declarative systems be extensible, in order to accommodate unforeseen needs in these new domains. In this paper, we apply the lessons of declarative systems to the internals of a declarative engine. Specifically, we describe our design and implementation of Evita Raced , an extensible compiler for the OverLog language used in our declarative networking system, P2. Evita Raced is a metacompiler : an OverLog compiler written in OverLog. We describe the minimalist architecture of Evita Raced, including its extensibility interfaces and its reuse of P2's data model and runtime engine. We demonstrate that a declarative language like OverLog is well-suited to expressing traditional and novel query optimizations as well as other query manipulations, in a compact and natural fashion. Finally, we present initial results of Evita Raced extended with various optimization programs, running on both Internet overlay networks and wireless sensor networks.

Runtime Engine for Dynamic Profile Guided Stride Prefetching

Stride prefetching is recognized as an important technique to improve memory access performance. The prior work usually profiles and/or analyzes the program behavior offline, and uses the identified stride patterns to guide the compilation process by injecting the prefetch instructions at appropriate places. There are some researches trying to enable stride prefetching in runtime systems with online profiling, but they either cannot discover cross-procedural prefetch opportunity, or require special supports in hardware or garbage collection. In this paper, we present a prefetch engine for JVM (Java Virtual Machine). It firstly identifies the candidate load operations during just-in-time (JIT) compilation, and then instruments the compiled code to profile the addresses of those loads. The runtime profile is collected in a trace buffer, which triggers a prefetch controller upon a protection fault. The prefetch controller analyzes the trace to discover any stride patterns, then modifies the compiled code to inject the prefetch instructions in place of the instrumentations. One of the major advantages of this engine is that, it can detect striding loads in any virtual code places for both regular and irregular code, not being limited with plain loop or procedure scopes. Actually we found the cross-procedural patterns take about 30% of all the prefetchings in the representative Java benchmarks. Another major advantage of the engine is that it has runtime overhead much smaller (the maximal is less than 4.0%) than the benefits it brings. Our evaluation with Apache Harmony JVM shows that the engine can achieve an average 6.2% speed-up with SPECJVM98 and DaCapo on Intel Pentium 4 platform, in spite of the runtime overhead.

Ontologizer 2.0—a multifunctional tool for GO term enrichment analysis and data exploration

The Ontologizer is a Java application that can be used to perform statistical analysis for overrepresentation of Gene Ontology (GO) terms in sets of genes or proteins derived from an experiment. The Ontologizer implements the standard approach to statistical analysis based on the one-sided Fisher's exact test, the novel parent-child method, as well as topology-based algorithms. A number of multiple-testing correction procedures are provided. The Ontologizer allows users to visualize data as a graph including all significantly overrepresented GO terms and to explore the data by linking GO terms to all genes/proteins annotated to the term and by linking individual terms to child terms. The Ontologizer application is available under the terms of the GNU GPL. It can be started as a WebStart application from the project homepage, where source code is also provided: http://compbio.charite.de/ontologizer. Ontologizer requires a Java SE 5.0 compliant Java runtime engine and GraphViz for the optional graph visualization tool.

Computational framework for remotely operable laboratories

Decision-makers envision a significant role for remotely operable laboratories in advancing research in structural engineering, as seen from the tremendous support for the network for earthquake engineering simulation (NEES) framework. This paper proposes a computational framework that uses LabVIEW and web technologies to enable observation and control of laboratory experiments via the internet. The framework, which is illustrated for a shaketable experiment, consists of two key hardware components: (1) a local network that has an NI-PXI with hardware for measurement acquisition and shaketable control along with a Windows-based PC that acquires images from a high-speed camera for video, and (2) a proxy server that controls access to the local network. The software for shaketable control and data/video acquisition are developed in the form of virtual instruments (VI) using LabVIEW development system. The proxy server employs a user-based authentication protocol to provide security to the experiment. The user can run perl-based CGI scripts on the proxy server for scheduling to control or observe the experiment in a future timeslot as well as gain access to control or observe the experiment during that timeslot. The proxy server implements single-controller multiple-observer architecture so that many users can simultaneously observe and download measurements as a single controller decides the waveform input into the shaketable. A provision is also created for users to simultaneously view the real-time video of the experiment. Two different methods to communicate the video are studied. It is concluded that a JPEG compression of the images acquired from the camera offers the best performance over a wide range of networks. The framework is accessible by a remote user with a computer that has access to a high-speed internet connection and has the LabVIEW runtime engine that is available at no cost to the user. Care is taken to ensure that the implementation of the LabVIEW applications and the perl scripts have little dependency for ease of portability to other experiments.

X3D: Extensible 3D Graphics Standard [Standards in a Nutshell

Extensible 3D (X3D) is the open standard for Web-delivered three-dimensional (3D) graphics. It specifies a declarative geometry definition language, a run-time engine, and an application programming interface (API) that provide an interactive, animated, real-time environment for 3D graphics. The X3D specification documents are freely available, the standard can be used without paying any royalties, and numerous implementations are available.

Remote Experiments in Control Engineering Education Laboratory

This paper presents Automatic Control Engineering Laboratory (ACEL) - WebLab, an under-developed, internet-based remote laboratory for control engineering education at the Faculty of Electronic Engineering in Niš. Up to now, the remote laboratory integrates two physical systems (velocity servo system and magnetic levitation system) and enables some levels of measurement and control. To perform experiments in ACEL-WebLab, the "LabVIEW Run Time Engine"and a standard web browser are needed.

XULRunner: A New Approach for Developing Rich Internet Applications

The Web 2.0 world abounds with solutions for developing Web-based rich Internet applications (RIAs). Desktop application developers have seen a similar maturation of full-featured frameworks to help simplify development. Mozilla's XULRunner application runtime engine offers a compromise between Web-based RIAs and a desktop application's power

Enabling scalable parallel implementations of structured adaptive mesh refinement applications

Parallel implementations of dynamic structured adaptive mesh refinement (SAMR) methods lead to significant runtime management challenges that can limit their scalability on large systems. This paper presents a runtime engine that addresses the scalability of SAMR applications with localized refinements and high SAMR efficiencies on large numbers of processors (upto 1024 processors). The SAMR runtime engine augments hierarchical partitioning with bin-packing based load-balancing to manage the space-time heterogeneity of the SAMR grid hierarchy, and includes a communication substrate that optimizes the use of MPI non-blocking communication primitives. An experimental evaluation on the IBM SP2 supercomputer using the 3-D Richtmyer-Meshkov compressible turbulence kernel demonstrates the effectiveness of the runtime engine in improving SAMR scalability.

Efficient Parallel Execution of Event-Driven Electromagnetic Hybrid Models

New discrete-event formulations of physics simulation models are emerging that can outperform traditional time-stepped models, especially in simulations containing multiple timescales. Detailed simulation of the Earth's magnetosphere, for example, requires execution of sub-models that operate at timescales that differ by orders of magnitude. In contrast to time-stepped simulation which requires tightly coupled updates to almost the entire system state at regular time intervals, the new discrete event simulation (DES) approaches help evolve the states of sub-models on relatively independent timescales. However, in contrast to relative ease of parallelization of time-stepped codes, the parallelization of DES-based models raises challenges with respect to their scalability and performance. One of the key challenges is to improve the computation granularity to offset synchronization and communication overheads within and across processors. Our previous work on parallelization was limited in scalability and runtime performance due to such challenges. Here we report on optimizations we performed on DES-based plasma simulation models to improve parallel execution performance. The mapping of the model to simulation processes is optimized via aggregation techniques, and the parallel runtime engine is optimized for communication and memory efficiency. The net result is the capability to simulate hybrid particle-in-cell (PIC) models with over 2 billionmore » ion particles using 512 processors on supercomputing platforms.« less

Autonomic resource provisioning for software business processes

Software development nowadays involves several levels of abstraction: starting from the programming of single objects, to their combination into components, to their publication as services and the overall architecture linking elements at each level. As a result, software engineering is dealing with a wider range of artifacts and concepts (i.e., in the context of this paper: services and business processes) than ever before. In this paper we explore the importance of having an adequate engine for executing business processes written as compositions of Web services. The paper shows that, independently of the composition language used, the overall scalability of the system is determined by how the run-time engine treats the process execution. This is particularly relevant at the service level because publishing a process through a Web service interface makes it accessible to an unpredictable and potentially very large number of clients. As a consequence, the process developer is confronted with the difficult question of resource provisioning. Determining the optimal configuration of the distributed engine that runs the process becomes sensitive both to the actual number of clients and to the kinds of processes to be executed. The main contribution of the paper is to show how resource provisioning for software business processes can be solved using autonomic computing techniques. The engine separates execution in two stages (navigation and dispatching) and uses a controller to allocate the node of a cluster of computers to each one of those stages as the workload changes. The controller can be configured with different policies that define how to reconfigure the system. To prove the feasibility of the concept, we have implemented the autonomic controller and evaluated its performance with an extensive set of experiments.

모바일 표준 플랫폼(WIPI) 검증 도구 설계 및 개발

WIPI는 한국무선인터넷표준화 포럼에서 개발하였으며 한국정보통신기술협회가 채택한 무선인터넷 표준 플랫폼이다. 상호 호환성을 보장받기 위해서는 개발한 WIPI플랫폼이 표준을 준수하고 있는지 검증하는 절차가 필요하다. WIPI는 하드웨어 추상화 계층인 HAL, 실행 엔진, 그리고 API(WIPI-C, WIPI-Java)로 나뉘어져 있다. WIPI 응용 프로그램은 WIPI API를 이용해 작성되며 WIPI API는 자체적으로 수행이 완료될 수도 있고 이벤트나 사용자 입력을 처리하기 위해 실행 엔진 또는 HAL 계층으로부터 필요한 기능을 제공받기도 한다. 따라서, 응용 프로그램에서 오류가 발생했을 때 어느 계층에서 문제점이 발생했는지 검증하는 것이 필요하다. 본 논문에서 WIPI 규격에 대한 검증 도구로서 플랫폼의 전체 기능과 API에 대한 검증 도구인 PCT와 하드웨어 추상화 계층인 HAL의 API 검증 도구인 HCT를 제안한다. PCT는 최종적으로 플랫폼에 대한 검증 결과만을 보고하기 때문에 검증에 실패하면 어느 계층에서 문제점이 발생했는지 알 수 가 없다. 따라서 문제점이 발생한 지점을 정확히 진단하고 정정하기 위해서는 전체 플랫폼에 대한 인증과는 별도로 HAL에 대한 인증이 필요하다. WIPI is developed by KWISF(Korea Wireless Internet Standardization Forum) and a wireless internet standard platform adopted by TTA. It needs the certification Process for standard specification in order to confirm interoperability. The WIPI is composed of the HAL, the Runtime Engine, and APIs(WIPI-C, WIPI-Java). nl applications are implemented through WIPI APIs that can be finished by themselves or provided essential functions from runtime engine or HAL. Therefore it needs to certify where the problems occur when errors occurred in a application. In this paper we propose the PCT that certifies a WIPI platform's functionality and APIs and the HCT that certifies HAL APIs. Because the PCT reports the final certification results for the platform it is impossible to know where the problems occur when it fails to certify platform. So, it needs to certify the HAL regardless of platform certification.

Quantitative histogram analysis of images

A routine for histogram analysis of images has been written in the object-oriented, graphical development environment LabVIEW. The program converts an RGB bitmap image into an intensity-linear greyscale image according to selectable conversion coefficients. This greyscale image is subsequently analysed by plots of the intensity histogram and probability distribution of brightness, and by calculation of various parameters, including average brightness, standard deviation, variance, minimal and maximal brightness, mode, skewness and kurtosis of the histogram and the median of the probability distribution. The program allows interactive selection of specific regions of interest (ROI) in the image and definition of lower and upper threshold levels (e.g., to permit the removal of a constant background signal). The results of the analysis of multiple images can be conveniently saved and exported for plotting in other programs, which allows fast analysis of relatively large sets of image data. The program file accompanies this manuscript together with a detailed description of two application examples: The analysis of fluorescence microscopy images, specifically of tau-immunofluorescence in primary cultures of rat cortical and hippocampal neurons, and the quantification of protein bands by Western-blot. The possibilities and limitations of this kind of analysis are discussed. Program summary Title of program: HAWGC Catalogue identifier: ADXG_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/ADXG_v1_0 Program obtainable from: CPC Program Library, Queen's University of Belfast, N. Ireland Computers: Mobile Intel Pentium III, AMD Duron Installations: No installation necessary—Executable file together with necessary files for LabVIEW Run-time engine Operating systems or monitors under which the program has been tested: WindowsME/2000/XP Programming language used: LabVIEW 7.0 Memory required to execute with typical data: ∼ 16 MB for starting and ∼ 160 MB used for loading of an image No. of bits in a word: 32 No. of processors used: 1 Has the code been vectorized or parallelized?: No No of lines in distributed program, including test data, etc.:138 946 No. of bytes in distributed program, including test data, etc.:15 166 675 Distribution format: tar.gz Nature of physical problem: Quantification of image data (e.g., for discrimination of molecular species in gels or fluorescent molecular probes in cell cultures) requires proprietary or complex software packages, which might not include the relevant statistical parameters or make the analysis of multiple images a tedious procedure for the general user. Method of solution: Tool for conversion of RGB bitmap image into luminance-linear image and extraction of luminance histogram, probability distribution, and statistical parameters (average brightness, standard deviation, variance, minimal and maximal brightness, mode, skewness and kurtosis of histogram and median of probability distribution) with possible selection of region of interest (ROI) and lower and upper threshold levels. Restrictions on the complexity of the problem: Does not incorporate application-specific functions (e.g., morphometric analysis) Typical running time: Seconds (depending on image size and processor speed) Unusual features of the program: None

The Reload Learning Design Tools

<p class="commentary_div"><strong>Commentary on:</strong> Chapter7: Learning Design Tools. (Griffiths, Blat, García, Vogten and Kwong,2005) <div class="abstract_container"> <strong>Abstract:</strong> The Reload Learning Design Editor (LDE) is an Open Source, close-to-specification, tree-based Learning Design (LD) editor written in Java using the Eclipse platform. The editor tools are complemented by a LD Player, which provides a familiar and user-friendly interface to the CopperCore LD runtime engine. This paper will describe the history and design rationale underpinning the tools, show how they fit into the LD authoring tools framework devised by Griffiths et al. (2005) and consider their suitability to various user roles and design approaches. The paper will conclude by outlining future versions of the software and how these new developments should facilitate the creation and manipulation of Units of Learning by staff in all user roles. </div> <div class="editors_container"> <strong>Editors:</strong> Colin Tattersall and Rob Koper. </div> <div class="demo_container"> <strong>Interactive demonstrations:</strong> The software tools described in this paper (the Reload Learning Design Editor and Reload Learning Design Player, both at version 2.0 as of May 27 2005) are available from the Reload project web site at <a href="http://www.reload.ac.uk">www.reload.ac.uk</a> </div>

Energy macromodeling of embedded operating systems

As embedded systems get more complex, deployment of embedded operating systems (OSs) as software run-time engines has become common. In particular, this trend is true even for battery-powered embedded systems, where maximizing battery life is a primary concern. In such OS-driven embedded software, the overall energy consumption depends very much on which OS is used and how the OS is used. Therefore, the energy effects of the OS need to be studied in order to design low-energy systems effectively.In this paper, we discuss the motivation for performing OS energy characterization and propose a methodology to perform the characterization systematically. The methodology consists of two parts. The first part is analysis , which is concerned with identifying a set of components that can be used to characterize the OS energy consumption, called energy characteristics . The second part is macromodeling , which is concerned with obtaining quantitative macromodels for the energy characteristics. It involves the process of experiment design, data collection, and macromodel fitting. The OS energy macromodels can be used conveniently as OS energy estimators in high-level or architectural optimization of embedded systems for low-energy consumption.As far as we know, this work is the first attempt to systematically tackle energy macromodeling of an embedded OS. To demonstrate our approach, we present experimental results for two well-known embedded OSs, namely, μC/OS and embedded Linux OS.