GPUFitnessEvaluator.java

package net.bmahe.genetics4j.gpu;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;

import org.apache.commons.collections4.ListUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.Validate;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.jocl.CL;
import org.jocl.cl_command_queue;
import org.jocl.cl_context;
import org.jocl.cl_context_properties;
import org.jocl.cl_device_id;
import org.jocl.cl_kernel;
import org.jocl.cl_platform_id;
import org.jocl.cl_program;
import org.jocl.cl_queue_properties;

import net.bmahe.genetics4j.core.Genotype;
import net.bmahe.genetics4j.core.evaluation.FitnessEvaluator;
import net.bmahe.genetics4j.gpu.opencl.DeviceReader;
import net.bmahe.genetics4j.gpu.opencl.DeviceUtils;
import net.bmahe.genetics4j.gpu.opencl.KernelInfoReader;
import net.bmahe.genetics4j.gpu.opencl.OpenCLExecutionContext;
import net.bmahe.genetics4j.gpu.opencl.PlatformReader;
import net.bmahe.genetics4j.gpu.opencl.PlatformUtils;
import net.bmahe.genetics4j.gpu.opencl.model.Device;
import net.bmahe.genetics4j.gpu.opencl.model.KernelInfo;
import net.bmahe.genetics4j.gpu.opencl.model.Platform;
import net.bmahe.genetics4j.gpu.spec.GPUEAConfiguration;
import net.bmahe.genetics4j.gpu.spec.GPUEAExecutionContext;
import net.bmahe.genetics4j.gpu.spec.Program;

/**
 * GPU-accelerated fitness evaluator that leverages OpenCL for high-performance evolutionary algorithm execution.
 * 
 * <p>GPUFitnessEvaluator implements the core {@link FitnessEvaluator} interface to provide GPU acceleration for fitness
 * computation in evolutionary algorithms. This evaluator manages the complete OpenCL lifecycle, from device discovery
 * and kernel compilation to memory management and resource cleanup.
 * 
 * <p>Key responsibilities include:
 * <ul>
 * <li><strong>OpenCL initialization</strong>: Platform and device discovery, context creation, and kernel
 * compilation</li>
 * <li><strong>Resource management</strong>: Managing OpenCL contexts, command queues, programs, and kernels</li>
 * <li><strong>Population partitioning</strong>: Distributing work across multiple OpenCL devices</li>
 * <li><strong>Asynchronous execution</strong>: Coordinating concurrent GPU operations with CPU-side logic</li>
 * <li><strong>Memory lifecycle</strong>: Ensuring proper cleanup of GPU resources</li>
 * </ul>
 * 
 * <p>Architecture overview:
 * <ol>
 * <li><strong>Initialization ({@link #preEvaluation})</strong>: Discover platforms/devices, compile kernels, create
 * contexts</li>
 * <li><strong>Evaluation ({@link #evaluate})</strong>: Partition population, execute fitness computation on GPU</li>
 * <li><strong>Cleanup ({@link #postEvaluation})</strong>: Release all OpenCL resources and contexts</li>
 * </ol>
 * 
 * <p>Multi-device support:
 * <ul>
 * <li><strong>Device filtering</strong>: Selects devices based on user-defined criteria (type, capabilities)</li>
 * <li><strong>Load balancing</strong>: Automatically distributes population across available devices</li>
 * <li><strong>Parallel execution</strong>: Concurrent fitness evaluation on multiple GPUs or devices</li>
 * <li><strong>Asynchronous coordination</strong>: Non-blocking execution with CompletableFuture-based results</li>
 * </ul>
 * 
 * <p>Resource management patterns:
 * <ul>
 * <li><strong>Lazy initialization</strong>: OpenCL resources created only when needed</li>
 * <li><strong>Automatic cleanup</strong>: Guaranteed resource release through lifecycle methods</li>
 * <li><strong>Error recovery</strong>: Robust handling of OpenCL errors and device failures</li>
 * <li><strong>Memory optimization</strong>: Efficient GPU memory usage and transfer patterns</li>
 * </ul>
 * 
 * <p>Example usage in GPU EA system:
 * 
 * <pre>{@code
 * // GPU configuration with OpenCL kernel
 * Program fitnessProgram = Program.ofResource("/kernels/optimization.cl");
 * GPUEAConfiguration<Double> config = GPUEAConfigurationBuilder.<Double>builder()
 * 		.program(fitnessProgram)
 * 		.fitness(new MyGPUFitness())
 * 		// ... other EA configuration
 * 		.build();
 * 
 * // Execution context with device preferences
 * GPUEAExecutionContext<Double> context = GPUEAExecutionContextBuilder.<Double>builder()
 * 		.populationSize(2000)
 * 		.deviceFilter(device -> device.type() == DeviceType.GPU)
 * 		.platformFilter(platform -> platform.profile() == PlatformProfile.FULL_PROFILE)
 * 		.build();
 * 
 * // Evaluator handles all OpenCL lifecycle automatically
 * GPUFitnessEvaluator<Double> evaluator = new GPUFitnessEvaluator<>(context, config, executorService);
 * 
 * // Used by EA system - lifecycle managed automatically
 * EASystem<Double> system = EASystemFactory.from(config, context, executorService, evaluator);
 * }</pre>
 * 
 * <p>Performance characteristics:
 * <ul>
 * <li><strong>Initialization overhead</strong>: One-time setup cost for OpenCL compilation and context creation</li>
 * <li><strong>Scalability</strong>: Performance scales with population size and problem complexity</li>
 * <li><strong>Memory bandwidth</strong>: Optimal for problems with high computational intensity</li>
 * <li><strong>Concurrency</strong>: Supports concurrent evaluation across multiple devices</li>
 * </ul>
 * 
 * <p>Error handling:
 * <ul>
 * <li><strong>Device failures</strong>: Graceful degradation when devices become unavailable</li>
 * <li><strong>Memory errors</strong>: Proper cleanup and error reporting for GPU memory issues</li>
 * <li><strong>Compilation errors</strong>: Clear error messages for kernel compilation failures</li>
 * <li><strong>Resource leaks</strong>: Guaranteed cleanup even in exceptional circumstances</li>
 * </ul>
 * 
 * @param <T> the type of fitness values produced, must be comparable for selection operations
 * @see FitnessEvaluator
 * @see GPUEAConfiguration
 * @see GPUEAExecutionContext
 * @see OpenCLExecutionContext
 * @see net.bmahe.genetics4j.gpu.fitness.OpenCLFitness
 */
