Search

A complex and important task in the cloud resource management is the efficient allocation of virtual machines (VMs), or containers, in physical machines (PMs). The evaluation of VM placement techniques in real-world clouds can be tedious, complex and time-consuming. This situation has motivated an increasing use of cloud simulators that facilitate this type of evaluations. However, most of the reported VM placement techniques based on simulations have been evaluated taking into account one specific cloud resource (e.g., CPU), whereas values often unrealistic are assumed for other resources (e.g., RAM, awaiting times, application workloads, etc.). This situation generates uncertainty, discouraging their implementations in real-world clouds. This paper introduces CloudBench, a methodology to facilitate the evaluation and deployment of VM placement strategies in private clouds. CloudBench considers the integration of a cloud simulator with a real-world private cloud. Two main tools were developed to support this methodology, a specialized multi-resource cloud simulator (CloudBalanSim), which is in charge of evaluating VM placement techniques, and a distributed resource manager (Balancer), which deploys and tests in a real-world private cloud the best VM placement configurations that satisfied user requirements defined in the simulator. Both tools generate feedback information, from the evaluation scenarios and their obtained results, which is used as a learning asset to carry out intelligent and faster evaluations. The experiments implemented with the CloudBench methodology showed encouraging results as a new strategy to evaluate and deploy VM placement algorithms in the cloud. [ABSTRACT FROM AUTHOR]

The continuous progress in the performance of supercomputers has made possible the understanding of many fundamental problems in science. Simulation, the third scientific pillar, constantly demands more powerful machines to use algorithms that would otherwise be unviable. That will inevitably lead to the deployment of an exascale machine during the next decade. However, fault tolerance is a major challenge that has to be overcome to make such a machine usable. With an unprecedented number of parts, machines at extreme scale will have a small mean-time-between-failures. The popular checkpoint/restart mechanism used in today's machines may not be effective at that scale. One promising way to revamp checkpoint/restart is to use message-logging techniques. By storing messages during execution and replaying them in case of a failure, message logging is able to shorten recovery time and save a substantial amount of energy. The downside of message logging is that memory footprint may grow to unsustainable levels. This paper presents a technique that decreases the memory pressure in message-logging protocols by only storing the necessary messages in collective-communication operations. We introduce Camel, a protocol that has a low memory overhead for multicast and reduction operations. Our results show that Camel can reduce memory footprint in a molecular dynamics benchmark for more than 95 % on 16,384 cores. [ABSTRACT FROM AUTHOR]

Previous approaches to the dynamic updating of Shortest Path Trees (SPTs) have in the main focused on just one link state change. Not much work has been done on the problem of deriving a new SPT from an existing SPT for multiple link state decrements in a network that applies link-state routing protocols such as OSPF and IS-IS. This problem is complex because in the process of updating an SPT there are, firstly, no simple forms of node set to presumable contain all nodes to be updated and, secondly, multiple decrements can be accumulated to make the updating much harder. If we adopt the updating mechanisms engaged in one link state change for the case of multiple link state decrements, the result is node update redundancy, as a node changes several times before it reaches its final state in the new SPT. This paper proposes two dynamic algorithms ( MaxR, MinD) for obviating unnecessary node updates by having part nodes updated in a branch on the SPT only after selecting a particular node from a built node list. The algorithm complexity analysis and simulation results show that MaxR and MinD require fewer node updates during dynamic update procedures than do other algorithms for updating SPT of multiple link state decrements. [ABSTRACT FROM AUTHOR]

The motif finding problem is one of the important and challenging problems in bioinformatics. A variety of sequential algorithms have been proposed to find exact motifs, but the running time is still not suitable due to high computational complexity of finding motifs. In this paper we parallelize three efficient sequential algorithms which are HEPPMSprune, PMS5 and PMS6. We implement the algorithms on a Dual Quad-Core machine using openMP to measure the performance of each algorithm. Our experiment on simulated data show that: (1) the parallel PMS6 is faster than the other algorithms in case of challenging instances, while the parallel HEPPMSprune is faster than the other algorithms in most of solvable instances; (2) the scalability of parallel HEPPMSprune is linear for all instances, while the scalability of parallel PMS5 and PMS6 is linear in case of challenging instances only; (3) the memory used by HEPPMSprune is less than that of the other algorithms. [ABSTRACT FROM AUTHOR]

This paper develops an algorithm for iterative learning control on the basis of the quasi-Newton method for nonlinear systems. The new quasi-Newton iterative learning control scheme using the rank-one update to derive the recurrent formula has numerous benefits, which include the approximate treatment for the inverse of the system's Jacobian matrix. The rank-one update-based ILC also has the advantage of extension for convergence domain and hence guaranteeing the choice of initial value. The algorithm is expressed as a very general norm optimization problem in a Banach space and, in principle, can be used for both continuous and discrete time systems. Furthermore, a detailed convergence analysis is given, and it guarantees theoretically that the proposed algorithm converges at a superlinear rate. Initial conditions which the algorithm requires are also established. The simulations illustrate the theoretical results. [ABSTRACT FROM AUTHOR]

