Search

The particle swarm optimization (PSO) algorithm has been the object of many studies and modifications for more than twentyfive years. Ranging from small refinements to the incorporation of sophisticated novel ideas, the majority of modifications proposed to this algorithm have been the result of a manual process in which developers try new designs based on their own knowledge and expertise. However, manually introducing changes is very time consuming and makes the systematic exploration of all the possible algorithm configurations a difficult process. In this paper, we propose to use automatic design to overcome the limitations of having to manually find performing PSO algorithms. We develop a flexible software framework for PSO, called PSO-X, which is specifically designed to integrate the use of automatic configuration tools into the process of generating PSO algorithms. Our framework embodies a large number of algorithm components developed over more than twentyfive years of research that have allowed PSO to deal with a large variety of problems, and uses irace, a state-of-the-art configuration tool, to automatize the task of selecting and configuring PSO algorithms starting from these components. We show that irace is capable of finding high performing instances of PSO algorithms never proposed before.

Noisy gate-model quantum processing units (QPUs) are currently available from vendors over the cloud, and digital quantum programming approaches exist to run low-depth circuits on physical hardware. These digital representations are ultimately lowered to pulse-level instructions by vendor quantum control systems to affect unitary evolution representative of the submitted digital circuit. Vendors are beginning to open this pulse-level control system to the public via specified interfaces. Robust programming methodologies, software frameworks, and backend simulation technologies for this analog model of quantum computation will prove critical to advancing pulse-level control research and development. Prototypical use cases for this include error mitigation, optimal pulse control, and physics-inspired pulse construction. Here we present an extension to the XACC quantum-classical software framework that enables pulse-level programming for superconducting, gate-model quantum computers, and a novel, general, and extensible pulse-level simulation backend for XACC that scales on classical compute clusters via MPI. Our work enables custom backend Hamiltonian definitions and gate-level compilation to available pulses with a focus on performance and scalability. We end with a demonstration of this capability, and show how to use XACC for pertinent pulse-level programming tasks.

As the scientific community prepares to deploy an increasingly complex and diverse set of applications on exascale platforms, the need to assess reproducibility of simulations and identify the root causes of reproducibility failures increases correspondingly. One of the greatest challenges facing reproducibility issues at exascale is the inherent non-determinism at the level of inter-process communication. The use of non-deterministic communication constructs is necessary to boost performance, but communication non-determinism can also hamper software correctness and result reproducibility. To address this challenge, we propose a software framework for identifying the percentage and sources of communication non-determinism. We model parallel executions as directed graphs and leverage graph kernels to characterize run-to-run variations in inter-process communication. We demonstrate the effectiveness of graph kernel similarity as a proxy for non-determinism, by showing that these kernels can quantify the type and degree of non-determinism present in communication patterns. To demonstrate our framework’s ability to link and quantify runtime non-determinism to root sources, demonstrate with present for an adaptive mesh refinement application, where our framework automatically quantifies the impact of function calls on non-determinism, and a Monte Carlo application, where our framework automatically quantifies the impact of parameter configurations on non-determinism.

Analog computing has been recovering its relevance in the recent years. Field-Programmable Analog Arrays (FPAAs) are the equivalent to Field-Programmable Gate Arrays (FPGAs) but in the analog and mixed-signal domain. In order to increase the amount of analog resources, in this brief a cluster of 40 FPAAs is proposed. As a use case, a 19-8-6-4 feedforward Neural Network has been implemented on such cluster. With the help of a DCT-based software framework, this NN is able to classify $28 \times 28$ images from MNIST. Results show that the analog network is able to obtain similar results as the software baseline network.

Aerial manipulation is an emerging field in robotics with various potential applications such as transport and delivery, agriculture, and, infrastructure inspection. To deploy aerial vehicles in the real world, the safety and reliability of these systems is paramount. Motivated by the need for safety and reliability, this work proposes a software framework that has built-in robustness to algorithmic failures and hardware faults. The framework allows users to build complex applications while reasoning about faults that can happen at different stages of an aerial manipulation task and specifying fallback actions to return to normal operating mode. The aerial manipulator is further endowed with a magnetic gripper that can handle positional errors arising from perception and control uncertainties. We also introduce a bias estimator for measuring the contact forces and sensor bias. We demonstrate how the estimator can be used to detect either completion or failures across several tasks. We demonstrate the reliability of the proposed framework on two tasks: package sorting task (e.g. as might be used in a distribution center) and sensor placement task (for infrastructure inspection). We show different failure modes that can occur and how our aerial manipulation system recovers from them.

