Incrementally upgradable data center architecture using hyperbolic tessellations

Current trends in cloud computing suggest that both large, public clouds and small, private clouds will proliferate in the near future. Operational requirements, such as high bandwidth, dependability and smooth manageability, are similar for both types of clouds and their underlying data center architecture. Such requirements can be satisfied with utilizing fully distributed, low-overhead mechanisms at the algorithm level, and an efficient layer 2 implementation at the practical level. On the other hand, owners of evolving private data centers are in dire need of an incrementally upgradeable architecture which supports a small roll-out and continuous expansion in small quanta. In order to satisfy both requirements, we propose Poincaré, a data center architecture inspired by hyperbolic tessellations, which utilizes low-overhead, greedy routing. On one hand, Poincaré scales to support large data centers with low diameter, high bisection bandwidth, inherent multipath and multicast capabilities, and efficient error recovery. On the other hand, Poincaré supports incremental plug & play upgradability with regard to both servers and switches. We evaluate Poincaré using analysis, extensive simulations and a prototype implementation.     

An efficient key distribution system for data fusion in V2X heterogeneous networks

Data fusion in Vehicle-to-Everything (V2X) networks for different data types coming from different sources is the foundation for decision making in the smart vehicle driving systems. Different communication technologies have been combined to form a heterogeneous V2X network to support the data exchange. However, data fusion trust models are still designed for single use cases which cannot meet the general needs of Cooperative Intelligent Transport Systems (C-ITS). In this paper, we first define a data fusion trust architecture with different trust levels. Then, we propose an efficient and practical data fusion trust system for the multi-source and multi-formats of data exchange in the V2X heterogeneous networks. In particular, a location-based PKI system with acceleration brought by General Purpose Graphic Processing Unit (GPGPU) is presented for efficient key distribution with a high level of trust achieved. A performance evaluation is given to verify our data fusion trust system can meet the strict latency requirements in V2X networks.     

Integrating structured OO approaches with formal techniques for the development of real-time systems

The use of formal methods in the development of time-critical applications is essential if we want to achieve a high level of assurance in them. However, these methods have not yet been widely accepted in industry as compared to the more established structured and informal techniques. A reliable linkage between these two techniques will provide the developer with a powerful tool for developing a provably correct system. In this article, we explore the issue of integrating a real-time formal technique, TAM (Temporal Agent Model), with an industry-strength structured methodology known as HRT-HOOD. TAM is a systematic formal approach for the development of real-time systems based on the refinement calculus. Within TAM, a formal specification can be written (in a logic-based formalism), analysed and then refined to concrete representation through successive applications of sound refinement laws. Both abstract specification and concrete implementation are allowed to freely intermix. HRT-HOOD is an extension to the Hierarchical Object-Oriented Design (HOOD) technique for the development of Hard Real-Time systems. It is a two-phase design technique dealing with the logical and physical architecture designs of the system which can handle both functional and non-functional requirement, respectively. The integrated technique is illustrated on a version of the mine control system.     

Plans and resource-bounded practical reasoning

An architecture for a rational agent must allow for means-end reasoning, for the weighing of competing alternatives, and for interactions betwen these two forms of reasoning. Such an architecture must also address the problem of resource boundedness. We sketch a solution of the first problem that points the way to a solution of the second. In particular, we present a high-level specification of the practical-reasoning component of an architecture for a resource-bounded rational agent. In this architecture, a major role of the agent's plans is to constrain the amount of further practical reasoning she must perform.     

Safety first: a two-stage algorithm for the synthesis of reactive systems

In the game-theoretic approach to the synthesis of reactive systems, specifications are often expressed as ω-regular languages. Computing a winning strategy to an infinite game whose winning condition is an ω-regular language is then the main step in obtaining an implementation. Conjoining all the properties of a specification to obtain a monolithic game suffers from the doubly exponential determinization that is required. Despite the success of symbolic algorithms, the monolithic approach is not practical. Existing techniques achieve efficiency by imposing restrictions on the ω-regular languages they deal with. In contrast, we present an approach that achieves improvement in performance through the decomposition of the problem while still accepting the full set of ω-regular languages. Each property is translated into a deterministic ω-regular automaton explicitly while the two-player game defined by the collection of automata is played symbolically. Safety and persistence properties usually make up the majority of a specification. We take advantage of this by solving the game incrementally. Each safety and persistence property is used to gradually construct the parity game. Optimizations are applied after each refinement of the graph. This process produces a compact symbolic encoding of the parity game. We then compose the remaining properties and solve one final game after possibly solving smaller games to further optimize the graph. An implementation is finally derived from the winning strategies computed. We compare the results of our tool to those of the synthesis tool Anzu.     

