Efficient support of dynamic inheritance for class- and prototype-based languages

Virtualisation is a major technology in cloud computing for optimising the cloud data centre's power usage. In the current scenario, most of the services are migrated to the cloud, putting more load on the cloud data centres. As a result, the data center's size expands resulting in increased energy usage. To address this problem, a resource allocation optimisation method that is both efficient and effective is necessary. The optimal utilisation of cloud infrastructure and optimisation algorithms plays a vital role. The cloud resources rely on the allocation policy of the virtual machine on cloud resources. A virtual machine placement technique, based on the Harris Hawk Optimisation (HHO) model for the cloud data centre is presented in this paper. The proposed HHO model aims to find the best place for virtual machines on suitable hosts with the least load and power consumption. PlanetLab's real-time workload traces are used for performance evaluation with existing PSO (Particle Swarm Optimisation) and PABFD (Best Fit Decreasing). The performance evaluation of the proposed method is done using power consumption, SLA, CPU utilisation, RAM utilisation, Execution time (ms) and the number of VM migrations. The performance evaluation is done using two simulation scenarios with scaling workload in scenario 1 and increasing resources for the virtual machine to study the performance in underloaded and overloaded conditions. Experimental results show that the proposed HHO algorithm improved execution time(ms) by 4%, had a 27% reduction in power consumption, a 16% reduction in SLA violation and an increase in resource utilisation by 17%. The HHO algorithm is also effective in handling dynamic and uncertain environments, making it suitable for real-world cloud infrastructures.

Virtual Machine (VM) placement has to carefully consider the aggregated resource consumption of co-located VMs in order to obey service level agreements at lower possible cost. In this paper, we focus on satisfying the traffic demands of the VMs in addition to CPU and memory requirements. This is a much more complex problem both due to its quadratic nature (being the communication between a pair of VMs) and since it involves many factors beyond the physical host, like the network topologies and the routing scheme. Moreover, traffic patterns may vary over time and predicting the resulting effect on the actual available bandwidth between hosts within the data center is extremely difficult. We address this problem by trying to allocate a placement that not only satisfies the predicted communication demand but is also resilient to demand time-variations. This gives rise to a new optimization problem that we call the Min Cut Ratio-aware VM Placement (MCRVMP). The general MCRVMP problem is NP-Hard, hence, we introduce several heuristics to solve it in reasonable time. We present extensive experimental results, associated with both placement computation and run-time performance under time-varying traffic demands, to show that our heuristics provide good results (compared to the optimal solution) for medium size data centers.

Just-in-time (JIT) compilation during program execution and ahead-of-time (AOT) compilation during software installation are alternate techniques used by managed language virtual machines (VM) to generate optimized native code while simultaneously achieving binary code portability and high execution performance. Profile data collected by JIT compilers at run-time can enable profile-guided optimizations (PGO) to customize the generated native code to different program inputs. AOT compilation removes the speed and energy overhead of online profile collection and dynamic compilation, but may not be able to achieve the quality and performance of customized native code. The goal of this work is to investigate and quantify the implications of the AOT compilation model on the quality of the generated native code for current VMs. First, we quantify the quality of native code generated by the two compilation models for a state-of-the-art (HotSpot) Java VM. Second, we determine how the amount of profile data collected affects the quality of generated code. Third, we develop a mechanism to determine the accuracy or similarity for different profile data for a given program run, and investigate how the accuracy of profile data affects its ability to effectively guide PGOs. Finally, we categorize the profile data types in our VM and explore the contribution of each such category to performance.

As more and more applications migrate into clouds, the placement of virtual machines for these applications has much impact on the performance of cloud systems. A number of virtual machine (VM) placement techniques have been proposed over recent years. However, most of the existing works on VM placement ignore the response latency of the requests from tenants. In this paper, we investigate the techniques of VM placement with stochastic requests from the tenants to minimize the total (average) response latency. We first model the requests for each application from the corresponding tenant as independent Poisson stream. Moreover, the VMs are modeled as simple M/M/1 queueing systems. Then, we define the problem of VM placement for minimizing the total response delay (VMMD) and show it is NP-hard. We propose three heuristic algorithms, namely, Greedy, Local Adjustment (LA) and Simulated Annealing (SA). We conduct abundant simulation experiments to evaluate the performance of our proposed algorithms. The simulation results show that the proposed algorithms are efficient in decreasing the total response latency of the requests from tenants. Especially, the SA heuristic, which decreases the total response latency about 68% at most, shows the best performance on minimizing the total response latency in cloud systems.

eJSTK: Building JavaScript virtual machines with customized datatypes for embedded systems

Dynamic translation for virtual machine based traffic simulation

