Introduction

• Interprets 57 billion GP primitives per second (212 peak)
• How?
  • Submachine code each int contains 32 Booleans
  • Park-miller randomised test case selection
  • Simple CUDA reverse polish interpreter
• 20 mux solved (<< 1500 days)
• 37 mux solved. 137 billion test cases

Submachine Code GP

• int contains 32 bits. Treat each as Boolean.
• 32 Boolean (and or, nor, if, not etc) done simultaneously.
• Load 32 test cases
  • D₀ = 01010101…
  • D₁ = 00110011…
  • D_N = 00000000… or 11111111…
• Check 32 answers simultaneously
• CPU speed up 24 fold (32) 60 fold (64 bits)

Randomised Samples

• Park-Miller only used for 20-mux and 37-mux 2048 of 1million, 8192 of 137 billion)
• Always multiple of 32 (lowest 5 inputs)
  • 20 mux sample from 0..2³¹-1 (could repeat)
  • 37 mux Park-Miller only 31 bits (not zero) so test PRNG and then negate it.
• Same tests for everyone in 4-tournament
• New tests for new gen and each tournament
• (Statistical significance test tried on GPU but in the end not needed)

Reverse Polish Interpreter

• (A-10)×B ≡ A 10 - B ×
  • Variable: push onto stack
  • Function pop arguments, do operation, push result

RPN interpreters

int SP = 0;
for(unsigned int PC = 0;; PC++){
Read opcode from global/constant
if(OPCODE==OPNOP) break;
if(optype==leaf) push(trainingdata);
else { //function
const unsigned int sp1 = stack(SP-1);
const unsigned int sp2 = stack(SP-2);
SP -= 2;
if(      optype==OPAND) push(AND(sp1,sp2));
else if(optype==OPOR) push(  OR(sp1,sp2));
//NAND, NOR negate top of stack
}}

int SP = 0;
for(unsigned int PC = 0;; PC++){
Read opcode from global/constant
if(OPCODE==OPNOP) break;
top(leaf) = trainingdata;
const unsigned int sp1 = stack(SP-1);
const unsigned int sp2 = stack(SP-2);
top(OPAND) = AND(sp1,sp2);
top(OPOR)  =  OR(sp1,sp2);
SP += delta[optype];
stack(SP-1) = top(optype);
//NAND, NOR negate top of stack
}

(Almost) Branchless Interpreter

• The idea was to avoid the problem of excessive thread blocking encountered in previous GP interpreters. These are caused by the many ifs (or case statements) per interpreted opcode, which leads threads to diverge as they try to take different if-then-else branches in parallel.
  • So interpreter executes every opcode every time.
  • Result stored in shared array.
  • Adjust stack pointer up/down.
  • Move required result onto top of stack.
• No branches
• If end of RPN tree exit loop (special case)

Validation

• Solutions run on all test cases in GPU.
• Evolved 20-mux and 37-mux expressions converted to C code, compiled and run against all tests

Performance v RPN size

Performance

• nVidia Tesla T10P early engineering sample (192 stream processors)
• 57 10⁹ GP operations/second (peak 212 10⁹)
• Branchless array based ≈ if based
  • Small improvement 192 →240 thread
  • Big (88 10⁹ → 212 10⁹ GPops) when test generality of evolved single individual on many threads
• 70 times RapidMind [EuroGP 2008].
  • hardware similar nVidia GeForce 8800 GTX (128 stream processors)