Low-level Implementation Details Research Articles

Cropbox: a declarative crop modelling framework

AbstractWe introduce Cropbox, a novel modelling framework that supports various aspects of crop modelling in a unique yet concise style. Building a crop model can be easily riddled with technical details looking trivial at first but later becoming major obstacles that hamper the whole development or application process. This is particularly the case when implementing models from scratch without relying on an established framework. Cropbox adopts a declarative approach providing a domain-specific language to reduce technical debt and assist modellers to focus on high-level abstraction formed by relations between variables and enclosing systems, rather than tinkering with low-level implementation details. The syntax of Cropbox framework is based on the Julia programming language and is deliberately constrained to avoid unintended side effects caused by common mistakes while its architecture remains open to extension. We highlight key capabilities of the framework through case studies featuring a leaf gas-exchange model and a whole-plant simulation model. We also illustrate potential extensions for supporting functional-structural plant modelling by demonstrating a 3D root architectural model as an example.

Deep Dive into ZGC: A Modern Garbage Collector in OpenJDK

ZGC is a modern, non-generational, region-based, mostly concurrent, parallel, mark-evacuate collector recently added to OpenJDK. It aims at having GC pauses that do not grow as the heap size increases, offering low latency even with large heap sizes. The ZGC C++ source code is readily accessible in the OpenJDK repository, but reading it (25 KLOC) can be very intimidating, and one might easily get lost in low-level implementation details, obscuring the key concepts. To make the ZGC algorithm more approachable, this work provides a thorough description on a high-level, focusing on the overall design with moderate implementation details. To explain the concurrency aspects, we provide a SPIN model that allows studying races between mutators and GC threads, and how they are resolved in ZGC. Such a model is not only useful for learning the current design (offering a deterministic and interactive experience) but also beneficial for prototyping new ideas and extensions. Our hope is that our detailed description and the SPIN model will enable the use of ZGC as a building block for future GC research, and research ideas implemented on top of it could even be adopted in the industry more readily, bridging the gap between academia and industry in the context of GC research.

An agnostic and efficient approach to identifying features from execution traces

Program comprehension is a necessary step during software understanding and maintenance. It is usually performed by analyzing data gathered from program execution. These execution traces reveal the relationship between high-level concepts (features) and low-level implementation details. However, identifying features from execution traces is difficult and time-consuming due to their large volume and complexity. Existing work assists the process by semi-automated tools, leveraging either human input or prior knowledge of the program implementation. It remains the key limitation towards a general method to build such mapping. In this paper, we proposed TRASE, an approach to identify features by segmenting the execution traces without the need for any human intervention. The segments are identified by mining recurring patterns on a sequence database, which is constructed by numerous execution traces gathered from normal use of a program. Each segment refers to a feature and the labels are inferred from the traces to assist program comprehension. The performance is evaluated on traces collected from android applications and a synthetic dataset. TRASE achieved up to 86% in F1 score and the result indicates that it is robust to highly variate traces while efficient for large data.

MontiThings: Model-Driven Development and Deployment of Reliable IoT Applications

Internet of Things (IoT) applications are exposed to harsh conditions due to factors such as device failure, network problems, or implausible sensor values. We investigate how the inherent encapsulation of component and connector (C&C) architectures can be used to develop and deploy reliable IoT applications. Existing C&C languages for the development of IoT applications mainly focus on the description of architectures and the distribution of components to IoT devices. Furthermore, related approaches often pollute the models with low-level implementation details, tying the models to a particular platform and making them harder to understand. In this paper, we introduce MontiThings, a C&C language offering automatic error handling capabilities and a clear separation between business logic and implementation details. The error-handling methods presented in this paper can make C&C-based IoT applications more reliable without cluttering the business logic with error-handling code that is time-consuming to develop and makes the models hard to understand, especially for non-experts.

A Service-Oriented Component-Based Framework for Dynamic Reconfiguration Modeling Targeting SystemC/TLM