Cloud computing is a new computation technology that provides services to consumers and businesses. The main idea of Cloud computing is to present software and hardware services through the Internet to the users and organizations at all levels. In Cloud computing, the users pay for the services, which means a usage-based payment system is used in this technology. Using virtualization technology in computation resources enables the appropriate utilization of resources in cloud computing. One of the most significant challenging issues in virtualization technology is the placement of optimal virtual machines on physical machines in cloud data centers. The placement of virtual machines comprises a process wherein virtual machines are mapped onto physical machines in cloud data centers. Optimal deployment leads to the reduction in power consumption, optimal use of resources, traffic reduction in data centers, costs reduction, and efficiency enhancement of the data center in the cloud. The present article proposed a new approach using a combination of the Sine–Cosine Algorithm and Salp Swarm Algorithm as discrete multi-objective and chaotic functions for optimal virtual machine placement. The first goal of the proposed algorithm was to reduce the power consumption in cloud data centers by condensing the number of active physical machines. The second goal was to reduce the waste of resources and manage it by optimally virtual machine placement on physical machines in cloud data centers. The third objective was to minimize and reduce Service Level Agreement among the active physical machines in cloud data centers. The proposed method prevent the increase in the migration of virtual machines onto physical machines. Ultimately, the results obtained from the proposed algorithm were compared with those of previous akin algorithms in the literature, including First Fit, Virtual Machine Placement Ant Colony System, and Modified Best Fit Decreasing. The proposed scheme is tested using Amazon EC2 Instances and the result indicated that the proposed algorithm performs better than the existing algorithms for various performance metrics.

Virtualization, one of the most actively adopted technologies today in computer systems, is increasingly widening its range of applications. As multiple virtual machines are concurrently executed on a physical machine, they compete for physical resources such as CPU, DRAM, HDD and NIC. In large scale data centers or cluster systems, therefore, it is required to balance each physical machine's load by migrating a virtual machine to another physical machine. Since system performance is significantly hindered during migration, a technique that can reduce the migration overheads is required. Interestingly, we notice that virtual machines' memory contain numerous dispensable data. Therefore, in this paper, we propose an efficient virtual machine migration technique called D3 (Discarding Dispensable Data). The basic idea is simple but effective: finding indispensable page frames, and then, transferring only those page frames. In D3, simple metadata is handed over for the dispensable page frames, instead of actual data transmission, and the discarded page frames are reconstructed appropriately after the migration process. One issue is that checking whether a page frame is dispensable or not based on comparing the entire content yields excessive overhead. To overcome this problem, we devise a novel sampling based dispensable page frame detection technique. D3 have implemented in Xen virtualization software and evaluated on a realistic environment with relevant workloads. We show that D3 can efficiently reduce migration time up to 64.2% and size of memory required for completing a migration up to 94.8%. We also present that D3 is very useful to provide a certain level of QoS and better performance.

Safepoints are a virtual machine mechanism that allows one thread to suspend other threads in a known state so that runtime actions can be performed without interruption and with data structures in a consistent state. Many virtual machines use safepoints as a mechanism to provide services such as stop-the-world garbage collection, debugging, and modification to running code such as installing or replacing classes. Languages implemented on these virtual machines may have access to these services, but not directly to the safepoint mechanism itself. We show that safepoints have many useful applications for the implementation of guest languages running on a virtual machine. We describe an API for using safepoints in languages that were implemented under the Truffle language implementation framework on the Java Virtual Machine and show several applications of the API to implement useful guest-language functionality. We present an efficient implementation of this API, when running in combination with the Graal dynamic compiler. We also demonstrate that our safepoints cause zero overhead with respect to peak performance and statistically insignificant overhead with respect to compilation time. We compare this to other techniques that could be used to implement the same functionality and demonstrate the large overhead that they incur.

Virtual machines raise the abstraction level of the execution environment at the cost of restricting the set of supported languages. Moreover, the ability of a language implementation to integrate with other languages hosted on the same virtual machine typically constrains the features of the language. In this paper, we present a highly flexible yet efficient approach to hosting multiple programming languages on an objectoriented virtual machine. Our approach is based on extending the interface of each class with language-specific wrapper methods, offering each language a tailored view of a given class. This approach can be deployed both on a statically typed virtual machine, such as the JVM, and on a dynamic virtual machine, such as a Smalltalk virtual machine. We have implemented our approach to language interoperability on top of a prototype virtual machine for embedded systems based on the Smalltalk object model, which provides interoperability for embedded versions of the Smalltalk, Java, and BETA programming languages. (Less)

