Enabling Performance Modeling for the Masses: Initial Experiences

Software design stage is an important phase in the software development process, resulting in a design specification document for further use in program development. In order to produce a quality product that fulfills the user requirements, designs are usually therefore proposed through the creation of models to cover the various aspects of the system design criteria. Consistency property checking among design models and their components is one of the software design serious issues since the conflict may occur among design models which may bring an incorrect result. This research presents a consistency verification method based on the proposed rules constructed from the relationship among design models; functional model, structural model, window navigation diagram and user interface design.

There exists a large body of work on the specification and detection of anti-patterns in the source code of software systems. However, there are very few studies on the origins of the occurrences of anti-patterns in the source code: do the very design of the systems lead to the occurrences of anti-patterns or are anti-patterns introduced during implementation? Knowing when anti-patterns are introduced could help software designers and developers improve the quality of the source code, for example by eliminating fault-prone anti-patterns early during the design of the systems, even before their implementation. Therefore, we detect occurrences of anti-patterns in design models and in the source code of some systems, trace these occurrences between design and implementation, and study their relation and impact on the source code. First, we analyze both the UML design models and the source code of 10 open-source systems and show that antipatterns exist in design models. We observe that, on average, 37% of the classes in the design models that belong to anti-patterns also exist in the source code and also play roles in the same anti-patterns. Second, we investigate two open-source systems to assess the impact of the anti-patterns in their design models on the source code in terms of changes and faults. We show that classes that have anti-patterns in the design models have more changes and faults in the source code. Our results suggest that the design of the systems lead to anti-patterns and that the antipatterns impact negatively the change-and fault-proneness of the classes in the source code. Thus, designers should be wary of anti-patterns in their design models and could benefit from tools that detect and trace these anti-patterns into the source code.

Real-time analysis and modeling of users for improving engagement, and interaction is a burgeoning area of interest with applications to web sites, social networks and mobile applications. Apart from scalability issues, this domain poses a number of modeling and algorithmic challenges. In this talk, as an illustrative example, we present DAL, a system that leverages real-time user activity/signals for dynamic ad loads, and designed to improve the overall user experience on YouTube. This system uses machine learning to optimize for user activity during a visit and helps decide on real-time advertising policies dynamically for the user. We conclude the talk with challenges and opportunities in this important area of real-time user analysis and social modeling.

Web systems are becoming more and more popular. An efficiently working network system is the basis for the functioning of every enterprise. Performance models are powerful tools for performance prediction. The creation of performance models requires significant effort. In the article, we want to present various performance models of customer and Web systems. In particular, we want to examine a system behaviour related to different flow routes of clients in the system. Therefore we propose Queueing Petri Nets, the new modeling methodology for dealing with performance issues of production systems. We follow the simulation-based approach. We consider 25 different models to check performance. Then we evaluate them based on the proposed metrics. The validation results show that the model is able to predict the performance with a relative error lower than 20%. Our evaluation shows that prepared models can reduce the effort of production system preparation. The resulting performance model can predict the system behaviour in a particular layer at the indicated load.

Software performance engineering supports software architects to identify potential performance problems, such as bottlenecks, in their software systems during the design phase. In such early stages of the software life-cycle, only little information is available about the system's implementation and execution environment. However, these details are crucial for accurate performance predictions. Performance completions close the gap between available high-level models and required low-level details. Using model-driven technologies, transformations can include details of the implementation and execution environment into abstract performance models. Existing approaches do not consider the relation of actual implementations and performance models used for prediction. Furthermore, they neglect the broad variety of implementations and middleware platforms, possible configurations, and varying usage scenarios. To allow more accurate performance predictions, we extend classical performance engineering by automated model refinements based on a library of reusable performance completions. We use model-driven techniques, more specifically higher-order transformations, to implement and automatically integrate performance completions in the context of the Palladio Component Model. With our tool set, software architects can model an application in a language specific to their domain. They can annotate the model elements that require further refinement. Higher-order transformations then apply the selected completion with its configuration. In a case study of a middleware configuration, we illustrate the benefit of performance completions with respect to the accuracy of performance predictions.

