Operation Tiers

Tier 0: 114 ns between built values

Addition, subtraction, integer-scalar multiplication and left shift update the protected value in place. Between two values that already exist, x += y took 114 ns, cheap enough for per-frame game logic. With a plain-number operand, += and -= first build a temporary protected value and destroy it afterwards: x += 25 took 6.2 µs and x -= Compuon<int>(25) 6.6 µs, more than a Tier 1 assignment. Integer-scalar *= and <<= take the plain number directly and build no temporary (not timed). In a per-frame path, build a fixed operand once and reuse it.¹

Compuon<int> hp(100);
Compuon<int> regen(5);   // built once, reused every tick
Compuon<int> x(4);

hp += regen;             // both values built: 114 ns (x += y)
hp += Compuon<int>(10);  // temporary value per call: ~6.6 µs (x -= Compuon<int>(25))
hp -= 25;                // plain number, same: ~6.2 µs (x += 25)
x <<= 3;                 // Tier 0, not timed

Tier 1: 5.9 µs

Operations that re-encode the value from scratch. Assigning a plain number (x = v) took 5.9 µs; the other Tier 1 operators were not timed. Still usable per frame — 100 assignments come to about 0.59 ms, 3.5% of a 16.67 ms (60 Hz) frame.¹

Compuon<int> hp(100);
Compuon<int> other(2);
Compuon<int> mask(0x3F);

hp = 50;                  // assignment: 5.9 µs (x = v)
hp *= other;              // multiply: Tier 1, not timed
hp /= other;              // division: Tier 1, not timed
hp %= Compuon<int>(10);   // modulo: Tier 1, not timed (plus a temporary value)
hp >>= 1;                 // right shift: Tier 1, not timed
hp &= mask;               // bitwise AND/OR/XOR: Tier 1, not timed
auto flipped = ~mask;     // bitwise NOT (integer only): Tier 1, not timed

Tier 2: comparisons

Comparisons read the cached value of each side. They were not timed separately; a read of the cache took 0.2 ns, at the benchmark's resolution. Compare against a value that already exists or against a plain number: hp > Compuon<int>(0) first builds and destroys a temporary protected value, which took 6.1 µs on its own.¹

Compuon<int> hp(100);
Compuon<int> other(100);

bool dead  = hp <= 0;               // reads the cache
bool same  = hp == other;           // reads both caches
bool alive = hp > Compuon<int>(0);  // builds a temporary value first

Deferred mode

Compuon<T, true>keeps no plaintext, so every read and every operation folds against the server's operand bundle, and a read then decodes. On the same machine a read (val()) took 37.1 µs, about 17 times verify() (2.2 µs); x += y took 30.7 µs, x += 25 75.9 µs and x = v 43.2 µs. A comparison reads each deferred side. Use deferred mode for values read occasionally, not every frame.¹

Performance Guidelines