Michaël Krajecki

Parallel Ant Colony Optimization on Graphics Processing Units

The purpose of this paper is to propose effective parallelization strategies for the Ant Colony Optimization (ACO) metaheuristic on Graphics Processing Units (GPUs). The Max-Min Ant System (MMAS) algorithm augmented with 3-opt local search is used as a framework for the implementation of the parallel ants and multiple ant colonies general parallelization approaches. The four resulting GPU algorithms are extensively evaluated and compared on both speedup and solution quality on a state-of-the-art Fermi GPU architecture. A rigorous effort is made to keep parallel algorithms true to the original MMAS applied to the Traveling Salesman Problem. We report speedups of up to 23.60 with solution quality similar to the original sequential implementation. With the intent of providing a parallelization framework for ACO on GPUs, a comparative experimental study highlights the performance impact of ACO parameters, GPU technical configuration, memory structures and parallelization granularity.

Comparing parallelization of an ACO: message passing vs. shared memory

We present a shared memory approach to the parallelization of the Ant Colony Optimization (ACO) metaheuristic and a performance comparison with an existing message passing implementation. Our aim is to show that the shared memory approach is a competitive strategy for the parallelization of ACO algorithms. The sequential ACO algorithm on which are based both parallelization schemes is first described, followed by the parallelization strategies themselves. Through experiments, we compare speedup and efficiency measures on four TSP problems varying from 318 to 657 cities. We then discuss factors that explain the difference in performance of the two approaches. Further experiments are presented to show the performance of the shared memory implementation when varying numbers of ants are distributed among the available processors. In this last set of experiments, the solution quality obtained is taken into account when analyzing speedup and efficiency measures.

CONFIIT: a middleware for peer to peer computing

Once applications with Finite number of Independent and Irregular Tasks (FIIT) have been introduced, CONFIIT is presented. This is a fully distributed peer-to-peer environment designed to compute FIIT problems. This Java written middleware aims at setting a logical ring organization for networks resources, such as PCs, workstations or parallel architectures. It also offers a low-cost communication solution to share, and compute, the different tasks of a FIIT problem over the structured system. The efficiency of this solution, is shown, through experiments, using the Langfords problem.

Decomposition techniques for parallel resolution of constraint satisfaction problems in shared memory: a comparative study

This paper provides both a formal and an empirical study of decomposition techniques for parallel resolution of Constraint Satisfaction Problems (CSP) in shared memory. The main contribution of this study is to bring together decomposition techniques with Backtrack search to solve CSP on parallel architectures in shared memory. Another contribution is to demonstrate how to obtain good scalability up to hundreds of processors in shared memory for CSP resolution and more generally for Irregular Applications.

Parallel GPU implementation of iterated local search for the travelling salesman problem

The purpose of this paper is to propose effective parallelization strategies for the Iterated Local Search ILS metaheuristic on Graphics Processing Units GPU. We consider the decomposition of the 3-opt Local Search procedure on the GPU processing hardware and memory structure. Two resulting algorithms are evaluated and compared on both speedup and solution quality on a state-of-the-art Fermi GPU architecture. We report speedups of up to 6.02 with solution quality similar to the original sequential implementation on instances of the Travelling Salesman Problem ranging from 100 to 3038 cities.

MultiGPU computing using MPI or OpenMP

The GPU computing follows the trend of GPGPU, driven by the innovations in both hardware and programming languages made available to nongraphic programmers. Since some problems require an important time to solve or data quantities that do not fit on one single GPU, the logical continuation was to make use of multiple GPUs.

Multi-colony parallel ant colony optimization on SMP and multi-core computers

The purpose of this paper is to propose an effective implementation of the Ant Colony Optimization metaheuristic on actual shared-memory parallel computers. We deal with the management of multiple colonies which use a global shared-memory to exchange information. We report considerable speedups on a SMP node of multi-core processors while witnessing solution quality equal or greater than the original sequential implementation.

An Object Oriented Environment to Manage the Parallelism of the FIIT Applications

The main goal of this paper is to propose an environment helping the user to parallelize a FIIT application. This object oriented environment is not only independent of the particular application considered, but also of the target parallel machine. It offers a facility of programming: in fact, parallelism is managed by the environment, it is thus completely transparent for the user. We experiment this environment in the framework of parallel ray tracing and show the main advantages.

Solving the Langford problem in parallel

In this paper, the parallel resolution of the Langford problem is studied. Two different approaches are developed. First, an explicit construction of all the solutions is done using a shared memory. The application associated to this approach is written in C using the standard OpenMP library. Second, a parallelization of the algebraic method introduced by Godfrey is proposed. The application is taking advantage of MPI and has revealed efficient up to 128 processors. This solution opens up some new perspectives such as solving the already resolved instances of the problem more quickly and solving the next two open instances of the problem in a near future.

Focus on the communication scheme in the middleware CONFIIT using XML-RPC

Summary form only given. The need of computation power increases, and grid computing seems to be a good complement to expensive parallel computers. This paper deals with the evolution of CONFIIT (computation over network with finite number of independent and irregular tasks): a purely decentralized peer to peer middleware for grid computing. We specially focus on topology management (virtual ring), and mainly how CONFIIT can be robust according to computer crashdowns, transmission failures, and dynamic evolution of the system. CONFIIT is designed to manage computation distribution and result gathering. Its fully implemented in Java for portability and execution on Internet. Communications are based on XML-RPC calls.