Graph structures are a natural representation of important and pervasive data. While graph applications have significant parallelism, their characteristic pointer indirect loads to neighbor data hinder scalability to large datasets on multicore systems. A scalable and efficient system must tolerate latency while leveraging data parallelism across millions of vertices. Modern Out-of-Order (OoO) cores inherently tolerate a fraction of long latencies, but become clogged when running severely memory-bound applications. Combined with large power/area footprints, this limits their parallel scaling potential and, consequently, the gains that existing software frameworks can achieve. Conversely, accelerator and memory hierarchy designs provide performant hardware specializations, but cannot support diverse application demands. To address these shortcomings, we present GraphAttack, a hardware-software data supply approach that accelerates graph applications on in-order multicore architectures. GraphAttack proposes compiler passes to (1) identify idiomatic long-latency loads and (2) slice programs along these loads into data Producer/ Consumer threads to map onto pairs of parallel cores. Each pair shares a communication queue; the Producer asynchronously issues long-latency loads, whose results are buffered in the queue and used by the Consumer. This scheme drastically increases memory-level parallelism (MLP) to mitigate latency bottlenecks. In equal-area comparisons, GraphAttack outperforms OoO cores, do-all parallelism, prefetching, and prior decoupling approaches, achieving a 2.87× speedup and 8.61× gain in energy efficiency across a range of graph applications. These improvements scale; GraphAttack achieves a 3× speedup over 64 parallel cores. Lastly, it has pragmatic design principles; it enhances in-order architectures that are gaining increasing open-source support.

Deep learning technology is widely used in many modern fields and a number of models and software frameworks have been proposed. However, it is still very difficult to process deep learning tasks efficiently on traditional high performance computing (HPC) systems. In this paper, we propose swFLOW: a large-scale distributed framework for deep learning on Sunway TaihuLight. Based on the performance analysis results of convolutional neural network (CNN), we optimize the convolutional layer , and get 10.42× speedup compared to the original version. As for distributed training, we use elastic averaging stochastic gradient descent (EASGD) algorithm to reduce communication. On 512 processes, we get a parallel efficiency of 81.01% with communication period τ = 8 . Particularly, a decentralized implementation of distributed swFLOW system is presented to alleviate bottleneck of the central server. By using distributed swFLOW system, we can scale the batch size up to 4096 among 1024 concurrent processes for cancerous region detection algorithm . The successful application on swFLOW reveals the great opportunity for joint combination of deep learning and HPC system.

Online experiments are ubiquitous. As the scale of experiments has grown, so has the complexity of their design and implementation. In response, firms have developed software frameworks for designing and deploying online experiments. Ensuring that experiments in these frameworks are correctly designed and that their results are trustworthy---referred to as *internal validity*---can be difficult. Currently, verifying internal validity requires manual inspection by someone with substantial expertise in experimental design. We present the first approach for statically checking the internal validity of online experiments. Our checks are based on well-known problems that arise in experimental design and causal inference. Our analyses target PlanOut, a widely deployed, open-source experimentation framework that uses a domain-specific language to specify and run complex experiments. We have built a tool, PlanAlyzer, that checks PlanOut programs for a variety of threats to internal validity, including failures of randomization, treatment assignment, and causal sufficiency. PlanAlyzer uses its analyses to automatically generate *contrasts*, a key type of information required to perform valid statistical analyses over experimental results. We demonstrate PlanAlyzer's utility on a corpus of PlanOut scripts deployed in production at Facebook, and we evaluate its ability to identify threats to validity on a mutated subset of this corpus. PlanAlyzer has both precision and recall of 92% on the mutated corpus, and 82% of the contrasts it automatically generates match hand-specified data., 30 pages, hella long

During the implementation process of identification systems, multiple factors need to be considered at the same time. Due to the large amount of calculation and the randomness of the signal, the automatic identification capability of the machine is currently poor, especially for continuous signal. In order to solve this problem, a neuron fuzzy identification system was described based on a complex nonlinear mathematical model, which was designed from both hardware and software aspects of the system. The hardware architecture diagram was constructed based on the S3C:2440 microprocessor. The main modules include the power module, acquisition module, storage module, and output module. The DSP/BIOS system was used to construct the software framework diagram of the neuron fuzzy identification system to describe the identification process of video data stream, image data stream and control signal data. The software algorithm was designed based on the neuron fuzzy theory to establish a fuzzy similarity matrix and the best identification result was found by the maximum and minimum methods. The experimental results show that the designed system has higher recognition ability. When the frame length reaches 40 frames, the recognition rate increases to a larger value, the recognition rate is 75%, and the information is more accurate.