To deal with the complex design issues of Dynamically Reconfigurable Systems-on-Chip (DRSoCs), it is extremely relevant to raise the abstraction level in which models are expressed. A high abstraction level allows great flexibility and reusability while bypassing low-level implementation details. In this context, model-driven engineering (MDE) provides support to build and transform precise and structured models for a particular purpose at different levels of abstraction. Indeed, high-level models are successively refined to low-level models until reaching the executable ones. Thus, this paper presents an MDE-based framework for DRSoCs design enabling the transformation of UML/MARTE specifications to SystemC/TLM implementation. To achieve a high degree of expressiveness for modeling dynamic reconfiguration, we use a suitable software engineering approach based on service-oriented component architecture. Since MARTE does not cover the common features of dynamic reconfiguration domain and service orientation concepts, new stereotypes are created by refinement to add missing capabilities to the profile. Likewise, SystemC does not provide native support for dynamic reconfiguration, thus leading us to adopt a design pattern based solution for DRSoCs implementation in compliance with standards. The proposed framework is validated through a reconfigurable active 3-way crossover case study in which we demonstrate the practicability of the approach by gradual model transformations with reduced implementation effort and significant design productivity gain.

CogTool+

Cognitive modeling tools have been widely used by researchers and practitioners to help design, evaluate, and study computer user interfaces (UIs). Despite their usefulness, large-scale modeling tasks can still be very challenging due to the amount of manual work needed. To address this scalability challenge, we propose CogTool+, a new cognitive modeling software framework developed on top of the well-known software tool CogTool. CogTool+ addresses the scalability problem by supporting the following key features: (1) a higher level of parameterization and automation; (2) algorithmic components; (3) interfaces for using external data; and (4) a clear separation of tasks, which allows programmers and psychologists to define reusable components (e.g., algorithmic modules and behavioral templates) that can be used by UI/UX researchers and designers without the need to understand the low-level implementation details of such components. CogTool+ also supports mixed cognitive models required for many large-scale modeling tasks and provides an offline analyzer of simulation results. In order to show how CogTool+ can reduce the human effort required for large-scale modeling, we illustrate how it works using a pedagogical example, and demonstrate its actual performance by applying it to large-scale modeling tasks of two real-world user-authentication systems.

Simulink Implementation of the Data Distribution Service for Vehicular Controllers on Top of GBE and AFDX

AbstractVehicular networks have seen major changes in the past few years in order to offer reliable and real-time capable high-speed data transmission between electrical and mechatronic components to map current and future innovative functions into distributed systems within automotive applications. In the same context, the real-time middleware data distribution service (DDS) is an appropriate alternative for the standard vehicular middleware considering that it handles quality of service (QoS) parameters including real-time ones. In this paper, we are proposing a new approach for DDS implementation and integration into the vehicular system by creating a model-based design blocks. To validate this implementation, we have used the case of the Society of Automotive Engineers (SAE) vehicle benchmark as a simulation and test model. Therefore, we designed a Simulink vehicle as specified by SAE benchmark. Then, we have introduced a new methodology to link each module to a Simulink DDS blockset. The goal of this approach is to facilitate the use of DDS with vehicular controllers and to reduce the deployment and configuration complexities associated with DDS. It will also enable distributed real-time embedded systems developers to concentrate more on the business logic of the application instead of the low-level implementation details. The final developed architecture has been tested using three different types of real-time networks: FlexRay, Gigabit Ethernet and AFDX, to demonstrate that real-time application’s QoS are always met using this model.

Synthesis of Incremental Linear Algebra Programs

This article targets the Incremental View Maintenance (IVM) of sophisticated analytics (such as statistical models, machine learning programs, and graph algorithms) expressed as linear algebra programs. We present LAGO, a unified framework for linear algebra that automatically synthesizes efficient incremental trigger programs, thereby freeing the user from error-prone manual derivations, performance tuning, and low-level implementation details. The key technique underlying our framework is abstract interpretation, which is used to infer various properties of analytical programs. These properties give the reasoning power required for the automatic synthesis of efficient incremental triggers. We evaluate the effectiveness of our framework on a wide range of applications from regression models to graph computations.

Implementing a Language for Distributed Systems: Choices and Experiences with Type Level and Macro Programming in Scala

