Search

Boki is a new serverless runtime that exports a shared log API to serverless functions. Boki shared logs enable stateful serverless applications to manage their state with durability, consistency, and fault tolerance. Boki shared logs achieve high throughput and low latency. The key enabler is the metalog, a novel mechanism that allows Boki to address ordering, consistency and fault tolerance independently. The metalog orders shared log records with high throughput and it provides read consistency while allowing service providers to optimize the write and read path of the shared log in different ways. To demonstrate the value of shared logs for stateful serverless applications, we build Boki support libraries that implement fault-tolerant workflows, durable object storage, and message queues. Our evaluation shows that shared logs can speed up important serverless workloads by up to 4.7x.

The Internet of Things (IoT) is the term coined to encompass the myriad of devices that have some data processing and transmitting capabilities. Due to the increasing number of IoT devices connected to the Internet, network protocols intended for IoT technology have gained interest. This paper analyzes the performance of one of the most popular ones, named MQTT (Message Queuing Telemetry Transport), focused on Mosquitto, a widely used implementation. Our principal metric is the transmission time, defined as the time it takes a message to pass from one client through the broker to another client, since MQTT uses a publish/subscribe model with a broker. We evaluate different scenarios against some base configurations to give a firm comparison on how different factors affect the performance of an MQTT system based on Mosquitto, for payload sizes ranging from 512 to 1,048,576 bytes. For example, we assess how different network technologies (Ethernet, WiFi in the 2.4 GHz and 5 GHz bands) and QoS levels may yield better results at different message payload sizes. We also make a broker software comparison, evaluating Mosquitto against ActiveMQ and RabbitMQ. Our experiments exhibited similar results, with a slight advantage for RabbitMQ. Finally, we provide measurements on how DoS attacks can affect the Mosquitto broker, by flooding it with illegal MQTT petitions or making a TCP SYN flood attack. The goal of this study is to help MQTT implementers in making adequate decisions when selecting the different hardware and software solutions, for their MQTT systems.

The usage of Internet of Things has increased in the recent years allowing a new way of connecting devices together. Many transactions happen over the IoT calling for protocols to ensure the efficiency and management of the communication traffic. This paper examines 2 particular protocols, Message Queuing Telemetry Transport (MQTT) and Constrained application protocol (CoAP). The main differences between MQTT and CoAP that MQTT runs over TCP and CoAP runs over UDP. MQTT uses three level of QoS to ensure the message delivery while CoAP uses 4 types of transmission attempts which are confirmable, non-confirmable, acknowledgment, and rest. Through a set of experiments, we show that MQTT is more accurate when ensuring packet delivery. However, CoAP is better when it comes to performance when sending a limited number of messages.

The publish and subscribe messaging model has proven itself as a dominant messaging paradigm for IoT systems. An example of such is the commonly used Message Queuing Telemetry Transport (MQTT) protocol. However, the security concerns with this protocol have presented vital security challenges in most IoT applications. For example, the MQTT protocol does not have secure authentication mechanisms implemented and leaves that task to the developer as all the included native security services are fragile. This paper will present a well-thought approach involving a lightweight authentication and authorization scheme together with a decentralized identity system to manage the users' identities. This mechanism helps in facilitating the authentication for both subscribers and publishers by utilizing a smart contract in Ethereum blockchain to guarantee trust, accountability and preserve user privacy. We provided a proof-of-concept implementation to prove our work, which involves a decentralized MQTT platform and dashboard using our approach. The usability of this approach was further analyzed, particularly concerning CPU and memory utilization. Our analysis proved that our approach satisfies IoT applications' requirements since it reduces the consumption of resources and that smart contracts help in the automation of data management processes.