Substantial research is available on detectinginfluencerson social media platforms. In contrast, comparatively few studies exists on the role ofonline activists, defined informally as users who actively participate in socially-minded online campaigns. Automatically discovering activists who can potentially be approached by organisations that promote social campaigns is important, but not easy, as they are typically active only locally, and, unlike influencers, they are not central to large social media networks. We make the hypothesis that such interesting users can be found on Twitter within temporally and spatially localisedcontexts. We define these as small but topical fragments of the network, containing interactions about social events or campaigns with a significant online footprint. To explore this hypothesis, we have designed an iterative discovery pipeline consisting of two alternating phases of user discovery and context discovery. Multiple iterations of the pipeline result in a growing dataset of user profiles for activists, as well as growing set of online social contexts. This mode of exploration differs significantly from prior techniques that focus on influencers, and presents unique challenges because of the weak online signal available to detect activists. The paper describes the design and implementation of the pipeline as a customisable software framework, where user-defined operational definitions of online activism can be explored. We present an empirical evaluation on two extensive case studies, one concerning healthcare-related campaigns in the UK during 2018, the other related to online activism in Italy during the COVID-19 pandemic.

Differential privacy offers a formal framework for reasoning about the privacy and accuracy of computations on private data. It also offers a rich set of building blocks for constructing private data analyses. When carefully calibrated, these analyses simultaneously guarantee the privacy of the individuals contributing their data, and the accuracy of the data analysis results, inferring useful properties about the population. The compositional nature of differential privacy has motivated the design and implementation of several programming languages to ease the implementation of differentially private analyses. Even though these programming languages provide support for reasoning about privacy, most of them disregard reasoning about the accuracy of data analyses. To overcome this limitation, we present DPella, a programming framework providing data analysts with support for reasoning about privacy, accuracy, and their trade-offs. The distinguishing feature of DPella is a novel component that statically tracks the accuracy of different data analyses. To provide tight accuracy estimations, this component leverages taint analysis for automatically inferring statistical independence of the different noise quantities added for guaranteeing privacy. We evaluate our approach by implementing several classical queries from the literature and showing how data analysts can calibrate the privacy parameters to meet the accuracy requirements, and vice versa.

Robotic manipulation is fundamental to many realworld applications; however, it is an unsolved problem that remains a very active research area. New algorithms for robot perception and control are frequently proposed by the research community. These methods must be thoroughly evaluated in realistic conditions before they can be adopted by industry. This process can be extremely time consuming, mainly due to the complexity of integrating different hardware and software components.

Using large, multi-national datasets for high-performance medical imaging AI systems requires innovation in privacy-preserving machine learning so models can train on sensitive data without requiring data transfer. Here we present PriMIA (Privacy-preserving Medical Image Analysis), a free, open-source software framework for differentially private, securely aggregated federated learning and encrypted inference on medical imaging data. We test PriMIA using a real-life case study in which an expert-level deep convolutional neural network classifies paediatric chest X-rays; the resulting model’s classification performance is on par with locally, non-securely trained models. We theoretically and empirically evaluate our framework’s performance and privacy guarantees, and demonstrate that the protections provided prevent the reconstruction of usable data by a gradient-based model inversion attack. Finally, we successfully employ the trained model in an end-to-end encrypted remote inference scenario using secure multi-party computation to prevent the disclosure of the data and the model. Gaining access to medical data to train AI applications can present problems due to patient privacy or proprietary interests. A way forward can be privacy-preserving federated learning schemes. Kaissis, Ziller and colleagues demonstrate here their open source framework for privacy-preserving medical image analysis in a remote inference scenario.

Deep learning has sparked a renaissance in computer systems and architecture. Despite the breakneck pace of innovation, there is a crucial issue concerning the research and industry communities at large: how to enable neutral and useful performance assessment for machine learning (ML) software frameworks, ML hardware accelerators, and ML systems comprising both the software stack and the hardware. The ML field needs systematic methods for evaluating performance that represents real-world use cases and useful for making comparisons across different software and hardware implementations. MLPerf answers the call. MLPerf is an ML benchmark standard driven by academia and industry (70+ organizations). Built out of the expertise of multiple organizations, MLPerf establishes a standard benchmark suite with proper metrics and benchmarking methodologies to level the playing field for ML system performance measurement of different ML inference hardware, software, and services.

Edge computing technologies facilitate the deployment of services on nearby edge servers with a large number of end users and their mobile devices to fulfill personalized demands. Owing to frequent changes in user mobility and demands, service systems deployed in an edge–cloud environment must continuously adapt to ensure that the quality of service (QoS) perceived by the end users is maintained at a stable and satisfactory level. As it is difficult for system operation engineers to manually deal with such frequent and large-scale evolution due to problems of cost and efficiency, self-adaptation of the system is essential. In this paper, we present a programming framework for microservices (EPF4M) and an infrastructure for self-adaptive microservice systems (EI4MS) for the cloud–edge environment based on microservice architecture. Our study follows a “monitoring–analyzing–planning–execution” control loop that empowers the service systems to redeploy the services according to changes in the QoS. A two-phase strategy is adopted to minimize the side effects of the loop on the performance of the service system. A prototype of this framework and infrastructure has been open-sourced and verified through experiments conducted in a real cloud–edge environment. The results demonstrate the usefulness and advantages of our approach.

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.