Multitier programming languages reduce the complexity of developing distributed systems by developing the distributed system in a single coherent code base. The compiler or the runtime separate the code for the components of the distributed system, enabling abstraction over low level implementation details such as data representation, serialization and network protocols. Our ScalaLoci language allows developers to declare the different components and their architectural relation at the type level, allowing static reasoning about about distribution and remote communication and guaranteeing static type safety across components. The compiler splits the multitier program into the component-specific code and automatically generates the communication boilerplate. Communication between components can be modeled by declaratively specifying data flows between components using reactive programming. In this paper, we report on the implementation of our design and our experience with embedding our language features into Scala as a host language. We show how a combination of Scala's advanced type level programming and its macro system can be used to enrich the language with new abstractions. We comment on the challenges we encountered and the solutions we developed for our current implementation and outline suggestions for an improved macro system to support the such use cases of embedding of domain-specific abstractions.

The Kendrick modelling platform: language abstractions and tools for epidemiology

BackgroundMathematical and computational models are widely used to study the transmission, pathogenicity, and propagation of infectious diseases. Unfortunately, complex mathematical models are difficult to define, reuse and reproduce because they are composed of several concerns that are intertwined. The problem is even worse for computational models because the epidemiological concerns are also intertwined with low-level implementation details that are not easily accessible to non-computing scientists. Our goal is to make compartmental epidemiological models easier to define, reuse and reproduce by facilitating implementation of different simulation approaches with only very little programming knowledge.ResultsWe achieve our goal through the definition of a domain-specific language (DSL), Kendrick, that relies on a very general mathematical definition of epidemiological concerns as stochastic automata that are combined using tensor-algebra operators. A very large class of epidemiological concerns, including multi-species, spatial concerns, control policies, sex or age structures, are supported and can be defined independently of each other and combined into models to be simulated by different methods. Implementing models does not require sophisticated programming skills any more. The various concerns involved within a model can be changed independently of the others as well as reused within other models. They are not plagued by low-level implementation details.ConclusionsKendrick is one of the few DSLs for epidemiological modelling that does not burden its users with implementation details or required sophisticated programming skills. It is also currently the only language for epidemiology modelling that supports modularity through clear separation of concerns hence fostering reproducibility and reuse of models and simulations. Future work includes extending Kendrick to support non-compartmental models and improving its interoperability with existing complementary tools.

StakeQP: A semi-automated stakeholder quantification and prioritisation technique for requirement selection in software system projects

Stakeholder quantification and prioritisation (SQP) is performed on the basis of the stakeholder's influence. The involvement of adequate stakeholders plays a crucial role in identifying and selecting the most essential requirements to produce a successful system. However, the current SQP techniques still face serious limitations, such as having insufficient low-level implementation details, being time-consuming, lacking an automation level, heavily relying on professional expertise and having no attribute measurement criteria (AMC) for stakeholder evaluation. These key issues serve as the motivation of the present study. Hence, this study is aimed at proposing a new semi-automated technique called StakeQP to address the reported key limitations. StakeQP introduces new low-level implementation details to perform SQP automatically on the basis of the newly proposed AMC using the multi-attribute decision-making method, namely, the technique of order preference similarity to the ideal solution (TOPSIS), to achieve an efficient StakeQP. The effectiveness of StakeQP is evaluated using a benchmark dataset of the actual software project. The findings show that StakeQP can produce more accurate results with less time consumption and is more effective in addressing the defined key limitations compared with other alternative techniques.

Towards a context-aware Wireless Sensor Networks

Recently, the development of wireless sensor networks (WSNs) is spreading rapidly. WSNs are highly distributed self-organized systems which comprise a large number of resource constrained sensor nodes. Developers of WSNs face many challenges from communication, memory, limited energy… Also, mobility has become a major concern for WSN researchers. Indeed, Mobile WSNs (MWSN) consist of mobile sensor nodes that can move on their own and also interact with the physical environment. Developing applications for MWSN is a complicated process because of the wide variety of WSN applications and low-level implementation details. Integrating context-awareness can improve MWSN applications results. In this paper, some research issues and challenges involved in the design of WSNs are presented. Model-Driven Engineering offers an effective solution to WSN application developers by hiding the details of lower layers and raising the level of abstraction. In this sense, we propose a context-aware WSN architecture and WSN metamodel to ease the work for developers in this field.

Facial expressions as a model to test the role of the sensorimotor system in the visual perception of the actions.