Designing multi-agent unit tests using systematic test design patterns-(extended version)

Software agents are the basic building blocks in many software systems especially those based on artificial intelligence methods, e.g., reinforcement learning based multi-agent systems (MASs). However, testing software agents is considered a challenging problem. This is due to the special characteristics of agents which include its autonomy, distributed nature, intelligence, and heterogeneous communication protocols. Following the test-driven development (TDD) paradigm, we present a framework that allows MAS developers to write test scenarios that test each agent individually. The framework relies on the concepts of building mock agents and testing common agent interaction design patterns. We analyze the most common agent interaction patterns including pair and mediation patterns in order to provide stereotype implementation for their corresponding test cases. These implementations serve as test building blocks and are provided as a set of ready-for-reuse components in our repository. This way, the developer can concentrate on testing the business logic itself and spare him/her the burden of implementing tests for the underlying agent interaction patterns. Our framework is based on standard components such as the JADE agent platform, the JUnit framework, and the eclipse plug-in architecture. In this paper, we present in details the design and function of the framework. We demonstrate how we can use the proposed framework to define more stereotypes in the code repository and provide a detailed analysis of the code coverage for our designed stereotype test code implementations.     

Software reference architecture for smart environments: Perception

With the increase of intelligent devices, ubiquitous computing is spreading to all scopes of people life. Smart home (or industrial) environments include automation and control devices to save energy, perform tasks, assist and give comfort in order to satisfy specific preferences.This paper focuses on the proposal for Software Reference Architecture for the development of smart applications and their deployment in smart environments. The motivation for this Reference Architecture and its benefits are also explained. The proposal considers three main processes in the software architecture of these applications: perception, reasoning and acting.This paper centres attention on the definition of the Perception process and provides an example for its implementation and subsequent validation of the proposal.The software presented implements the Perception process of a smart environment for a standard office, by retrieving data from the real world and storing it for further reasoning and acting processes. The objectives of this solution include the provision of comfort for the users and the saving of energy in lighting. Through this verification, it is also shown that developments under this proposal produce major benefits within the software life cycle.     

ADE: STEPS TOWARD A DISTRIBUTED DEVELOPMENT AND RUNTIME ENVIRONMENT FOR COMPLEX ROBOTIC AGENT ARCHITECTURES

In this paper we present the agent architecture development environment (ADE), intended for the design, implementation, and testing of distributed robotic agent architectures. ADE is unique among robotic architecture development environments in that it is based on a universal agent architecture framework called APOC, which allows it to implement architectures in any design methodology, and in that it uses an underlying multi-agent system to allow for the the distribution of architectural components over multiple host computers. After a short exposition of the theory behind ADE, we present the multi-agent system setup and give an example of using ADE in a multi-robot setting. A general discussion then highlights some of the novel features of ADE and illustrates how ADE can be used for designing, implementing, testing, and running agent architectures.     

Black-Box Trace&Revoke Codes

We address the problem of designing an efficient broadcast encryption scheme which is also capable of tracing traitors. We introduce a code framework to formalize the problem. Then, we give a probabilistic construction of a code which supports both traceability and revocation. Given N users with at most r revoked users and at most t traitors, our code construction gives rise to a Trace&Revoke system with private keys of size O((r+t)logN) (which can also be reduced to constant size based on an additional computational assumption), ciphertexts of size O((r+t)logN), and O(1) decryption time. Our scheme can deal with certain classes of pirate decoders, which we believe are sufficiently powerful to capture practical pirate strategies. In particular, our code construction is based on a combinatorial object called (r,s)-disjunct matrix, which is designed to capture both the classic traceability notion of disjunct matrix and the new requirement of revocation capability. We then probabilistically construct (r,s)-disjunct matrices which help design efficient Black-Box Trace&Revoke systems. For dealing with “smart” pirates, we introduce a tracing technique called “shadow group testing” that uses (close to) legitimate broadcast signals for tracing. Along the way, we also proved several bounds on the number of queries needed for black-box tracing under different assumptions about the pirate’s strategies.     