In CCS 2019, the privacy-preserving deep package inspection (PrivDPI) was proposed to detect anomalies and suspicious activities in encrypted network traffic, which is a provably secure and highly efficient approach for the end-to-end communication model. However, PrivDPI cannot be applied directly on the scenarios of the Internet of Things (IoT) due to its one/many-to-many communication model in which key agreement will bring giant power consumption. In this paper, we propose a group key agreement based encrypted traffic detection scheme for the Internet of Things (GKA_DPI) to solve it. In GKA_DPI, we still use BlindBox for traffic detection, which was used in PrivDPI and Sherry's scheme. The difference is that we use a dynamic group key agreement to replace the original key agreement protocol to reduce power consumption. Then we can perform deep traffic detection over encrypted packages on the widely used protocol Message Queuing Telemetry Transport (MQTT) of IoT. GKA_DPI can detect encrypted traffic without decrypting transmitted messages and find out malicious traffic to ensure the security of sensor network communication. Finally, we prove the forward and backward secrecy of proposed GKA_DPI.

In this paper we address the energy consumption of the Constraint Application Protocol (CoAP) and the Message Queue Telemetry Transport (MQTT) protocol and compare their overhead. We also pay attention to the use case of security in IoT and analyze the energy consumption when using TLS/DTLS for the two protocols. In our experiments we use ESP32 with libcoap, MQTT, and mbed TLS libraries and conduct real-world measurements using Otii, a high precision voltage and current measurement tool. While the particular numbers are implementation and hardware dependent, we can still make interesting observations. For data transfer, we find that aggregating data to larger packets can significantly reduce the energy consumption. We also find that AES-CCM8 seems slightly more efficient than other modes of operation. In comparison, the DTLS handshake for setting up the secure connection is very expensive, and also very dependent on security level and algorithm choices. For firmware updates, AES-CCM8 is again slightly better than the alternatives, but the differences between CoAP and MQTT are much more significant, favoring MQTT due to the use of the retransmission support in TCP. This is also evident in lossy networks, where MQTT saves up to 91% energy compared to CoAP at 20% loss rate. Finally, we find that energy consumption in CoAP can to some extent be reduced in lossy networks by modifying the retransmission timeout.

The dramatic increase of attacks and malicious activities has made security a major concern in the development of interconnected cyber-physical systems and raised the need to address this concern also in testing. The goal of security testing is to discover vulnerabilities in the system under test so that they can be fixed before an attacker finds and abuses them. However, testing for security issues faces the challenge of systematically exploring a potentially non-tractable number of interaction scenarios that have to include also invalid inputs and possible harmful interaction attempts. In this paper, we describe an approach for automated generation of test cases for security testing, which are based on attack patterns. These patterns are blueprints that can be used for exploiting common vulnerabilities. The approach combines random test case generation with attack patterns implemented for the Message Queuing Telemetry Transport (MQTT) protocol. We have applied the proposed testing approach to five popular and widely available MQTT brokers, generating 1,804 interaction sequences in form of executable test cases which resulted in numerous test failures, unhandled exceptions and crashes. A detailed manual analysis of these cases have revealed 28 security-relevant issues and critical shortcomings in the tested MQTT broker implementations.

As companies increasingly deploy message-oriented middleware (MOM) systems in mission-critical components of their infrastructures and services, the demand for improved performance and functionality has accelerated the rate at which new systems are being developed. Unfortunately, existing MOM systems are not designed to take advantages of techniques for high-performance data center communication (e.g., RDMA). In this paper, we describe the design and implementation of RocketBufs, a framework which provides infrastructure for building high-performance, in-memory Message-Oriented Middleware (MOM) applications. RocketBufs provides memory-based buffer abstractions and APIs, which are designed to work efficiently with different transport protocols. Applications implemented using RocketBufs manage buffer data using input (rIn) and output (rOut) classes, while the framework is responsible for transmitting, receiving and synchronizing buffer access. We use our current implementation, that supports both TCP and RDMA, to demonstrate the utility and evaluate the performance of RocketBufs by using it to implement a publish/subscribe message queuing system called RBMQ and a live streaming video application. When comparing RBMQ against two widely-used, industry-grade MOM systems, namely RabbitMQ and Redis, our evaluations show that when using TCP, RBMQ achieves broker messaging throughput up to 1.9 times higher than RabbitMQ and roughly on par with that of Redis, when configured comparably. However, RBMQ subscribers require significantly less CPU resources than those using Redis, allowing those resources to be used for other purposes like processing application data. When configured to use RDMA, RBMQ provides throughput up to 3.7 times higher than RabbitMQ and up to 1.7 times higher than Redis. We also demonstrate the flexibility of RocketBufs by implementing a live streaming video service and show that it can increase the number of simultaneous viewers by up to 55%.