A long-term debate concerns whether the sensorimotor coding carried out during transitive actions observation reflects the low-level movement implementation details or the movement goals. On the contrary, phonemes and emotional facial expressions are intransitive actions that do not fall into this debate. The investigation of phonemes discrimination has proven to be a good model to demonstrate that the sensorimotor system plays a role in understanding actions acoustically presented. In the present study, we adapted the experimental paradigms already used in phonemes discrimination during face posture manipulation, to the discrimination of emotional facial expressions. We submitted participants to a lower or to an upper face posture manipulation during the execution of a four alternative labelling task of pictures randomly taken from four morphed continua between two emotional facial expressions. The results showed that the implementation of low-level movement details influence the discrimination of ambiguous facial expressions differing for a specific involvement of those movement details. These findings indicate that facial expressions discrimination is a good model to test the role of the sensorimotor system in the perception of actions visually presented.

Метод автоматического построения гибридных UML-моделей на основе журналов событий систем с сервис-ориентированной архитектурой

In the paper we consider a method for mining so-called “hybrid” UML models, that refers to software process mining. Models are built from execution traces of information systems with service-oriented architecture (SOA), given in the form of event logs. While common reverse engineering techniques usually require the source code, which is often unavailable, our approach deals with event logs which are produced by a lot of information systems, and some heuristic parameters. Since an individual type of UML diagrams shows only one perspective of a system’s model, we propose to mine a combination of various types of UML diagrams (namely, sequence and activity ), which are considered together with communication diagrams. This allows us to increase the expressive power of the individual diagram. Each type of diagram correlates with one of three levels of abstraction (workflow, interaction and operation), which are commonly used while considering web-service interaction. The proposed algorithm consists of four tasks. They include splitting an event log into several parts and building UML sequence, activity and communication diagrams. We also propose to encapsulate some insignificant or low-level implementation details (such as internal service operations) into activity diagrams and connect them with a more general sequence diagram by using interaction use semantics. To cope with a problem of immense size of synthesized UML sequence diagrams, we propose an abstraction technique based on regular expressions. The approach is evaluated by using a developed software tool as a Windows-application in C#. It produces UML models in the form of XML-files. The latter are compatible with well-known Sparx Enterprise Architect and can be further visualized and utilized by that tool.

A Framework for Direct and Transparent Data Exchange of Filter-stream Applications in Multi-GPUs Architectures

The massive data generation has been pushing for significant advances in computing architectures, reflecting in heterogeneous architectures composed by different types of processing units. The filter-stream paradigm is typically used to exploit the parallel processing power of these new architectures. The efficiency of applications in this paradigm is achieved by exploring a set of interconnected computers (cluster) using filters and communication between them in a coordinated way. In this work we propose, implement and test a generic abstraction for direct and transparent data exchange of filter-stream applications in heterogeneous cluster with multi-GPU (Graphics Processing Units). This abstraction allows hiding from the programmers all the low-level implementation details related to GPU communication and the control related to the location of filters. Further, we consolidate such abstraction into a framework. Empirical assessments using a real application show that the proposed abstraction layer eases the implementation of filter-stream applications without compromising the overall application performance.

Designing a Tunable Nested Data-Parallel Programming System

This article describes Surge, a nested data-parallel programming system designed to simplify the porting and tuning of parallel applications to multiple target architectures. Surge decouples high-level specification of computations, expressed using a C++ programming interface, from low-level implementation details using two first-class constructs: schedules and policies. Schedules describe the valid ways in which data-parallel operators may be implemented, while policies encapsulate a set of parameters that govern platform-specific code generation. These two mechanisms are used to implement a code generation system that analyzes computations and automatically generates a search space of valid platform-specific implementations. An input and architecture-adaptive autotuning system then explores this search space to find optimized implementations. We express in Surge five real-world benchmarks from domains such as machine learning and sparse linear algebra and from the high-level specifications, Surge automatically generates CPU and GPU implementations that perform on par with or better than manually optimized versions.

Grid workflow validation using ontology-based tacit knowledge: A case study for quantitative remote sensing applications

