Low-level Communication Research Articles

A hardware-software architecture for computer vision systems

Computer vision systems are based on capture and processing of images, from which information for the application is extracted. This paper presents a hybrid platform which can be easily configured and efficiently used for a large number of applications in computer vision. It consists of a dedicated processor integrated to the capture element, connected to a general-purpose computer for the high-level application processing. The camera module consists of a DSP executing a middleware which provides all the basic functions, such as image capture, low-level image processing, control, and communication. Experiments showed that good performance is obtained with this platform, and the framework presented may simplify the development of computer vision systems. An application for the hardware-software architecture presented here would be the validation and prototyping of computer vision systems.

Programming and proving with distributed protocols

Distributed systems play a crucial role in modern infrastructure, but are notoriously difficult to implement correctly. This difficulty arises from two main challenges: (a) correctly implementing core system components (e.g., two-phase commit), so all their internal invariants hold, and (b) correctly composing standalone system components into functioning trustworthy applications (e.g., persistent storage built on top of a two-phase commit instance). Recent work has developed several approaches for addressing (a) by means of mechanically verifying implementations of core distributed components, but no methodology exists to address (b) by composing such verified components into larger verified applications. As a result, expensive verification efforts for key system components are not easily reusable, which hinders further verification efforts. In this paper, we present Disel, the first framework for implementation and compositional verification of distributed systems and their clients, all within the mechanized, foundational context of the Coq proof assistant. In Disel, users implement distributed systems using a domain specific language shallowly embedded in Coq and providing both high-level programming constructs as well as low-level communication primitives. Components of composite systems are specified in Disel as protocols, which capture system-specific logic and disentangle system definitions from implementation details. By virtue of Disel's dependent type system, well-typed implementations always satisfy their protocols' invariants and never go wrong, allowing users to verify system implementations interactively using Disel's Hoare-style program logic, which extends state-of-the-art techniques for concurrency verification to the distributed setting. By virtue of the substitution principle and frame rule provided by Disel's logic, system components can be composed leading to modular, reusable verified distributed systems. We describe Disel, illustrate its use with a series of examples, outline its logic and metatheory, and report on our experience using it as a framework for implementing, specifying, and verifying distributed systems.

Evaluation of different control algorithm with low-level communication requirements to increase the maximum electric vehicle penetration

This contribution discusses three different types of charge control approaches: A local voltage-driven control, a central power-driven control and a combination of these two. These three approaches have been simulated and evaluated in a low-voltage grid with around 300 customers and three different penetration levels for electric vehicles (EVs) (22, 55 and 85%). The main results of this contribution are the direct comparison of different control algorithm in their capabilities to raise the maximum grade of EV penetration for low-voltage grids without a cost intense grid expansion. The implemented algorithms have deliberately been designed as simple as possible with only one control parameter in order to allow an evaluation of the effects of each control without generation cross correlation issues caused by different input parameters.

The development and validation of the Instructional Practices Log in Science: a measure of K-5 science instruction

ABSTRACTThe Instructional Practices Log in Science (IPL-S) is a daily teacher log developed for K-5 teachers to self-report their science instruction. The items on the IPL-S are grouped into scales measuring five dimensions of science instruction: Low-level Sense-making, High-level Sense-making, Communication, Integrated Practices, and Basic Practices. As part of the current validation study, 206 elementary teachers completed 4137 daily log entries. The purpose of this paper is to provide evidence of validity for the IPL-S’s scales, including (a) support for the theoretical framework; (b) cognitive interviews with logging teachers; (c) item descriptive statistics; (d) comparisons of 28 pairs of teacher and rater logs; and (e) an examination of the internal structure of the IPL-S. We present evidence to describe the extent to which the items and the scales are completed accurately by teachers and differentiate various types of science instructional strategies employed by teachers. Finally, we point to several practical implications of our work and potential uses for the IPL-S. Overall, results provide neutral to positive support for the validity of the groupings of items or scales.

The characterisation of engineering activity through email communication and content dynamics, for support of engineering project management

