In the present paper we demonstrate a novel approach to handling small updates on Flash called In-Place Appends (IPA). It allows the DBMS to revisit the traditional write behavior on Flash. Instead of writing whole database pages upon an update in an out-of-place manner on Flash, we transform those small updates into update deltas and append them to a reserved area on the very same physical Flash page. In doing so we utilize the commonly ignored fact that under certain conditions Flash memories can support in-place updates to Flash pages without a preceding erase operation. The approach was implemented under Shore-MT and evaluated on real hardware. Under standard update-intensive workloads we observed 67% less page invalidations resulting in 80% lower garbage collection overhead, which yields a 45% increase in transactional throughput, while doubling Flash longevity at the same time. The IPA outperforms In-Page Logging (IPL) by more than 50%. We showcase a Shore-MT based prototype of the above approach, operating on real Flash hardware – the OpenSSD Flash research platform. During the demonstration we allow the users to interact with the system and gain hands on experience of its performance under different demonstration scenarios. These involve various workloads such as TPC-B, TPC-C or TATP.

In the present paper we demonstrate the novel technique to apply the recently proposed approach of In-Place Appends - overwrites on Flash without a prior erase operation. IPA can be applied selectively: only to DB-objects that have frequent and relatively small updates. To do so we couple IPA to the concept of NoFTL regions, allowing the DBA to place update-intensive DB-objects into special IPA-enabled regions. The decision about region configuration can be (semi-)automated by an advisor analyzing DB-log files in the background.

Multipath TCP enables remarkable optimizations for throughput, load balancing, and mobility in today's networks. The design space of Multipath TCP scheduling, i.e., the application-aware mapping of packets to paths, is largely unexplored due to its inherent complexity. Evidence in this paper suggests that an application-aware scheduling decision, if leveraged right, pushes Multipath TCP beyond throughput optimization and thereby provides benefits for a wide range of applications.

Under update intensive workloads (TPC, LinkBench) small updates dominate the write behavior, e.g. 70% of all updates change less than 10 bytes across all TPC OLTP workloads. These are typically performed as in-place updates and result in random writes in page-granularity, causing major write-overhead on Flash storage, a write amplification of several hundred times and lower device longevity.

In this paper we present our work in progress on revisiting traditional DBMS mechanisms to manage space on native Flash and how it is administered by the DBA. Our observations and initial results show that: the standard logical database structures can be used for physical organization of data on native Flash; at the same time higher DBMS performance is achieved without incurring extra DBA overhead. Initial experimental evaluation indicates a 20% increase in transactional throughput under TPC-C, by performing intelligent data placement on Flash, less erase operations and thus better Flash longevity.

More and more Internet-enabled devices, such as server instances or smartphones, have multiple network interfaces. Multipath TCP (MPTCP) has proven to increase bandwidth for these devices, while remaining compatible with the existing network infrastructure and applications. For interactive applications and services, however, low latency and low jitter often is more important than bandwidth. In this paper, we rethink the MPTCP approach, focusing on end-to-end latency and jitter. We propose ReMP TCP, an MPTCP extension that sends data redundantly over multiple paths in the network. Exchanging bandwidth for latency, this approach guarantees the lowest possible latency in existing best-effort networks. The integration into the MPTCP protocol provides benefits such as transparent end-to-end connection establishment, multipath-enabled congestion control, and the prevention of head of line blocking. We discuss end-to-end latency in multipath environments considering both queuing delays and packet drops. Further, we evaluate the performance of our ReMP TCP Linux Kernel implementation for data center and mobile scenarios in Mininet and real world experiments. We show for a real world mobile scenario in a stressed environment that ReMP TCP can halve the average round-trip time and reduce its standard deviation by a factor of 19.

Network emulations are widely used in the networking community. The network emulator Mininet recently gained popularity, as it allows running real Linux applications on top of an emulated network. The specification of the network includes the topology as well as static bandwidth, latency, and packet drops probability parameters. Even though evaluations with static parameters provide useful insights, real world measurements show dynamically changing bandwidths, posing special challenges that need to be addressed in network research.