public class GPUFitnessEvaluator<T extends Comparable<T>> implements FitnessEvaluator<T> {
	public static final Logger logger = LogManager.getLogger(GPUFitnessEvaluator.class);

	private final GPUEAExecutionContext<T> gpuEAExecutionContext;
	private final GPUEAConfiguration<T> gpuEAConfiguration;
	private final ExecutorService executorService;

	private List<Pair<Platform, Device>> selectedPlatformToDevice;

	final List<cl_context> clContexts = new ArrayList<>();
	final List<cl_command_queue> clCommandQueues = new ArrayList<>();
	final List<cl_program> clPrograms = new ArrayList<>();
	final List<Map<String, cl_kernel>> clKernels = new ArrayList<>();
	final List<OpenCLExecutionContext> clExecutionContexts = new ArrayList<>();

	/**
	 * Constructs a GPU fitness evaluator with the specified configuration and execution context.
	 * 
	 * <p>Initializes the evaluator with GPU-specific configuration and execution parameters. The evaluator will use the
	 * provided executor service for coordinating asynchronous operations between CPU and GPU components.
	 * 
	 * <p>The constructor performs minimal initialization - the actual OpenCL setup occurs during
	 * {@link #preEvaluation()} to follow the fitness evaluator lifecycle pattern.
	 * 
	 * @param _gpuEAExecutionContext the GPU execution context with device filters and population settings
	 * @param _gpuEAConfiguration    the GPU EA configuration with OpenCL program and fitness function
	 * @param _executorService       the executor service for managing asynchronous operations
	 * @throws IllegalArgumentException if any parameter is null
	 */
	public GPUFitnessEvaluator(final GPUEAExecutionContext<T> _gpuEAExecutionContext,
			final GPUEAConfiguration<T> _gpuEAConfiguration,
			final ExecutorService _executorService) {
		Objects.requireNonNull(_gpuEAExecutionContext);
		Objects.requireNonNull(_gpuEAConfiguration);
		Objects.requireNonNull(_executorService);

		this.gpuEAExecutionContext = _gpuEAExecutionContext;
		this.gpuEAConfiguration = _gpuEAConfiguration;
		this.executorService = _executorService;

		CL.setExceptionsEnabled(true);
	}

