Martín Pedemonte

A survey on parallel ant colony optimization

Abstract: Ant colony optimization (ACO) is a well-known swarm intelligence method, inspired in the social behavior of ant colonies for solving optimization problems. When facing large and complex problem instances, parallel computing techniques are usually applied to improve the efficiency, allowing ACO algorithms to achieve high quality results in reasonable execution times, even when tackling hard-to-solve optimization problems. This work introduces a new taxonomy for classifying software-based parallel ACO algorithms and also presents a systematic and comprehensive survey of the current state-of-the-art on parallel ACO implementations. Each parallel model reviewed is categorized in the new taxonomy proposed, and an insight on trends and perspectives in the field of parallel ACO implementations is provided.

Towards the Design of Systolic Genetic Search

This paper elaborates on a new, fresh parallel optimization algorithm specially engineered to run on Graphic Processing Units (GPUs). The underlying operation relates to Systolic Computation. The algorithm, called Systolic Genetic Search (SGS) is based on the synchronous circulation of solutions through a grid of processing units and tries to profit from the parallel architecture of GPUs. The proposed model has shown to outperform a random search and two genetic algorithms for solving the Knapsack Problem over a set of increasingly sized instances. Additionally, the parallel implementation of SGS on a GeForce GTX 480 graphics processing unit (GPU), obtaining a runtime reduction up to 35 times.

Bitwise operations for GPU implementation of genetic algorithms

Research on the implementation of evolutionary algorithms in graphics processing units (GPUs) has grown in recent years since it significantly reduces the execution time of the algorithm. A relevant aspect, which has received little attention in the literature, is the impact of the memory space occupied by the population in the performance of the algorithm, due to limited capacity of several memory spaces in the GPUs. In this paper we analyze the differences in performance of a binary Genetic Algorithm implemented on a GPU using a boolean data type or packing multiple bits into a non boolean data type. Our study considers the influence on the performance of single point and double point crossover for solving the classical One-Max problem. The results obtained show that packing bits for storing binary strings can reduce the execution time up to 50%.

A cellular ant colony optimisation for the generalised Steiner problem

The development of exact and heuristic algorithms for communication network design requires ever-growing amounts of computational power. In particular, finding a dependable, fault-tolerant network topology can be modelled as the generalised Steiner problem (GSP). This problem belongs to the NP-hard class, so that exact methods cannot be applied to real life sized problems. An alternative is using metaheuristics, but even in this case the computation time can quickly grow leading to extremely long runs or to degraded quality results. In this paper, we discuss the use of parallel implementations as a means to tackle this computational performance bottleneck. In particular, we concentrate on the ant colony optimisation (ACO) metaheuristic. We review previous ACO approaches for solving the GSP, as well as literature on parallelisation of this method. We propose and develop a new parallel model suitable for ACO, called cellular ACO, which is then applied to the GSP. We present computational results for large GSP instances, showing that cellular ACO finds high quality solutions, comparable to the best published sequential and parallel metaheuristics, while attaining a large speedup, resulting in very good computational efficiency.

Systolic genetic search, a systolic computing-based metaheuristic

In this paper, we propose a new parallel optimization algorithm that combines ideas from the fields of metaheuristics and Systolic Computing. The algorithm, called Systolic Genetic Search (SGS), is designed to explicitly exploit the high degree of parallelism available in modern Graphics Processing Unit (GPU) architectures. In SGS, solutions circulate synchronously through a grid of processing cells, which apply adapted evolutionary operators on their inputs to compute their outputs that are then ejected from the cells and continue moving through the grid. Four different variants of SGS are experimentally studied for solving two classical benchmarking problems and a real-world application. An extensive experimental analysis, which considered several instances for each problem, shows that three of the SGS variants designed are highly effective since they can obtain the optimal solution in almost every execution for the instances and problems studied, as well as they outperform a Random Search (sanity check) and two Genetic Algorithms. The parallel implementation on GPU of the proposed algorithm has achieved a high performance obtaining runtime reductions from the sequential implementation that, depending on the instance considered, can arrive to around a hundred times, and have also exhibited a good scalability behavior when solving highly dimensional problem instances.

Systolic Genetic Search for Software Engineering: The Test Suite Minimization Case