Flash SSDs are omnipresent as database storage. HDD replacement is seamless since Flash SSDs implement the same legacy hardware and software interfaces to enable backward compatibility. Yet, the price paid is high as backward compatibility masks the native behaviour, incurs significant complexity and decreases I/O performance, making it non-robust and unpredictable. Flash SSDs are black-boxes. Although DBMS have ample mechanisms to control hardware directly and utilize the performance potential of Flash memory, the legacy interfaces and black-box architecture of Flash devices prevent them from doing so. In this paper we demonstrate NoFTL, an approach that enables native Flash access and integrates parts of the Flashmanagement functionality into the DBMS yielding significant performance increase and simplification of the I/O stack. NoFTL is implemented on real hardware based on the OpenSSD research platform. The contributions of this paper include: (i) a description of the NoFTL native Flash storage architecture; (ii) its integration in Shore-MT and (iii) performance evaluation of NoFTL on a real Flash SSD and on an on-line data-driven Flash emulator under TPCB, C,E and H workloads. The performance evaluation results indicate an improvement of at least 2.4x on real hardware over conventional Flash storage; as well as better utilisation of native Flash parallelism.

Due to complex interdependencies and feedback loops between network layers and nodes, the development of adaptive applications is difficult. As networking applications respond nonlinearly to changes in the environment and adaptations, defining concrete adaptation rules is nontrivial. In this paper, we present the offline learner Fossa, which uses genetic programming to automatically learn suitable Event Condition Action (ECA) rules. Based on utility functions defined by the developer, the genetic programming learner generates a multitude of rule sets and evaluates them using simulations to obtain their utility. We show, for a concrete example scenario, how the genetic programming learner benefits from the clear model of the ECA rules, and that the methodology efficiently generates ECA rules which outperform nonadaptive and manually tuned solutions.

The handover from WiFi to mobile networks is known to lead to TCP connection drops due to changing IP addresses. Multipath TCP (MPTCP), a recent TCP extension, enables a transparent mobile handover by combining subflows on multiple interfaces, such as WiFi and LTE, to one logical connection. MPTCP provides multiple handover modes, which differ in their energy consumption and the performance during the handover. The Full-MPTCP mode uses permanently both WiFi and the mobile network, which increases energy consumption. The Single-Path mode establishes the mobile network connection after the WiFi connection broke, which leads to a short performance degradation. In this paper, we argue that this trade-off is not necessary. We propose to use the available (sensor) information to forecast the mobile handover. This allows switching to the Full-MPTCP mode before the WiFi connection breaks, providing both low energy consumption and high performance during the handover. For a first experimental evaluation, we use a declining WiFi link quality to forecast a handover. Our real world measurements show that both low energy consumption and high performance during the handover are possible at the same time.

An ever-growing range of wireless sensors for medical monitoring has shown that there is significant interest in monitoring patients in their everyday surroundings. It however remains a challenge to merge information from several wireless sensors and applications are commonly built from scratch. This paper presents a middleware targeted for medical applications on smartphone-like platforms that relies on an event-based design to enable flexible coupling with changing sets of wireless sensor units, while posing only a minor overhead on the resources and battery capacity of the interconnected devices. We illustrate the requirements for such middleware with three different healthcare applications that were deployed with our middleware solution, and characterize the performance with energy consumption, overhead caused for the smartphone, and processing time under real-world circumstances. Results show that with sensing-intensive applications, our solution only minimally impacts the phone's resources, with an added CPU utilization of 3% and a memory usage under 7 MB. Furthermore, for a minimum message delivery ratio of 99.9%, up to 12 sensor readings per second are guaranteed to be handled, regardless of the number of applications using our middleware.