Workflow for remote sensing quantitative retrieval is the “bridge” between Grid services and Grid-enabled application of remote sensing quantitative retrieval. Workflow averts low-level implementation details of the Grid and hence enables users to focus on higher levels of application. The workflow for remote sensing quantitative retrieval plays an important role in remote sensing Grid and Cloud computing services, which can support the modelling, construction and implementation of large-scale complicated applications of remote sensing science. The validation of workflow is important in order to support the large-scale sophisticated scientific computation processes with enhanced performance and to minimize potential waste of time and resources. To research the semantic correctness of user-defined workflows, in this paper, we propose a workflow validation method based on tacit knowledge research in the remote sensing domain. We first discuss the remote sensing model and metadata. Through detailed analysis, we then discuss the method of extracting the domain tacit knowledge and expressing the knowledge with ontology. Additionally, we construct the domain ontology with Protégé. Through our experimental study, we verify the validity of this method in two ways, namely data source consistency error validation and parameters matching error validation.

A search engine for finding and reusing architecturally significant code

A code search engine to automate the discovery, extraction and indexing of tactics.A big data compatible architecture to search through 22 million source files.Novel techniques to detect tactics and technical context in which they are used.Introducing a novel ranking algorithm to order the retrieved tactical files.Enhancing the state-of-the-art code search engines in finding tactical-code. Architectural tactics are the building blocks of software architecture. They describe solutions for addressing specific quality concerns, and are prevalent across many software systems. Once a decision is made to utilize a tactic, the developer must generate a concrete plan for writing code and implementing the tactic. Unfortunately, this is a non-trivial task even for experienced developers. Often, developers resort to using search engines, crowd-sourcing websites, or discussion forums to find sample code snippets to implement a tactic. A fundamental problem of finding implementation for architectural tactics/patterns is the mismatch between the high-level intent reflected in the descriptions of these patterns and the low-level implementation details of them. To reduce this mismatch, we created a novel Tactic Search Engine called ArchEngine (ARCHitecture search ENGINE). ArchEngine can replace this manual internet-based search process and help developers find and reuse tactical code from a wide range of open source systems. ArchEngine helps developers find implementation examples of an architectural tactic for a given technical context. It uses information retrieval and program analysis techniques to retrieve applications that implement these design concepts. Furthermore, it lists and rank the code snippets where the patterns/tactics are located. Our case study with 21 graduate students (with experience level of junior software developers) shows that ArchEngine is more effective than other search engines (e.g., Krugle and Koders) in helping programmers to quickly find implementations of architectural tactics/patterns.

High performance image acquisition and processing architecture for fast plant system controllers based on FPGA and GPU

The two dominant technologies that are being used in real time image processing are Field Programmable Gate Array (FPGA) and Graphical Processor Unit (GPU) due to their algorithm parallelization capabilities. But not much work has been done to standardize how these technologies can be integrated in data acquisition systems, where control and supervisory requirements are in place, such as ITER (International Thermonuclear Experimental Reactor). This work proposes an architecture, and a development methodology, to develop image acquisition and processing systems based on FPGAs and GPUs compliant with ITER fast controller solutions. A use case based on a Camera Link device connected to an FPGA DAQ device (National Instruments FlexRIO technology), and a NVIDIA Tesla GPU series card has been developed and tested. The architecture proposed has been designed to optimize system performance by minimizing data transfer operations and CPU intervention thanks to the use of NVIDIA GPUDirect RDMA and DMA technologies. This allows moving the data directly between the different hardware elements (FPGA DAQ-GPU-CPU) avoiding CPU intervention and therefore the use of intermediate CPU memory buffers. A special effort has been put to provide a development methodology that, maintaining the highest possible abstraction from the low level implementation details, allows obtaining solutions that conform to CODAC Core System standards by providing EPICS and Nominal Device Support.

Abstractions for Practical Virtual Machine Replay

Efficient deterministic replay of whole operating systems is feasible and useful, so why isn't replay a default part of the software stack? While implementing deterministic replay is hard, we argue that the main reason is the lack of general abstractions for understanding and addressing the significant engineering challenges involved in the development of a replay engine for a modern VMM. We present a design blueprint---a set of abstractions, general principles, and low-level implementation details---for efficient deterministic replay in a modern hypervisor. We build and evaluate our architecture in Xen, a full-featured hypervisor. Our architecture can be readily followed and adopted, enabling replay as a ubiquitous part of a modern virtualization stack.