In proton therapy, the knowledge of the proton stopping power, i.e. the energy deposition per unit length within human tissue, is essential for accurate treatment planning. One suitable method to directly measure the stopping power is proton computed tomography (pCT). Due to the proton interaction mechanisms in matter, pCT image reconstruction faces some challenges: the unique path of each proton has to be considered separately in the reconstruction process adding complexity to the reconstruction problem. This study shows that the GPU-based open-source software toolkit TIGRE, which was initially intended for X-ray CT reconstruction, can be applied to the pCT image reconstruction problem using a straight line approach for the proton path. This simplified approach allows for reconstructions within seconds. To validate the applicability of TIGRE to pCT, several Monte Carlo simulations modeling a pCT setup with two Catphan® modules as phantoms were performed. Ordered-Subset Simultaneous Algebraic Reconstruction Technique (OS-SART) and Adaptive-Steepest-Descent Projection Onto Convex Sets (ASD-POCS) were used for image reconstruction. Since the accuracy of the approach is limited by the straight line approximation of the proton path, requirements for further improvement of TIGRE for pCT are addressed.

The work is devoted to the research that was carried out within the framework of computer vision problems applicable to the analysis of images and video information with vehicles. We solve the problem of classifying vehicles. We analyze the drawbacks of Haar features and convolutional neural networks and test the obtained networks using the key point method; we construct an integral algorithm that includes several networks, and we further validate it on a large number of real photographs and types of vehicles. Next, we solve the task to develop a software framework for tracking vehicles by analyzing adjacent photographs from a video sequence. After that, we consider the tracking task in more detail. We analyze modern tracking algorithms using machine learning and describe our implemented tracker with support for the appearance of obstacles between the camera and a moving vehicle. As a result, we propose algorithms and open-source software that, after being configured for specific cameras, can be used in traffic analysis systems.

As a part of the future upgrade program of the Multi-Purpose Detector (MPD) experiment at the Nuclotron-Based Ion Collider Facility (NICA) complex, an Inner Tracking System (ITS) made of Monolitic Active Pixel Sensors (MAPSs) is proposed between the beam pipe and the Time Projection Chamber (TPC). It is expected that the new detector will enhance the experimental potential for the reconstruction of short-lived particles—in particular, those containing the open charm particle. To study the detector performance and select its best configuration, a track reconstruction approach based on a constrained combinatorial search was developed and implemented as a software toolkit called Vector Finder. This paper describes the proposed approach and demonstrates its characteristics for primary and secondary track finding in ITS, ITS-to-TPC track matching and hyperon reconstruction within the MPD software framework. The results were obtained on a set of simulated central gold–gold collision events at sNN=9 GeV with an average multiplicity of ∼1000 charged particles in the detector acceptance produced with the Ultra-Relativistic Quantum Molecular Dynamics (UrQMD) generator.

Domain-specific programming frameworks are usually effective to simplify the development of large-scale applications on supercomputers. This paper introduces a parallel programming framework named JCOGIN for particle transport on combinatorial geometry. JCOGIN provides a combinatorial geometry data model and a patch-based parallel computing model to manage the data distribution in parallel computing and implements the hybrid parallelism of the domain decomposition and the particle parallelism on MPI/OpenMP to overcome the bottleneck of huge memory demand and long computational time. The application programming interface of JCOGIN can support users to quickly develop their parallel particle transport applications. Based on this framework, users only need to write serial codes for large-scale numerical simulations on modern supercomputers. The parallel efficiency of applications based on JCOGIN can reach up to 80% on hundreds of thousands of CPU cores.

This paper presents an extension to a software framework designed to evaluate the efficiency of different software and hardware-accelerated virtual switches, each commonly adopted on Linux to provide virtual network connectivity to containers in high-performance scenarios, like in Network Function Virtualization (NFV). We present results from the use of our tools, showing the performance of multiple high-performance networking frameworks on a specific platform, comparing the collected data for various key metrics, namely throughput, latency and scalability, with respect to the required computational power.

The standardization of the physical aspects of nanosatellites (also known as CubeSats) and their wide adoption in academia and industry has made the mass production and availability of off-the-shelf components possible. While this has led to a significant reduction in satellite development time, the fact remains that a considerable amount of mission development time and effort continues to be spent on flight software development. The CubeSat’s agile development environment makes it challenging to utilize the advantages of existing software frameworks. Such an adoption is not straightforward due to the added complexity characterized by a steep learning curve. A well-designed flight software architecture mitigates possible sources of failure and increases mission success rate while maintaining moderate complexity. This paper presents a novel approach to a flight software framework developed specifically for nanosatellites. The software framework is characterized by simplicity, reliability, modularity, portability, and real-time capability. The main features of the proposed framework include providing a standardized and explicit skeleton for each module to simplify their construction, offering standardized interfaces for all modules to simplify communication, and providing a collection of ready-to-use common services open for further enhancement by CubeSat software developers. The framework efficiency was demonstrated through a software developed for the MeznSat mission that was successfully launched into Low Earth Orbit in September 2020. The proposed software framework proved to simplify software development for the application developer while significantly enhancing software modularity.