Multi-Version Database Management Systems (MV-DBMS) are wide-spread and can effectively address the characteris-tics of new storage technologies such as Flash, yet they are mainly optimized for traditional storage. A modification of a tuple in a MV-DBMS results in a new version of that item and the invalidation of the old version. Under Snapshot Isolation (SI) the invalidation is performed as an in-place update, which is suboptimal for Flash. We introduce Snap-shot Isolation Append Storage – Vectors (SIAS-V), which avoids the invalidation related updates by organising tuple versions as a simple linked list and by utilizing bitmap vec-tors representing different states of a single version. SIAS-V sequentializes writes and reduces the write-overhead by ap-pending in tuple-version granularity, writing out only com-pletely filled pages, and eliminating in-place invalidation. In this demonstration we showcase the SIAS-V imple-mentation in PostgreSQL side-to-side with SI. Firstly, we demonstrate that the I/O distribution of PostgreSQL un-der a TPC-C style workload, exhibits a dominant small-sequential write pattern for SIAS-V, as opposed to a ran-dom write dominated pattern under SI. Secondly, we demon-strate how the dense packing of tuple-versions on pages un-der SIAS-V reduces significantly the amount of data written. Thirdly, we show that SIAS-V yields to stable write per-formance and low transaction response times under mixed loads. Last but not least, we demonstrate that SIAS-V also provides performance improvements for traditional HDDs. 1.

An index in a Multi-Version DBMS (MV-DBMS) has to reflect different tuple versions of a single data item. Existing approaches follow the paradigm of logically separating the tuple version data from the data item, e.g. an index is only allowed to return at most one version of a single data item (while it may return multiple data items that match a search criteria). Hence to determine the valid (and therefore visible) tuple version of a data item, the MV-DBMS first fetches all tuple versions that match the search criteria and subsequently filters visible versions using visibility checks. This involves I/O storage accesses to tuple versions that do not have to be fetched. In this vision paper we present the Multi-Version Index (MV-IDX) approach that allows index-only visibility checks which significantly reduce the amount of I/O storage accesses as well as the index maintenance overhead. The MV-IDX achieves significantly lower response times and higher transactional throughput on OLTP workloads.

Append-/Log-based Storage Managers (LbSM) for database systems represent a good match for the characteristics and behaviour of Flash technology. LbSM alleviate random writes reducing the impact of Flash read/write asymmetry, increasing endurance and performance. A recently proposed combination of Multi-Versioning database approaches and LbSM called SIAS [9] offers further benefits: it substantially lowers the write rate due to tuple version append granularity and therefore improves the performance. In SIAS a page contains versions of tuples of the same table. Once appended such a page is immutable. The only allowable operations are reads (lookups, scans, version visibility checks) in tuple version granularity. Optimising for them offers an essential performance increase. In the present work-in-progress paper we propose two types of read optimisations: Multi-Version Index and Ordered Log Storage.

In distributed real-time applications, such as online games or interactive conferencing systems, timeliness of update event dissemination is a prevailing requirement. Direct connections are often the best solution. However, participants' connection bandwidths, especially uplink capacities of asymmetric end user Internet connections, impose a limit to this. We present and evaluate a lightweight local algorithm that optimizes many-to-many event dissemination in highly dynamic scenarios. The algorithm exploits the high clustering of interest networks, as observed in virtual environments based on local vision, but also in social networks of many kinds. Our approach allows reducing traffic by aggregating messages as well as balancing traffic among participants based on their capabilities.

In Networked Virtual Environments (NVE), Interest Management (IM) is a key part of the system that determines which of a participant's actions have to be communicated to which subset of the other participants. Since traditional client/server approaches have several drawbacks, a variety of alternative peer-to-peer (P2P) approaches have been presented by the community [1]. In many of these approaches, interest management is also responsible for maintaining connectivity of the P2P network. Aiming for latency-sensitive applications, systems like VON [2] and pSense [3] use mutual notification mechanisms, building the topology based on the participants' virtual world proximities. A common limitation of these, however, is their fixed dimensionality: most are only designed for two spatial dimensions, a few are capable of handling three. In this work, we discuss options for dealing with an arbitrary number of dimensions. We propose a dynamic localized peer-to-peer IM that supports and exploits any number of dimensions. In our IM, peers communicate directly within their vision range. The space outside of the vision range is divided in sectors, each guarded by a sensor node that notifies them of approaching peers. We determine criteria for an efficient sector partitioning, discuss several approaches and present a suitable algorithm.

Comparing experimental results obtained on different wireless sensor network deployments is typically very cumbersome and in most cases unfeasible. This is due to the lack of a methodology to describe the properties of network deployments and the experimental conditions under which experiments have been run. Our work focuses on the design and development of a site properties assessment framework, called SiteWork, that aims at providing the means to quickly, automatically and accurately quantify their properties. This poster abstract describes the preliminary design and evaluation of the basic site properties assessment mechanisms provided by SiteWork.