Significant challenge exists in the effective monitoring and management of engineering design and development projects. Due to traits such as contextual variation and scale, detailed understanding of engineering projects and activity are difficult to form, with monitoring hence reliant on interpretation of managerial personnel and adherence to defined performance indicators. This paper presents a novel approach to the quantitative monitoring and analysis of engineering activity through computational topic identification and analysis of low-level communication data. Through three metrics of communication activity, this approach enables detailed detection and tracking of activity associated with specific project work areas. By application to 11,832 emails within two industry email corpora, this work identifies four distinct patterns in activity, and derives seven characteristics of communication activity within engineering design and development. Patterns identified are associated with background discussion, focused working, and the appearance of issues, supporting detailed managerial understanding. Characteristics identified relate to through-process norms against which a manager may compare and assess. Such project-specific information extends the ability of managers to understand the activity within their specific project scenario. Through detailed description of activity and its characteristics, in tandem with existing toolsets, a manager may be supported in their interpretation and decision-making processes.

Accelerating Intercommunication in Highly Parallel Systems

Every HPC system consists of numerous processing nodes interconnect using a number of different inter-process communication protocols such as Messaging Passing Interface (MPI) and Global Arrays (GA). Traditionally, research has focused on optimizing these protocols and identifying the most suitable ones for each system and/or application. Recently, there has been a proposal to unify the primitive operations of the different inter-processor communication protocols through the Portals library. Portals offer a set of low-level communication routines which can be composed in order to implement the functionality of different intercommunication protocols. However, Portals modularity comes at a performance cost, since it adds one more layer in the actual protocol implementation. This work aims at closing the performance gap between a generic and reusable intercommunication layer, such as Portals, and the several monolithic and highly optimized intercommunication protocols. This is achieved through the development of a novel hardware offload engine efficiently implementing the basic Portals’ modules. Our innovative system is up to two2 orders of magnitude faster than the conventional software implementation of Portals’ while the speedup achieved over the conventional monolithic software implementations of MPI and GAs is more than an order of magnitude. The power consumption of our hardware system is less than 1/100th of what a low-power CPU consumes when executing the Portal's software while its silicon cost is less than 1/10th of that of a very simple RISC CPU. Moreover, our design process is also innovative since we have first modeled the hardware within an untimed virtual prototype which allowed for rapid design space exploration; then we applied a novel methodology to transform the untimed description into an efficient timed hardware description, which was then transformed into a hardware netlist through a High-Level Synthesis (HLS) tool.

Automatic distributed code generation from formal models of asynchronous processes interacting by multiway rendezvous

Formal process languages inheriting the concurrency and communication features of process algebras are convenient formalisms to model distributed applications, especially when they are equipped with formal verification tools (e.g., model checkers) to help hunting for bugs early in the development process. However, even starting from a fully verified formal model, bugs are likely to be introduced while translating (generally by hand) the concurrent model—which relies on high-level and expressive communication primitives—into the distributed implementation—which often relies on low-level communication primitives. In this paper, we present DLC, a compiler that enables distributed code to be generated from models written in a formal process language called LNT, which is equipped with a rich verification toolbox named CADP, and where processes interact by value-passing multiway rendezvous. The generated code uses an elaborate protocol to implement rendezvous, and can be either executed in an autonomous way (i.e., without requiring additional code to be defined by the user), or connected to external software through user-modifiable C functions. The protocol itself is modeled in LNT and verified using CADP. We present several experiments assessing the performance of DLC, including the Raft consensus algorithm.

The AXIOM software layers

People and objects will soon share the same digital network for information exchange in a world named as the age of the cyber-physical systems. The general expectation is that people and systems will interact in real-time. This poses pressure onto systems design to support increasing demands on computational power, while keeping a low power envelop. Additionally, modular scaling and easy programmability are also important to ensure these systems to become widespread. The whole set of expectations impose scientific and technological challenges that need to be properly addressed.The AXIOM project (Agile, eXtensible, fast I/O Module) will research new hardware/software architectures for cyber-physical systems to meet such expectations. The technical approach aims at solving fundamental problems to enable easy programmability of heterogeneous multi-core multi-board systems. AXIOM proposes the use of the task-based OmpSs programming model, leveraging low-level communication interfaces provided by the hardware. Modular scalability will be possible thanks to a fast interconnect embedded into each module. To this aim, an innovative ARM and FPGA-based board will be designed, with enhanced capabilities for interfacing with the physical world. Its effectiveness will be demonstrated with key scenarios such as Smart Video-Surveillance and Smart Living/Home (domotics).

