Krnl_GA.cl

// Enable the channels extension
#pragma OPENCL EXTENSION cl_altera_channels : enable

//IC:  initial calculation of energy of populations
//GG:  genetic generation 
//LS:  local search
//OFF: turn off 

#include "../defines.h"

#define CHAN_DEPTH_ATOMXYZ   (MAX_NUM_OF_ATOMS/2)
//#define CHAN_DEPTH_ATOMXYZ   MAX_NUM_OF_ATOMS
#define CHAN_DEPTH_GENOTYPE  ACTUAL_GENOTYPE_LENGTH

#define CHAN_NEW_DEPTH_GENOTYPE (MAX_POPSIZE*CHAN_DEPTH_GENOTYPE)
#define CHAN_NEW_DEPTH_ATOMXYZ  (MAX_POPSIZE*CHAN_DEPTH_ATOMXYZ)

// Send active signal to IGL_Arbiter
channel bool    chan_GA2IGL_IC_active;
channel bool    chan_GA2IGL_GG_active;

// Send genotypes from producers (IC, GG) to Conform
#if 0
channel float  	chan_IC2Conf_genotype          __attribute__((depth(CHAN_DEPTH_GENOTYPE)));
channel float  	chan_GG2Conf_genotype          __attribute__((depth(CHAN_DEPTH_GENOTYPE)));
#endif
channel float  	chan_IC2Conf_genotype          __attribute__((depth(CHAN_NEW_DEPTH_GENOTYPE)));
channel float  	chan_GG2Conf_genotype          __attribute__((depth(CHAN_NEW_DEPTH_GENOTYPE)));


// Send ligand-atom positions from Conform to InterE & IntraE
#if 0
channel float8  chan_Conf2Intere_xyz           __attribute__((depth(CHAN_DEPTH_ATOMXYZ)));
#endif
channel float8  chan_Conf2Intere_xyz           __attribute__((depth(CHAN_NEW_DEPTH_ATOMXYZ)));

channel char  	chan_Conf2Intere_actmode;

#if 0
channel float8	chan_Conf2Intrae_xyz           __attribute__((depth(CHAN_DEPTH_ATOMXYZ)));
#endif
channel float8	chan_Conf2Intrae_xyz           __attribute__((depth(CHAN_NEW_DEPTH_ATOMXYZ)));

channel char  	chan_Conf2Intrae_actmode;	

// Send energy values from InterE & IntraE to genotype-senders (IC, GG)
#if 1
channel float 	chan_Intere2StoreGG_intere     __attribute__((depth(MAX_POPSIZE)));
#endif
#if 1
channel float 	chan_Intere2StoreIC_intere     __attribute__((depth(MAX_POPSIZE)));
#endif

#if 1
channel float 	chan_Intrae2StoreGG_intrae     __attribute__((depth(MAX_POPSIZE)));
#endif
#if 1
channel float 	chan_Intrae2StoreIC_intrae     __attribute__((depth(MAX_POPSIZE)));
#endif

// Send PRNG outputs from generators to consumers
channel float8   chan_PRNG2GA_BT_ushort_float_prng;
channel uchar2   chan_PRNG2GA_GG_uchar_prng;
channel float    chan_PRNG2GA_GG_float_prng     __attribute__((depth(CHAN_DEPTH_GENOTYPE)));

// Turn-off signals to PRNG generators

// FIXME: these channels don't go anymore through IGL_Arbiter.
// That was initially the case, but was fixed.
// Name should be changed accordingly (GA instead of Arbiter)
// to avoid misleading data-flow information
channel bool 	chan_Arbiter_BT_ushort_float_off;
channel bool    chan_Arbiter_GG_uchar_off;
channel bool    chan_Arbiter_GG_float_off;

// Send genotype-producer-channel selector and genotype 
// from IGL_Arbiter to Conform
channel char  chan_IGL2Conform_actmode	       __attribute__((depth(3))); // mode