We present the scope, concepts, data structures and application programming models of the open-source Lattice Boltzmann library Palabos. Palabos is a C++ software platform developed since 2010 for Computational Fluid Dynamics simulations and Lattice Boltzmann modeling, which specifically targets applications with complex, coupled physics. The software proposes a very broad modeling framework, capable of addressing a large number of applications of interest in the Lattice Boltzmann community, yet exhibits solid computational performance. The article describes the philosophy of this programming framework and lists the models already implemented. Finally, benchmark simulations are provided which serve as a proof of quality of the implemented core functionalities.

To improve the programming efficiency of automatic assembly system, a novel skill programming framework based on task learning is proposed for modular assembly system in this paper. In this framework, the motion sequence of assembly skills can be modeled by demonstration data. And the assembly task is represented hierarchically. A complete assembly process of a part is divided into several skills, and each skill is divided into several sequential assembly motion primitives (AMP) of multiple modules. Then, a learning method of assembly motion sequence based on Hidden Markov Model is proposed, and the maximum probability method is used to generate the optimal sequential AMP. Each AMP is input to the assembly system in the form of instruction to complete the assembly. Aiming at the problem of accurate positioning and trajectory planning, visual guidance and direct teaching method are used to settle this problem. To evaluate the viability of the proposed framework, a customized modular assembly system is used to acquire the demonstration data, and a graphical user interface (GUI) software is designed. Five assembly skills are learned. Experimental are conducted to validate the effectiveness of the proposed method.

In recent years, on-line processing of data streams (DaSP) has been established as a major computing paradigm. This is due mainly to two reasons: first, more and more data that are generated in near real-time need to be processed; the second reason is given by the need of efficient parallel applications. However, the above-mentioned areas expose a tough challenge over traditional data-analysis techniques, which have been forced to evolve to a stream perspective. In this work, we apply a novel multiple back end programming framework for stream data and task based parallelism to a multi-staged diffusion magnetic resonance imaging (MRI) toolkit, named pHARDI. The results demonstrate the benefits of using our framework in terms of performance and memory usage. The evaluation carried out also depicts that the speed-up of our parallel framework increases with the problem size. This work was supported by the EU project \ASPIDE: Exascale Programming Models for Extreme Data Processing" under grant 801091 and project TIN2016-79637-P \Towards unification of HPC and Big Data Paradigms" from the Spanish Ministry of Economy and Competitiveness of Spain. This research was partially supported by Madrid regional Government (Spain) under the grant \Convergencia Big data-Hpc: de los sensores a las Aplicaciones. (CABAHLA-CM)" Ref: S2018/TCS-4423.

In clinical scenarios, there is an increasing interest in complex computational experiments, as for example the training of Deep Learning models. Reproducibility is an essential property of such experiments, especially if the result contributes to a patient’s treatment. This paper introduces Curious Containers, a software framework for computational reproducibility that treats data, software and runtime environment as decentralized network resources. All experiment resources are described in a single file, using a new format that is compatible with a subset of the Common Workflow Language. Docker is used to deploy the experiment software in a container image, including arbitrary data transmission programs to connect with existing storage solutions. The framework supports Deep Learning applications, that have a high demand in storage and processing capabilities. Large datasets can be mounted inside containers via network filesystems like SSHFS based on the filesystem in user-space technology. The Nvidia-Container-Toolkit enables GPU usage. Curious Containers has been tested in two biomedical scenarios. The first use case is a Deep Learning application for tumor classification in images that requires a large dataset and a GPU. In this context, a prototypical integration of the framework with the existing Data Version Control system for exploratory Deep Learning modeling has been developed. The second use case extends an existing container image, including a scientific workflow for detection and comparison of human protein in mass spectrography data. The container image was originally developed for an archiving platform and could be extended to be compatible with both Curious Containers and cwltool, the Common Workflow Language reference implementation. The presented solution allows for consistent description and execution of computational experiments, while trying to be both flexible and interoperable with existing software and standards. Support for Deep Learning experiments is gaining importance as such systems are increasingly validated as medical decision support systems.

This article describes the development of a software architectural framework for implementing compute-aware control systems, where the term “compute-aware” describes controllers that can modify existing low-level computing platform power managers in response to the needs of the physical system controller. This level of interaction means that high-level decisions can be made as to when to operate the computing platform in a power-savings mode or a high-performance mode in response to situation awareness of the physical system. The framework is demonstrated experimentally on a mobile robot platform. In this example, a situation-aware governor is developed that adjusts the speed of the processor based on the physical performance of the robot as it traverses a path through obstacles. The results show that the situation-aware governor results in overall power savings of up to 38.9 percent with 1.3 percent degradation in performance compared to the static high-power strategy.

