Measuring the performance of aspect oriented software: A case study of Leader/Followers and Half-Sync/Half-Async architectures

The aim of this work is to measure the impact of aspect-oriented programming on software performance. Thus, we hypothesized as follow: adding aspects to a base program will affect its performance because of the overhead caused by the control flow switching, and that incremental effect on performance is more obvious as the number of join points increases. To test our hypotheses we carried out a case study of two concurrent architectures: Half-Sync/Half-Async and Leader/Followers. Aspects are extracted and encapsulated and the base program performance was compared to the aspect program. Our results show that the aspect-oriented approach does not have significant effect on the performance and that in some cases an aspect-oriented program even outperforms the non-aspect program. We also investigated the effect of cache fault rate on performance for both aspect and non-aspect programs. Based on our experiments, the results demonstrate that there is a close correlation between the cache fault rate and performance, which may be in favor of aspect code if some aspects are frequently accessed. Additionally, the introduction of a large number of join points does not have significant effect on performance.     

Analogy-based domain analysis approach to software reuse

Domain analysis is an expansion of conventional requirements analysis. Domain analysis can support effective software reuse. However, domain analysis is time consuming and is limited to a particular application area. Analogical approaches to software reuse, on the other hand, often occur across domains. Analogical problem solving is a process of transferring knowledge from a well-understood base domain to a new target problem area. Analogy can facilitate software reuse for poorly understood problems or new application areas. Analogy shares similar concepts with reuse and some analogy theories have been applied to software reuse. However, current research on software analogy often overlooks the importance of analysis for the base domain and does not consider some critical aspects of analogy concepts. Reuse must be based on high quality artifacts, especially reuse across domains. This paper presents an approach to integrate domain analysis and analogy methods. In our view, domain analysis and software analogy have complementary roles. Domain analysis is regarded as a process to identify and supply necessary information for analogical transfer. Software analogy can provide the analyst with similar problems and solutions to reuse previous domain analysis knowledge or artifacts for a new domain. This paper presents case studies to demonstrate the increase of efficiency in applying the approach. Evaluation of the approach from various perspectives is also reported.     

Experience of building an architecture-based generator using GenVoca for distributed systems

Selecting the architecture that meets the requirements, both functional and non-functional, is a challenging task, especially at the early stage when more uncertainties exist. Architectural prototyping is a useful approach in supporting the evaluation of alternative architectures and balancing different architectural qualities. Generative programming has gained increasing attention, but it mostly deals with lower-level artifacts; hence, it usually supports lower degrees of software automation. This paper proposes an architecture-centric generative approach in facilitating architectural prototyping and evaluation. We also present our empirical experience in raising the level of abstraction to the architecture layer for distributed and concurrent systems using GenVoca. GenVoca is a generative programming approach that is used here to support the generation or instantiation of a particular architectural pattern in distributed computing based on user’s selection. As a result, it can support rapid architectural prototyping and evaluation of both functional and non-functional requirements and encourage greater degrees of software automation and reuse. Lessons learned from the empirical study are also reported and could be applied to other areas.     

Controller Placement in Software-Defined Multihop Wireless Networks: Optimal Solution and GA-based Approximation

In a multi-controller software-defined networking (SDN) architecture, solving the controller placement problem (CPP) has a direct effect on the generated control overhead in the network. We aim to minimize the control overhead exchanged in the network, especially in software-defined multihop wireless networks (SDMWN), i.e., a network that is built on multihop communications using a wireless medium. We solve this problem both optimally, using a nonlinear optimization model, and via a heuristic algorithm. The proposed heuristic approach is based on the genetic algorithm (GA). The objective of both the proposed optimization problem and the proposed GA algorithm is to find a given number of controllers, controller placements and assignments of controllers to devices while minimizing the generated control overhead in the network. Our results show the impact of different metrics, including the number of controllers, the arrival rate of new flows and the capacity limit of wireless links on the control overhead and the average number of controller-device and inter-controller hops. In addition, our results demonstrate that the GA-based heuristic approach can derive the same optimal solution for a small network with much less computational overhead, and can solve larger networks in a short period of time, making it feasible for non-trivial network sizes.

     

Stability of bilateral teleoperators with generalized projection-based force reflection algorithms

A general stability result for bilateral teleoperator systems with projection-based force reflection algorithms from a broad class is presented. It is shown that the overall stability of a teleoperator system can be achieved under mild assumptions on subsystem stability, properties of the communication channel, dynamics of the human operator, and the human force measurement/estimation process. In particular, the stability is achieved under a new general assumption on human dynamics which allows for both passive and nonpassive behaviour of the human operator. It is demonstrated that the use of projection-based force reflection algorithms effectively removes the constraints on subsystem gains that are typical for direct application of the small-gain design, thus solving the trade-off between stability, manoeuvrability, and high force reflection gain in bilateral teleoperation over communication networks.     

A Force-Reflection Algorithm for Improved Transparency in Bilateral Teleoperation With Communication Delay

The problem of stable force-reflecting teleoperation with time-varying communication delay is addressed in this paper. A new force-reflection (FR) algorithm is presented, where the environmental force reflected on the master side can be altered depending on the forces applied by the human operator. This alteration is not felt by the human operator; however, it makes the FR safe in the sense it does not destroy the stability of the teleoperator system. In particular, using input-to-output stability small gain approach, it is shown that the overall stability in the teleoperator system with the force-reflecting algorithm proposed can be achieved theoretically for arbitrarily low damping on the master side and arbitrarily high FR gain. The simulation results presented confirm that the proposed FR algorithm significantly improves the stability/performance characteristics of the force-reflecting teleoperator system in the presence of time-varying communication delays.     

A subtree-based approach to failure detection and protection for multicast in SDN

Software-defined networking (SDN) has received tremendous attention from both industry and academia. The centralized control plane in SDN has a global view of the network and can be used to provide more effective solutions for complex problems, such as traffic engineering. This study is motivated by recent advancement in SDN and increasing popularity of multicasting applications. We propose a technique to increase the resiliency of multicasting in SDN based on the subtree protection mechanism. Multicasting is a group communication technology, which uses the network infrastructure efficiently by sending the data only once from one or multiple sources to a group of receivers that share a common path. Multicasting applications, e.g., live video streaming and video conferencing, become popular, but they are delay-sensitive applications. Failures in an ongoing multicast session can cause packet losses and delay, which can significantly affect quality of service (QoS). In this study, we adapt a subtree-based technique to protect a multicast tree constructed for OpenFlow switches in SDN. The proposed algorithm can detect link or node failures from a multicast tree and then determines which part of the multicast tree requires changes in the flow table to recover from the failure. With a centralized controller in SDN, the backup paths can be created much more effectively in comparison to the signaling approach used in traditional multiprotocol label switching (MPLS) networks for backup paths, which makes the subtree-based protection mechanism feasible. We also implement a prototype of the algorithm in the POX controller and measure its performance by emulating failures in different tree topologies in Mininet.     

A control scheme for stable force-reflecting teleoperation over IP networks.

The problem of force-reflecting teleoperation over Internet protocol networks is addressed. The existence of time-varying communication delay and the possibility of data losses are taken into consideration. Since significant data loss may result in discontinuity of the reference trajectory transmitted through the communication channel, the proposed control scheme includes a filter that provides a smooth approximation of a possibly discontinuous reference trajectory. The stability of the overall system is guaranteed by a version of the input-to-output stable small-gain theorem for functional differential equations. If the communication delay in the forward channel is an "approximately smooth" function of time, the proposed scheme guarantees that the slave manipulator tracks the delayed trajectory of the master within a prescribed small error.