Package net.bmahe.genetics4j.gpu.spec

Class GPUEAConfiguration<T extends Comparable<T>>

java.lang.Object
net.bmahe.genetics4j.core.spec.AbstractEAConfiguration<T>
net.bmahe.genetics4j.gpu.spec.GPUEAConfiguration<T>
Type Parameters:
T - the type of fitness values produced by the GPU fitness function
Direct Known Subclasses:
ImmutableGPUEAConfiguration
@Immutable public abstract class GPUEAConfiguration<T extends Comparable<T>> extends AbstractEAConfiguration<T>
GPU-specific evolutionary algorithm configuration that extends the core EA framework with OpenCL capabilities.

GPUEAConfiguration extends AbstractEAConfiguration to include GPU-specific settings required for OpenCL-based fitness evaluation. This configuration combines traditional EA parameters (selection, mutation, crossover) with GPU-specific components like OpenCL programs and specialized fitness functions.

Key GPU-specific additions:

  • OpenCL Program: Specifies kernel source code, build options, and compilation settings
  • GPU Fitness Function: Specialized fitness implementation that leverages OpenCL execution
  • Kernel Integration: Automatic coordination between EA framework and OpenCL kernels

Configuration workflow:

  1. Core EA setup: Define chromosome specs, selection policies, mutation rates
  2. OpenCL program: Specify kernel source code and compilation options
  3. GPU fitness: Implement fitness evaluation using OpenCL primitives
  4. Integration: Combine components into complete GPU-accelerated EA system

Example configuration: 


 // Define OpenCL program with kernel source
 Program optimizationKernels = Program.ofResource("/kernels/tsp_fitness.cl")
     .withBuildOption("-DCITY_COUNT=100")
     .withBuildOption("-DLOCAL_SIZE=256");
 
 // Create GPU-specific fitness function
 OpenCLFitness<Double> gpuFitness = new TSPGPUFitness();
 
 // Build complete GPU EA configuration
 GPUEAConfiguration<Double> config = GPUEAConfiguration.<Double>builder()
     // Core EA components
     .chromosomeSpecs(intPermutationSpec)
     .parentSelectionPolicy(Tournament.of(3))
     .combinationPolicy(OrderCrossover.build())
     .mutationPolicies(SwapMutation.of(0.1))
     .replacementStrategy(Elitism.builder().offspringRatio(0.8).build())
     
     // GPU-specific components
     .program(optimizationKernels)
     .fitness(gpuFitness)
     .build();

OpenCL integration benefits:

  • Performance: Massive parallelism for fitness evaluation
  • Scalability: Handle large populations efficiently
  • Hardware utilization: Leverage GPU compute units
  • Memory bandwidth: High-throughput data processing

Configuration validation:

  • Program completeness: Ensures all required kernels are specified
  • Fitness compatibility: Validates fitness function matches program interface
  • Resource requirements: Checks memory and compute requirements are feasible

Builder pattern usage:

  • Type safety: Generic builder ensures fitness type consistency
  • Validation: Build-time validation of configuration completeness
  • Convenience methods: Simplified specification of chromosome and mutation arrays
  • Immutability: Thread-safe configuration objects
See Also:

  • Constructor Details

    • GPUEAConfiguration

      public GPUEAConfiguration()

  • Method Details

    • program

      public abstract Program program()
      Returns the OpenCL program specification containing kernel source code and build options.

      The program defines the OpenCL kernels that will be compiled and executed on GPU devices for fitness evaluation. This includes source code, build flags, and kernel definitions required for the evolutionary algorithm execution.

      Returns:
      the OpenCL program specification for kernel compilation

    • fitness

      public abstract OpenCLFitness<T> fitness()
      Returns the GPU-specific fitness function that implements evaluation using OpenCL.

      The fitness function encapsulates the logic for evaluating individual solutions using GPU acceleration. It coordinates data transfer, kernel execution, and result extraction for efficient parallel fitness computation.

      Returns:
      the OpenCL fitness function for GPU-accelerated evaluation

    • builder

      public static <U extends Comparable<U>> GPUEAConfiguration.Builder<U> builder()
      Creates a new builder for constructing GPU EA configurations.

      The builder provides a fluent interface for specifying both core EA components and GPU-specific settings. Type safety is ensured through generic parameterization.

      Type Parameters:
      U - the type of fitness values for the EA configuration
      Returns:
      a new builder instance for creating GPU EA configurations