Economic nonlinear model predictive control (NMPC) is a variant of NMPC that directly optimizes an economic performance index instead of a tracking error. Although economic NMPC can achieve excellent closed-loop performance, the associated computational effort as well as the difficulty of guaranteeing stability in practice are its main drawbacks. Motivated by these difficulties, a formal procedure was developed that tunes a tracking (non)linear MPC scheme so that it is first-order equivalent to economic NMPC. This letter introduces TuneMPC, a new open-source software framework that closes the gap between the underlying theory and practical application of this tuning procedure. For user-provided system dynamics, constraints and economic objective, TuneMPC enables automated computation of optimal steady states and periodic trajectories, and returns the corresponding tuned stage cost matrices. To demonstrate the potential of the tool, we apply the technique to the challenging example of an autonomous tethered aircraft flying periodic orbits for airborne wind energy harvesting.

In common design pattern collections, e.g., design pattern books, design patterns are documented with templates that consist of multiple attributes, such as intent, structure, and sample code. To adapt to modern developers, the depictions of design patterns, especially some specific attributes, should advance with the current programming technologies, for example, “known uses”, which exemplifies the use scenarios of design patterns in practice, and “related patterns”, which describes the relatedness between a design pattern and the others within a context. However, it is not easy to update the contents of these attributes manually due to the diversity of the programming technologies. To address this problem, in this work, we conducted a case study to mine design pattern use scenarios and related design pattern pairs from Stack Overflow posts to enrich the two attributes. We first extracted the question posts relevant to each design pattern by identifying the design pattern tags. Then, the topics of the posts were discovered by applying topic modeling techniques. Finally, by analyzing the topics specified for each design pattern, we detected 195 design pattern use scenarios and 70 related design pattern pairs, involving 61 design patterns totally. These findings are associated with a variety of popular software frameworks and programming techniques. They could complement the existing design pattern collections and help developers better acknowledge the usage and relatedness of design patterns in today’s programming practice.

SUMMARYThis paper proposes an approach for the high-level programming of co-designed robots that reduces programming complexity. Particularly, the work presented focuses on the programming framework of an intelligent system, based on the IEEE Standard Ontologies for Robotics and Automation, which allows users the automatic design of robots and the automatic implementation of controllers in the Robot Operating System (ROS). In our approach, the co-designed robot functionalities are automatically translated into visual programming blocks allowing non-expert users an easy robot programming by means of a visual programming language. Several robot configurations and three case studies are provided as a proof of concept. The validation, in terms of usability, of the framework has been carried out with inexperienced users showing promising results.

Analyzing real-world software is challenging due to complexity of the software frameworks or APIs they depend on. In this paper, we present a tool, PROMPT, that facilitates the analysis of software components using API model guided symbolic execution. PROMPT has a specification component, PROSE, that lets users define an API model, which consists of a set of data constraints and life-cycle rules that define control-flow constraints among sequentially composed API functions. Given a PROSE model and a software component, PROMPT symbolically executes the component while enforcing the specified API model. PROMPT has been implemented on top of the KLEE symbolic execution engine and has been applied to Linux device drivers from the video, sound, and network subsystems and to some vulnerable components of BlueZ, the implementation of the Bluetooth protocol stack for the Linux kernel. PROMPT detected two new and four known memory vulnerabilities in some of the analyzed system software components.

Emergent paradigms of Industry 4.0 and Industrial Internet of Things expect cyber-physical systems to reliably provide services overcoming disruptions in operative conditions and adapting to changes in architectural and functional requirements. In this paper, we describe a hardware/software framework supporting operation and maintenance of software-controlled systems enhancing resilience by promoting a Model-Driven Engineering (MDE) process to automatically derive structural configurations and failure models from reliability artifacts. Specifically, a reflective architecture developed around digital twins enables representation and control of system Configuration Items properly derived from SysML Block Definition Diagrams, providing support for variation. Besides, a plurality of distributed analytic agents for qualitative evaluation over executable failure models empowers the system with runtime self-assessment and dynamic adaptation capabilities. We describe the framework architecture outlining roles and responsibilities in a System of Systems perspective, providing salient design traits about digital twins and data analytic agents for failure propagation modeling and analysis. We discuss a prototype implementation following the MDE approach, highlighting self-recovery and self-adaptation properties on a real cyber-physical system for vehicle access control to Limited Traffic Zones.