The database architecture and workhorse algorithms have been designed to compensate for hard disk properties. The I/O characteristics of Flash memories have significant impact on database systems and many algorithms and approaches taking advantage of those have been proposed recently. Nonetheless on system level Flash storage devices are still treated as HDD compatible block devices, black boxes and fast HDD replacements. This backwards compatibility (both software and hardware) masks the native behaviour, incurs significant complexity and decreases I/O performance, making it non-robust and unpredictable. Database systems have a long tradition of operating directly on RAW storage natively, utilising the physical characteristics of storage media to improve performance. In this paper we demonstrate an approach called NoFTL that goes a step further. We show that allowing for native Flash access and integrating parts of the FTL functionality into the database system yields significant performance increase and simplification of the I/O stack. We created a real-time data-driven Flash emulator and integrated it accordingly into Shore-MT. We demonstrate a performance improvement of up to 3.7× compared to Shore-MT on RAW block-device Flash storage under various TPC workloads.

The architecture and algorithms of database systems have been built around the properties of existing hardware technologies. Many such elementary design assumptions are 20--30 years old. Over the last five years we witness multiple new I/O technologies (e.g. Flash SSDs, NV-Memories) that have the potential of changing these assumptions. Some of the key technological differences to traditional spinning disk storage are: (i) asymmetric read/write performance; (ii) low latencies; (iii) fast random reads; (iv) endurance issues.

Peer-to-peer overlays for Networked Virtual Environments have recently gained much research interest, resulting in a variety of different approaches for spatial information dissemination. Although designed for the same purpose, the evaluation methodologies used by particular authors differ widely. This makes any comparison of existing systems difficult, if not impossible. To overcome this problem we present a benchmarking methodology which allows for a fair comparison of those systems. We, therefore, define a common set of workloads and metrics. We demonstrate the feasibility of our approach by testing four typical systems for spatial information dissemination and discovering their specific performance profiles.

In this demo we present a testbed environment for Peer-to-Peer (P2P) game architectures. It is based on Planet PI4, an online multiplayer game whose gameplay provides a standard workload for a set of gaming-specific network interfaces. Its pluggable architecture allows for the evaluation and comparison of existing and new P2P networking approaches. Planet PI4 can run on a real network for prototypical evaluation as well as in a discrete-event simulator providing a reproducible environment.

Different evaluation methods for distributed systems like prototyping, simulation and emulation have different tradeoffs. We present a testbed for Internet applications that supports real-network prototypes and multiple simulators with unchanged application code. To ensure maximum portability between runtimes, a compact but flexible system interface is defined.

Simulation has become an important evaluation method in the area of Peer-to-Peer (P2P) research due to the scalability limitations of evaluation test beds such as Planet Lab or G-Lab. Current simulators provide various abstraction levels for different underlay models, such that applications can be evaluated at different granularity. However, existing simulators suffer from a lack of interoperability and portability making the comparison of research results extremely difficult. To overcome this problem, we present an approach for a generic application interface for discrete-event P2P overlay network simulators. It enables porting of the same implementation of a targeted application once and then running it on various simulators as well as in a real network environment, thereby enabling a diverse and extensive evaluation. We established the feasibility of our approach and showed negligible memory and runtime overhead.

This paper presents a novel transport protocol, CUSP, specifically designed with complex and dynamic network applications in mind. Peer-to-peer applications benefit in particular, as their requirements are met by neither UDP nor TCP. While other modern transports like SCTP or SST have also tried to combine the advantages of TCP and UDP, CUSP overcomes their technical and conceptual shortcomings. CUSP makes it possible to directly express application logic in the message flow. Modern applications need a mixture of request-response, request-multiple-response, publish-subscribe, and message-passing. All of these operations can be conveniently implemented using CUSP's unidirectional streams. We separate low-level packet management from streams into reusable channels. A channel connects two applications providing negotiation, congestion control, and cryptography. Developers operate on the stream level, sending messages as reliable and ordered byte-streams. Although they may share a common channel, a stall or loss in one stream does not block the others.