The model-based real-time optimization (MRTO) of heating, ventilation, and air-conditioning (HVAC) systems is an efficient tool for improving energy efficiency and for effective operation. Model-based real-time optimization of HVAC systems needs to regularly optimize the set points for local-loop operation, taking into account the interactions between HVAC components with the help of system-performance models. MRTO relies on the accuracy of the performance model to provide reliability in decision making. In practice, due to high diversity in ambient conditions and load demands, system-model mismatches are difficult to avoid. This paper presents an adaptive, model-based, real-time optimization (AMRTO) approach for large-scale, complex HVAC systems, to counter any model mismatches by updating the performance model in real time with real-time measurements. Furthermore, to make this approach practically applicable and to keep the online training process computationally manageable, an empirical-physical model of HVAC system components was set up that is suitable for online training, and hybrid genetic algorithms (HGAs) method was used for faster, yet reliable, online training of the performance model. A case study was used to evaluate the performance of the proposed approach. The results demonstrated that the proposed AMRTO was able to provide energy saving approximately 8% and reduce the online computational burden by 99%.

Whether the developed software system completed all functions in the software design specification and consistent with the design algorithm is an important work in software testing. Analysis of the source code artificial and verify whether the software system is to meet the requirements of the design specification is laborious job. Testers need to have rich experience in programming and strong ability of algorithm analysis. This paper proposes a method to verify consistency of software implementation and design based on function call path. The method can be summarized as analyze the calling relationship of functions from design specifications and source code, extraction function calling path, generation function cluster model. In documents aspect, the function calling relationship can be got by manual analysis of the design specification, then the designed function cluster model can be generated automatically. We can get function calling relationship, function features by static analysis of source code and the specific implementations of function with those features. Finally, compare the two function cluster model to verify that the consistency of software implementation and design. The experimental results showed that this method can obtain the system function structure and algorithm features accurately, make effective judgment of the consistency of the design specification and the software implementation, provides a new way to verify the consistency of software implementation and design.

Cyber-Physical-Social Systems (CPSS) epitomize the modern era’s intelligent connectivity. They integrate physical devices, computer networks, and social networks, forming an innovative paradigm for intelligent systems. Utilizing CPSS to enhance intelligence, automation, and remote services in healthcare represents a primary research focus. Pulmonary embolism, a prevalent condition resulting from the blockage of the pulmonary artery and its branches by emboli, leads to a spectrum of clinical syndromes marked by impaired pulmonary circulation and right heart dysfunction, contributing to sudden and unpredictable fatalities. Nevertheless, the diagnosis of pulmonary embolism remains challenging due to non-specific clinical presentations, constrained diagnostic capabilities, delayed diagnoses, insufficient physician knowledge, and suboptimal diagnostic techniques. Consequently, we introduce the innovative LSCU-Net architecture within the CPSS framework, designed to develop an automated segmentation and intelligent assessment system for pulmonary embolism, facilitating its automated and intelligent detection. The experimental findings demonstrate that the model accurately segments pulmonary embolism, evidenced by a Jaccard index of 0.6958, a Dice coefficient of 0.8193, a Mean Pixel Accuracy (mPA) of 0.8519, and an accuracy of 0.9993. Empirical studies reveal that our proposed model substantially surpasses existing models in performance. Consequently, this model can aid physicians in the diagnosis of pulmonary embolism during clinical practice. The established pulmonary embolism automatic segmentation and assessment system also showcases the application successes of CPSS in intelligent remote healthcare. The system’s development and deployment not only streamline physicians’ diagnostic processes but also elevate public health standards and advance CPSS research within the medical domain.

Performance of a software system is the result of many interacting factors. This paper describes a rule-based framework to identify root causes of performance limits, to untangle the effects of the system configuration (such as the allocation of processors) from limits imposed by the software design, and to recommend both configuration and design improvements. The framework uses a performance model which represents (and is derived from) a UML design model, and applies transformations to the given performance model to obtain another improved one. The improvements imply configuration and design changes which can be applied to the system. This paper describes the approach and demonstrates feasibility by applying a small set of rules to the design of a web application.

In the design of a chemical process (CP), certain design specifications (for example, those related to process economics, process performance, safety, and the environment) must be satisfied. During the operation of the plant, because design models have uncertainties associated with them, we need to ensure that, within the region of uncertainty, all design specifications are satisfied. In recent years, research has focused on the investigation of the process flexibility (Biegler et al. Systematic Methods of Chemical Process Design; Prentice Hall: Englewood Cliffs, NJ, 1997) based on the feasibility function (Halemane and Grossmann AIChE J. 1983, 29 (3), 425) which is a measure of the CP's ability to meet design specifications under uncertainty. Several researchers have proposed methods for calculating the process feasibility function, which involves solving a very complex multiextremal and nondifferentiable optimization problem. Current methods for calculation of the flexibility function use an enumeration procedure (explicit or implicit), which in the worst case can require a large number of iterations. To try to address this issue, in this paper, we have introduced an efficient approach, which avoids enumeration. Through examples, we have shown that the new method leads to a small number of iterations and has low CPU requirements.