Servers have different energy efficiency and energy proportionality (EP) due to their hardware configuration (i.e., CPU generation and memory installation) and workload. However, current virtual machine (VM) scheduling in virtualized environments will saturate servers without considering their energy efficiency and EP differences. This article will discuss EASE, the energy efficiency and proportionality aware VM scheduling approach. EASE first executes customized computing intensive, memory intensive, and hybrid benchmarks to calculate a server's energy efficiency and EP. Then it schedules VMs to servers to keep them working at their peak energy efficiency point (or optimal working range). This step improves the overall energy efficiency of the cluster and the data center. For performance guarantee, EASE migrates VMs from servers under highly contending conditions. The experimental results on real clusters show that power consumption can be saved 37.07% ~ 49.98% in the homogeneous cluster. The average completion time of the computing intensive VMs increases only 0.31 % ~ 8.49%. In the heterogeneous nodes, the power consumption of the computing intensive VMs can be reduced by 44.22 %. The job completion time can be saved by 53.80%.

In large-scale software applications, programmers often combine different programming languages because this allows them to use the most suitable language for a given problem, to gradually migrate existing projects from one language to another, or to reuse existing source code. However, different programming languages have fundamentally different implementations, which are hard to combine. The composition of language implementations often results in complex interfaces between languages, insufficient flexibility, or poor performance. We propose TruffleVM, a virtual machine (VM) that can execute different programming languages and is able to compose them in a seamless way. TruffleVM supports dynamically-typed languages (e.g., JavaScript and Ruby) as well as statically typed low-level languages (e.g., C). It consists of individual language implementations, which translate source code to an intermediate representation that is executed by a shared VM. TruffleVM composes these different language implementations via generic access . Generic access is a language-agnostic mechanism that language implementations use to access foreign data or call foreign functions. It features language-agnostic messages that the TruffleVM resolves to efficient foreign-language-specific operations at runtime. Generic access supports multiple languages, enables an efficient multi-language development, and ensures high performance. We evaluate generic access with two case studies. The first one explains the transparent composition of JavaScript, Ruby, and C. The second one shows an implementation of the C extensions application programming interface (API) for Ruby. We show that generic access guarantees good runtime performance. It avoids conversion or marshalling of foreign objects at the language boundary and allows the dynamic compiler to perform its optimizations across language boundaries.

We present a transparent optimisation framework for automatically improving run-time performance of component-based enterprise applications. Run-time performance is improved by automatically identifying and dynamically switching to an optimised but functionally equivalent program flow, for a specific transaction type. More precisely, one or more application components can have both static and dynamic inputs, where the former and its output remain mostly fixed from invocation-to-invocation, while the latter is unconstrained. Through dynamic profiling and run-time adaptation, an optimised program flow is derived, that allows only future execution of program points that operate on dynamic inputs and not static inputs. During execution, a target application is instrumented to switch to an optimised program flow. Additional instrumentation occurs to profile key program points that may invalidate an optimised program flow. If these points execute, then the application reverts back to its pre-optimised program flow. We evaluate and demonstrate how run-time performance for a typical thre-tired enterprise system can be improved for frequently accessed data that remains mostly static. For the application studied we showed a 49% marked improvement in the number of users serviced per second.

In this paper, we investigate virtual machine (VM) scheduling problem for the downlink joint transmission (JT) of coordinated multi-point (CoMP) systems in centralized radio access networks (C-RAN). The inter-dependent computing tasks of users are centralized and scheduled on heterogeneous VMs to be executed. In order to achieve efficient scheduling, a priority based VM scheduling model is designed. Then, a delay-constrained and resource-constrained optimization problem to minimize the maximum completion time among users is formulated. Three scheduling algorithms including genetic algorithm (GA), genetic simulated annealing algorithm (GSAA) and packing algorithm (PA) are developed to solve the problem. Simulation results show that GSAA outperforms GA and PA in guaranteeing joint synchronization of all cooperating entities and fairness of users.

Cloud computing has overtaken the traditional computing technologies by providing virtualized resources on demand. Cloud data centers consume a huge amount of power and emit much carbon dioxide, resulting in two challenging problems: high energy consumption and global warming. Our prior work has derived an enhanced energy model that considered energy consumed in computing, migration and host reactivating, and proposed three highly efficient virtual machine (VM) migration schemes. In this work, the three schemes are further enhanced, through considering the traffic factor in VM migration and adopting VM clustering. The resulting schemes have significantly reduced the number of VM migration and their migration costs. The time complexities of these schemes have been analyzed, their performance evaluated through simulation. Results showed that, comparing with the ones without VM clustering, the migration energy usage is dropped to 32%, resulting in the total energy saving of 23%, with a small increase in SLA violation. The proposed schemes would have significant impact when applying to virtualization of wireless mobile networks, in which the communication cost, including bandwidth and delay factors, is significant.