Example1-Speed

A simple, benchmarking scenario.

Below code tests the speed of a neutral, constant population simulation on a GPU:

/*
 * run.cu
 *
 *      Author: David Lawrie
 */

#include "go_fish.cuh"

void run_speed_test()
{
    //----- speed test scenario parameters -----
    GO_Fish::allele_trajectories a;
    a.sim_input_constants.num_populations = 1;                                  //1 population
    Sim_Model::F_mu_h_constant mutation(pow(10.f,-9));                          //per-site mutation rate 10^-9
    Sim_Model::F_mu_h_constant inbreeding(1.f);                                 //constant inbreeding (fully inbred)
    Sim_Model::demography_constant demography(pow(10.f,5)*(1+inbreeding(0,0))); //200,000 haploid individuals in population, set to maintain consistent effective number of chromosomes invariant w.r.t. inbreeding
    Sim_Model::migration_constant_equal migration;                              //constant, 0, migration rate
    Sim_Model::selection_constant selection(0);                                 //constant, neutral, selection coefficient
    Sim_Model::F_mu_h_constant dominance(0.f);                                  //constant allele dominance (effectively ignored since F = 1)
    a.sim_input_constants.num_generations = pow(10.f,3);                        //1,000 generations in simulation
    a.sim_input_constants.seed1 = 0xbeeff00d;                                   //random number seeds
    a.sim_input_constants.seed2 = 0xdecafbad;

    a.sim_input_constants.num_sites = 20*2*pow(10.f,7);                         //number of sites
    a.sim_input_constants.compact_interval = 15;                                //compact interval (in general: decrease compact interval for larger number of sites)
    //----- end speed test scenario parameters -----

    //----- speed test -----
    cudaEvent_t start, stop;                                                    //CUDA timing functions
    float elapsedTime;
    int num_iter = 20;
    cudaEventCreate(&start);
    cudaEventCreate(&stop);

    for(int i = 0; i < num_iter; i++){
        if(i == num_iter/2){ cudaEventRecord(start, 0); }                       //use half of the simulations to warm-up GPU, the other half to time simulation runs
        GO_Fish::run_sim(a,mutation,demography,migration,selection,inbreeding,dominance,Sim_Model::bool_off(),Sim_Model::bool_off());
    }

    elapsedTime = 0;
    cudaEventRecord(stop, 0);
    cudaEventSynchronize(stop);
    cudaEventElapsedTime(&elapsedTime, start, stop);
    cudaEventDestroy(start);
    cudaEventDestroy(stop);

    std::cout<<"number of sites:\t"<< a.sim_input_constants.num_sites<<std::endl<< "compact interval:\t"<< a.sim_input_constants.compact_interval<<std::endl<<"number of mutations:\t"<<a.maximal_num_mutations()<<std::endl<<"time elapsed (ms):\t"<<2*elapsedTime/num_iter<<std::endl;
    //----- end speed test -----
    //
}



int main(int argc, char **argv){ run_speed_test(); }

In the example makefile below, each line is documented by the top part of the makefile:

Tip: The makefile below compiles machine code explicitly for generation 3.0 and 5.2 GPUs and uses just in time (JIT) compilation for everything else (lowest GPU generation which works for 3P is 3.0). Compilation (and program execution) will be faster if compiling for your specific GPU.

e.g. if running a Tesla K20 or Tesla K40, then the corresponding GPU generation is 3.5: all the current --generate-code arch=##,code=## flags can be deleted and replaced with --generate-code arch=compute_35,code=sm_35.

# Description of Mac/Linux/Unix Makefile for example_speed. 
#
#############################
# build_path := Where to build program and put executable (note: folder must already exist)
# api_path_source := Location of API source folder
# api_path_include := Location of API include folder
# EXEC_FILE := Name of executable 
#
# NVCC := Compiler path, in this case nvcc is in $PATH
# CFLAGS := Compiler Flags: optimize most, fast math, add API include folder to include search path, equivalent to --relocatable-device-code=true --compile
# CODE := GPU types for which to build explicitly (I have a NVIDIA GTX 780M and 980) https://developer.nvidia.com/cuda-gpus, creates machine code for code=sm_30 (780) and code=sm_52 (980) and virtual architectures for all other generations which can be compiled JIT - code=compute_30 for generations between (3.0,5.0) and code=compute_50 for generations (5.0 and up) http://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#options-for-steering-gpu-code-generation
#
# object_names := Objects required for executable
# objects := Prepends build path to object names
#
# all := Command 'make' or 'make all' builds executable file $(EXEC_FILE) in location $(build_path)/
#
# ##### Object Dependencies Lists #####
# If one of the files on the right hand side of the : changes, the corresponding object must be recompiled.
# This is a users makefile - it assumes there will be no changes to the GOFish API files, so does not include
# all the non-*.cu (non source file) dependencies. If changes to the API .h or .cuh files are expected see
# Object Dependencies Lists in example_dadi or run 'make clean' before each 'make all'.
# ##### End Object Dependencies Lists #####
#
# $(objects) := Make target all objects
#  Compile source code into objects, $< := dependencies from Object Dependencies Lists, $@ := object in $(objects)
#
# $(build_path)/$(EXEC_FILE) := Make target executable EXEC_FILE which depends on all objects
#  Link objects into executable EXEC_FILE, $@ := $(build_path)/$(EXEC_FILE)
#
# .PHONY := Defines 'all' and 'clean' as not true targets (i.e. don't remake executable if can't find files called 'all' or 'clean')
#
# clean := Action to perform for command 'make clean'
#  Remove all objects and EXEC_FILE from build_path
#############################

build_path = ../example_speed
api_path_source = ../../3P/_internal
api_path_include = ../../3P
EXEC_FILE = GOFish

NVCC = nvcc
CFLAGS = -O3 --use_fast_math -I $(api_path_include)/ -dc
CODE = --generate-code arch=compute_30,code=sm_30 --generate-code arch=compute_52,code=sm_52 --generate-code arch=compute_30,code=compute_30 --generate-code arch=compute_50,code=compute_50

object_names = run.o shared.o go_fish_impl.o
objects = $(addprefix $(build_path)/,$(object_names))

all:$(build_path)/$(EXEC_FILE)

##### OBJECT DEPENDENCIES #####
$(build_path)/run.o: run.cu
$(build_path)/shared.o: $(api_path_source)/shared.cu
$(build_path)/go_fish_impl.o: $(api_path_source)/go_fish_impl.cu
##### END OBJECT DEPENDENCIES #####

$(objects):
   $(NVCC) $(CODE) $(CFLAGS) $< -o $@

$(build_path)/$(EXEC_FILE): $(objects)

   $(NVCC) $(CODE) $(objects) -o $@

.PHONY: all clean

clean:
   rm -f $(objects) $(build_path)/$(EXEC_FILE)