A directional sensor network consists of a large number of directional sensors (e.g., image/video sensors), which have a limited angle of sensing range due to technical constraints or cost considerations. In such directional sensor networks, the power saving issue is a challenging problem. In this paper, we address the Directional Cover and Transmission (DCT) problem of organizing the directional sensors into a group of non-disjoint subsets to extend the network lifetime. One subset in which the directional sensors cover all the targets and forward the sensed data to the sink is activated at one time, while the others sleep to conserve their energy. For the DCT problem proven to be the NP-complete problem, we present a heuristic algorithm called the Shortest Path from Target to Sink (SPTS)-greedy algorithm. To verify and evaluate the proposed algorithm, we conduct extensive simulations and show that it can contribute to extending the network lifetime to a reasonable extent. [ABSTRACT FROM AUTHOR]

In this paper, we study the problem of scheduling tasks on a distributed system, with the aim to simultaneously minimize energy consumption and makespan subject to the deadline constraints and the tasks' memory requirements. A total of eight heuristics are introduced to solve the task scheduling problem. The set of heuristics include six greedy algorithms and two naturally inspired genetic algorithms. The heuristics are extensively simulated and compared using an simulation test-bed that utilizes a wide range of task heterogeneity and a variety of problem sizes. When evaluating the heuristics, we analyze the energy consumption, makespan, and execution time of each heuristic. The main benefit of this study is to allow readers to select an appropriate heuristic for a given scenario. [ABSTRACT FROM AUTHOR]

Ad hoc grids are highly heterogeneous and dynamic, in which the availability of resources and tasks may change at any time. The paper proposes a utility based resource selection scheme for QoS satisfaction and load balancing in ad hoc grid environments. The proposed scheme intends to maximize the QoS satisfaction of ad hoc grid users and support load balancing of grid resources. For each candidate ad hoc grid resource, the scheme obtains values from the computations of utility function for QoS satisfaction and benefit maximization game for ad hoc grid resource preference. The utility function for QoS satisfaction computes the utility value based on the satisfaction of QoS requirements of the grid user request. The benefit maximization game for grid resource node preference computes the preference value from the resource point of view. Its main goal is to achieve load balancing and decrease the number of resource selection failure. The utility value and the preference value of each candidate ad hoc grid resource are combined to select the most suitable grid resource for ad hoc grid user request. In the simulation, the performance evaluation of proposed algorithm for ad hoc grid is conducted. [ABSTRACT FROM AUTHOR]

To investigate the behavior of biochemical systems, many runs of Gillespie's Stochastic Simulation Algorithm (SSA) are generally needed, causing excessive computational costs on Central Processing Units (CPUs). Since all SSA runs are independent, the Intel Xeon Phi coprocessors based on the Many Integrated Core (MIC) architecture can be exploited to distribute the workload. We considered two execution modalities on MIC: one consisted in running exactly the same CPU code of SSA, while the other exploited MIC's vector instructions to reuse the CPU code with only few modifications. MIC performance was compared with Graphics Processing Units (GPUs), specifically implemented in CUDA to optimize the use of memory hierarchy. Our results show that GPU largely outperforms MIC and CPU, but required a complete redesign of SSA. MIC allows a relevant speedup, especially when vector instructions are used, with the additional advantage of requiring minimal modifications to CPU code. [ABSTRACT FROM AUTHOR]

To overcome the difficulties of efficient scalable numerical algorithms implementation on multicomputers with a large number of computing nodes, LuNA system is being developed. LuNA automatically generates a code related to communications, resources management and dynamic workload balancing, thus simplifying construction of parallel programs. To examine the efficiency of numerical model implementation, created with LuNA, a real application of a three-phase (oil, water and gas) fluid filtration simulation is studied. The application algorithm is parallelized and implemented using LuNA and conventional approach using MPI (Message Passing Interface). A comparative performance testing of the two implementations is done. The results show that LuNA implementation is easier to develop, but its efficiency is significantly lower than the efficiency of MPI program, but manual tuning of the program execution makes its efficiency comparable to that of MPI program. [ABSTRACT FROM AUTHOR]

Ultra wideband (UWB) systems are currently an important wireless infrastructure for high performance short-range communications and mobile applications. Indeed, forming ad-hoc networks among various UWB enabled devices is considered as an important mobile data exchange operating environment. In our study, we explore the problem of jointly optimizing the power level and data rate used in the devices in such a UWB based ad-hoc network. We propose a practical optimization algorithm based on judicious power control for real-time applications and opportunistic scheduling for non-real-time applications. Simulation results indicate that our proposed techniques are effective under various practical scenarios. [ABSTRACT FROM AUTHOR]