Testing distributed real-time systems in the presence of inaccurate clock synchronizations

This article deals with testing distributed real-time systems. More precisely, we propose: (1) a model for describing the specification of the implementation under test, (2) a distributed architecture of the test system (TS), (3) an approach for coordinating the testers which constitute the TS, and (4) a procedure for deriving automatically the test sequence of each tester from a global test sequence. In comparison with a very recent work, the proposed test method has the following important advantage: the clocks used by the different testers are not assumed perfectly synchronized. Rather, we assume more realistically that each clock is synchronized with a reference clock with a given (nonnull) inaccuracy. This advantage is very relevant if, for example, the testers communicate through the Internet.     

Smart task support through proactive access to organizational memory

We describe an approach towards integrating the semantics of semi-structured documents with task-support for (weakly structured) business processes and proactive inferencing capabilities of a desk support agent. The mechanism of our Proactive Inferencing Agent is motivated by the requirements posed in (weakly structured) business processes performed by a typical knowledge worker and by experiences we have made from a first trial with a Reactive Agent Support scheme.Our reactive scheme is an innovative approach for smart task support that links knowledge from an organizational memory to business tasks. The scheme is extended to include proactive inferencing capabilities in order to improve user-friendliness and to facilitate modeling of actual agent support. In particular, the improved scheme copes with varying precision of knowledge found in the organizational memory and it reasons proactively about what might be interesting to you and what might be due in your next step.     

An area/performance trade-off analysis of a GF(2) multiplier architecture for elliptic curve cryptography

A hardware architecture for GF(2^m) multiplication and its evaluation in a hardware architecture for elliptic curve scalar multiplication is presented. The architecture is a parameterizable digit-serial implementation for any field order m. Area/performance trade-off results of the hardware implementation of the multiplier in an FPGA are presented and discussed.     

A throughput maximised parallel architecture for 2D fast Discrete Pascal Transform

In this paper, we present a fully pipelined parallel implementation of a two dimensional (2D) Discrete Pascal Transform (DPT). Our approach first makes use of the properties of the Kronecker product and the vec operation on matrices to form an alternate 2D DPT representation suitable for column parallel computation. Next, we lend ourselves to the results from Skodras’ work in 1D DPT to achieve the final architecture for fast 2D DPT. With a fully pipelined implementation, the architecture possesses an initial latency of 2(N-1) clock cycles and a maximum throughput of one complete two dimensional transform every clock cycle, given any input matrix of size N×N. To evaluate our work, our results obtained from actual FPGA implementation were benchmarked against results from other previous works.     

Using schedulers to test probabilistic distributed systems

Formal methods are one of the most important approaches to increasing the confidence in the correctness of software systems. A formal specification can be used as an oracle in testing since one can determine whether an observed behaviour is allowed by the specification. This is an important feature of formal testing: behaviours of the system observed in testing are compared with the specification and ideally this comparison is automated. In this paper we study a formal testing framework to deal with systems that interact with their environment at physically distributed interfaces, called ports, and where choices between different possibilities are probabilistically quantified. Building on previous work, we introduce two families of schedulers to resolve nondeterministic choices among different actions of the system. The first type of schedulers, which we call global schedulers, resolves nondeterministic choices by representing the environment as a single global scheduler. The second type, which we call localised schedulers, models the environment as a set of schedulers with there being one scheduler for each port. We formally define the application of schedulers to systems and provide and study different implementation relations in this setting.     

The Shadow Knows: Refinement and security in sequential programs

Stepwise refinement is a crucial conceptual tool for system development, encouraging program construction via a number of separate correctness-preserving stages which ideally can be understood in isolation. A crucial conceptual component of security is an adversary’s ignorance of concealed information. We suggest a novel method of combining these two ideas.Our suggestion is based on a mathematical definition of “ignorance-preserving” refinement that extends classical refinement by limiting an adversary’s access to concealed information: moving from specification to implementation should never increase that access. The novelty is the way we achieve this in the context of sequential programs.Specifically we give an operational model (and detailed justification for it), a basic sequential programming language and its operational semantics in that model, a “logic of ignorance” interpreted over the same model, then a program-logical semantics bringing those together — and finally we use the logic to establish, via refinement, the correctness of a real (though small) protocol: Rivest’s Oblivious Transfer. A previous report^? treated Chaum’s Dining Cryptographers similarly.In passing we solve the Refinement Paradox for sequential programs.