In this demo we present a performance evaluation testbed for peer-to-peer gaming overlays. It consists of a 3D first person shooter game that is designed to run in a simulated network environment as well as on a real network. Simulation with autonomous players (bots) guarantees scalability, a controlled workload, and reproducible results; a prototype deployment on a real network can then validate the simulation results. The information dissemination overlay pSense is implemented as a first subject for evaluation.

This paper illustrates both challenges and benefits found in expanding a traditional game concept to a situated environment with a distributed set of wireless sensing modules. Our pervasive game equivalent of the Whac-A-Mole game, Whac-A-Bee, retains the find-and-seek aspects of the original game while extending the location, the number of players, and the time-span in which it can be played. We discuss the obstacles met during this work, and specifically address challenges in making the game robust and flexible enough for large and long-term deployments in unknown territory.

Replication is widely used in unstructured peer-to-peer systems to improve search or achieve availability. We identify and solve a subclass of replication problems where each object is associated with a maintainer node, and its replicas should only be available as long as its maintainer is part of the network. Such requirement can be found in various applications, e.g., when objects are directory lists, service lists, or subscriptions of a publish/subscribe system. We provide maintainers with proven guarantees on the number of replicas, in spite of network churn and crash failures. We also tackle the related problems of changing the number of replicas, updating replicas, balancing storage load in a heterogeneous network, and eliminating replicas left by crashing maintainers. Our algorithm is based on probabilistic methods and is simple to implement. We show by simulation and formal proof that our algorithm is correct. 1.

Presents the introductory welcome message from the conference proceedings.

Metadata repository systems store metadata in the form of models and meta-models. In this paper we introduce a general architecture of a MOF repository system and describe its modules. In addition, we examine the architectures of several existing MOF repositories such as MDR, EMF, dMOF and iRM and illustrate how these related to the proposed general architecture.

Distributed event-based systems (DEBS) are gaining increasing attention in new application areas such as transport information monitoring, event-driven supply-chain management and ubiquitous sensor-rich environments. However, as DEBS increasingly enter the enterprise and commercial domains, performance and quality of service issues are becoming a major concern. While numerous approaches to performance modeling and evaluation of conventional request/reply-based distributed systems are available in the literature, no general approach exists for DEBS. This paper is the first to provide a comprehensive methodology for workload characterization and performance modeling of DEBS. A workload model of a generic DEBS is developed and operational analysis techniques are used to characterize the system traffic and derive an approximation for the mean event delivery latency. Following this, a modeling technique is presented that can be used for accurate performance prediction. The paper is concluded with a case study of a real life system demonstrating the effectiveness and practicality of the proposed approach.

This paper presents an algorithm for creating and maintaining a dynamic localized peer-to-peer overlay network with its main application to massively multiplayer games. In these games, players reside in a large game world with many thousands of players but each player has typically a limited vision range. In our solution, players join the network as peers and mainly connect to neighbor peers that are close to them in the virtual game world. As players move in the game they change their neighbors dynamically with very little overhead. Peers can multicast messages that are received by peers in their locality very fast (often faster than in client-server solutions) while players that are further away receive them later or not at all. Not receiving messages from remote players is important in order to not cause the load on each peer to grow with the number of players in the game. Our performance analysis confirms that our solution allows for dynamic game worlds of practically unlimited size, only limited in scale by the number of players within the vision range.

The usage of RFID and sensing technologies in supply chain management applications requires the automatic conversion of large amounts of raw data into manageable business process information. This has led to many performance and scalability issues in existing RFID infrastructures. We present an approach to alleviate these shortcomings based on a flexible system architecture that partially migrates business data processing towards the periphery.

Distributed summation is computed in asymptotically minimal rounds by Kempe et al's Push-Sum algorithm. Unfortunately it has minor problems in practise, resolved here.

Peer-to-peer systems promise inexpensive scalability, adaptability, and robustness. Thus, they are an attractive platform for file sharing, distributed wikis, and search engines. These applications often store weakly structured data, requiring sophisticated search algorithms. To simplify the search problem, most scalable algorithms introduce structure to the network. However, churn or violent disruption may break this structure, compromising search guarantees.

