Doubt Branchless code

[matheus]

On Monday, 6 April 2026 at 19:08:53 UTC, matheus wrote:
> ...

I ask deepseek and got the answer and sharing for the future:

Calling Functions Without Branches in D

In D, you can call functions without branches using several 
techniques. Here's a comprehensive guide:

1. Function Pointer Tables (Direct Lookup)

The most common branchless function calling method - use an array 
index instead of conditionals.
d

import std.stdio;

// Define functions
int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }
int div(int a, int b) { return b != 0 ? a / b : 0; }

void main()
{
     // Array of function pointers - branchless dispatch
     int delegate(int, int)[] operations = [&add, &sub, &mul, 
&div];

     int opCode = 2;  // 0=add, 1=sub, 2=mul, 3=div

     // NO branch - direct table lookup and call
     int result = operations[opCode](10, 5);

     writeln(result);  // 50 (mul)
}

2. Using final Switch (Compile-Time Optimized)

D's final switch with an enum can be optimized to a jump table:
d

import std.stdio;

enum Operation { add, sub, mul, div }

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }
int div(int a, int b) { return b != 0 ? a / b : 0; }

int execute(Operation op, int a, int b)
{
     final switch (op) {  // Compiler can optimize to jump table
         case Operation.add: return add(a, b);
         case Operation.sub: return sub(a, b);
         case Operation.mul: return mul(a, b);
         case Operation.div: return div(a, b);
     }
}

void main()
{
     // The compiler may generate branchless code here
     int result = execute(Operation.mul, 10, 5);
     writeln(result);  // 50
}

3. Template-Based Compile-Time Selection

Zero runtime overhead - function selection happens at compile 
time:
d

import std.stdio;

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }

// Template that selects function at compile time
auto execute(alias Func, T...)(T args)
{
     return Func(args);
}

void main()
{
     // These calls are resolved at compile time - NO branches
     int r1 = execute!add(10, 5);     // Direct call to add
     int r2 = execute!sub(10, 5);     // Direct call to sub
     int r3 = execute!mul(10, 5);     // Direct call to mul

     writeln(r1, " ", r2, " ", r3);  // 15 5 50
}

4. Delegate Arrays with Compile-Time Construction

Pre-build delegate arrays for OOP-style branchless dispatch:
d

import std.stdio;

class Handler
{
     void process(int x) { writeln("Handler: ", x); }
}

class Logger
{
     void process(int x) { writeln("Logging: ", x); }
}

void main()
{
     auto handler = new Handler();
     auto logger = new Logger();

     // Array of delegates - branchless dispatch
     void delegate(int)[] processors = [
         (int x) => handler.process(x),
         (int x) => logger.process(x)
     ];

     int type = 1;  // Select at runtime

     // NO if/else - direct table lookup
     processors[type](42);  // Output: Logging: 42
}

5. Using std.functional for Compile-Time Dispatch
d

import std.functional;
import std.stdio;

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }

// Compose functions at compile time
alias Add5 = curry!(add, 5);
alias Mul10 = curry!(mul, 10);

void main()
{
     // All resolved at compile time - branchless
     int r1 = Add5(3);    // 8
     int r2 = Mul10(7);   // 70

     writeln(r1, " ", r2);
}

6. Virtual Function Table (VTBL) - Already Branchless

D's classes use vtables internally, which is naturally branchless:
d

import std.stdio;

interface Operation
{
     int execute(int a, int b);
}

class Add : Operation
{
     int execute(int a, int b) { return a + b; }
}

class Mul : Operation
{
     int execute(int a, int b) { return a * b; }
}

void main()
{
     Operation op;
     int choice = 1;  // Runtime decision

     // This if is the ONLY branch (to select object)
     if (choice == 0)
         op = new Add();
     else
         op = new Mul();

     // The virtual call itself is branchless (vtable lookup)
     int result = op.execute(10, 5);  // No branch here!

     writeln(result);  // 50
}

7. Function Pointer from Associative Array

For sparse or non-sequential selections:
d

import std.stdio;

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }
int power(int a, int b) {
     int r = 1;
     foreach(_; 0..b) r *= a;
     return r;
}

void main()
{
     // Associative array for string-based lookup
     int delegate(int, int)[string] ops = [
         "add": &add,
         "mul": &mul,
         "pow": &power
     ];

     string opName = "pow";

     // Branchless hash lookup + call
     int result = ops[opName](2, 3);
     writeln(result);  // 8
}

Performance Comparison
d

import std.stdio;
import std.datetime;

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }

// Branch version
int withBranches(int op, int a, int b)
{
     if (op == 0) return add(a, b);
     if (op == 1) return sub(a, b);
     return mul(a, b);
}

// Branchless table version
int delegate(int, int)[] table = [&add, &sub, &mul];

int branchless(int op, int a, int b)
{
     return table[op](a, b);
}

void main()
{
     const ITERS = 100_000_000;

     // Test branch version
     auto sw = StopWatch.Auto.start;
     int sum1;
     foreach (i; 0..ITERS)
         sum1 += withBranches(i % 3, 10, 5);
     auto time1 = sw.peek;

     // Test branchless version
     sw.reset();
     int sum2;
     foreach (i; 0..ITERS)
         sum2 += branchless(i % 3, 10, 5);
     auto time2 = sw.peek;

     writeln("Branch version: ", time1);
     writeln("Branchless table: ", time2);
}

Key Takeaway
Function pointer tables (delegate[] or function[]) are the most 
straightforward way to call functions without branches in D. They 
replace:
d

if (op == 0) add();
else if (op == 1) sub();  // BAD: branches
else mul();

With d:

table[op]();  // GOOD: branchless

This works because array indexing is a constant-time operation 
with no conditional branches, and the indirect function call 
through the pointer/delegate is also branchless (the CPU just 
loads the address and jumps).