	private String loadResource(final String filename) {
		Validate.notBlank(filename);

		try {
			return IOUtils.resourceToString(filename, StandardCharsets.UTF_8);
		} catch (IOException e) {
			throw new IllegalStateException("Unable to load resource " + filename, e);
		}
	}

	private List<String> grabProgramSources() {
		final Program programSpec = gpuEAConfiguration.program();

		logger.info("Load program source: {}", programSpec);

		final List<String> sources = new ArrayList<>();

		sources.addAll(programSpec.content());

		programSpec.resources().stream().map(this::loadResource).forEach(program -> sources.add(program));

		return sources;
	}

	/**
	 * Initializes OpenCL resources and prepares GPU devices for fitness evaluation.
	 * 
	 * <p>This method performs the complete OpenCL initialization sequence:
	 * <ol>
	 * <li><strong>Platform discovery</strong>: Enumerates available OpenCL platforms</li>
	 * <li><strong>Device filtering</strong>: Selects devices based on configured filters</li>
	 * <li><strong>Context creation</strong>: Creates OpenCL contexts for selected devices</li>
	 * <li><strong>Queue setup</strong>: Creates command queues with profiling and out-of-order execution</li>
	 * <li><strong>Program compilation</strong>: Compiles OpenCL kernels from source code</li>
	 * <li><strong>Kernel preparation</strong>: Creates kernel objects and queries execution info</li>
	 * <li><strong>Fitness initialization</strong>: Calls lifecycle hooks on the fitness function</li>
	 * </ol>
	 * 
	 * <p>Device selection process:
	 * <ul>
	 * <li>Applies platform filters to discovered OpenCL platforms</li>
	 * <li>Enumerates devices for each qualifying platform</li>
	 * <li>Applies device filters to select appropriate devices</li>
	 * <li>Validates that at least one device is available</li>
	 * </ul>
	 * 
	 * <p>The method creates separate OpenCL contexts for each selected device to enable concurrent execution and optimal
	 * resource utilization. Each context includes compiled programs and kernel objects ready for fitness evaluation.
	 * 
	 * @throws IllegalStateException if no compatible devices are found
	 * @throws RuntimeException      if OpenCL initialization, program compilation, or kernel creation fails
	 */
	@Override
	public void preEvaluation() {
		logger.trace("Init...");
		FitnessEvaluator.super.preEvaluation();

		final var platformReader = new PlatformReader();
		final var deviceReader = new DeviceReader();
		final var kernelInfoReader = new KernelInfoReader();

		final int numPlatforms = PlatformUtils.numPlatforms();
		logger.info("Found {} platforms", numPlatforms);

		final List<cl_platform_id> platformIds = PlatformUtils.platformIds(numPlatforms);

		logger.info("Selecting platform and devices");
		final var platformFilters = gpuEAExecutionContext.platformFilters();
		final var deviceFilters = gpuEAExecutionContext.deviceFilters();

		selectedPlatformToDevice = platformIds.stream()
				.map(platformReader::read)
				.filter(platformFilters)
				.flatMap(platform -> {
					final var platformId = platform.platformId();
					final int numDevices = DeviceUtils.numDevices(platformId);
					logger.trace("\tPlatform {}: {} devices", platform.name(), numDevices);

					final var deviceIds = DeviceUtils.getDeviceIds(platformId, numDevices);
					return deviceIds.stream().map(deviceId -> Pair.of(platform, deviceId));
				})
				.map(platformToDeviceId -> {
					final var platform = platformToDeviceId.getLeft();
					final var platformId = platform.platformId();
					final var deviceID = platformToDeviceId.getRight();

					return Pair.of(platform, deviceReader.read(platformId, deviceID));
				})
				.filter(platformToDevice -> deviceFilters.test(platformToDevice.getRight()))
				.toList();

		if (logger.isTraceEnabled()) {
			logger.trace("============================");
			logger.trace("Selected devices:");
			selectedPlatformToDevice.forEach(pd -> {
				logger.trace("{}", pd.getLeft());
				logger.trace("\t{}", pd.getRight());
			});
			logger.trace("============================");
		}

		Validate.isTrue(selectedPlatformToDevice.isEmpty() == false, "No compatible devices found for the given filters");

		final List<String> programs = grabProgramSources();
		final String[] programsArr = programs.toArray(new String[programs.size()]);

		for (final var platformAndDevice : selectedPlatformToDevice) {
			final var platform = platformAndDevice.getLeft();
			final var device = platformAndDevice.getRight();

			logger.info("Processing platform [{}] / device [{}]", platform.name(), device.name());

			logger.info("\tCreating context");
			cl_context_properties contextProperties = new cl_context_properties();
			contextProperties.addProperty(CL.CL_CONTEXT_PLATFORM, platform.platformId());

			final cl_context context = CL
					.clCreateContext(contextProperties, 1, new cl_device_id[] { device.deviceId() }, null, null, null);

			logger.info("\tCreating command queue");
			final cl_queue_properties queueProperties = new cl_queue_properties();
			queueProperties.addProperty(
					CL.CL_QUEUE_PROPERTIES,
					CL.CL_QUEUE_PROFILING_ENABLE | CL.CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE);
			final cl_command_queue commandQueue = CL
					.clCreateCommandQueueWithProperties(context, device.deviceId(), queueProperties, null);

			logger.info("\tCreate program");
			final cl_program program = CL.clCreateProgramWithSource(context, programsArr.length, programsArr, null, null);

			final var programSpec = gpuEAConfiguration.program();
			final var buildOptions = programSpec.buildOptions().orElse(null);
			logger.info("\tBuilding program with options: {}", buildOptions);
			CL.clBuildProgram(program, 0, null, buildOptions, null, null);

			final Set<String> kernelNames = gpuEAConfiguration.program().kernelNames();

			final Map<String, cl_kernel> kernels = new HashMap<>();
			final Map<String, KernelInfo> kernelInfos = new HashMap<>();
			for (final String kernelName : kernelNames) {

				logger.info("\tCreate kernel {}", kernelName);
				final cl_kernel kernel = CL.clCreateKernel(program, kernelName, null);
				Objects.requireNonNull(kernel);

				kernels.put(kernelName, kernel);

				final var kernelInfo = kernelInfoReader.read(device.deviceId(), kernel, kernelName);
				logger.trace("\t{}", kernelInfo);
				kernelInfos.put(kernelName, kernelInfo);
			}

			clContexts.add(context);
			clCommandQueues.add(commandQueue);
			clKernels.add(kernels);
			clPrograms.add(program);

			final var openCLExecutionContext = OpenCLExecutionContext.builder()
					.platform(platform)
					.device(device)
					.clContext(context)
					.clCommandQueue(commandQueue)
					.kernels(kernels)
					.kernelInfos(kernelInfos)
					.clProgram(program)
					.build();

			clExecutionContexts.add(openCLExecutionContext);
		}

		final var fitness = gpuEAConfiguration.fitness();
		fitness.beforeAllEvaluations();
		for (final OpenCLExecutionContext clExecutionContext : clExecutionContexts) {
			fitness.beforeAllEvaluations(clExecutionContext, executorService);
		}
	}