The Test Suite Minimization Problem (TSMP) is a (mathcal {NP})-hard real-world problem that arises in the field of software engineering. It lies in selecting the minimal set of test cases from a large test suite, ensuring that the test cases selected cover a given set of elements of a computer program under test. In this paper, we propose a Systolic Genetic Search (SGS) algorithm for solving the TSMP. We use the global concept of SGS to derive a particular algorithm to explicitly exploit the high degree of parallelism available in modern GPU architectures. The experimental evaluation on seven real-world programs shows that SGS is highly effective for the TSMP, as it obtains the optimal solution in almost every single run for all the tested software. It also outperforms two competitive Genetic Algorithms. The GPU-based implementation of SGS has achieved a high performance, obtaining runtime reductions of up to 40(times ) compared to its sequential implementation, and solving all the instances considered in less than nine seconds.

New Ideas in Parallel Metaheuristics on GPU: Systolic Genetic Search

This chapter presents an in-depth study of a novel parallel optimization algorithm specially designed to run on Graphic Processing Units (GPUs). The underlying operation relates to systolic computing and is inspired by the systolic contraction of the heart that makes possible blood circulation. The algorithm, called Systolic Genetic Search (SGS), is based on the synchronous circulation of solutions through a grid of processing units and tries to profit from the parallel architecture of GPUs to achieve high time performance. SGS has shown not only to numerically outperform a random search and two genetic algorithms for solving the Knapsack Problem over a set of increasingly sized instances, but also its parallel implementation can obtain a runtime reduction that, depending on the GPU technology used, can reach more than 100 times. A study of the performance of the parallel implementation of SGS on four different GPUs has been conducted to show the impact of the Nvidia’s GPU compute capabilities on the runtimes of the algorithm.

A Systolic Genetic Search for reducing the execution cost of regression testing

Graphical abstractDisplay Omitted HighlightsWe propose a Systolic Genetic Search for the cost-aware Test Suite Minimization Problem (TSMP).SGS outperforms two evolutionary algorithms and four heuristics specially designed for this problem on instances from eight real-world programs.The GPU implementation of SGS shows a good scalability behavior when solving instances with a large number of test cases.The GPU implementation of SGS is a state of the art alternative for solving real-world instances of the cost-aware TSMP. The Test Suite Minimization Problem (TSMP) is a NP-hard real-world problem that arises in the field of software engineering. It consists in selecting a minimal set of test cases from a large test suite, ensuring that the test cases selected cover a given set of requirements of a piece of software at the same time as it minimizes the amount of resources required for its execution. In this paper, we propose a Systolic Genetic Search (SGS) algorithm for solving the TSMP. SGS is a recently proposed optimization algorithm capable of taking advantage of the high degree of parallelism available in modern GPU architectures. The experimental evaluation conducted on a large number of test suites generated for seven real-world programs and seven large test suites generated for a case study from a real-world program shows that SGS is highly effective for the TSMP. SGS not only outperforms two competitive genetic algorithms, but also outperforms four heuristics specially conceived for this problem. The results also show that the GPU implementation of SGS has achieved a high performance, obtaining a large runtime reduction with respect to the CPU implementation for solutions with similar quality. The GPU implementation of SGS also shows an excellent scalability behavior when solving instances with a large number of test cases. As a consequence, the GPU-based SGS stands as a state of the art alternative for solving the TSMP in real-world software testing environments.

A Study on Mixed Precision Techniques for a GPU-based SIP Solver

This article presents the study and application of mixed precision techniques to accelerate a GPU-based implementation of the Strongly Implicit Procedure (SIP) to solve hepta-diagonal linear systems. In particular, two different options to incorporate mixed precision in the GPU implementation are discussed and one of them is implemented. The experimental evaluation of our proposal demonstrates that a runtime similar to a single precision implementation on GPU can be attained, but achieving a numerical accuracy comparable to double precision arithmetic.

A theoretical and empirical study of the trajectories of solutions on the grid of Systolic Genetic Search

Abstract Systolic Genetic Search (SGS) is a recently proposed optimization algorithm based on the circulation of solutions through a bidimensional grid of cells and the application of evolutionary operators within the cells to the moving solutions. Until now, the influence of the solutions flow on the results of SGS has only been empirically studied. In this article, we theoretically analyze the trajectories of the solutions along the grid of SGS. This analysis shows that, in the grids used so far, there are cells in which the incoming solutions are descendants of a pair of solutions that have been previously mated. For this reason, we propose a new variant of SGS which uses a grid that guarantees that, given a pair of solutions that coincide in any cell, a pair of ancestors of these two solutions have not been previously mated. The experimental evaluation conducted on three deceptive problems shows that SGS has a better numerical efficiency when it uses grids that limit the mating of descendants of pairs of solutions that have already been mated. It also shows that this property helps to keep a larger diversity in the pairs of solutions that are mated in each cell.