The existing Web service flow (WS-flow) technologies enable both static and dynamic binding of participating Web services (WSs) on the process model level. Adaptability on per-instance basis is not sufficiently supported and therefore must be addressed to improve process flexibility upon changes in the environment. Ad-hoc process instance changes can be enabled by swapping participating WS instances, by modifying port types of the partners to be invoked, and by changing process logic. In this work, we address the problem of dynamic binding of WSs to WS-flow instances at run time, i.e. the ability to exchange a WS instance participating in a WS-flow instance with an alternative one. The problem is additionally complicated by the fact that the execution of a process depends on its deployment. We describe the "find and bind" mechanism, and we show its representation as a BPEL extension. We discuss the benefits that could be gained and the disadvantages it brings in. The mechanism extends and improves the existing process technologies. It facilitates a precisely controlled policy-based selection of WSs at run time and also provides for process instance repair, while maintaining simplicity. We also discuss a prototypical implementation of the presented functionality.

In this paper we show how Queuing Petri Net (QPN) models can be exploited for performance analysis of distributed e-business systems. We study a real-world application, and demonstrate the benefits, in terms of modelling power and expressiveness, that QPN models provide over conventional modelling paradigms such as Queuing Networks and Petri Nets. As shown, QPNs facilitate the integration of both hardware and software aspects of system behavior in the same model. In addition to hardware contention and scheduling strategies, using QPNs one can easily model simultaneous resource possession, synchronization, blocking and contention for software resources. By validating the models presented through measurements, we show that they are not just powerful as a specification mechanism, but are also very powerful as a performance analysis and prediction tool. However, currently available tools and techniques for QPN analysis are limited. Improved solution methods, which enable larger models to be analyzed, need to be developed. By demonstrating the power of QPNs as a modelling paradigm in realistic scenarios, we hope to motivate further research in this area.

A company's local data is often insufficient for analyzing market trends and making reasonable business plans. Decision making must also be based on information from suppliers, partners and competitors. Systematically integrating suitable external data from the Web into a data warehouse is a meaningful solution and will benefit the enterprise. However, the autonomy and dynamics of the Web make the task of selecting relevant and qualified external data from the Web challenging. We develop a set of criteria for evaluating and selecting Web resources as external data sources of a data warehouse and discuss how to screen Web data sources using multi-criteria decision making (MCDM) methods. The final decision with respect to selecting Web sources is sensitive to critical factors, i.e., the criterion weight and performance score of alternatives in terms of each criterion. We analyzed the sensitivity of the final rank of alternatives in terms of critical factors in order to gain an insight into the stability of our final decision. The comparison of several MCDM approaches for Web source screening is also presented.

Many interesting application systems, ranging from workflow management and CSCW to air traffic control, are event-driven and time-dependent and must interact with heterogeneous components in the real world. Event services are used to glue together distributed components. They assume a virtual global time base to trigger actions and to order events. The notion of a global time that is provided by synchronized local clocks in distributed systems has a fundamental impact on the semantics of event-driven systems, especially the composition of events. The well studied 2g-precedence model, which assumes that the granularity of global time-base g can be derived from a priori known and bounded precision of local clocks may not be suitable for the Internet where the accuracy and external synchronization of local clocks is best effort and cannot be guaranteed because of large transmission delay variations and phases of disconnection. We introduce a mechanism based on NTP synchronized local clocks with global reference time injected by GPS time servers. We agree that timestamps of events can be related to global reference time with bounded accuracy and propose that event timestamps are modeled using accuracy intervals. We present algorithms for event composition and event consumption which make use of accuracy interval based timestamping and illustrate the problems that arise due to inaccuracy and message transmission delays.

Agent systems are well suited for applications requiring great flexibility. We propose a mechanism that uses multiple mobile agents to implement distributed transactions in a wide area network. Of special interest are applications in which resources change over time. By using multiple, mobile and autonomous agents in our model we are able to monitor resources in a distributed system and to react to changes in a very flexible manner. Each agent is responsible for a single resource and corresponds with the Object Transaction Service (OTS) for the coordination of the global transaction. For the management and the control of the agents we propose X-TRA, our extensible trusted agent system which offers a trust service for agent identification and control with exactly once semantics for agent migration, controlled agent termination, grouping of agents, and a bank service.