Taking the course selection system of South china Institute of Software Engineering of Guangzhou University as an example, the underlying data interaction technology of the system and its advantages and disadvantages are analyzed, and an optimization scheme is proposed based on this. The optimization solution uses the fast access feature of memory data to pre-load necessary data into memory, uses ConcurrentHashMap to improve the system's concurrency and processing efficiency, uses locks to ensure that lock acquisition is performed in the order of requested locks, and then uses the message queue component Rabbitmq to asynchronously memory data Update to the background database. Experimental results verify the feasibility and effectiveness of the scheme.

Publish-Subscribe protocols such as the Message Queuing Telemetry Transport (MQTT) protocol are considered scalable, lightweight, and one-size-fits-all solutions for the Internet-of-Things (IoT) networking. MQTT has been widely adopted in the Industrial IoT to automate distributed power grid equipment such as smart meters and sensors. Such protocols are being adopted rapidly, without much attention being paid to security. Although these protocols support client-side TLS certificates, operators of ten do not enable these features, fearing performance and availability issues. Moreover, managing these certificates would be yet another challenging problem. We present MaQaTooT, a key-management and communication scheme based on Macaroons for the IoT and Smart Grid applications. MaQaTooT offers a technique to authenticate devices throughout their lifecycle, while sustaining the lightweight nature of MQTT, and also keeping the communication confidential and maintaining its integrity. Furthermore, it allows us to revoke keys reliably. To validate our key-management scheme, we built a prototype client for the Firefly RK3288 ARM Development Board and a key-management server for a GNU/Linux machine. We demonstrate that its performance on the prototype client fits the 4 ms latency limit of Industrial IoT protocols. We also verified our session-key establishment protocol using Proverif to ensure that the protocol never leaks the shared secrets.

The importance of the Internet of Things is constantly growing, together with the proliferation of IoT devices which are changing our daily life and empowering industrial processes. However, the most IoT devices and protocols were not designed with security in mind, and economic and energyconsumption constraints make the implementation of security measures a non-trivial problem. One of the most used messaging protocol in IoT, which is MQTT (Message Queuing Telemetry Transport), leaves to developers the task to implement security, as native security services provided by the protocol are very weak. This paper focuses on MQTT authentication, which is definitely insecure in the protocol, even though the implementations can combine MQTT with other mechanisms to obtain a suitable level of security. The aim of the present work is to propose an innovative OTP-authentication scheme for MQTT which uses Ethereum to implement an independent logic channel for the second-factor authentication. The implementation of the proposed scheme relies on the trusted behavior of smart contracts and adopts suitable strategies to preserve the privacy of users.

The basic concept behind the emergence of Internet of Things (IoT) is to connect as many objects to the Internet as possible in an attempt to make our lives better in some way. However, connecting everyday objects like your car or house to the Internet can open up major security concerns. In this paper, we present a novel security framework for the Message Queue Transport Telemetry (MQTT) protocol based on publish/subscribe messages in order to enhance secure and privacy-friendly Internet of Things services. MQTT has burst onto the IoT scene in recent years due to its lightweight design and ease of use implementation necessary for IoT. Our proposed solution provides 3 security levels. The first security level suits for lightweight data exchanges of non-tampered messages. The second security level enhances the privacy protection of data sources and data receivers. The third security level offers robust long-term security with mutual authentication for all parties. The security framework is based on light cryptographic schemes in order to be suitable for constrained and small devices that are widely used in various IoT use cases. Moreover, our solution is tailored to MQTT without using additional security overhead.