	/**
	 * Evaluates fitness for a population of genotypes using GPU acceleration.
	 * 
	 * <p>This method implements the core fitness evaluation logic by distributing the population across available OpenCL
	 * devices and executing fitness computation concurrently. The evaluation process follows these steps:
	 * 
	 * <ol>
	 * <li><strong>Population partitioning</strong>: Divides genotypes across available devices</li>
	 * <li><strong>Parallel dispatch</strong>: Submits evaluation tasks to each device asynchronously</li>
	 * <li><strong>GPU execution</strong>: Executes OpenCL kernels for fitness computation</li>
	 * <li><strong>Result collection</strong>: Gathers fitness values from all devices</li>
	 * <li><strong>Result aggregation</strong>: Combines results preserving original order</li>
	 * </ol>
	 * 
	 * <p>Load balancing strategy:
	 * <ul>
	 * <li>Automatically calculates partition size based on population and device count</li>
	 * <li>Round-robin assignment of partitions to devices for balanced workload</li>
	 * <li>Asynchronous execution allows devices to work at their optimal pace</li>
	 * </ul>
	 * 
	 * <p>The method coordinates with the configured fitness function through lifecycle hooks:
	 * <ul>
	 * <li>{@code beforeEvaluation()}: Called before each device partition evaluation</li>
	 * <li>{@code compute()}: Executes the actual GPU fitness computation</li>
	 * <li>{@code afterEvaluation()}: Called after each device partition completes</li>
	 * </ul>
	 * 
	 * <p>Concurrency and performance:
	 * <ul>
	 * <li>Multiple devices execute evaluation partitions concurrently</li>
	 * <li>CompletableFuture-based coordination for non-blocking execution</li>
	 * <li>Automatic workload distribution across available GPU resources</li>
	 * </ul>
	 * 
	 * @param generation the current generation number for context and logging
	 * @param genotypes  the population of genotypes to evaluate
	 * @return fitness values corresponding to each genotype in the same order
	 * @throws IllegalArgumentException if genotypes is null or empty
	 * @throws RuntimeException         if GPU evaluation fails or OpenCL errors occur
	 */
	@Override
	public List<T> evaluate(final long generation, final List<Genotype> genotypes) {

		final var fitness = gpuEAConfiguration.fitness();

		/**
		 * TODO make it configurable from execution context
		 */
		final int partitionSize = (int) (Math.ceil((double) genotypes.size() / clExecutionContexts.size()));
		final var subGenotypes = ListUtils.partition(genotypes, partitionSize);
		logger.debug("Genotype decomposed in {} partition(s)", subGenotypes.size());
		if (logger.isTraceEnabled()) {
			for (int i = 0; i < subGenotypes.size(); i++) {
				final List<Genotype> subGenotype = subGenotypes.get(i);
				logger.trace("\tPartition {} with {} elements", i, subGenotype.size());
			}
		}

		final List<CompletableFuture<List<T>>> subResultsCF = new ArrayList<>();
		for (int i = 0; i < subGenotypes.size(); i++) {
			final var openCLExecutionContext = clExecutionContexts.get(i % clExecutionContexts.size());
			final var subGenotype = subGenotypes.get(i);

			fitness.beforeEvaluation(generation, subGenotype);
			fitness.beforeEvaluation(openCLExecutionContext, executorService, generation, subGenotype);

			final var resultsCF = fitness.compute(openCLExecutionContext, executorService, generation, subGenotype)
					.thenApply(results -> {

						fitness.afterEvaluation(openCLExecutionContext, executorService, generation, subGenotype);
						fitness.afterEvaluation(generation, subGenotype);

						return results;
					});

			subResultsCF.add(resultsCF);
		}

		final List<T> resultsEvaluation = new ArrayList<>(genotypes.size());
		for (final CompletableFuture<List<T>> subResultCF : subResultsCF) {
			final var fitnessResults = subResultCF.join();
			resultsEvaluation.addAll(fitnessResults);
		}
		return resultsEvaluation;
	}