Complex query types, huge data volumes, and very high read/update ratios make the indexing techniques designed and tuned for traditional database systems unsuitable for data warehouses (DW). We propose an encoded bitmap indexing for DWs which improves the performance of known bitmap indexing in the case of large cardinality domains. A performance analysis and theorems which identify properties of good encodings for better performance are presented. We compare encoded bitmap indexing with related techniques, such as bit slicing, projection-, dynamic-, and range-based indexing.

The paper describes an active abject-oriented mediator for the enforcement of global consistency between relational legacy databases. The authors discuss the problem of integrating several local relational systems into a federated system by the usage of an object-oriented mediator system. They explore how relational DBMSs can be enhanced to signal local updates that may violate global constraints without sacrificing too much autonomy and present a database gateway for detection, logging and signalling. They show how the gateway is embedded into the architecture of an object-relational mediator system. They give a solution to the problem of mapping SQL commands to method calls in a C++ based system using a so-called mediator generator. Furthermore, they discuss how the federated system can be enriched by rule mechanisms that make the mediator behave actively.

Active OODBMSs must provide efficient support for event detection, composition and rule execution. Previous experience of building active capabilities on top of existing closed OODBMSs has proven to be ineffective. We propose instead an active OODBMS architecture where event detection and rule support are tightly integrated with the rest of the core OODBMS functionality. After presenting an analysis of the requirements of active OODBMSs, we discuss the event set, rule execution modes and lifespan of the events supported in our architecture. We also discuss event composition coupling relative to transaction boundaries. Since building an active OODBMS ex nihilo is extremely expensive, we are building the REACH (REal-time ACtive Heterogeneous) OODBMS by extending Texas Instruments' Open OODB toolkit. Open OODB is particularly well-suited for our purposes because it is the first DBMS whose architecture closely resembles the active database paradigm. It provides low-level event detection and invokes appropriate DBMS functionality as actions. We describe the architecture of the event detection and composition mechanisms, and the rule-firing process of the REACH active OODBMS, and show how these mechanisms interplay with the Open OODB core mechanisms.>

No abstract available.

A framework is presented for analysis of time-critical scheduling algorithms. The main assumptions are analyzed behind real-time scheduling and concurrency control algorithms, and a unified approach is proposed. Two main classes of schedulers are identified according to the availability of information about resource requirements and execution times: conflict-resolving schedulers resolve conflicts at run-time, and hence can only produce a sequence of operations satisfying task priorities and resource constraints; and conflict-avoiding schedulers determine resource requirements and expected execution times through offline transaction-class preanalysis and produce a complete time-critical schedule satisfying both timing and resource constraints. For the latter case, the resolution of overload is essential. Examples are given to illustrate the framework and the main classes of scheduling algorithms.>

A large group of database design methodologies relies solely on graphic representations of the conceptual schema. When this conceptual schema is translated manually to the DDL of a target DBMS errors are frequently introduced. The database design tool presented in this paper consists of a conceptual model definition language with its compiler, a data dictionary in which the metamodel of the database is stored and a mapping interface. The tool is based on the ELKA (Entity, Link, Key, Attribute) conceptual model, a model which normally relies on a graphic notation. In this tool ELKA structures are defined by the Database Administrator through the conceptual model definition language from where they are mapped automatically into database structures. The metamodel is accessible to the user through the DBMS's data manipulation language, while the equivalent database structures are accessible both to the user and the application programs. Finally, the modeling power of this tool is explored and necessary extensions are identified that are needed to handle the notion of molecular aggregation.

Recursive graphs (R-graphs) are modified for use Is a formalism to represent evolving drawings spanning various levels of detail, and store them in a database. A separation of the structural information and the physical image information is advocated. To guarantee maximum flexibility, the physical image information is represented in relational form, and for consistency and ease of manipulation, the R-graphs containing the structural information are mapped into normalized relations. Major design aspects for implementation are considered, such as, the feasibility of a mapping into binary associations and the drawing generation strategy. Binary associations are an adequate model to express conceptual schemata and are often used as input format for existing computer aided database dsesign packages. As an illustration of the propose formalism, the evolution through three levels of detail in nested drawings handled during the design of chemical process plants is demonstrated.