Noriyuki Fujimoto

Solving quadratic assignment problems by genetic algorithms with GPU computation: a case study

This paper describes designing a parallel GA with GPU computation to solve the quadratic assignment problem (QAP) which is one of the hardest optimization problems in permutation domains. For the parallel method, a multiple-population, coarse-grained GA model was used. Each subpopulation is evolved by a multiprocessor in a GPU (NVIDIA GeForce GTX285). At predetermined intervals of generations all individuals in subpopulations are shuffled via the VRAM of the GPU. The instances on which this algorithm was tested were taken from the QAPLIB benchmark library. Results were promising, showing a speedup ration from 3 to 12 times, compared to the Intel i7 965 processor.

A highly-parallel TSP solver for a GPU computing platform

The traveling salesman problem (TSP) is probably the most widely studied combinatorial optimization problem and has become a standard testbed for new algorithmic ideas. Recently the use of a GPU (Graphics Processing Unit) to accelerate non-graphics computations has attracted much attention due to its high performance and low cost. This paper presents a novel method to solve TSP with a GPU based on the CUDA architecture. The proposed method highly parallelizes a serial metaheuristic algorithm which is a genetic algorithm with the OX (order crossover) operator and the 2-opt local search. The experiments with an NVIDIA GeForce GTX285 GPU and a single core of 3.0 GHz Intel Core2 Duo E6850 CPU show that our GPU implementation is about up to 24.2 times faster than the corresponding CPU implementation.

ACO with tabu search on a GPU for solving QAPs using move-cost adjusted thread assignment

This paper proposes a parallel ant colony optimization (ACO) for solving quadratic assignment problems (QAPs) on a graphics processing unit (GPU) by combining tabu (TS) with ACO in CUDA (ompute unified device architecture). In TS for QAP, all neighbor moves are tested. These moves form two groups based on computing of move cost. In one group, the computing of cost is O(1) and in the other group, the computing of move cost is O(n). We compute these two groups of moves in parallel by assigning the computations to threads of CUDA. In this assignment, we propose an efficient method which we call Move-Cost Adjusted Thread Assignment (MATA). The results with GPU computation with MATA show a promising speedup compared to computation with the CPU. It is also shown that MATA is effective in applying 2-opt local search.

Parallel ant colony optimization algorithm on a multi-core processor

This paper proposes parallelization methods of ACO algorithms on a computing platform with a multi-core processor aiming at fast execution to find acceptable solutions. As an ACO algorithm, we use the cunning Ant System and test on several sizes of TSP instances. As the parallelization method, we use agent level parallelization in one colony using Java thread programming. According to the synchronization and exclusive control modes among threads, we propose three types of parallel ACO algorithms. Among them, that which we call the rough asynchronous parallel model shows the most promising results.

An analytical study of GPU computation for solving QAPs by parallel evolutionary computation with independent run

This paper proposes an evolutionary algorithm for solving QAPs with parallel independent run using GPU computation and gives a statistical analysis on how speedup can be attained with this model. With the proposed model, we achieve a GPU computation performance that is nearly proportional to the number of equipped multi-processors (MPs) in the GPUs. We explain these computational results by performing statistical analysis. Regarding performance comparison to CPU computations, GPU computation shows a speedup of x4.4 and x7.9 on average using a single GPU and two GPUs, respectively.

High throughput multiple-precision GCD on the CUDA architecture

Investigation of the cryptanalytic strength of RSA cryptography requires computing many GCDs of two long integers (e.g., of length 1024 bits). This paper presents a high throughput parallel algorithm to perform many GCD computations concurrently on a GPU based on the CUDA architecture. The experiments with an NVIDIA GeForce GTX285 GPU and a single core of 3.0 GHz Intel Core2 Duo E6850 CPU show that the proposed GPU algorithm runs 11.3 times faster than the corresponding CPU algorithm.

Fast QAP solving by ACO with 2-opt local search on a GPU

This paper proposes a parallel ant colony optimization (ACO) for solving quadratic assignment problems (QAPs) on a graphics processing unit (GPU) by combining fast, 2-opt local search in compute unified device architecture (CUDA). In 2-opt for QAP, 2-opt moves can be divided into two groups based on computing cost. In one group, the computing cost is O(1) and in the other group, the computing cost is O(n). We compute these groups of 2-opt moves in parallel by assigning the computations to threads of CUDA. In this assignment, we propose an efficient method that can reduce disabling time in each thread of CUDA. The results show GPU computation with 2-opt produces a speedup of ×24.6 on average, compared to computation with CPU.

Parallelizing a genetic operator for GPUs

Genetic algorithms (GAs) have parallelism among applications of genetic operators to individuals, but in order to extract high performance of a GPU, parallelizing each genetic operator is desirable. This paper presents parallelization of the OX (order crossover) operator and experimentally show that our parallelized OX is effective on a GPU based on the CUDA architecture. The experiments with an NVIDIA GeForce GTX580 GPU show that our GPU program for the traveling salesman problem (TSP) is about up to 101.3 times faster than the corresponding CPU program on a single core of 2.67 GHz Intel Xeon X5550.

An Analytical Study of Parallel GA with Independent Runs on GPUs

This chapter proposes a genetic algorithm for solving QAPs with parallel independent run using GPU computation and gives a statistical analysis on how speedup can be attained with this model. With the proposed model, we achieve a GPU computation performance that is nearly proportional to the number of equipped multiprocessors (MPs) in the GPUs. We explain these computational results by performing statistical analysis. Regarding performance comparison to CPU computations, GPU computation shows a speedup of 7.2× and 13.1× on average using a single GTX 285 GPU and two GTX 285 GPUs, respectively. The parallel independent run model is the simplest of the various parallel evolutionary computation models, and among the models it demonstrates the lower limit performance.

Tuning of fuzzy rules with a real-codec genetic algorithm in car racing game

Car Racing Game is a competition of computer programs in IEEE CEC 2007, where two car agents compete with each other for taking way points in a two-dimensional plane. The agent can get information on itself, the other agent, and the current and next way points. In our previous research, we have evaluated agent states for the current and next way points with fuzzy rules from their speeds and the distances and angles to way points, to decide which way point to take. Then we have calculated the steering and the speed with fuzzy rules. We, however, have not won some programs in the competition. In this paper, we tune fuzzy rules with a real-coded genetic algorithm. The car agent tuned with a real-coded genetic algorithm for one of the best programs can win almost all programs. Moreover, it gets higher in performance than an ordinary simple genetic algorithm.