VMPP: a virtual machine for parallel processing

The ALEPH Collaboration [1] took data at the LEP (CERN) electron-positron collider in the period 1989-2000, producing more than 300 scientific papers. While most of the Collaboration activities stopped in the last years, the data collected still has physics potential, with new theoretical models emerging, which ask checks with data at the Z and WW production energies. An attempt to revive and preserve the ALEPH Computing Environment is presented; the aim is not only the preservation of the data files (usually called bit preservation), but of the full environment a physicist would need to perform brand new analyses. Technically, a Virtual Machine approach has been chosen, using the VirtualBox platform. Concerning simulated events, the full chain from event generators to physics plots is possible, and reprocessing of data events is also functioning. Interactive tools like the DALI event display can be used on both data and simulated events. The Virtual Machine approach is suited for both interactive usage, and for massive computing using Cloud like approaches.

Summary form only given, as follows. This talk briefly reviews some of the most popular high-level and low-level parallel programming languages used for scientific computing. We will report our experiences of using these languages in our research and compare the performance of several parallel scientific equation solvers implemented in different parallel languages. Major features and comparisons of these languages will be discussed. Some insights into when and where these languages should be used will be provided.

Major problems with parallel languages are concerned with the complexity and lack of expressive power which makes it difficult to produce efficient code and the ease of mapping onto parallel hardware. Also, a parallel language must be independent of specific hardware features as well as the underlying run-time support for it to be manned efficiently on a range of hardware. This paper presents a parallel language (LIPS) which allows the programs to be mapped onto a range of parallel hardware in an efficient manner. LIPS encourages a pipelining effect to occur onboard each processor in a parallel system, with data becoming available to each node once the pipe is full. LIPS uses an asynchronous communication subsystem so that synchronisation delays can be avoided. The communication dynamics being of a dataflow nature, where variables are passed from one process to another as the values become available. LIPS offers facilities for representation of data, flow of control and the manipulation of the network of processes in a practical form suitable for constructing programs for MIMD computing.

A novel energy-aware resource management technique using joint VM and container consolidation approach for green computing in cloud data centers

The rapid growth in cloud computing encourages the cloud provider to create more reliable, scalable and efficient cloud environment. For providing such a scalable environment, cloud provider develops large-scale Cloud Data Centers (CDC). Such CDCs consume a large amount of electrical energy for operational purpose and cooling purpose to keep the machines operating at a right temperature, but it also emits a large amount of carbon-dioxide. Thus to decrease the energy consumption, Virtual Machines (VMs) are consolidated to fewer numbers of active servers through VM migration techniques, this leads to Service Level Agreement (SLA) violation and performance degradation. Therefore to retain the energy-performance tradeoff, we should perform an optimum number of VM migrations. There are two cases when the VM migration performed: First when a hot spot is found and Second when a cold spot is found. But in both the cases we do not directly migrate the VM instead first we check whether it is required to migrate the VM. After that, the algorithm finds an appropriate destination host on which the VM will be migrated. In this paper, we implement three approaches to select destination host: First-fit, Best-fit, and Worst-fit. Finally compare the result of a number of VM migration performed, energy consumption and SLA violations with existing one.

We proposed a parallel programming language based on Petri net, named PNPL. It consists of graphical and text components, where the text components are similar to programs written in Pascal and the graphical components form a Petri net which describes the flow of control in parallel processing. PNPL programs can be executed on multiprocessor machines controlled by a Petri net. This paper reports the implementation of an PNPL programming environment for workstations. The programming environment consists of an editor, a compiler and a simulator which includes a debugger. A Petri net is drawn using the graphic functions available in the editor, and the text components can be edited in multiple windows. The compiler translates PNPL programs into an intermediate C-language code and the simulator implemented using parallel processes on UNIX, and realizes the environment of the multiprocessor controlled by the Petri net. The debugger can trace the execution following the graph and text components, and can plot the movement of tokens in the Petri net graph. We can develop PNPL programs and evaluate the simulated hardware as if using the real machine. >

The PFG language is a parallel programming language with graphical syntax. Its formal operational semantics are expressed by the HG model of concurrent real-time software systems. Informally, each procedure in a PFG program is a hierarchical graph expressing the data state and a place-timed Petri net expressing the possible parallel threads of control operating the data state. The author demonstrates how the PFG language, which is sufficient in itself for software construction, can be used as a kernel language for the implementation of higher-level languages. PFG can then be thought of as a graphical assembly language, with the HG model being the virtual machine. >

Cloud computing is a technology in which the Cloud Service Providers (CSP) provide many virtual servers to the users to store their information in the cloud. The faults occurring on the assignment and dismission of the virtual machines, the processing cost in the allocation of resources must also be considered. The parallel processing of the information on the virtual machines must be done effectively and in an efficient manner. A variety of systems were developed to facilitate Many Task Computing (MTC). These systems aim to hide the issues of parallelism and fault tolerant and they are used in many applications. In this paper, we introduced Nephele, a data processing framework to exploit dynamic resource provisioning offered by IaaS clouds. The performance evaluation of the virtual machines has been evaluated and the allocation and deallocation of job tasks to the specific virtual machines has also been considered. A performance comparison with the well known data processing framework hadoop has been done. Thus this paper tells about the effective and efficient manner of processing the data by parallel processing and allocating the correct resources for the desired task. It also helps to reduce the cost of resource utilization by exploiting the dynamic resource utilization.