	/**
	 * Cleans up OpenCL resources and releases GPU memory after evaluation completion.
	 * 
	 * <p>This method performs comprehensive cleanup of all OpenCL resources in the proper order to prevent memory leaks
	 * and ensure clean shutdown. The cleanup sequence follows OpenCL best practices for resource deallocation:
	 * 
	 * <ol>
	 * <li><strong>Fitness cleanup</strong>: Calls lifecycle hooks on the fitness function</li>
	 * <li><strong>Kernel release</strong>: Releases all compiled kernel objects</li>
	 * <li><strong>Program release</strong>: Releases compiled OpenCL programs</li>
	 * <li><strong>Queue release</strong>: Releases command queues and pending operations</li>
	 * <li><strong>Context release</strong>: Releases OpenCL contexts and associated memory</li>
	 * <li><strong>Reference cleanup</strong>: Clears internal data structures and references</li>
	 * </ol>
	 * 
	 * <p>Resource management guarantees:
	 * <ul>
	 * <li>All GPU memory allocations are properly released</li>
	 * <li>OpenCL objects are released in dependency order to avoid errors</li>
	 * <li>No resource leaks occur even if individual cleanup operations fail</li>
	 * <li>Evaluator returns to a clean state ready for potential reinitialization</li>
	 * </ul>
	 * 
	 * <p>The method coordinates with the configured fitness function to ensure any fitness-specific resources (buffers,
	 * textures, etc.) are also properly cleaned up through the {@code afterAllEvaluations()} lifecycle hooks.
	 * 
	 * @throws RuntimeException if cleanup operations fail (logged but not propagated to prevent interference with EA
	 *                          system shutdown)
	 */
	@Override
	public void postEvaluation() {

		final var fitness = gpuEAConfiguration.fitness();

		for (final OpenCLExecutionContext clExecutionContext : clExecutionContexts) {
			fitness.afterAllEvaluations(clExecutionContext, executorService);
		}
		fitness.afterAllEvaluations();

		logger.debug("Releasing kernels");

		for (final Map<String, cl_kernel> kernels : clKernels) {
			for (final cl_kernel clKernel : kernels.values()) {
				CL.clReleaseKernel(clKernel);
			}
		}
		clKernels.clear();

		logger.debug("Releasing programs");
		for (final cl_program clProgram : clPrograms) {
			CL.clReleaseProgram(clProgram);
		}
		clPrograms.clear();

		logger.debug("Releasing command queues");
		for (final cl_command_queue clCommandQueue : clCommandQueues) {
			CL.clReleaseCommandQueue(clCommandQueue);
		}
		clCommandQueues.clear();

		logger.debug("Releasing contexts");
		for (final cl_context clContext : clContexts) {
			CL.clReleaseContext(clContext);
		}
		clContexts.clear();

		clExecutionContexts.clear();
		selectedPlatformToDevice = null;

		FitnessEvaluator.super.postEvaluation();
	}
}



















































































































