Performance Benchmarks

import { Sia } from "@timeleap/sia";

const serializeUser = (s: Sia, user: User): void => {
  s.addUInt32(user.id)
    .addString8(user.name)
    .addString8(user.email)
    .addUInt8(user.age)
    .addBool(user.active)
    .addArray8(user.tags, (s, tag) => s.addString8(tag))
    .addUInt16(user.score)
    .addString16(user.bio);
};

const sia = new Sia();
// Benchmark loop
for (let i = 0; i < iterations; i++) {
  sia.seek(0);
  serializeUser(sia, user);
  const bytes = sia.toUint8Array();
}

import protobuf from "protobufjs";

const UserMessage = new protobuf.Type("User")
  .add(new protobuf.Field("id", 1, "uint32"))
  .add(new protobuf.Field("name", 2, "string"))
  .add(new protobuf.Field("email", 3, "string"))
  .add(new protobuf.Field("age", 4, "uint32"))
  .add(new protobuf.Field("active", 5, "bool"))
  .add(new protobuf.Field("tags", 6, "string", "repeated"))
  .add(new protobuf.Field("score", 7, "uint32"))
  .add(new protobuf.Field("bio", 8, "string"));

// Benchmark loop
for (let i = 0; i < iterations; i++) {
  const msg = UserMessage.create(user);
  const bytes = UserMessage.encode(msg).finish();
}

const encoder = new TextEncoder();

// Benchmark loop
for (let i = 0; i < iterations; i++) {
  const json = JSON.stringify(user);
  const bytes = encoder.encode(json);
}

import { pack } from "msgpackr";

// Benchmark loop
for (let i = 0; i < iterations; i++) {
  const bytes = pack(user);
}

const deserializeUser = (s: Sia): User => ({
  id: s.readUInt32(),
  name: s.readString8(),
  email: s.readString8(),
  age: s.readUInt8(),
  active: s.readBool(),
  tags: s.readArray8((s) => s.readString8()),
  score: s.readUInt16(),
  bio: s.readString16(),
});

const reader = new Sia(serializedBytes);
// Benchmark loop
for (let i = 0; i < iterations; i++) {
  reader.seek(0);
  const user = deserializeUser(reader);
}

// Benchmark loop
for (let i = 0; i < iterations; i++) {
  const decoded = UserMessage.decode(serializedBytes);
  const user = UserMessage.toObject(decoded);
}

const decoder = new TextDecoder();

// Benchmark loop
for (let i = 0; i < iterations; i++) {
  const json = decoder.decode(serializedBytes);
  const user = JSON.parse(json);
}

import { unpack } from "msgpackr";

// Benchmark loop
for (let i = 0; i < iterations; i++) {
  const user = unpack(serializedBytes);
}

// Sia: zero allocations in the hot path
const sia = new Sia(); // uses shared 32 MB buffer (lazy-allocated on first use)

for (let i = 0; i < 100_000; i++) {
  sia.seek(0); // reset offset — no allocation
  serializeUser(sia, user);
  const bytes = sia.toUint8Array(); // one allocation: the output copy
}
// Total allocations: 100,000 (one Uint8Array per iteration)

const encoder = new TextEncoder();

for (let i = 0; i < 100_000; i++) {
  const json = JSON.stringify(user); // allocation: string
  const bytes = encoder.encode(json); // allocation: Uint8Array
}
// Total allocations: 200,000 (one string + one Uint8Array per iteration)

// 1. Reuse Sia instances
const writer = new Sia();

function serialize(user: User): Uint8Array {
  writer.seek(0);
  serializeUser(writer, user);
  return writer.toUint8Array();
}

// 2. Use addAscii8 for ASCII-only strings
writer.addAscii8("status"); // faster than addString8

// 3. Pre-define serializer functions (avoid closures in loops)
const serializeTag = (s: Sia, tag: string): void => {
  s.addString8(tag);
};

// 4. Use toUint8ArrayReference for immediate consumption
const ref = writer.toUint8ArrayReference();
socket.send(ref);

// 1. Reuse Sia reader instances with setContent
const reader = new Sia(new Uint8Array(0));

function deserialize(data: Uint8Array): User {
  reader.setContent(data);
  return deserializeUser(reader);
}

// 2. Use reference reads for temporary data
const tempBytes = reader.readByteArray32(true); // zero-copy

// 3. Read directly into processing — avoid intermediate variables
processUser(
  reader.readUInt32(), // id
  reader.readString8(), // name
  reader.readUInt8(), // age
);