// Turn-off signal to IGL_Arbiter, Conform, InterE, IntraE
channel bool   chan_IGLArbiter_Off;

#if defined (FIXED_POINT_CONFORM) 
#include "../defines_fixedpt.h"
typedef int3          fixedpt3;
typedef int4	      fixedpt4;
#endif

#if defined (FIXED_POINT_INTERE) || defined (FIXED_POINT_INTRAE)
#include "../defines_fixedpt_64.h"
#endif

// --------------------------------------------------------------------------
// Map the argument into the interval 0 - 180, or 0 - 360
// by adding/subtracting n*ang_max to/from it.
// Originally from: searchoptimum.c
// --------------------------------------------------------------------------

float map_angle_180(float angle)
{
	float x = angle;
	//while (x < 0.0f)
	if (x < 0.0f)   
	{ x += 180.0f; }
	//while (x > 180.0f)
	if (x > 180.0f) 
	{ x -= 180.0f; }
	return x;
}

float map_angle_360(float angle)
{
	float x = angle;
	//while (x < 0.0f)
	if (x < 0.0f)
	{ x += 360.0f; }
	//while (x > 360.0f)
	if (x > 360.0f)
	{ x -= 360.0f;}
	return x;
}

// Shift register sizes
// Such registers are used to reduce Initiation Interval (II)
#define SHIFT_REG_SIZE 10
#define SHIFT_REG_SIZE_MINUS_ONE (SHIFT_REG_SIZE-1)