Active mutators

CONDITIONALS_BOUNDARY
CONSTRUCTOR_CALLS
EMPTY_RETURNS
EXPERIMENTAL_ARGUMENT_PROPAGATION
EXPERIMENTAL_BIG_DECIMAL
EXPERIMENTAL_BIG_INTEGER
EXPERIMENTAL_MEMBER_VARIABLE
EXPERIMENTAL_NAKED_RECEIVER
EXPERIMENTAL_REMOVE_SWITCH_MUTATOR_[0-99]
EXPERIMENTAL_SWITCH
FALSE_RETURNS
INCREMENTS
INLINE_CONSTS
INVERT_NEGS
MATH
NEGATE_CONDITIONALS
NON_VOID_METHOD_CALLS
NULL_RETURNS
PRIMITIVE_RETURNS
REMOVE_CONDITIONALS_EQUAL_ELSE
REMOVE_CONDITIONALS_EQUAL_IF
REMOVE_CONDITIONALS_ORDER_ELSE
REMOVE_CONDITIONALS_ORDER_IF
REMOVE_INCREMENTS
TRUE_RETURNS
VOID_METHOD_CALLS
Tests examined

Report generated by PIT 1.25.7 support
1		package net.bmahe.genetics4j.gpu;
2
3		import java.io.IOException;
4		import java.nio.charset.StandardCharsets;
5		import java.util.ArrayList;
6		import java.util.HashMap;
7		import java.util.List;
8		import java.util.Map;
9		import java.util.Objects;
10		import java.util.Set;
11		import java.util.concurrent.CompletableFuture;
12		import java.util.concurrent.ExecutorService;
13
14		import org.apache.commons.collections4.ListUtils;
15		import org.apache.commons.io.IOUtils;
16		import org.apache.commons.lang3.Validate;
17		import org.apache.commons.lang3.tuple.Pair;
18		import org.apache.logging.log4j.LogManager;
19		import org.apache.logging.log4j.Logger;
20		import org.jocl.CL;
21		import org.jocl.cl_command_queue;
22		import org.jocl.cl_context;
23		import org.jocl.cl_context_properties;
24		import org.jocl.cl_device_id;
25		import org.jocl.cl_kernel;
26		import org.jocl.cl_platform_id;
27		import org.jocl.cl_program;
28		import org.jocl.cl_queue_properties;
29
30		import net.bmahe.genetics4j.core.Genotype;
31		import net.bmahe.genetics4j.core.evaluation.FitnessEvaluator;
32		import net.bmahe.genetics4j.gpu.opencl.DeviceReader;
33		import net.bmahe.genetics4j.gpu.opencl.DeviceUtils;
34		import net.bmahe.genetics4j.gpu.opencl.KernelInfoReader;
35		import net.bmahe.genetics4j.gpu.opencl.OpenCLExecutionContext;
36		import net.bmahe.genetics4j.gpu.opencl.PlatformReader;
37		import net.bmahe.genetics4j.gpu.opencl.PlatformUtils;
38		import net.bmahe.genetics4j.gpu.opencl.model.Device;
39		import net.bmahe.genetics4j.gpu.opencl.model.KernelInfo;
40		import net.bmahe.genetics4j.gpu.opencl.model.Platform;
GPUFitnessEvaluator.java

Mutations

Active mutators

Tests examined
