2,043 research outputs found
Abstract Interpretation of Stateful Networks
Modern networks achieve robustness and scalability by maintaining states on
their nodes. These nodes are referred to as middleboxes and are essential for
network functionality. However, the presence of middleboxes drastically
complicates the task of network verification. Previous work showed that the
problem is undecidable in general and EXPSPACE-complete when abstracting away
the order of packet arrival.
We describe a new algorithm for conservatively checking isolation properties
of stateful networks. The asymptotic complexity of the algorithm is polynomial
in the size of the network, albeit being exponential in the maximal number of
queries of the local state that a middlebox can do, which is often small.
Our algorithm is sound, i.e., it can never miss a violation of safety but may
fail to verify some properties. The algorithm performs on-the fly abstract
interpretation by (1) abstracting away the order of packet processing and the
number of times each packet arrives, (2) abstracting away correlations between
states of different middleboxes and channel contents, and (3) representing
middlebox states by their effect on each packet separately, rather than taking
into account the entire state space. We show that the abstractions do not lose
precision when middleboxes may reset in any state. This is encouraging since
many real middleboxes reset, e.g., after some session timeout is reached or due
to hardware failure
The Paths to Choreography Extraction
Choreographies are global descriptions of interactions among concurrent
components, most notably used in the settings of verification (e.g., Multiparty
Session Types) and synthesis of correct-by-construction software (Choreographic
Programming). They require a top-down approach: programmers first write
choreographies, and then use them to verify or synthesize their programs.
However, most existing software does not come with choreographies yet, which
prevents their application.
To attack this problem, we propose a novel methodology (called choreography
extraction) that, given a set of programs or protocol specifications,
automatically constructs a choreography that describes their behavior. The key
to our extraction is identifying a set of paths in a graph that represents the
symbolic execution of the programs of interest. Our method improves on previous
work in several directions: we can now deal with programs that are equipped
with a state and internal computation capabilities; time complexity is
dramatically better; we capture programs that are correct but not necessarily
synchronizable, i.e., they work because they exploit asynchronous
communication
Complex Actions for Event Processing
Automatic reactions triggered by complex events have been
deployed with great success in particular domains, among
others, in algorithmic trading, the automatic reaction to realtime
analysis of marked data. However, to date, reactions
in complex event processing systems are often still limited
to mere modifications of internal databases or are realized
by means similar to remote procedure calls.
In this paper, we argue that expressive complex actions
with support for composite work
ows and integration of
so called external actions are desirable for a wide range
of real-world applications among other emergency management.
This article investigates the particularities of external
actions needed in emergency management, which are initiated
inside the event processing system but which are actually
executed by external actuators, and discuss the implications
of these particularities on composite actions. Based
on these observations, we propose versatile complex actions
with temporal dependencies and a seamless integration of
complex events and external actions. This article also investigates
how the proposed integrated approach towards
complex events and complex actions can be evaluated based
on simple reactive rules. Finally, it is shown how complex actions
can be deployed for a complex event processing system
devoted to emergency management
Design Considerations for Low Power Internet Protocols
Over the past 10 years, low-power wireless networks have transitioned to
supporting IPv6 connectivity through 6LoWPAN, a set of standards which specify
how to aggressively compress IPv6 packets over low-power wireless links such as
802.15.4.
We find that different low-power IPv6 stacks are unable to communicate using
6LoWPAN, and therefore IP, due to design tradeoffs between code size and energy
efficiency. We argue that applying traditional protocol design principles to
low-power networks is responsible for these failures, in part because receivers
must accommodate a wide range of senders.
Based on these findings, we propose three design principles for Internet
protocols on low-power networks. These principles are based around the
importance of providing flexible tradeoffs between code size and energy
efficiency. We apply these principles to 6LoWPAN and show that the resulting
design of the protocol provides developers a wide range of tradeoff points
while allowing implementations with different choices to seamlessly
communicate
Coordination via Interaction Constraints I: Local Logic
Wegner describes coordination as constrained interaction. We take this
approach literally and define a coordination model based on interaction
constraints and partial, iterative and interactive constraint satisfaction. Our
model captures behaviour described in terms of synchronisation and data flow
constraints, plus various modes of interaction with the outside world provided
by external constraint symbols, on-the-fly constraint generation, and
coordination variables. Underlying our approach is an engine performing
(partial) constraint satisfaction of the sets of constraints. Our model extends
previous work on three counts: firstly, a more advanced notion of external
interaction is offered; secondly, our approach enables local satisfaction of
constraints with appropriate partial solutions, avoiding global synchronisation
over the entire constraints set; and, as a consequence, constraint satisfaction
can finally occur concurrently, and multiple parts of a set of constraints can
be solved and interact with the outside world in an asynchronous manner, unless
synchronisation is required by the constraints. This paper describes the
underlying logic, which enables a notion of local solution, and relates this
logic to the more global approach of our previous work based on classical
logic
Recommended from our members
Business Grid Services
Grid services have come to represent the synthesis of web services and grid computing paradigms. Web services provide the means to modularize software, enabling loosely coupled and novel synthesis. Grid computing removes the binding between functional software components and specific hosting hardware, enabling software to be deployed dynamically over a network (e.g. intra-, extra- or inter-net). Applying the constructs of grid computing to the service orientation of enterprise software will allow business service networks to utilize more specialized services. An upper service ontology that enables business grid services to be described and then related to the grid hosting platform is presented. Explicit knowledge is required for enterprise software, hosting servers and the domain that can then be utilized by both SLA and reservation systems. The ontology presented is derived from and validated using a collection of web services taken from leading investment banks
Dura
The reactive event processing language, that is developed in the context of this project, has been called DEAL in previous documents. When we chose this name for our language it has not been used by other authors working in the same research area (complex event processing). However, in the meantime it appears in publications of other authors and because we have not used the name in publications yet we cannot claim that we were the first to use it. In order to avoid ambiguities and name conflicts in future publications we decided to rename our language to Dura which stands for “Declarative uniform reactive event processing language”. Therefore the title of this deliverable has been updated to “Dura – Concepts and Examples”
- …