// --------------------------------------------------------------------------
// Lamarckian Genetic-Algorithm (GA): GA + LS (Local Search) 
// Originally from: searchoptimum.c
// --------------------------------------------------------------------------
__kernel __attribute__ ((max_global_work_dim(0)))
void Krnl_GA(__global       float*           restrict GlobPopulationCurrent,
	     __global       float*           restrict GlobEnergyCurrent,
	     #if defined(SINGLE_COPY_POP_ENE)
   	     __global       unsigned int*    restrict GlobEvals_performed,
             __global       unsigned int*    restrict GlobGens_performed,
	     #else
	     __global       unsigned int*    restrict GlobEvalsGenerations_performed,
	     #endif
			    unsigned int              DockConst_pop_size,
		     	    unsigned int              DockConst_num_of_energy_evals,
			    unsigned int              DockConst_num_of_generations,
		      	    float                     DockConst_tournament_rate,
			    float                     DockConst_mutation_rate,
		    	    float                     DockConst_abs_max_dmov,
			    float                     DockConst_abs_max_dang,
		    	    float                     Host_two_absmaxdmov,
			    float                     Host_two_absmaxdang,
			    float                     DockConst_crossover_rate,
#if 0
			    unsigned int              DockConst_num_of_lsentities,
#endif
			    unsigned char             DockConst_num_of_genes
	     #if defined(SINGLE_COPY_POP_ENE)
	     					      ,
	                    unsigned short            Host_RunId,
			    unsigned int 	      Host_Offset_Pop,
			    unsigned int	      Host_Offset_Ene
	     #endif
	     )
{
	#if defined (DEBUG_KRNL_GA)
	printf("\n");
	printf("%-40s %u\n", "DockConst_pop_size: ",        		DockConst_pop_size);
	printf("%-40s %u\n", "DockConst_num_of_energy_evals: ",  	DockConst_num_of_energy_evals);
	printf("%-40s %u\n", "DockConst_num_of_generations: ",  	DockConst_num_of_generations);
	printf("%-40s %f\n", "DockConst_tournament_rate: ", 		DockConst_tournament_rate);
	printf("%-40s %f\n", "DockConst_mutation_rate: ", 		DockConst_mutation_rate);
	printf("%-40s +/-%fA\n", "DockConst_abs_max_dmov: ",		DockConst_abs_max_dmov);
	printf("%-40s +/-%f°\n", "DockConst_abs_max_dang: ",  		DockConst_abs_max_dang);
	printf("%-40s +/-%fA\n", "Host_two_absmaxdmov: ",		Host_two_absmaxdmov);
	printf("%-40s +/-%f°\n", "Host_two_absmaxdang: ",  		Host_two_absmaxdang);
	printf("%-40s %f\n", "DockConst_crossover_rate: ", 		DockConst_crossover_rate);
#if 0
	printf("%-40s %u\n", "DockConst_num_of_lsentities: ",   	DockConst_num_of_lsentities);
#endif
	printf("%-40s %u\n", "DockConst_num_of_genes: ",        	DockConst_num_of_genes);
	#endif

	// Other banking configuration (see PopNext, eneNext) might reduce logic
	// but makes PopCurr stallable
	__local float LocalPopCurr[MAX_POPSIZE][ACTUAL_GENOTYPE_LENGTH];
	__local float LocalEneCurr[MAX_POPSIZE];

	#if defined(SINGLE_COPY_POP_ENE)
	__global float* GlobPopCurr = & GlobPopulationCurrent [Host_Offset_Pop];
	__global float* GlobEneCurr = & GlobEnergyCurrent     [Host_Offset_Ene];
	#endif

	bool main_loop_enable = false;
	bool exit_enable = false;
	uint eval_cnt;
	uint generation_cnt;

	// ------------------------------------------------------------------
	// Initial Calculation (IC) of scores
	// ------------------------------------------------------------------
	bool rx_IC_enable = false;

	for (ushort pop_cnt = 0; pop_cnt < DockConst_pop_size; pop_cnt++) {
		// Calculate energy
		write_channel_altera(chan_GA2IGL_IC_active, true);
		mem_fence(CLK_CHANNEL_MEM_FENCE);

		for (uchar pipe_cnt=0; pipe_cnt<DockConst_num_of_genes; pipe_cnt++) {

#if 0
			#if defined(SINGLE_COPY_POP_ENE)
			LocalPopCurr[pop_cnt][pipe_cnt & MASK_GENOTYPE] = GlobPopCurr[pop_cnt*ACTUAL_GENOTYPE_LENGTH + pipe_cnt];
			#else
			LocalPopCurr[pop_cnt][pipe_cnt & MASK_GENOTYPE] = GlobPopulationCurrent[pop_cnt*ACTUAL_GENOTYPE_LENGTH + pipe_cnt];
			#endif

			write_channel_altera(chan_IC2Conf_genotype, LocalPopCurr[pop_cnt][pipe_cnt & MASK_GENOTYPE]);	
#endif

#if 1
			float tmp_ic;
			#if defined(SINGLE_COPY_POP_ENE)
			tmp_ic = GlobPopCurr[pop_cnt*ACTUAL_GENOTYPE_LENGTH + pipe_cnt];
			#else
			tmp_ic = GlobPopulationCurrent[pop_cnt*ACTUAL_GENOTYPE_LENGTH + pipe_cnt];
			#endif
		
			LocalPopCurr[pop_cnt][pipe_cnt & MASK_GENOTYPE] = tmp_ic;
			write_channel_altera(chan_IC2Conf_genotype, tmp_ic);
#endif
		}

		#if defined (DEBUG_KRNL_IC)
		printf("\nIC - tx pop: %u", pop_cnt); 		
		#endif

		if (pop_cnt == (DockConst_pop_size-1)) {
			rx_IC_enable = true;
		}
	}

	// Read energy
	if (rx_IC_enable == true) {
		for (ushort pop_cnt = 0; pop_cnt < DockConst_pop_size; pop_cnt++) {
			float energyIA_IC_rx = read_channel_altera(chan_Intrae2StoreIC_intrae);
			float energyIE_IC_rx = read_channel_altera(chan_Intere2StoreIC_intere);
			mem_fence(CLK_CHANNEL_MEM_FENCE);
			LocalEneCurr[pop_cnt] = energyIA_IC_rx + energyIE_IC_rx;

			#if defined (DEBUG_KRNL_IC)
			printf(", IC - rx pop: %u\n", pop_cnt); 		
			#endif

			if (pop_cnt == (DockConst_pop_size - 1)){
				main_loop_enable = true;
				eval_cnt = DockConst_pop_size; // takes into account the IC evals
				generation_cnt = 0;
			}
		}
	}
	mem_fence(CLK_LOCAL_MEM_FENCE);
	// ------------------------------------------------------------------

	//printf("\nIC loop finished!"); 	

	if (main_loop_enable == true) {
		while ((eval_cnt < DockConst_num_of_energy_evals) && (generation_cnt < DockConst_num_of_generations)) {

			//float LocalPopNext[MAX_POPSIZE][ACTUAL_GENOTYPE_LENGTH];
			//float LocalEneNext[MAX_POPSIZE];

			// This configuration reduces logic and does not increase block RAM usage
			float __attribute__ ((
					       memory,
			   		       numbanks(4),
					       bankwidth(32),
					      )) LocalPopNext[MAX_POPSIZE][ACTUAL_GENOTYPE_LENGTH];

			float __attribute__ ((
					       memory,
			   		       numbanks(4),
					       bankwidth(4),
					      )) LocalEneNext[MAX_POPSIZE];

			// ------------------------------------------------------------------
			// Genetic Generation (GG)
			// ------------------------------------------------------------------
			float __attribute__ ((
					       memory,
			   		       numbanks(1),
					       bankwidth(64),
					       singlepump,
	 			               numreadports(6),
					       numwriteports(1)
					      )) loc_energies[MAX_POPSIZE];
		
			bool GG_gen_enable = false;

			// Shift register to reduce II (initially II=6) of best entity for-loop 
			float shift_reg[SHIFT_REG_SIZE];

			#pragma unroll
			for (uchar i=0; i<SHIFT_REG_SIZE; i++) {
				shift_reg[i] = 0.0f;
			}

			ushort best_entity = 0;

	//		for (ushort pop_cnt=1; pop_cnt<DockConst_pop_size; pop_cnt++) {
			for (ushort pop_cnt=0; pop_cnt<DockConst_pop_size; pop_cnt++) {
				// copy energy to local memory
				loc_energies[pop_cnt] = LocalEneCurr[pop_cnt];

				// Identifying best entity
				// The enclosing "if (pop_cnt>0) {}" should not be commented
				// but it is removed in order to improve performance.
				// It does not affect functionality as it performs 
				// an unnecessary evaluation when pop_cnt=0 
				//if (pop_cnt>0) {
				shift_reg[SHIFT_REG_SIZE_MINUS_ONE] = loc_energies[best_entity];

				#pragma unroll
				for (uchar j=0; j<SHIFT_REG_SIZE_MINUS_ONE; j++) {
					shift_reg[j] = shift_reg[j+1];
				}
			
				if (loc_energies[pop_cnt] < shift_reg[0]) {
					best_entity = pop_cnt;
				}
				//}

				if (pop_cnt == (DockConst_pop_size-1)) {
					GG_gen_enable = true;
				}
			}

			bool rx_GG_enable = false;

			if (GG_gen_enable ==  true) {
				#pragma ivdep array (LocalPopNext)
				#pragma ivdep array (LocalEneNext)
				for (ushort new_pop_cnt = 1; new_pop_cnt < DockConst_pop_size; new_pop_cnt++) {

					// ---------------------------------------------------
					// Elitism: copying the best entity to new population
					// ---------------------------------------------------
					if (new_pop_cnt == 1) {
						#pragma unroll
						for (uchar gene_cnt=0; gene_cnt<ACTUAL_GENOTYPE_LENGTH; gene_cnt++) { 		
							LocalPopNext[0][gene_cnt & MASK_GENOTYPE] = LocalPopCurr[best_entity][gene_cnt & MASK_GENOTYPE]; 	
						} 		
						LocalEneNext[0] = loc_energies[best_entity];
					}

					#if defined (DEBUG_KRNL_GA)
					printf("Krnl_GA: %u\n", new_pop_cnt);
					#endif

					float local_entity_1 [ACTUAL_GENOTYPE_LENGTH];
					float local_entity_2 [ACTUAL_GENOTYPE_LENGTH]; 
		
					// ---------------------------------------------------
					// Binary-Tournament (BT) selection
					// ---------------------------------------------------

					// Get ushort binary_tournament selection prngs (parent index)
					// Get float binary_tournament selection prngs (tournament rate)
					float8 bt_tmp = read_channel_altera(chan_PRNG2GA_BT_ushort_float_prng);
					mem_fence(CLK_CHANNEL_MEM_FENCE);

					// Convert: float prng that must be still converted to short
					float bt_tmp_uf0 = bt_tmp.s0; 
					float bt_tmp_uf1 = bt_tmp.s2;
					float bt_tmp_uf2 = bt_tmp.s4;
					float bt_tmp_uf3 = bt_tmp.s6;

					// short prng ready to be used, replace ushort prng_BT_U[4];
					ushort bt_tmp_u0 = *(uint*)&bt_tmp_uf0;
					ushort bt_tmp_u1 = *(uint*)&bt_tmp_uf1;
					ushort bt_tmp_u2 = *(uint*)&bt_tmp_uf2;
					ushort bt_tmp_u3 = *(uint*)&bt_tmp_uf3;

					// float prng ready to used, replace float prng_BT_F[4];
					float bt_tmp_f0 = bt_tmp.s1;
					float bt_tmp_f1 = bt_tmp.s3;
					float bt_tmp_f2 = bt_tmp.s5;
					float bt_tmp_f3 = bt_tmp.s7;

					ushort parent1;
					ushort parent2; 

					// First parent
					if (loc_energies[bt_tmp_u0] < loc_energies[bt_tmp_u1]) {
						if (bt_tmp_f0 < DockConst_tournament_rate) {parent1 = bt_tmp_u0;}
						else				           {parent1 = bt_tmp_u1;}}
					else {
						if (bt_tmp_f1 < DockConst_tournament_rate) {parent1 = bt_tmp_u1;}
						else				           {parent1 = bt_tmp_u0;}}

					// The better will be the second parent
					if (loc_energies[bt_tmp_u2] < loc_energies[bt_tmp_u3]) {
						if (bt_tmp_f2 < DockConst_tournament_rate) {parent2 = bt_tmp_u2;}
						else		          	           {parent2 = bt_tmp_u3;}}
					else {
						if (bt_tmp_f3 < DockConst_tournament_rate) {parent2 = bt_tmp_u3;}
						else			                   {parent2 = bt_tmp_u2;}}

					// local_entity_1 and local_entity_2 are population-parent1, population-parent2
					for (uchar gene_cnt=0; gene_cnt<DockConst_num_of_genes; gene_cnt++) {
						local_entity_1[gene_cnt & MASK_GENOTYPE] = LocalPopCurr[parent1][gene_cnt & MASK_GENOTYPE];
						local_entity_2[gene_cnt & MASK_GENOTYPE] = LocalPopCurr[parent2][gene_cnt & MASK_GENOTYPE];
					}

					// ---------------------------------------------------
					// Mating parents
					// ---------------------------------------------------	

					// get uchar genetic_generation prngs (gene index)
					// get float genetic_generation prngs (mutation rate)
					uchar2 prng_GG_C = read_channel_altera(chan_PRNG2GA_GG_uchar_prng);
					mem_fence(CLK_CHANNEL_MEM_FENCE);

					uchar covr_point_low;
					uchar covr_point_high;
					bool twopoint_cross_yes = false;

					if (prng_GG_C.x == prng_GG_C.y) {covr_point_low = prng_GG_C.x;}
					else {
						twopoint_cross_yes = true;
						if (prng_GG_C.x < prng_GG_C.y) { covr_point_low  = prng_GG_C.x;
									         covr_point_high = prng_GG_C.y; }
						else {		      		 covr_point_low  = prng_GG_C.y;
		   								 covr_point_high = prng_GG_C.x; }
					}
			
					// Reuse of bt prng float as crossover-rate
					bool crossover_yes = (DockConst_crossover_rate > bt_tmp_f0);

					write_channel_altera(chan_GA2IGL_GG_active, true);
					mem_fence(CLK_CHANNEL_MEM_FENCE);

					for (uchar gene_cnt=0; gene_cnt<DockConst_num_of_genes; gene_cnt++) {

						float prngGG = read_channel_altera(chan_PRNG2GA_GG_float_prng);
						mem_fence(CLK_CHANNEL_MEM_FENCE);

						float tmp_offspring;

						// Performing crossover
						if (   	(
							crossover_yes && (										// crossover
							( (twopoint_cross_yes == true)  && ((gene_cnt <= covr_point_low) || (gene_cnt > covr_point_high)) )  ||	// two-point crossover 			 		
							( (twopoint_cross_yes == false) && (gene_cnt <= covr_point_low))  					// one-point crossover
							)) || 
							(!crossover_yes)	// no crossover
						   ) {
							tmp_offspring = local_entity_1[gene_cnt & MASK_GENOTYPE];
						}
						else {
							tmp_offspring = local_entity_2[gene_cnt & MASK_GENOTYPE];
						}

						// Performing mutation
						if (DockConst_mutation_rate > prngGG) {
							if(gene_cnt<3) {
								tmp_offspring = tmp_offspring + Host_two_absmaxdmov*prngGG-DockConst_abs_max_dmov;
							}
							else {
								float tmp;
								tmp = tmp_offspring + Host_two_absmaxdang*prngGG-DockConst_abs_max_dang;
								if (gene_cnt==4) { tmp_offspring = map_angle_180(tmp); }
								else             { tmp_offspring = map_angle_360(tmp); }
							}
						}

						// Calculate energy
						LocalPopNext [new_pop_cnt][gene_cnt & MASK_GENOTYPE] = tmp_offspring;
						write_channel_altera(chan_GG2Conf_genotype, tmp_offspring);
					}

					#if defined (DEBUG_KRNL_GG)
					printf("GG - tx pop: %u", new_pop_cnt); 		
					#endif	

					if (new_pop_cnt == (DockConst_pop_size-1)) {
						rx_GG_enable = true;
					}
				}
			}

			// No channel nor global/local fence would be useful for synchronization here
			// as theres no such dependency between blocks in question,
			// update_pop_ene_enable is added
			bool update_pop_ene_enable = false;

			// Read energy
			if (rx_GG_enable == true) {
				for (ushort new_pop_cnt = 1; new_pop_cnt < DockConst_pop_size; new_pop_cnt++) {
					float energyIA_GG_rx = read_channel_altera(chan_Intrae2StoreGG_intrae);
					float energyIE_GG_rx = read_channel_altera(chan_Intere2StoreGG_intere);
					mem_fence(CLK_CHANNEL_MEM_FENCE);
					LocalEneNext[new_pop_cnt] = energyIA_GG_rx + energyIE_GG_rx;

					#if defined (DEBUG_KRNL_GG)
					printf(", GG - rx pop: %u\n", new_pop_cnt); 		
					#endif

					if (new_pop_cnt == (DockConst_pop_size-1)) {
						update_pop_ene_enable = true;
					}
				}
			}
		
			// TODO: check that pop en curr is correctly updated!

			// Update current pops & energies
			if (update_pop_ene_enable == true) {
				for (ushort pop_cnt=0; pop_cnt<DockConst_pop_size; pop_cnt++) {
					for (uchar gene_cnt=0; gene_cnt<DockConst_num_of_genes; gene_cnt++) {
						LocalPopCurr[pop_cnt][gene_cnt & MASK_GENOTYPE] = LocalPopNext[pop_cnt][gene_cnt & MASK_GENOTYPE];
					}

					LocalEneCurr[pop_cnt] = LocalEneNext[pop_cnt];
				}
			}
			mem_fence(CLK_LOCAL_MEM_FENCE);

			// Update energy evaluations count: GG evals
			eval_cnt += DockConst_pop_size; 

			// Update generation count
			generation_cnt++;

			#if defined (DEBUG_KRNL_GA)
			printf("eval_cnt: %u, generation_cnt: %u\n", eval_cnt, generation_cnt);
			#endif
		} // End while eval_cnt & generation_cnt

		if ((eval_cnt > DockConst_num_of_energy_evals) || (generation_cnt > DockConst_num_of_generations)) {
			exit_enable = true;
		}
	} // End if (main_loop_enable == true)

	// ------------------------------------------------------------------
	// Off: turn off all other kernels
	// ------------------------------------------------------------------

	if (exit_enable == true) {
		// Turn off PRNG kernels
		write_channel_altera(chan_Arbiter_BT_ushort_float_off,  false);
		write_channel_altera(chan_Arbiter_GG_uchar_off, 	false);
		write_channel_altera(chan_Arbiter_GG_float_off, 	false);
		mem_fence(CLK_CHANNEL_MEM_FENCE);

		// Turn off IGL_Arbiter, Conform, InterE, IntraE kernerls
		write_channel_altera(chan_IGLArbiter_Off,     		false);
		mem_fence(CLK_CHANNEL_MEM_FENCE);

		// Write final pop & energies back to FPGA-board DDRs
		for (ushort pop_cnt=0;pop_cnt<DockConst_pop_size; pop_cnt++) { 	

			for (uchar gene_cnt=0; gene_cnt<DockConst_num_of_genes; gene_cnt++) {
				#if defined(SINGLE_COPY_POP_ENE)
				GlobPopCurr[pop_cnt*ACTUAL_GENOTYPE_LENGTH + gene_cnt] = LocalPopCurr[pop_cnt][gene_cnt & MASK_GENOTYPE];
				#else
				GlobPopulationCurrent[pop_cnt*ACTUAL_GENOTYPE_LENGTH + gene_cnt] = LocalPopCurr[pop_cnt][gene_cnt & MASK_GENOTYPE];
				#endif
			}

			#if defined(SINGLE_COPY_POP_ENE)
			GlobEneCurr[pop_cnt] = LocalEneCurr[pop_cnt];
			#else
			GlobEnergyCurrent[pop_cnt] = LocalEneCurr[pop_cnt];
			#endif
		}

		#if defined (DEBUG_KRNL_GA)
		printf("GA: %u %u\n", active, DockConst_pop_size -1);
		#endif

		#if defined (DEBUG_ACTIVE_KERNEL)
		printf("	%-20s: %s\n", "Krnl_GA", "disabled");
		#endif

		// Write final evals & generation counts to FPGA-board DDRs
		#if defined(SINGLE_COPY_POP_ENE)
		GlobEvals_performed[Host_RunId] = eval_cnt;
		GlobGens_performed [Host_RunId] = generation_cnt;
		#else
		GlobEvalsGenerations_performed[0] = eval_cnt;
		GlobEvalsGenerations_performed[1] = generation_cnt;
		#endif
	}
}

// --------------------------------------------------------------------------
// --------------------------------------------------------------------------

#include "Krnl_PRNG.cl"

#include "Krnl_IGL_Arbiter.cl"
#include "Krnl_Conform.cl"
#include "Krnl_InterE.cl"
#include "Krnl_IntraE.cl"