Technology has changed our life and the way we work; however, technology has affected several methods of working in Small and Medium Enterprises (SME)s. Human Resource (HR) is one of the core components in businesses, and nowadays most businesses are using technology for daily basis tasks. However, it still is not used all over the world. In Kurdistan Region-Iraq (KRI), most of the SMEs still use the old way of working and follow the paper-based method for their daily basis tasks. According to a survey, more than seventy percent of SMEs in Kurdistan are not using software to manage human resource management tasks. However, some big companies are using HRMS; but even then, there is a lack of use of Cloud Technology. In this study, a model of the Enterprise Human Resource Management System (EHRMS) is proposed and implemented to solve the HR problems in this area using Cloud Technology. The proposed system consists of sixteen standard modules which used usually with famous HRM systems. The system has been developed by using several technologies such as CodeIgniter as a software framework. The system is launched and deployed on Amazon Web Service (AWS) Elastic Compute Cloud (EC2).

In aiming to create added intelligence for Things interfacing with IoT principles in the form of Services, Smart Heating Management is consistently a field of promising research. In the currently demonstrated work, an approach will be described for an operational software framework of modular components that can create intelligence in Housing Units as those presented in our scenario. The framework is based on the lightweight Case Based Reasoning approach and principles in order to describe the Problem and Solution of heating management, as well as to extract knowledge from generic historical data. Collaboration between houses is included through the sharing of anonymized high level problem-solution data, as an instantiation of the same social learning principles that govern human behavior and enable Knowledge diffusion. The approach is validated through historical data acquired in two time periods from the Camden (London) community residencies and demonstrates an average of 22% savings in boiler active time. Knowledge sharing is also analyzed along with the benefits and pitfalls it might produce.

A parallel framework software, CCFD, based on the structure grid, and suitable for parallel computing of super-large-scale structure blocks, is designed and implemented. An overdecomposition method, in which the load balancing strategy is based on the domain decomposition method, is designed for the graph subdivision algorithm. This method takes computation and communication as the limiting condition and realizes the load balance between blocks by dividing the weighted graph. The fast convergence technique of a high-efficiency parallel geometric multigrid greatly improves the parallel efficiency and convergence speed of CCFD software. This paper introduces the software structure, process invocations, and calculation method of CCFD and introduces a hybrid parallel acceleration technology based on the Sunway TaihuLight heterogeneous architecture. The results calculated by Onera-M6 and DLR-F6 standard model show that the software structure and method in this paper are feasible and can meet the requirements of a large-scale parallel solution.

This article describes the AutoMATiC software system that generates the C code of software implementation of model predictive control algorithms for a chosen target microcontroller. The following components of the AutoMATiC tool are described: the system structure, workflow, and software framework. The system includes a transcompiler, a simulator, and a profiler. To discuss effectiveness of the system, a dynamic process with two inputs and two outputs is considered. The following advantages of the AutoMATiC system are emphasized: simplicity of use, the possibility of activating/deactivating online different control algorithms in a seamless way, the possibility of adding new control algorithms in a straightforward way, and code efficiency.

With the development of remote sensing and large-scale environmental modelling, large amount of environmental data are continuously becoming available. An intuitive and comprehensive visualization of these data could facilitate data exploration, communication and collaboration between the stakeholders for informed decisions making. In Poyang lake basin regions, we demonstrate how to develop a software platform that can visualize three-dimensionally environmental data layers including terrain, weather, river net, water level, land use changes and interrelations between these data layers for environmental system monitoring and decision supporting. The tool is built by combining several prevailing projects including Unity, Paraview, and hydrological models, etc. We develop an open standardized framework for the software tool to host environmental data layers permitting the application of the tool, which could be employed for the intuitive and comprehensive data visualization in other regions facing environmental challenges.

This paper describes the genesis and early history of the F# programming language. I start with the origins of strongly-typed functional programming (FP) in the 1970s, 80s and 90s. During the same period, Microsoft was founded and grew to dominate the software industry. In 1997, as a response to Java, Microsoft initiated internal projects which eventually became the .NET programming framework and the C# language. From 1997 the worlds of academic functional programming and industry combined at Microsoft Research, Cambridge. The researchers engaged with the company through Project 7, the initial effort to bring multiple languages to .NET, leading to the initiation of .NET Generics in 1998 and F# in 2002. F# was one of several responses by advocates of strongly-typed functional programming to the "object-oriented tidal wave" of the mid-1990s. The development of the core features of F# 1.0 happened from 2004-2007, and I describe the decision-making process that led to the "productization" of F# by Microsoft in 2007-10 and the release of F# 2.0. The origins of F#'s characteristic features are covered: object programming, quotations, statically resolved type parameters, active patterns, computation expressions, async, units-of-measure and type providers. I describe key developments in F# since 2010, including F# 3.0-4.5, and its evolution as an open source, cross-platform language with multiple delivery channels. I conclude by examining some uses of F# and the influence F# has had on other languages so far.