Carbon monoxide (CO) is a particularly toxic gas, and the CO poisoning is the leading cause of fatal poisoning in the world. One solution to deal with this dangerous gas is to exploit the advantages given to us by the applications and the technology advances in internet of things (IoT). In this context, we propose to integrate carbon monoxide detection objects to the internet, as part of civil protection intervention applications in case of detection of carbon monoxide to avoid poisoning. To do this, we propose a typical IoT architecture to manage the alerts sent to civil protection in the event of detection of carbon monoxide (CO). The architecture is based on the Message Queue Telemetry Transport (MQTT) communication protocol. Finally, we present the realization of our Test-bed and its components to integrate the object of detection of carbon monoxide on the internet.

The Quality of Service (QoS) of Message Queuing Telemetry Transport (MQTT) and Constrained Application Protocol (CoAP) play significant role for the Internet of Things (IoT) application development to ensure that the messages transmission between the Machine to Machine (M2M) communications are achieved. The IoT is also rapidly developed that enabled everything to be connected to each other. This paper proposes the implementation of QoS to focus on 3 levels of MQTT protocols: (i) CoAP is a protocol to compare the result between the protocols such as average data throughput, (ii) the average round-trip delay time of publish and (iii) subscribe the data in the real environment in the smart environment. In addition, this work is also present the results of the experiment that shows the data transfer between client and server the performance of QoS, real devices such as raspberry pi 3, Node MCU and temperature sensors are proposed to implement and test the whole system.

A widely used application layer protocol for IoT communication is Message Queue Telemetry Transport (MQTT) protocol. The provision of security in MQTT protocol is an essential concern in IoT applications. In this paper, we show how the conventional secure MQTT protocol is vulnerable to cipher attack. Then, we present a novel approach to improve the MQTT security by providing lightweight authentication mechanism. The proposed approach is using chaotic algorithm with topic based self-key agreement and block cipher. Moreover, the empirical study is performed to measure the efficiency of proposed approach in Cooja simulated environment.

Orchestration management in a global multi-cloud environment encounters many challenges, such as the centralized management of global cloud computing and application resources, more diverse cloud platforms and APIs, differentiated service catalogs. Network latency and instability between cloud platforms in various countries and accessibility between data centers of different security levels also makes orchestration not easy to manage. Orchestration tools, such as Ansible[1], has high requirements for many server ports and network quality. In a complex network environment, SaltStack[2] or Puppet[3], cannot deal with the multi-cloud management of large-scale computing and storage resource nodes. Apache Ambari[4], for applications that run on different cloud computing service providers, it lacks effective management capabilities. Therefore, it is difficult for common orchestration management tools to overcome these problems. In this paper, we propose a global multi-cloud orchestration framework (MCOF), which converts the orchestration instructions initiated from the MCOF master into a standardized orchestration definition model that is distributed to the MCOF workers inside each data center through the message queue. Then the MCOF workers perform the orchestration activities suitable for the corresponding cloud service provider behind the data center firewall to adapt to the complex cloud platform operating environment, and achieve standardization, efficiency, quality, reliability, and traceable orchestration management.

Ubiquitous learning environments move learners out of a classroom and into the real world, where learners can engage in experiential and tangible learning. These environments setup peer-to-peer networks where learners, teachers, and objects of interest can take part in creating learning scenarios. A key component of such systems is a wireless-enabled edge device augmented with various types of sensors to represent the state of physical objects and environments. Most such current systems are built using traditional Internet technologies that often lead to cumbersome, unreliable, and overly complex designs. This paper presents a novel generic technical architecture for ubiquitous assessment systems based on the Internet of Things (IoT) computing paradigm. A commonly used IoT edge device was used to implement four variants of the proposed architecture. The variants were based on Advanced Message Queuing Protocol (AMQP), Constrained Application Protocol (CoAP), Message Queue Telemetry Transport (MQTT), and Extensible Messaging and Presence Protocol (XMPP). The four architectural variants were evaluated in terms of power consumption and CPU utilization as the system changes in scale. The variants were also evaluated under various network conditions in order to assess their effect on response time, which in turn influences the user experience. The evaluation revealed that while the MQTT-based implementation demonstrated a consistent, generally-better performance, in practice, all variants of the architecture have a similar resource footprint for this class of applications. Hence, an implementation of the proposed architecture using either of the four protocols is expected to enhance the learning experience by capturing the benefits of ubiquitous and context-aware learning at a low cost, making it ideal for resource-constrained learning environments.