SummaryVirtual clusters (VCs) have exhibited various advantages over traditional cluster computing platforms by virtue of their extensibility, reconfigurability, and maintainability. As such, they have become a major execution environment for cloud‐based cluster applications. However, compared with traditional clusters, their distributed‐memory programming paradigm still remains largely unchanged, which implies that cluster applications cannot be efficiently deployed in VCs, especially when virtual machines (VMs) are running in different physical hosts. Recently, some efforts have been made to improve inter‐VM communication, resulting in many studies on how cluster applications could take advantages of VCs. However, most of them mainly focus on the situation that the VMs are all coresident on the same physical machine where the message passing mechanism is usually optimized away by exploiting the host's shared memory. In this paper, we present a design and implementation of Naplus, a kernel‐based virtual machine approach to the inter‐VM communications that are across different physical hosts. Naplus is based on Nahanni, a mechanism for shared‐memory communication in virtual environments. As such, it not only inherits the major merits of Nahanni with respect to flexible data structures and efficient synchronization but also achieves a shared‐memory paradigm among VMs. With Naplus, we enable the size of shared space to be maximized as large as the sum of each machine's local memory to accommodate cluster applications with large memory footprints. We prototype Naplus in a dual‐host system where an empirical study is conducted to show the effectiveness of the Naplus approach in achieving distributed shared memory for VCs in data centers. Copyright © 2017 John Wiley & Sons, Ltd.

We present a new concurrency abstraction and implementation technique for high-level (symbolic) parallel languages that allows significant programmer control over load-balancing and mapping of fine-grained lightweight threads. Central to our proposal is the notion of a virtual topology. A virtual topology defines a relation over a collection of virtual processors, and a mapping of those processors to a set of physical processors; processor topologies configured as trees, graphs, butterflies, and meshes are some well-known examples. A virtual topology need not have any correlation with a physical one; it is intended to capture the interconnection structure best suited for a given algorithm. We consider a virtual processor to be an abstraction that defines scheduling, migration and load-balancing policies for the threads it executes. Thus, virtual topologies are intended to provide a simple, expressive and efficient high-level framework for defining complex thread/processor mappings that abstracts low-level details of a physical interconnection.

High-level control of parallel process behaviour simplifies the development of parallel software substantially by freeing the programmer from low-level process management and coordination details. The latter are handled by a sophisticated runtime system which controls program execution. In this paper we look behind the scenes and show how the enormous gap between high-level parallel language constructs and their low-level implementation has been bridged in the implementation of the parallel functional language Eden. The main idea has been to implement the process control in a functional language and to restrict the extensions of the low-level runtime system to a few selected primitive operations.

One of the Internet’s fastest-growing technologies is cloud computing, which needs each user to share various resources and virtual computers to access the services they demand. The difficulty is in allocating the user’s tasks among the many resources at hand while maintaining a balanced workload. In this work, we present the design of a new scheduling approach for cloud virtual machines in order to process events (related to resource overuse or underuse). This reduces the amount of effort consumed while maintaining the required performance levels in the cloud data center. To evaluate the effectiveness of the approach with real load paths, we conducted an experiment using the open-source cloud computing platform OpenNebula.

Virtual machining, based-on the model of a machining system, aims to simulate, evaluate and optimize the actual machining process with high sense of reality. It provides digital off-line optimization tools for NC machining. Taking advantage of virtual machining used in machining process simulation, one can build the framework of optimization system on NC machining so that the processes of reliability verification, cutting parameter optimization and error compensation can be integrated into one system to improve machining processes comprehensively. The optimization is realized via modifying NC programs. Several key issues such as virtual machining, cutting parameters optimization, error prediction and compensation are also highlighted. Optimization systems based on virtual machining have been developed to demonstrate the effectiveness of off-line optimization for different purposes. The results show that the machining process is obviously improved.

The increasing availability of commodity multicore processors is making parallel computing ever more widespread. In order to exploit its potential, programmers need languages that make the benefits of parallelism accessible and understandable. Previous parallel languages have traditionally been intended for large-scale scientific computing, and they tend not to be well suited to programming the applications one typically finds on a desktop system. Thus, we need new parallel-language designs that address a broader spectrum of applications. The Manticore project is our effort to address this need. At its core is Parallel ML, a high-level functional language for programming parallel applications on commodity multicore hardware. Parallel ML provides a diverse collection of parallel constructs for different granularities of work. In this paper, we focus on the implicitly threaded parallel constructs of the language, which support fine-grained parallelism. We concentrate on those elements that distinguish our design from related ones, namely, a novel parallel binding form, a nondeterministic parallel case form, and the treatment of exceptions in the presence of data parallelism. These features differentiate the present work from related work on functional data-parallel language designs, which have focused largely on parallel problems with regular structure and the compiler transformations—most notably, flattening—that make such designs feasible. We present detailed examples utilizing various mechanisms of the language and give a formal description of our implementation.

Hardware/software co-design and (re)configurable computing with field programmable gate arrays (FPGAs) are used to create a highly efficient implementation of the Java virtual machine (JVM). Guidelines are provided for applying a general hardware/software co-design process to virtual machines, as are algorithms for context switching between the hardware and software partitions. The advantages of using co-design as an implementation approach for virtual machines are assessed using several benchmarks applied to the implemented co-design of the JVM. It is shown that significant performance improvements are achievable with appropriate architectural and co-design choices. The co-designed JVM could be a cost-effective solution for use in situations where the usual methods of virtual machine acceleration are inappropriate.