ABSTRACT Volunteer Cloud computing, like traditional Cloud computing, has gained significant importance due to its ability to harness resources from individual personal machines, contributed voluntarily by their owners. In this paradigm, personal machine resources are shared voluntarily by their owners. This approach is particularly valuable for handling data‐intensive computations and storing Big Data. However, managing the potential unavailability of volunteer machines is crucial. Additionally, in Volunteer Cloud environments, energy consumption is becoming increasingly significant alongside execution time and cost. However, optimizing energy consumption remains a critical challenge, particularly in environments with dynamic and unpredictable availability of volunteer resources. This paper investigates the problem of energy‐efficient services placement in Volunteer Cloud environments. Specifically, we address the challenge of optimally deploying and running independent applications to minimize energy consumption while ensuring that physical machines are not overloaded and avoiding redundant deployments on the same machine. We propose two heuristic strategies to tackle this problem: the Dynamic Shortest Path Strategy (D‐SPS‐VC) for dynamic service placement and the Static Shortest Path Strategy (S‐SPS‐VC) for static service placement. These strategies are designed to optimize energy efficiency by considering constraints such as machine availability, capacity, and application duplication. The main contribution of this study is the development of these heuristic strategies, which are validated through a series of experiments that demonstrate their effectiveness in reducing energy consumption in Volunteer Cloud environments.

In this paper, we compare four libraries for efficiently running threads when the performance of a CPU cores are degraded. First, we are interested by 'brute performance' of the libraries when all the CPU resources are available and second, we would like to measure how the scheduling strategy impacts also the memory management in order to revisit, in the future, scheduling strategies when we artificially degrade the performance in advance. It is well known that work stealing, when done in an anarchic way, may lead to poor cache performance. It is also known that the migration of threads may induce penalties if they are too frequent. We study, at the processor level, the memory management in order to find trade-offs between active thread number that an application should start and the memory hierarchy. Our implementations, coded with the different libraries, were compared against a Pthread one where the threads are scheduled by the Linux kernel and not by a specific tool. Our experimental results indicate that scheduler may perfectly balance loads over cores but execution time is impacted in a negative way. We also put forward a relation between the L1 cache misses, the number of steals and the execution time that will allow to focus on specific points to improve 'work stealing' schedulers in the future.

We study, in this work, the load balancing of sort algorithm executed on a two cluster grid. Our solution is based on data partitioning. We use mainly geometrical interpretations to find out the optimal partition that reduces both communication and computing times in an heterogeneous context

The aim of the paper is to introduce techniques in order to optimize the parallel execution time of sorting on heterogeneous platforms (processors speeds are related by a constant factor). We develop a constant time technique for mastering processor load balancing and execution time in an heterogeneous environment. We develop an analytical model for the parallel execution time, sustained by preliminary experimental results in the case of a 2-processors systems. The computation of the solution is independent of the problem size. Consequently, there is no overhead regarding the sorting problem.

The paper considers the problem of parallel external sorting in the context of a form of heterogeneous clusters. We introduce two algorithms and we compare them to another one that we have previously developed. Since most common sort algorithms assume high-speed random access to all intermediate memory, they are unsuitable if the values to be sorted don't fit in main memory. This is the case for cluster computing platforms which are made of standard, cheap and scarce components. For that class of computing resources a good use of I/O operations compatible with the requirements of load balancing and computational complexity are the key to success. We explore three techniques and show how they can be deployed for clusters with processor performances related by a multiplicative factor. We validate the approaches in showing experimental results for the load balancing factor.