This work represents a study of Internet of Things (IoT) technology. An intelligent solution that aims to facilitate the daily life. Its ecosystem based on the use of specific network protocols that facilitate the operation of transporting. Reliable transfer and the energy consumption characterize these protocols. Several platforms developed designed for IoT, whose main purpose is to monitor the different uses of the sensors and send collected data to the cloud, according to the network protocols, to ensure the management as well as the quantity of energy consumed. One of the major challenges of IoT is the management of information heterogeneity, and its ability to exist in a complex ubiquitous and distributed system. With this in mind, we present a solution: The integration of the Multi Agent System (MAS) within IoT, by using a new Sigfox shield. This Shield is composed of the Sigfox and the Arduino. This contribution talk about the creation and management of IoT_Agent, setting up the constraints of communication, interactions and the interconnection between objects. To do this, we find that the Message Queue Telemetry Transport (MQTT) protocol performs well in terms of energy optimization during communications and interactions between IoT_agent. This approach proposes a dynamic management of the bridges, which solves the interconnection problems of the embedded systems in the different networks with an efficiency.

The Message Passing Interface (MPI) libraries use message queues to guarantee correct message ordering between communicating processes. Message queues are in the critical path of MPI communications and thus, the performance of message queue operations can have significant impact on the performance of applications. Collective communications are widely used in MPI applications and they can have considerable impact on generating long message queues. In this paper, we propose a message matching mechanism that improves the message queue search time by distinguishing messages coming from point-to-point and collective communications and allocating separate queues for them. Moreover, it dynamically profiles the impact of each collective call on message queues during the application runtime and uses this information to adapt the message queue data structure for each collective operation dynamically. The proposed approach can successfully reduce the queue search time while maintaining scalable memory consumption. The evaluation results show that we can obtain up to 5.5x runtime speedup for applications with long list traversals. Moreover, we can gain up to 15% and 45% queue search time improvement for applications with short and medium list traversals, respectively.

This paper proposes a novel approach for fast container networking that enables applications in containers to utilize host network stacks directly with proper access control. Our approach, called socket-grafting, offers a new socket-layer communication channel by grafting sockets in containers onto sockets in host network stacks. In contrast to recent approaches that make network stacks faster by using high-speed packet I/O techniques, socket-grafting makes container networking faster by bypassing a container's network stack and virtual interfaces. As a concrete implementation of socket-grafting, we designed AF_GRAFT, which is a new address family for the socket layer. AF_GRAFT performs interconnection between the two socket layers in the container and host network stacks. In this paper, we describe socket-grafting, AF_GRAFT design, and its implementation on Linux. Our evaluation results demonstrate that the proposed method doubled throughput and reduced latency by 23% compared with traditional NAT-based container networking, and improved the network performance of containerized HTTP servers and message queues.

In order to improve the efficiency of inter-process communication among microkernel operating systems, this paper proposes an inter-process communication mechanism for microkernels. The mechanism runs IPC (Inter-Process Communication) as a set of library functions. In the specific IPC design, message classification is used to classify messages into short messages and long messages. Short messages use registers. Communication, long messages use registers to hold message headers, message bodies are stored in message queues, and shared memory is used for message delivery. Experimental results show that this mechanism significantly shortens the communication time between processes and improves the efficiency of communication between processes.

A CloudIoT solution typically connects thousands of IoT things with cloud applications in order to store or process sensor data. In this environment, the cloud applications often consist of microservices which are connected to each other via message queues and must reliably handle a large number of messages produced by the IoT things. The state of a message queue in such a system can be a challenge if the rate of incoming messages continuously exceeds the rate of outgoing messages. This can lead to performance and reliability degradations due to overloaded queues and result in the unavailability of the cloud application. In this paper we present a case study to investigate which performance metrics to be used by a threshold-based auto-scaler for scaling consuming microservices of a message queue in order to prevent overloaded queues and to avoid SLA violations. We evaluate the suitability of each metric for scaling I/O-intensive and compute-intensive microservices with constant and varying characteristics, such as service time. We show, that scaling decisions based on message queue metrics are much more resilient to microservice characteristics variations. In this case, relying on the CPU utilization may result in massive overprovisioning or no scaling decision at all which could lead to an overloaded queue and SLA violations. We underline the benefits of using message queue metrics for scaling decisions instead of the more traditional CPU utilization particularly for I/O-intensive microservices due to the vulnerability to variations in the microservice characteristics.

