Abstract Users of cloud computing technology can lease resources instead of spending an excessive charge for their ownership. For service delivery in the infrastructure-as-a-service model of the cloud computing paradigm, virtual machines (VMs) are created by the hypervisor. This software is installed on a bare-metal server, called the host, and acted as a broker between the hardware of the host and its VMs. The host is responsible for the allocation of required resources, such as CPU, RAM and network bandwidth, for VMs. Therefore, allocating resources to a VM is equivalent to finding the location of the VM on the hosts. In this paper, we propose a model for resource allocation of a datacenter that includes clusters of hosts. This model is based on the birth–death process of queueing systems and continuous-time Markov chains. We will focus on RAM-intensive VMs and consider the allocation of RAM for a VM as a job in the queueing systems. The purpose of this modeling is to keep the number of running hosts minimum while guaranteeing the quality of service in terms of response. When the utilization of active hosts reaches a predefined threshold value, a new host is added to prevent response time violation, and when host utilization is reduced to a certain threshold, one of the hosts can be deactivated. The experimental results show that, in the long run, the odds of working with more jobs are increased.

A software system evolves over time in order to meet the needs of users. Understanding a program is the most important step to apply new requirements. Clustering techniques through dividing a program into small and meaningful parts make it possible to understand the program. In general, clustering algorithms are classified into two categories: hierarchical and non-hierarchical algorithms (such as search-based approaches). While clustering problems generally tend to be NP-hard, search-based algorithms produce acceptable clustering and have time and space constraints and hence they are inefficient in large-scale software systems. Most algorithms which currently used in software clustering fields do not scale well when applied to large and very large applications. In this paper, we present a new and fast clustering algorithm, FCA, that can overcome space and time constraints of existing algorithms by performing operations on the dependency matrix and extracting other matrices based on a set of features. The experimental results on ten small-sized applications, ten folders with different functionalities from Mozilla Firefox, a large-sized application (namely ITK), and a very large-sized application (namely Chromium) demonstrate that the proposed algorithm achieves higher quality modularization compared with hierarchical algorithms. It can also compete with search-based algorithms and a clustering algorithm based on subsystem patterns. But the running time of the proposed algorithm is much shorter than that of the hierarchical and non-hierarchical algorithms. The source code of the proposed algorithm can be accessed athttps://github.com/SoftwareMaintenanceLab.

Abstract Most important scientific and engineering applications have complex computations or large data. In all these applications, a huge amount of time is consumed by nested loops. Therefore, loops are the main source of the parallelization of scientific and engineering programs. Many parallelizing compilers focus on parallelization of nested loops with uniform dependences, and parallelization of nested loops with non-uniform dependences has not been extensively investigated. This paper addresses the problem of parallelizing two-level nested loops with non-uniform dependences. The aim is to minimize the execution time by improving the load balancing and minimizing the inter-processor communication. We propose a new tiling algorithm, k-StepIntraTiling, using bin packing problem to minimize the execution time. We demonstrate the effectiveness of the proposed method in several experiments. Simulation and experimental results show that the algorithm effectively reduces the total execution time of several benchmarks compared to the other tiling methods.

Probabilistic model checking is an automated technique for the verification of systems that exhibit stochastic behavior. Iterative numerical methods are usually used to solve quantitative verification problems of probabilistic models. In this paper, we consider Markov Decision Processes and propose three techniques to improve the performance of the iterative methods. While several methods have been proposed to improve the performance of the standard iterative methods, their performance depends on the structure of the models, and they are more useful for acyclic models. In contrast, we propose several heuristic methods to improve the performance of the standard iteration methods that are more useful for cyclic models. The first heuristic method prioritizes states according to their impact on the other states. The second prioritizes transitions according to their probability. In these two approaches, low priority states and transitions can be avoided in some iterations while the method reuses related values from the previous iteration. The third method reorders the information of the model to improve the memory access and reduce the impact of cache latency. Experimental results demonstrate that our methods outperform other iterative approaches for most case studies.

