Jonas Mellin

DeeDS towards a distributed and active real-time database system

DeeDS combines active database functionality with critical timing constraints and integrated system monitoring. Since the reactive database mechanisms, or rule management system, must meet critical deadlines, we must employ methods that make triggering of rules and execution of actions predictable. We will focus on the scheduling issues associated with dynamic scheduling of workloads where the triggered transactions have hard, firm or soft deadlines, and how transient overloads may be resolved by substituting transactions by computationally cheaper ones. The rationale for a loosely coupled general purpose event monitoring facility, that works in tight connection with the scheduler, is presented. For performance and predictability, the scheduler and event monitor are executing on a separate CPU from the rest of the system. Real-time database accesses in DeeDS are made predictable and efficient by employing methods such as main memory resident data, full replication, eventual consistency, and prevention of global deadlocks.

Test Case Generation for Mutation-based Testing of Timeliness

Temporal correctness is crucial for real-time systems. Few methods exist to test temporal correctness and most methods used in practice are ad-hoc. A problem with testing real-time applications is the response-time dependency on the execution order of concurrent tasks. Execution order in turn depends on execution environment properties such as scheduling protocols, use of mutual exclusive resources as well as the point in time when stimuli is injected. Model based mutation testing has previously been proposed to determine the execution orders that need to be verified to increase confidence in timeliness. An effective way to automatically generate such test cases for dynamic real-time systems is still needed. This paper presents a method using heuristic-driven simulation to generate test cases.

On the Testing Maturity of Software Producing Organizations

This paper presents data from a study of the current state of practice of software testing. Test managers from twelve different software organizations were interviewed. The interviews focused on the amount of resources spent on testing, how the testing is conducted, and the knowledge of the personnel in the test organizations. The data indicate that the overall test maturity is low. Test managers are aware of this but have trouble improving. One problem is that the organizations are commercially successful, suggesting that products must already be good enough. Also, the current lack of structured testing in practice makes it difficult to quantify the current level of maturity and thereby articulate the potential gain from increasing testing maturity to upper management and developers

Managing Conflicts When Using Combination Strategies to Test Software

Testers often represent systems under test in input parameter models. These contain parameters with associated values. Combinations of parameter values, with one value for each parameter, are potential test cases. In most models, some values of two or more parameters cannot be combined. Testers must then detect and avoid or remove these conflicts. This paper proposes two new methods for automatically handling such conflicts and compares these with two existing methods, based on the sizes of the final conflict-free test suites. A test suite reduction method, usable with three of the four investigated methods is also included in the study, resulting in seven studied conflict handling methods. In the experiment, the number and types of conflicts, as well as the size of the input parameter model and the coverage criterion used, are varied. All in all, 3854 test suites with a total of 929,158 test cases were generated. Two methods stand out as tractable and complementary. The best method (called the avoid methods) with respect to test suite size is to avoid selection of test cases with conflicts. However, this method cannot always be used. The second best method (called the replace method), removing conflicts from the final test suite, is completely general.

Visualization of the composite event detection process

Active database rules are problematic to explain, understand, debug and design, irrespective of knowledge about active rule semantics. In order to address this problem, various types of active database tools have been proposed in the literature such as browsers, debuggers, analyzers, and explanation tools. The paper focuses on visualization of event detection for an explanation tool and it presents the first study on what to visualize with respect to event detection at the lowest level (i.e. visualization of event detection for a specific event type).

Bounds on test effort for event-triggered real-time systems

The test effort required for full test coverage is much higher in event-triggered than in time-triggered real-time systems. Thus, it is hard to attain sufficient confidence in the correctness of event-triggered real-time applications by testing. We present a general upper bound on the test effort of constrained event-triggered real-time systems, assuming multiple resources (a refinement of previous results). The emphasis is on system-level testing of application timeliness, assuming that sufficient confidence in its functional correctness has been attained. The covered fault types are mainly incorrect assumptions about temporal attributes. An analysis of our approach shows that designated pre-emption points are required. A key factor in this approach is the ability to reduce the test effort while maintaining full test coverage.

Supporting System-Level Testing of Applications by Active Real-Time Database Systems

Event-triggered distributed real-time systems are prohibitively difficult to test due the required test effort. The test effort includes instrumenting the test object, and generating, executing, and analyzing the test results. The test effort can be significantly reduced by the use of an distributed active real-time database, thanks to the transaction concept and the built-in event monitor. The two major problems identified w.r.t. testing are the following. Firstly, whether the test effort is manageable. Secondly, whether the introduced run-time overhead is acceptable, i.e., no critical deadlines are missed due to testing.

Automatic Early Risk Detection of Possible Medical Conditions for Usage Within an AMI-System

Using hyperglycemia as an example, we present how Bayesian networks can be utilized for automatic early detection of a person’s possible medical risks based on information provided by unobtrusive sensors in their living environments. The network’s outcome can be used as a basis on which an automated AMI-system decides whether to interact with the person, their caregiver, or any other appropriate party. The networks’ design is established through expert elicitation and validated using a half-automated validation process that allows the medical expert to specify validation rules. To interpret the networks’ results we use an output dictionary which is automatically generated for each individual network and translates the output probability into the different risk classes (e.g., no risk, risk).

Refining Timing Constraints of Applications in Deeds

This chapter describes the Distributed Active Real-Time Database System (DeeDS)[1, 2], as well as a mathematical model for analyzing the behavior of an application using DeeDS, and practical experience gained from implementing the DeeDS prototype. The mathematical model describes the critical system services, consisting of event monitoring and scheduling services of the DeeDS prototype.

Predictable and Efficient Memory Management for Composite Events

Abstract Event composition can be viewed as the process of monitoring foreseeable behaviors, e.g. start of processes followed by termination of these processes. It encompasses techniques for specifying and monitoring such behaviors. One major problem in event composition is that memory management can be a bottleneck and a source of unpredictability. Hence, we introduce a combination of self-referencing memory and safe pointers to solve this problem. To this end, a framework based on abstract data types is introduced, which have been realized in C++. Empirical studies indicate that event composition based on this approach is, at least, 20% faster than if it is based on ordinary memory management without safe pointers.