Representing and Reasoning with the Internet of Things: a Modular Rule-Based Model for Ensembles of Context-Aware Smart Things

Context-aware smart things are capable of computational behaviour based on sensing the physical world, inferring context from the sensed data, and acting on the sensed context. A collection of such things can form what we call a thing-ensemble, when they have the ability to communicate with one another (over a short range network such as Bluetooth, or the Internet, i.e. the Internet of Things (IoT) concept), sense each other, and when each of them might play certain roles with respect to each other. Each smart thing in a thing-ensemble might have its own context-aware behaviours which when integrated with other smart things yield behaviours that are not straightforward to reason with. We present Sigma, a language of operators, inspired from modular logic programming, for specifying and reasoning with combined behaviours among smart things in a thing-ensemble. We show numerous examples of the use of Sigma for describing a range of behaviours over a diverse range of thing-ensembles, from sensor networks to smart digital frames, demonstrating the versatility of our approach. We contend that our operator approach abstracts away low-level communication and protocol details, and allows systems of context-aware things to be designed and built in a compositional and incremental manner.

MAC-Level Communication Time Modeling and Analysis for Real-Time WSNs

Low-level communication protocols and their timing behavior are essential to developing wireless sensor networks (WSNs) able to provide the support and operating guarantees required by ...

Communication in Cloud-of-Clouds Environment for Brokers

In advancement of cloud brokers for communication between different cloud providers, and the cloud-of-clouds territory denoting the integration of different cloudsincluding clouds offering different abstractions and services (e.g., Infrastructure as a Service vs. Platform as a Service) present new challenges to software developers. Actually, while support for developing specific types of applications to run in different individual cloud infrastructures is slowly becoming acceptable, there is little support for programming applications that run across several clouds or types of clouds. Combination of application, datacenters, and programming techniques in the multi-cloud environment poses numerous difficulties to framework engineers. Diverse cloud suppliers offer distinctive communication abstractions, and applications shows distinctive correspondence designs. By abstracting from hardware addresses and lower-level communication.

Programming Urban-Area Applications by Exploiting Public Transportation

The evolution of smartphones has given rise to urban-area applications: applications that communicate in a city by means of the public (moving) infrastructure (e.g., buses and trams). In this setting, applications need to communicate with and discover each other using intermediaries that move around the city and transfer data between them. This requires programmers to scatter code that deals with routing messages to the correct place and deal with network failures all over their programs. Our approach allows the programmer to specify urban-area applications in a high-level manner without the burden of directly encoding communication using intermediaries. We present this as a translation from a high-level object-oriented programming paradigm to a low-level communication mechanism. This translation allows the programmer to restrict routing of messages to, for example, a certain number of hops, geographic areas, or even types of carrier devices. In addition, we show how high-level group messaging can be efficiently represented in the low-level communication. Finally, we document our experiences in setting up a small-scale real-world urban-area application.

Universal Cross-Cloud Communication

Integration of applications, data-centers, and programming abstractions in the cloud-of-clouds poses many challenges to system engineers. Different cloud providers offer different communication abstractions, and applications exhibit different communication patterns. By abstracting from hardware addresses and lower-level communication, the publish/subscribe paradigm seems like an adequate abstraction for supporting communication across clouds, as it supports many-to-many communication between publishers and subscribers, of which one-to-one or one-to-many can be viewed as special cases. In particular, content-based publish/subscribe (CPS) systems provide an expressive abstraction that matches well with the key-value pair model of many established cloud storage and computing systems, and decentralized overlay-based CPS implementations scale up well. However, CPS systems perform poorly at small scale, e.g., one-to-one or one-to-many communication. This holds especially for multi-send scenarios which we refer to as entourages that may range from a channel between a publisher and a single subscriber to a broadcast between a publisher and a handful of subscribers. These scenarios are common in cloud computing, where cheap hardware is exploited for parallelism (efficiency) and redundancy (fault-tolerance). With CPS, multi-send messages go over several hops before their destinations are even identified via predicate matching, resulting in increased latency, especially when destinations are located in different data-centers or zones. Topic-based publish/subscribe (TPS) systems support communication at small scale more efficiently, but still route messages over multiple hops and inversely lack the flexibility of CPS systems. In this paper, we propose CPS protocols for cloud-of-clouds communication that can dynamically identify entourages of publishers and corresponding subscribers. Our CPS protocols dynamically connect the publishers with their entourages through uberlays . These uberlays can transmit messages from a publisher to its corresponding subscribers with low latency. Our experiments show that our protocols make CPS abstraction viable and beneficial for many applications. We introduce a CPS system named Atmosphere that leverages out CPS protocols and illustrate how Atmosphere has allowed us to implement, with little effort, versions of the popular HDFS and ZooKeeper systems which operate efficiently across data-centers.