In recent years there has been a surge in applications focusing on streaming data to generate insights in real-time. Both academia, as well as industry, have tried to address this use case by developing a variety of Stream Processing Engines (SPEs) with a diverse feature set. On the other hand, Big Data applications have started to make use of High-Performance Computing (HPC) which possess superior memory, I/O, and networking resources compared to typical Big Data clusters. Recent studies evaluating the performance of SPEs have focused on commodity clusters. However, exhaustive studies need to be performed to profile individual stages of a stream processing pipeline and how best to optimize each of these stages to best leverage the resources provided by HPC clusters. To address this issue, we profile the performance of a big data streaming pipeline using Apache Flink as the SPE and Apache Kafka as the intermediate message queue. We break the streaming pipeline into two distinct phases and evaluate percentile latencies for two different networks, namely 40GbE and InfiniBand EDR (100Gbps), to determine if a typical streaming application is network intensive enough to benefit from a faster interconnect. Moreover, we explore whether the volume of input data stream has any effect on the latency characteristics of the streaming pipeline, and if so how does it compare for different stages in the streaming pipeline and different network interconnects. Our experiments show an increase of over 10x in 98 percentile latency when input stream volume is increased from 128MB/s to 256MB/s. Moreover, we find the intermediate stages of the stream pipeline to be a significant contributor to the overall latency of the system.

A complete IoT solution for outdoor traceability of mobile things is presented. The system is composed of a mobile embedded system with a GPS/GPRS module (also referred in the article as tracking device) and cloud services. This embedded device has been designed using design for manufacturing, assembly and testing, with low power consumption and low cost in the scope. The cloud service, called Red Panda, is a published Web page developed by the authors in order to allow users easy remote access, and see the map with the data acquired from the tracking device. MQTT (Message Queue Telemetry Transport) is used to communicate the embedded device and the cloud service. First test show promising results of the complete solution. A position accuracy of 10-20 meters is obtained using raw data of the GPS module without post processing.

We propose a practical verification framework for preemptive OS kernels. The framework models the correctness of API implementations in OS kernels as contextual refinement of their abstract specifications. It provides a specification language for defining the high-level abstract model of OS kernels, a program logic for refinement verification of concurrent kernel code with multi-level hardware interrupts, and automated tactics for developing mechanized proofs. The whole framework is developed for a practical subset of the C language. We have successfully applied it to verify key modules of a commercial preemptive OS μC/OS-II, including the scheduler, interrupt handlers, message queues, and mutexes, etc. We also verify the priority-inversion-freedom (PIF) in μC/OS-II. All the proofs are mechanized in Coq. To our knowledge, our work is the first to verify the functional correctness of a practical preemptive OS kernel with machine-checkable proofs. More details about the project is available at

Most services inside a data center are distributed systems requiring coordination and synchronization in the form of primitives like distributed locks and message queues. We argue that extensibility is a crucial feature of the coordination infrastructures used in these systems. Without the ability to extend the functionality of coordination services, applications might end up using sub-optimal coordination algorithms, possibly leading to low performance. Adding extensibility, however, requires mechanisms that constrain extensions to be able to make reasonable security and performance guarantees. We propose a scheme that enables extensions to be introduced and removed dynamically in a secure way. To avoid performance overheads due to poorly designed extensions, it constrains the access of extensions to resources. Evaluation results for extensible versions of ZooKeeper and DepSpace show that it is possible to increase the throughput of a distributed queue by more than an order of magnitude (17x for ZooKeeper, 24x for DepSpace) while keeping the underlying coordination kernel small.