Clustering (modularisation) techniques are often employed for the meaningful decomposition of a program aiming to understand it. In the software clustering context, several external metrics are presented to evaluate and validate the resultant clustering obtained by an algorithm. These metrics use a ground‐truth decomposition to evaluate a resultant clustering. When there exists no ground‐truth decomposition for a software system, internal metrics are utilised to validate clustering algorithms. Due to the comparison with a reference decomposition, external metrics are preferred to internal metrics. Available internal metrics used to measure the clustering quality are not appropriate for evaluating because they do not consider the purpose of software clustering, which is to understand a software system. In this study, the authors present six criteria that influence the understanding of a program. Then the authors design an internal metric for estimating the software clustering quality considering those criteria. They selected ten folders of Mozilla Firefox with different sizes and functionalities to assess the reliability of the proposed metric. The experimental results confirm that the proposed internal metric is more accurate than the existing internal metrics in terms of proximity to expert decomposition. The proposed internal metric can be a substitute for external metrics.

One way to speed up the execution of sequential programs is to divide them into concurrent segments and execute such segments in a parallel manner over a distributed computing environment. We argue that the execution speedup primarily depends on the concurrency degree between the identified segments as well as communication overhead between the segments. To guarantee the best speedup, we have to obtain the maximum possible concurrency degree between the identified segments, taking communication overhead into consideration. Existing code distributor and multi-threading approaches do not fulfill such requirements; hence, they cannot provide expected distributability gains in advance. To overcome such limitations, we propose a novel approach for verifying the distributability of sequential object-oriented programs. The proposed approach enables users to see the maximum speedup gains before the actual distributability implementations, as it computes an objective function which is used to measure different distribution values from the same program, taking into consideration both remote and sequential calls. Experimental results showed that the proposed approach successfully determines the distributability of different real-life software applications compared with their real-life sequential and distributed implementations.

Due to the excess of human resource and not paying enough attention to layout and how to implement them, operations cost a lot and energy is wasted in big organizations. Thus, to improve layout, an imperialist competitive algorithm has been used in this research paper to achieve an acceptable and suitable answer for individuals' layout. In this paper, a new approach is introduced which is based on the imperialist competitive algorithm, named IL-ICA, which is an improvement of L-ICA. Buildings' information such as floors' physical characteristics, rooms, the distances between them and also the relationships between individuals and also physical characteristics of individuals such as age, disability and etc have been considered in this approach. Those individuals whose jobs are related shall be placed in the same room or if they are in different rooms, they shall be placed at the same floor and if they are at different floors, they shall be placed in floors next to each other. The proposed algorithm was compared with a similar sample by an implemented genetic algorithm and the results show that the proposed algorithm works better than the similar sample implemented by a genetic algorithm.

In this paper we present an approach la fault-tolerant stream processing. In contrast to previous techniques that handle node failures, our approach also tolerates network failures and network partitions. The approach is based on a principled trade-off between consistency and availability in the face of failure, that (1) ensures that all data on an input stream is processed within a specified time threshold, but (2) reduces the impact of failures by limiting if possible the number of results produced based on partially available input data, and (3) corrects these results when failures heal. Our approach is well-suited for applications such us environment monitoring. where high availability and "real-lime" response is preferable to perfect answers. Our approach uses replication and guarantees that all processing replicas achieve stale consistency, both in the absence of failures and after a failure heals. He achieve consistency in the former case by defining a data-serializing operator that ensures that the order of tuples to a downstream operator is the same at all the replicas. To achieve consistency after a failure heals, we develop approaches based on checkpoint/redo and undo/redo techniques. We have implemented these schemes in a prototype distributed stream processing system, and present experimental results that show that the system meets the desired availability-consistency trade-offs.

Mesh-connected systems have become popular because of their simple structure. Most of the allocation strategies in mesh systems are contiguous or noncontiguous. We propose a new hybrid processor allocation algorithm for mesh-connected systems. This method starts by processor allocation contiguously; when contiguous allocation is not possible, the request is decomposed into smaller sub-meshes, such that for each sub-mesh a region can be allocated. Regions formed in this method have no regular forms and as a result all the free processors in a mesh are useful in allocating process and number of rejected requests have become minimum. Compared to the other schemes, the proposed algorithm minimizes the communication delay among the selected processors. Our method combines the advantages of both contiguous and non-contiguous allocation schemes. We will show that it achieves minimum job response time and waiting time compared to the other strategies as well as improving the system utilization by using all idle processors in the system

Behavioral requirements engineering of large-scale software systems, using current Formal Description Techniques (FDT), is complex and difficult. In Statecharts, this complexity is evident in the form of a blow-up in the number of states and difficulty of managing the name space. We have introduced a notation, called Viewcharts, which reduces the complexity of expressing behavioral requirements of large systems. Viewcharts extends Statecharts to include behavioral views and their composition. In this paper we present an overview of the Viewcharts notation and establish its semantics via translation to Statecharts.