A model driven architecture for the development of smart card software

Smart cards are portable integrated devices that store and process data. Speed, security and portability properties enable smart cards to have a widespread usage in various fields including telecommunication, transportation and the credit card industry. However, the development of smart card applications is a difficult task due to hardware and software constraints. The necessity of the knowledge of both a very low-level communication protocol and a specific hardware causes smart card software development to be a big challenge for the developers. Written codes tend to be error-prone and hard to debug because of the limited memory resources. Hence, in this study, we introduce a model driven architecture which aims to facilitate smart card software development by both providing an easy design of smart card systems and automatic generation of the required smart card software from the system models. Differentiating from the previous work, the study in here contributes to the field by both providing various smart card metamodels in different abstraction layers and defines model-to-model transformations between the instances of these metamodels in order to support the realization of the same system on different smart card platforms. Applicability of the proposed methodology is shown for rapid and efficient application development in two major smart card frameworks: Java Card and ZeitControl Basic Card. Lessons learned during the industrial usage of the architecture are also reported in the paper. Finally, we discuss how the components of the architecture can be integrated in order to provide a domain-specific language for smart card software.

Using digital board games for genuine communication in EFL classrooms

EFL learners in Taiwan have a low-level communication ability because many learners are still not provided opportunities to use language for genuine communication in classrooms and receive insufficient language input due to the environment. This study examines the use of digital board game language learning set in a task-collaborative platform, digital learning playground, designed for classroom learning. This study investigates whether communicative skills and intrinsic motivation could be improved by seeing relevant context and receiving adequate practice through gaming. Ninety-six high school Taiwanese students (n = 96), who were randomly assigned to an ordinary instruction group, a board game language-learning group, or a digital board game language-learning group, engaged in a 50-min English class. Analysis of covariance was used for comparing learning performance through a speaking test between the three groups. A modified intrinsic motivation inventory was conducted to assess learners’ perceptions of learning experience and an interview was held for details. The quantitative data presents a higher learning performance for the instruction set at digital learning playground. The qualitative data confirms computerized simulation adapted from board game entails context-relevant immersion, encouraging communication and efficient game instruction management for EFL language learning.

High Performance Message-passing InfiniBand Communication Device for Java HPC

MPJ Express is a Java messaging system that implements an MPI-like interface. It is used for writing parallel Java applications on High Performance Computing (HPC) hardware including commodity clusters. The software is capable of executing in multicore and cluster mode. In the cluster mode, it currently supports Ethernet and Myrinet based interconnects and provide specialized communication devices for these networks. One recent trend in distributed memory parallel hardware is the emergence of InfiniBand interconnect, which is a high-performance proprietary network and provides low latency and high bandwidth for parallel MPI applications. Currently there is no direct support available in Java (and hence MPJ Express) to exploit the performance benefits of InfiniBand networks. The only option to run distributed Java programs over InfiniBand networks is to rely on TCP/IP emulation layers like IP over InfiniBand (IPoIB) and Sockets Direct Protocol (SDP), which provide poor communication performance. To tackle this issue in the context of MPJ Express, this paper presents a low-level communication device called ibdev that can be used to execute parallel Java applications on InfiniBand clusters. MPJ Express is based on a layered architecture and hence users can opt to use ibdev at runtime on an InfiniBand equipped commodity cluster. ibdev improves Java application performance with access to InfiniBand hardware using native verbs API. Our performance evaluation reveals that MPJ Express achieves much better latency and bandwidth using this new device, compared to IPoIB and SDP. Improvement in communication performance is also evident in NAS parallel benchmark results where ibdev helps MPJ Express achieve better scalability and speedups as compared to IPoIB and SDP. The results show that it is possible to reduce the performance gap between Java and native languages with efficient support for low level communication libraries.