Middleware performance models are useful building blocks in the performance models of distributed software applications. We focus on performance models of messaging middleware implementing the Java Message Service standard, showing how certain system design properties -- including pipelined processing and message coalescing -- interact to create performance behavior that the existing models do not capture accurately. We construct a performance model of the ActiveMQ messaging middleware that addresses the outlined issues and discuss how the approach extends to other middleware implementations.

Recent transactional systems such as financial trading systems require a more reliable, high-performance inter-process communication (IPC) technology. The main goal is to interact among processes and handle server shutdowns and failures in an efficient ways. In this paper, we present a reliable, high-performance inter-process communication (IPC) using a message queue, called XpeedQ. Our proposed scheme provides a block level message processing, but also offers reliable message delivery based on optional persistence to disk. We have implemented the XpeedQ in Linux and measured its performance in terms of the average latency. The implementation results show that the proposed scheme can improve the efficiency of IPC while providing a persistence of messages.

We present an autonomous system for outdoor terrain (road) mapping using a robot equipped with viable low cost sensors (2D laser scanner, cameras, odometry, gyroscope and commercial GPS). The research work on outdoor navigation with known maps has matured well in past few years, but navigation and exploration of roads in an unknown area is still emerging. The presented system is an amalgamation of various computation modules running in parallel and interacting asynchronously with each other through message queues. The goal of the system is for a vehicle to explore and build a road network graph of a given area by autonomously navigating through all the connected roads in the area. The graph nodes contain topographic and semantic properties to allow reconstruction of the road network at a later stage for easier navigation.

Message queuing enables asynchronous communications between loosely coupled components in large-scale distributed systems. Traditional enterprise queueing systems provide strong queuing consistency, but incur high cost and lack elasticity. Cloud-based queueing services are highly elastic and scalable at the cost of reduced consistency. We introduce QORG, a Queue reORGanization messaging system which brings the best of enterprise and cloud-based queuing techniques together. By maintaining a message caching layer and performing just-in-time prefetching of messages from the persistent queue layer, QORG enables fast retrieval of queued messages in FIFO order, without incurring additional overhead to enqueue and dequeue operations.

With the increasing importance of event-based systems the performance of underlying event transporting systems, such as message oriented middleware (MOM), becomes business critical. Therefore, we see a strong need for benchmarks for such environments. Several messaging standards and protocols for middleware exist; most popular is the Java Message Service (JMS) which is defining an API rather than a wire protocol. An emerging standard is the new wire level protocol Advanced Message Queuing Protocol (AMQP). It originated in the financial sector and is developed by a consortium of over 20 member organizations.

Motivated by emerging applications, we consider sensor networks where the sensors themselves (not just the sinks) are mobile. We focus on mobility scenarios characterized by heterogeneous, highly changing mobility roles in the network. To capture these high dynamics we propose a novel network parameter, the mobility level, which, although simple and local, quite accurately takes into account both the spatial and speed characteristics of motion. We then propose adaptive data dissemination protocols that use the mobility level estimation to improve performance. By basically exploiting high mobility (redundant message ferrying) as a cost-effective replacement of flooding, e.g., the sensors tend to dynamically propagate less data in the presence of high mobility, while nodes of high mobility are favored for moving data around. These dissemination schemes are enhanced by a distance-sensitive probabilistic message flooding inhibition mechanism that further reduces communication cost, especially for fast nodes of high mobility level, and as distance to data destination decreases. Our simulation findings demonstrate significant performance gains of our protocols compared to non-adaptive protocols, i.e., adaptation increases the success rate and reduces latency (even by 15%) while at the same time significantly reducing energy dissipation (in most cases by even 40%). Also, our adaptive schemes achieve significantly higher message delivery ratio and satisfactory energy-latency trade-offs when compared to flooding when sensor nodes have limited message queues.

The Java Messaging Service (JMS) facilitates communication among distributed software components according to the publish/subscribe principle. If the subscribers install filter rules on the JMS server, JMS can be used as a message routing platform, but it is not clear whether its message throughput is sufficiently high to support large-scale systems. In this paper, we investigate the capacity of three high performance JMS server implementations: FioranoMQ, SunMQ, and WebsphereMQ. In contrast to other studies, we focus on the message throughput in the presence of filters and show that filtering reduces the performance significantly. We present models for the message processing time of each server and validate them by measurement.