IP multimedia subsystems (IMS) is using session initiation protocol (SIP) as signalling protocol. SIP is becoming computing intensive and hence the ability of entry and exit proxies to process SIP messages has great impact on the overall performance of the IMS core network. This paper shows that the flow of SIP messages during handover process in the IMS core network complies with the well known central server model. The later is validated via discrete event simulation results. The performance prediction study reveals that S-CSCF is the bottleneck device of the IMS core network processing a large number of SIP messages.

Software architects seek efficient support for planning and designing models at multiple levels of abstraction and from different perspectives. For this it is desirable that software design tools support both informal and formal representation of design, and also support their combination and the transition between them. Furthermore, software design tools should be able to provide features for collaborative work on the design. OctoUML supports the creation of software models at various levels of formality, collaborative software design, and multi-modal interaction methods. By combining these features, OctoUML is a prototype of a new generation software design environment that aims to better supports software architects in their actual software design and modelling processes.Demo video URL: https://youtu.be/fsN3rfEAYHwOctoUML Project URL: https://github.com/Imarcus/OctoUML

Thermal management is evolving as a major challenge in the design of current and future more and all electric aircraft (M/AEA). These aircraft have ever increasing numbers of onboard heat sources, higher heat loads from integration of advanced intelligence, surveillance and reconnaissance (ISR) sensors and directed energy weapons, limited and even decreasing numbers of heat sinks, the use of composite materials, etc. The associated challenges have pushed the conventional thermal management systems and their components to the limit. More efficient methods of thermal management must be implemented to ensure that the M/AEA aircraft do not overheat and prematurely abort their missions. Crucial to this effort is the need to consider advanced heat exchanger concepts, comparing their designs and performance with those of the conventional compact exchangers currently used for onboard aircraft thermal management systems. The present work identifies two promising advanced concepts, namely, microchannel heat exchangers and phase change thermal energy storage systems. Detailed conceptual design and performance models are developed for these as well as a conventional plate-fin compact heat exchanger, and their design and performance optimized for minimum dry weight. In this paper, results of these studies are presented along with comparisons with current systems, conclusions, and recommendations for future research. The results show that microchannel heat exchangers and phase change energy storage systems offer potentially significant performance benefits for aircraft thermal management.

With the growth of social media, embedded sensors, and “smart” devices, those responsible for managing resources during emergencies, such as weather-related disasters, are transitioning from an era of data scarcity to data deluge. During a crisis situation, emergency managers must aggregate various data to assess the situation on the ground, evaluate response plans, give advice to state and local agencies, and inform the public. We make the case that social graph analysis and natural language modeling in real time are paramount to distilling useful intelligence from the large volumes of data available to crisis response personnel. Using ground truth information from social media data surrounding the 2012 Hurricane Sandy in New York City, we test and evaluate our real-time analytics platform to identify immediate and critical information that increases situational awareness during disastrous events.

Simulation is a common approach for assisting system design and optimization. For system-wide optimization, energy and computational resources are often the two most critical limitations. Modeling energy-states of each hardware component and time spent in each state is needed for accurate energy and performance prediction. Tracking software execution in a realistic operating environment with properly modeled input/output is key to accurate prediction. However, the conventional approaches can have difficulties in practice. First, for a complex system such as an Android smartphone, building a cycle-accurate simulation environment is no easy task. Secondly, for I/O-intensive applications, a slow simulation would significantly alter the application behavior and change its performance profile. Thirdly, conventional software profiling tools generally do not work on simulators, which makes it difficult for performance analysis of complicated software, e.g., Java applications executed by the Dalvik virtual machine. Recently, virtual machine technologies are widely used to emulate a variety of computer systems. While virtual machines do not model the hardware components in the emulated system, we can ease the effort of building a simulation environment by leveraging the infrastructure of virtual machines and adding performance and power models. Moreover, multiple sets of the performance and energy models can be selectively used to verify if the speed of the simulated system impacts the software behavior. Finally, performance monitoring facilities can be integrated to work with profiling tools. We believe this approach should help overcome the aforementioned difficulties. We have prototyped a framework and our case studies showed that the information provided by our tools are useful for software optimization and system design for Android smartphones.