Using graphic processing units (GPUs) in parallel with central processing unit in order to accelerate algorithms and applications demanding extensive computational resources has been a new trend used for the last few years. In this paper, we propose a GPU-accelerated method to parallelize different Computer vision tasks. We will report on parallelism and acceleration in computer vision applications, we provide an overview about the CUDA NVIDIA GPU programming language used. After that we will dive on GPU Architecture and acceleration used for time consuming optimization. We introduce a high-speed computer vision algorithm using graphic processing unit by using the NVIDIA’s programming framework compute unified device architecture (CUDA). We realize high and significant accelerations for our computer vision algorithms and we demonstrate that using CUDA as a GPU programming language can improve Efficiency and speedups. Especially we demonstrate the efficiency of our implementations of our computer vision algorithms by speedups obtained for all our implementations especially for some tasks and for some image sizes that come up to 8061 and 5991 and 722 acceleration times.

With the continuous improvement of modern surveying and mapping technology and with the plentiful of achievements, traditional quality inspection software for single machine, single task and single data type, difficult to massive multi-source isomerization achievements, difficult to meet the requirement of rapid, accurate and efficient quality inspection. With the development of IT technology such as cloud computing, big data and artificial intelligence, the quality inspection software needs to combine cloud computing technology with quality inspection business, refactoring software framework. Facing to the storage and spatial query requirement of inspection for surveying and mapping products, the paper researches and designs the spatial data distributed storage and the spatial data distributed index in cloud platform. The Management of inspection rule is the core in cloud platform. Inspection rule is the minimum operating independent unit, which becomes inspection item by parameterization, the paper builds full run-time operating mechanism in cloud platform for inspection rule. Finally, Combining the inspection requirement for surveying and mapping products and business, the paper researches and design the cloud framework for surveying and mapping products.

BornAgain is a free and open-source multi-platform software framework for simulating and fitting X-ray and neutron reflectometry, off-specular scattering, and grazing-incidence small-angle scattering (GISAS). This paper concentrates on GISAS., BornAgain is a free and open-source multi-platform software framework for simulating and fitting X-ray and neutron reflectometry, off-specular scattering, and grazing-incidence small-angle scattering (GISAS). This paper concentrates on GISAS. Support for reflectometry and off-specular scattering has been added more recently, is still under intense development and will be described in a later publication. BornAgain supports neutron polarization and magnetic scattering. Users can define sample and instrument models through Python scripting. A large subset of the functionality is also available through a graphical user interface. This paper describes the software in terms of the realized non-functional and functional requirements. The web site https://www.bornagainproject.org/ provides further documentation.

The goal of this work is an comprehensive experimental validation and verification of a computational CFD-DEM software platform. The software platform's modules and performance requirements specifically address the needs of pharmaceutical industry in terms of batch size (i.e., number of particles) and related phenomena (i.e., physical complexity). Moreover, we critically assessed the numerical models implemented. In addition to the review of relevant literature and selection of validation experiments, novel analytical solutions for the spray class in question are presented. As the presented method is independent of the spray model, the solution can be used to prove the correct implementation of various available spray models. The final outcome of this work is a validated software framework, which can be further used to investigate large-scale processes by resolving single particle trajectories in a coupled environment, including heat, mass and momentum transfer.

Big data is a ”relative” concept. It is the combination of data , application , and platform properties. Recently, big data specific technologies have emerged, including software frameworks, databases, hardware accelerators, storage technologies, etc. However, the automatic selection of these solutions for big data computations remains a non-trivial task. Presently, the big data tools are selected by analyzing the problem manually, or by using several performance prediction techniques. The manual identification is based on the data properties only, whereas the performance predictors only estimate basic execution metrics without linking them with big data (3Vs) thresholds. Hence, both ways of identification are mostly incorrect, which can lead to inefficient use of 3Vs optimizations, resulting into global inefficiency, reduced system performance, increasing power consumption, requiring greater effort on the part of the programming team, and misallocation of the hardware resources required for the task. In this regard, a novel framework has been proposed for automatic detection of 3Vs (Volume, Velocity, Variety) of big data, using machine learning. The detection is done through static code features , data , and platform properties , leading to relevant tool selection, and code generation, with minimal overheads, lesser programmer interventions, higher usability, and portability. Instead of handling each application with big data specialized solutions, or manually identifying the 3Vs, the framework can automatically detect and link the 3Vs to the relevant optimizations. Several standard applications have been tested using the proposed framework. In the case of volume, the average detection accuracy is up to 97.8% for seen and 95.9% for unseen applications. In the case of velocity, the average detection accuracy is up to 97.3% for seen and 92.6% for unseen applications. There is no margin of error in variety detection, as it has straightforward computations without any predictions. Furthermore, an airline recommendation system case study strengthens the effectiveness of the proposed approach.