DisASTer (Distributed Algorithms Simulation Terrain) is a platform for the implementation of distributed algorithms. It provides a Java class library that eases the programming of distributed algorithms in Java. Moreover, DisASTer constitutes an execution environment that enables the user to specify interactively a topology at runtime. It allows the user to control the execution of the algorithm (start, stop, suspend, resume, go back and forth). In addition, the execution of a distributed algorithm can be observed through some built-in visualization panels (topology view, sequence view, message queue view). DisASTer supports the implementation of further application-specific views.

Motivated by recent developments in Category theory and Web Community Discovery, we have developed an experimental platform to design Agent-based Systems. This paper describes why and how the architecture was developed under the Microsoft .Net environment with the Object-Oriented Language C#. The proposed architecture is based on three layers. The .Net C# Agent Infrastructure, that enables agents to live and interact, supporting the distribution of agents and the use of .Net remoting and MSMQ (Microsoft Message Queuing) service. The .Net C# Agent Framework, that provides an agent design and tools for implementing agents and making them interoperate. The third layer is the LEOPARD application http://www.csse.monash.edu.au/~arequile/leopard.html for which this experimental platform was built, where Learning Object repository nodes and users are considered as agents that observe traversals from both the repositories and the user perspective, and support the inference of dynamic semantics based on actual usage.

This paper presents a specification of a randomized shared queue that can lose some elements or return them out of order (not in FIFO), shows that the specification can be implemented over the probabilistic quorum algorithm of [4, 3], and analyzes the behavior of this implementation. Distributed algorithms that can tolerate some lost and out-of-order messages are candidates for replacing the message queues with random queues. The modified algorithms will inherit positive attributes concerning load and availability from the underlying queue implementation. The behavior of an application — a class of combinatorial optimization algorithms — when it is implemented using random queues is analyzed.

Virtual machine service threads can perform many tasks in parallel with program execution such as garbage collection, dynamic compilation, and profile collection and analysis. Hardware-assisted profiling is essential for providing service threads with needed information in a flexible and efficient way. A relational profiling architecture (RPA) is proposed for meeting this goal. The RPA selects particular instructions for profiling, and communicates collected information to service threads through shared memory message queues. The RPA's capabilities lead to new profiling applications, such as concurrent garbage collection. Simulations indicate that a low-cost implementation of the RPA should be able to profile four in-flight instructions simultaneously, and provide storage for eight profile records. Profiling overhead is less than 0.5% for concurrent garbage collection and edge profiling.

The PrismTM multi-process debugger was designed from its inception to support scalable debugging paradigms, implemented on top of a scalable architecture. Its features provide a good base for developing MPI programs, and we have extended them in a number of ways to improve its support for MPI. We have added more visualization support, including the ability to specify the geometry of globally-distributed arrays, to visualize MPI’s internal message queues, and to visualize linked data structures. We have provided an integrated MPI performance analysis capability in the form of an event-capture and display tool. Lastly, we have further enhanced the Prism architecture to improve scalability and ease-of-use for MPI debugging.

We propose a machine architecture for a high-performance processing node for a message-passing, MIMD concurrent computer. The principal mechanisms for attaining this goal are the direct execution and buffering of messages and a memory-based architecture that permits very fast context switches. Our architecture also includes a novel memory organization that permits both indexed and associative accesses and that incorporates an instruction buffer and message queue. Simulation results suggest that this architecture reduces message reception overhead by more than an order of magnitude.

This paper is concerned with the behaviour of message queues in distributed discrete event simula tors . We view a logical process in a distributed simulation as comprising a message sequencer with associated message queues, followed by an event processor. We show that, with standard stochastic assumptions for message arrival and time-stamp processes, the message queues are unstable for conservative sequencing, and for conservative sequencing with maximum lookahead and hence for optimistic resequencing, and for any resequencing algorithm that does not employ interprocessor “flow control”. These results point towards certain fundamental limits on the performance of distributed simulation of open queueing networks.