MVCC: An Architectural Pattern for Developing Context-aware Frameworks

Presenting a personalized service and information is a key aspect of pervasive computing, but development of such context-aware systems is quite complicated. Context-aware applications should be able to acquire raw data from sensors, make high-level context information, recognize the user's situation, and adapt behavior of the system. Developers need an infrastructure layer to mitigate such complexities. Also, programmers have tended to use software frameworks for getting away from low-level communication challenges of the infrastructure layer. Software frameworks should develop an architecture and implement facilities to support programmers’ requirements. In this paper, we identify an existing obstacles that each programmer faced with in the application layer development. Following, we will introduce MVCC (Model-View-Controller-Context) as an architectural pattern solution for software frameworks to overcome the mentioned obstacles. This architectural pattern can be implemented in a variety of frameworks and will brings easy and rapid development, reusability of the code, and flexibility for developers.

On the integration of Smalltalk and Java

After decades of development in programming languages and programming environments, Smalltalk is still one of few environments that provide advanced features and is used in the industry. However, as Java became prevalent, the ability to call a Java code from Smalltalk became important. A traditional approach to integrate the Java and Smalltalk languages is through low-level communication between separate Java and Smalltalk virtual machines. To our best knowledge there is no other project attempting to execute and integrate the Java language directly in the Smalltalk environment. A direct integration allows for a very tight integration of the languages and their objects within a single environment. Yet integration and language interoperability impose challenging issues related to method naming conventions, method overloading, exception handling and thread-locking mechanisms.In this paper we describe ways to overcome these challenges and to integrate Java into the Smalltalk environment. We focus on a possibility to call a Java code from Smalltalk using standard Smalltalk idioms while the semantics of both languages remains preserved. We present stx:libjava – an implementation of a Java virtual machine within Smalltalk/X – as a validation of our approach.

Data mining agent conversations: A qualitative approach to multiagent systems analysis

This paper presents a novel method for analysing the behaviour of multiagent systems on the basis of the semantically rich information provided by agent communication languages and interaction protocols specified at the knowledge level. More low-level communication mechanisms only allow for a quantitative analysis of the occurrence of message types, the frequency of message sequences, and the empirical distributions of parameter values. Quite differently, the semantics of languages and protocols in multiagent systems can help to extract qualitative properties of observed conversations among agents. This can be achieved by interpreting the logical constraints associated with protocol execution paths or individual messages as the context of an observed interaction, and using them as features of learning samples. The contexts “mined” from such analyses, or context models, can then be used for various tasks, e.g. for predicting others’ future responses (useful when trying to make strategic communication decisions to achieve a particular outcome), to support ontological alignment (by comparing the properties of logical constraints attached to messages across participating agents), or to assess the trustworthiness of agents (by verifying the logical coherence of their behaviour). This paper details a formal approach that describes our notion of context models in multiagent conversations, an implementation of this approach in a practical tool for mining qualitative context models, and experimental results to illustrate its use and utility.

Implementing DDS Listeners using CAN Driver and its State manager

This paper addresses the Data Distribution Service DDS publish/subscribe middleware, which uses CAN driver and its State manager under µCOSII real-time operating system. Our research work consists on developing a real-time middleware in the C language. Starting with the Object Management Group (OMG) specification, which is developed in interface description language (idl) file, we use the idl to C mapping rules to create the Data Centric Publish Subscribe Application Programming Interface (API). We attach a special attention to DDS listeners and we give an approach to establish low-level communication using listeners, callback functions and CAN state manager. We specially focus on the default response of DDS entities following the ISR (Interrupt Service Routine) as communication behavior.