Rust・Python・Java・TSなど10言語をAI実装で実測比較！実行時間とメモリ差

// ビルド例: clang++ -std=c++20 -O3 bench.cpp -o bin_cpp
#include <algorithm>
#include <chrono>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>

struct Record {
    uint32_t id;
    uint32_t category;
    uint32_t amount;
};

int main(int argc, char **argv) {
    uint32_t seed = (argc > 1) ? static_cast<uint32_t>(std::strtoul(argv[1], nullptr, 10)) : 123456789u;
    const char *log_path = (argc > 2) ? argv[2] : "access.log";

    using clock = std::chrono::steady_clock;
    auto ms_diff = [](clock::time_point a, clock::time_point b) {
        return std::chrono::duration<double, std::milli>(b - a).count();
    };

    auto t0 = clock::now();

    // Stage 1
    uint32_t x = seed;
    uint32_t acc = 0;
    for (uint32_t i = 0; i < 30000000u; ++i) {
        x ^= x << 13;
        x ^= x >> 17;
        x ^= x << 5;
        if (x & 1u) {
            acc += (x ^ 0x9E3779B9u);
        } else {
            acc ^= (x >> 2);
        }
    }
    uint32_t chk1 = acc;
    auto t1 = clock::now();

    // Stage 2
    const size_t m = 1000000;
    std::vector<Record> records;
    records.reserve(m);
    uint32_t s = seed ^ 0xA5A5A5A5u;
    for (uint32_t i = 0; i < static_cast<uint32_t>(m); ++i) {
        s ^= s << 13;
        s ^= s >> 17;
        s ^= s << 5;
        records.push_back(Record{i, s & 63u, s % 1000000u});
    }
    std::sort(records.begin(), records.end(), [](const Record &a, const Record &b) {
        if (a.amount != b.amount) return a.amount < b.amount;
        return a.id < b.id;
    });
    uint64_t chk2 = 0;
    for (size_t i = 0; i < m; ++i) {
        chk2 += static_cast<uint64_t>(records[i].amount) * static_cast<uint64_t>((i & 255u) + 1u) +
                static_cast<uint64_t>(records[i].category);
    }
    auto t2 = clock::now();

    // Stage 3
    std::ifstream ifs(log_path);
    std::unordered_map<std::string, uint64_t> map;
    map.reserve(128);
    std::string line;
    while (std::getline(ifs, line)) {
        if (!line.empty() && line.back() == '\r') line.pop_back();
        std::string_view sv(line);
        size_t p1 = sv.find('|');
        if (p1 == std::string_view::npos) continue;
        size_t p2 = sv.find('|', p1 + 1);
        if (p2 == std::string_view::npos) continue;
        std::string_view lvl = sv.substr(p1 + 1, p2 - p1 - 1);
        if (lvl != "ERROR" && lvl != "WARN") continue;
        size_t p3 = sv.find('|', p2 + 1);
        if (p3 == std::string_view::npos) continue;
        std::string_view svc = sv.substr(p2 + 1, p3 - p2 - 1);
        size_t p4 = sv.find('|', p3 + 1);
        if (p4 == std::string_view::npos) continue;
        std::string_view ms_field = sv.substr(p4 + 1);
        if (ms_field.substr(0, 3) == "ms=") {
            uint64_t ms_val = std::strtoull(ms_field.data() + 3, nullptr, 10);
            map[std::string(svc)] += ms_val;
        }
    }
    uint64_t total_ms = 0;
    for (const auto &kv : map) total_ms += kv.second;
    uint64_t svc0_ms = map["service_0"];
    uint64_t chk3 = total_ms * 1000ULL + (svc0_ms % 1000ULL);
    auto t3 = clock::now();

    std::printf("RESULT|C++|stage1=%.2f|stage2=%.2f|stage3=%.2f|total=%.2f|chk=%u-%llu-%llu\n",
                ms_diff(t0, t1), ms_diff(t1, t2), ms_diff(t2, t3), ms_diff(t0, t3),
                chk1, static_cast<unsigned long long>(chk2), static_cast<unsigned long long>(chk3));
    return 0;
}

// ビルド例: clang -O3 bench.c -o bin_c
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

typedef struct {
    uint32_t id;
    uint32_t category;
    uint32_t amount;
} Record;

static int cmp_record(const void *pa, const void *pb) {
    const Record *a = (const Record *)pa;
    const Record *b = (const Record *)pb;
    if (a->amount < b->amount) return -1;
    if (a->amount > b->amount) return 1;
    if (a->id < b->id) return -1;
    if (a->id > b->id) return 1;
    return 0;
}

// C言語には標準HashMapが存在しないため、オープンアドレス法の最小ハッシュ表を自前実装
#define HT_CAP 256
typedef struct {
    char *key;
    uint64_t val;
    int used;
} Entry;

static uint32_t hash_str(const char *s, size_t len) {
    uint32_t h = 2166136261u;
    for (size_t i = 0; i < len; i++) {
        h ^= (uint8_t)s[i];
        h *= 16777619u;
    }
    return h;
}

static void ht_add(Entry *ht, const char *key, size_t len, uint64_t delta) {
    uint32_t idx = hash_str(key, len) & (HT_CAP - 1);
    while (ht[idx].used) {
        if (strlen(ht[idx].key) == len && memcmp(ht[idx].key, key, len) == 0) {
            ht[idx].val += delta;
            return;
        }
        idx = (idx + 1) & (HT_CAP - 1);
    }
    char *copy = (char *)malloc(len + 1);
    memcpy(copy, key, len);
    copy[len] = '\0';
    ht[idx].key = copy;
    ht[idx].val = delta;
    ht[idx].used = 1;
}

static uint64_t ht_get(Entry *ht, const char *key) {
    size_t len = strlen(key);
    uint32_t idx = hash_str(key, len) & (HT_CAP - 1);
    while (ht[idx].used) {
        if (strcmp(ht[idx].key, key) == 0) return ht[idx].val;
        idx = (idx + 1) & (HT_CAP - 1);
    }
    return 0;
}

static double now_ms(void) {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (double)ts.tv_sec * 1000.0 + (double)ts.tv_nsec / 1000000.0;
}

int main(int argc, char **argv) {
    uint32_t seed = (argc > 1) ? (uint32_t)strtoul(argv[1], NULL, 10) : 123456789u;
    const char *log_path = (argc > 2) ? argv[2] : "access.log";

    double t0 = now_ms();

    // Stage 1
    uint32_t x = seed;
    uint32_t acc = 0;
    for (uint32_t i = 0; i < 30000000u; i++) {
        x ^= x << 13;
        x ^= x >> 17;
        x ^= x << 5;
        if (x & 1u) {
            acc += (x ^ 0x9E3779B9u);
        } else {
            acc ^= (x >> 2);
        }
    }
    uint32_t chk1 = acc;
    double t1 = now_ms();

    // Stage 2
    size_t m = 1000000;
    Record *records = (Record *)malloc(m * sizeof(Record));
    uint32_t s = seed ^ 0xA5A5A5A5u;
    for (uint32_t i = 0; i < (uint32_t)m; i++) {
        s ^= s << 13;
        s ^= s >> 17;
        s ^= s << 5;
        records[i].id = i;
        records[i].category = s & 63u;
        records[i].amount = s % 1000000u;
    }
    qsort(records, m, sizeof(Record), cmp_record);
    uint64_t chk2 = 0;
    for (size_t i = 0; i < m; i++) {
        chk2 += (uint64_t)records[i].amount * (uint64_t)((i & 255u) + 1u) + (uint64_t)records[i].category;
    }
    free(records);
    double t2 = now_ms();

    // Stage 3
    FILE *fp = fopen(log_path, "r");
    if (!fp) return 1;
    char io_buf[65536];
    setvbuf(fp, io_buf, _IOFBF, sizeof(io_buf));

    Entry ht[HT_CAP];
    memset(ht, 0, sizeof(ht));

    char line[256];
    while (fgets(line, sizeof(line), fp)) {
        char *p1 = strchr(line, '|');
        if (!p1) continue;
        char *lvl = p1 + 1;
        char *p2 = strchr(lvl, '|');
        if (!p2) continue;
        size_t lvl_len = (size_t)(p2 - lvl);
        if (!((lvl_len == 5 && memcmp(lvl, "ERROR", 5) == 0) ||
              (lvl_len == 4 && memcmp(lvl, "WARN", 4) == 0))) {
            continue;
        }
        char *svc = p2 + 1;
        char *p3 = strchr(svc, '|');
        if (!p3) continue;
        size_t svc_len = (size_t)(p3 - svc);
        char *p4 = strchr(p3 + 1, '|');
        if (!p4) continue;
        char *ms_field = p4 + 1;
        if (strncmp(ms_field, "ms=", 3) == 0) {
            uint64_t ms_val = strtoull(ms_field + 3, NULL, 10);
            ht_add(ht, svc, svc_len, ms_val);
        }
    }
    fclose(fp);

    uint64_t total_ms = 0;
    for (int i = 0; i < HT_CAP; i++) {
        if (ht[i].used) total_ms += ht[i].val;
    }
    uint64_t svc0_ms = ht_get(ht, "service_0");
    uint64_t chk3 = total_ms * 1000ULL + (svc0_ms % 1000ULL);
    for (int i = 0; i < HT_CAP; i++) {
        if (ht[i].used) free(ht[i].key);
    }
    double t3 = now_ms();

    printf("RESULT|C|stage1=%.2f|stage2=%.2f|stage3=%.2f|total=%.2f|chk=%u-%llu-%llu\n",
           t1 - t0, t2 - t1, t3 - t2, t3 - t0,
           chk1, (unsigned long long)chk2, (unsigned long long)chk3);
    return 0;
}

// ビルド例: go build -o bin_go bench.go
package main

import (
	"bufio"
	"cmp"
	"fmt"
	"os"
	"slices"
	"strconv"
	"strings"
	"time"
)

type Record struct {
	id       uint32
	category uint32
	amount   uint32
}

func main() {
	seed := uint32(123456789)
	logPath := "access.log"
	if len(os.Args) > 1 {
		if v, err := strconv.ParseUint(os.Args[1], 10, 32); err == nil {
			seed = uint32(v)
		}
	}
	if len(os.Args) > 2 {
		logPath = os.Args[2]
	}

	t0 := time.Now()

	// Stage 1
	x := seed
	var acc uint32 = 0
	for i := uint32(0); i < 30000000; i++ {
		x ^= x << 13
		x ^= x >> 17
		x ^= x << 5
		if (x & 1) != 0 {
			acc += x ^ 0x9E3779B9
		} else {
			acc ^= x >> 2
		}
	}
	chk1 := acc
	t1 := time.Now()

	// Stage 2
	const m = 1000000
	records := make([]Record, m)
	s := seed ^ 0xA5A5A5A5
	for i := uint32(0); i < m; i++ {
		s ^= s << 13
		s ^= s >> 17
		s ^= s << 5
		records[i] = Record{
			id:       i,
			category: s & 63,
			amount:   s % 1000000,
		}
	}
	slices.SortFunc(records, func(a, b Record) int {
		if c := cmp.Compare(a.amount, b.amount); c != 0 {
			return c
		}
		return cmp.Compare(a.id, b.id)
	})
	var chk2 uint64 = 0
	for i, r := range records {
		chk2 += uint64(r.amount)*uint64((i&255)+1) + uint64(r.category)
	}
	t2 := time.Now()

	// Stage 3
	f, err := os.Open(logPath)
	if err != nil {
		panic(err)
	}
	defer f.Close()

	scanner := bufio.NewScanner(f)
	buf := make([]byte, 64*1024)
	scanner.Buffer(buf, 1024*1024)
	counts := make(map[string]uint64, 128)

	for scanner.Scan() {
		line := scanner.Text()
		p1 := strings.IndexByte(line, '|')
		if p1 < 0 {
			continue
		}
		rest1 := line[p1+1:]
		p2 := strings.IndexByte(rest1, '|')
		if p2 < 0 {
			continue
		}
		lvl := rest1[:p2]
		if lvl != "ERROR" && lvl != "WARN" {
			continue
		}
		rest2 := rest1[p2+1:]
		p3 := strings.IndexByte(rest2, '|')
		if p3 < 0 {
			continue
		}
		svc := rest2[:p3]
		rest3 := rest2[p3+1:]
		p4 := strings.IndexByte(rest3, '|')
		if p4 < 0 {
			continue
		}
		msField := rest3[p4+1:]
		if strings.HasPrefix(msField, "ms=") {
			val, _ := strconv.ParseUint(msField[3:], 10, 64)
			counts[svc] += val
		}
	}

	var totalMs uint64 = 0
	for _, v := range counts {
		totalMs += v
	}
	svc0Ms := counts["service_0"]
	chk3 := totalMs*1000 + (svc0Ms % 1000)
	t3 := time.Now()

	s1 := float64(t1.Sub(t0).Nanoseconds()) / 1e6
	s2 := float64(t2.Sub(t1).Nanoseconds()) / 1e6
	s3 := float64(t3.Sub(t2).Nanoseconds()) / 1e6
	tot := float64(t3.Sub(t0).Nanoseconds()) / 1e6

	fmt.Printf("RESULT|Go|stage1=%.2f|stage2=%.2f|stage3=%.2f|total=%.2f|chk=%d-%d-%d\n",
		s1, s2, s3, tot, chk1, chk2, chk3)
}

// ビルド＆実行例: javac Bench.java && java Bench 123456789 access.log
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

public class Bench {
    static final class Record implements Comparable<Record> {
        final int id;
        final int category;
        final int amount;

        Record(int id, int category, int amount) {
            this.id = id;
            this.category = category;
            this.amount = amount;
        }

        @Override
        public int compareTo(Record o) {
            int c = Integer.compareUnsigned(this.amount, o.amount);
            if (c != 0) return c;
            return Integer.compareUnsigned(this.id, o.id);
        }
    }

    public static void main(String[] args) throws Exception {
        int seed = (args.length > 0) ? Integer.parseUnsignedInt(args[0]) : 123456789;
        String logPath = (args.length > 1) ? args[1] : "access.log";

        long t0 = System.nanoTime();

        // Stage 1
        int x = seed;
        int acc = 0;
        for (int i = 0; i < 30_000_000; i++) {
            x ^= (x << 13);
            x ^= (x >>> 17);
            x ^= (x << 5);
            if ((x & 1) != 0) {
                acc += (x ^ 0x9E3779B9);
            } else {
                acc ^= (x >>> 2);
            }
        }
        long chk1 = Integer.toUnsignedLong(acc);
        long t1 = System.nanoTime();

        // Stage 2
        int m = 1_000_000;
        Record[] records = new Record[m];
        int s = seed ^ 0xA5A5A5A5;
        for (int i = 0; i < m; i++) {
            s ^= (s << 13);
            s ^= (s >>> 17);
            s ^= (s << 5);
            int cat = s & 63;
            int amt = (int) (Integer.toUnsignedLong(s) % 1_000_000L);
            records[i] = new Record(i, cat, amt);
        }
        Arrays.sort(records);
        long chk2 = 0L;
        for (int i = 0; i < m; i++) {
            Record r = records[i];
            chk2 += Integer.toUnsignedLong(r.amount) * (long) ((i & 255) + 1)
                    + Integer.toUnsignedLong(r.category);
        }
        long t2 = System.nanoTime();

        // Stage 3
        Map<String, Long> map = new HashMap<>(128);
        try (BufferedReader br = new BufferedReader(new FileReader(logPath), 65536)) {
            String line;
            while ((line = br.readLine()) != null) {
                int p1 = line.indexOf('|');
                if (p1 < 0) continue;
                int p2 = line.indexOf('|', p1 + 1);
                if (p2 < 0) continue;
                String lvl = line.substring(p1 + 1, p2);
                if (!lvl.equals("ERROR") && !lvl.equals("WARN")) continue;
                int p3 = line.indexOf('|', p2 + 1);
                if (p3 < 0) continue;
                String svc = line.substring(p2 + 1, p3);
                int p4 = line.indexOf('|', p3 + 1);
                if (p4 < 0) continue;
                if (line.startsWith("ms=", p4 + 1)) {
                    long msVal = Long.parseLong(line.substring(p4 + 4));
                    map.merge(svc, msVal, Long::sum);
                }
            }
        }
        long totalMs = 0L;
        for (long v : map.values()) totalMs += v;
        long svc0Ms = map.getOrDefault("service_0", 0L);
        long chk3 = totalMs * 1000L + (svc0Ms % 1000L);
        long t3 = System.nanoTime();

        double s1 = (t1 - t0) / 1e6;
        double s2 = (t2 - t1) / 1e6;
        double s3 = (t3 - t2) / 1e6;
        double tot = (t3 - t0) / 1e6;

        System.out.printf(Locale.US,
                "RESULT|Java|stage1=%.2f|stage2=%.2f|stage3=%.2f|total=%.2f|chk=%d-%d-%d%n",
                s1, s2, s3, tot, chk1, chk2, chk3);
    }
}

// ビルド例: swiftc -O bench.swift -o bin_swift
import Darwin

struct Record {
    var id: UInt32
    var category: UInt32
    var amount: UInt32
}

@inline(__always)
func nowMs() -> Double {
    var ts = timespec()
    clock_gettime(CLOCK_MONOTONIC, &ts)
    return Double(ts.tv_sec) * 1000.0 + Double(ts.tv_nsec) / 1_000_000.0
}

let args = CommandLine.arguments
let seed: UInt32 = (args.count > 1 ? UInt32(args[1]) : nil) ?? 123_456_789
let logPath = args.count > 2 ? args[2] : "access.log"

let t0 = nowMs()

// Stage 1
var x: UInt32 = seed
var acc: UInt32 = 0
for _ in 0..<30_000_000 {
    x ^= x << 13
    x ^= x >> 17
    x ^= x << 5
    if (x & 1) != 0 {
        acc = acc &+ (x ^ 0x9E37_79B9)
    } else {
        acc ^= (x >> 2)
    }
}
let chk1 = acc
let t1 = nowMs()

// Stage 2
let m = 1_000_000
var records = [Record]()
records.reserveCapacity(m)
var s: UInt32 = seed ^ 0xA5A5_A5A5
for i in 0..<UInt32(m) {
    s ^= s << 13
    s ^= s >> 17
    s ^= s << 5
    records.append(Record(id: i, category: s & 63, amount: s % 1_000_000))
}
records.sort { a, b in
    if a.amount != b.amount { return a.amount < b.amount }
    return a.id < b.id
}
var chk2: UInt64 = 0
for (i, r) in records.enumerated() {
    chk2 &+= UInt64(r.amount) &* UInt64((i & 255) + 1) &+ UInt64(r.category)
}
let t2 = nowMs()

// Stage 3
var map = [String: UInt64](minimumCapacity: 128)
if let fp = fopen(logPath, "r") {
    var ioBuf = [CChar](repeating: 0, count: 65536)
    setvbuf(fp, &ioBuf, _IOFBF, ioBuf.count)
    var lineBuf = [CChar](repeating: 0, count: 256)
    while fgets(&lineBuf, Int32(lineBuf.count), fp) != nil {
        var line = String(cString: lineBuf)
        while let last = line.last, last == "\n" || last == "\r" {
            line.removeLast()
        }
        let parts = line.split(separator: "|", omittingEmptySubsequences: false)
        if parts.count >= 5 {
            let lvl = parts[1]
            if lvl == "ERROR" || lvl == "WARN" {
                let svc = String(parts[2])
                let msField = parts[4]
                if msField.hasPrefix("ms=") {
                    if let val = UInt64(msField.dropFirst(3)) {
                        map[svc, default: 0] += val
                    }
                }
            }
        }
    }
    fclose(fp)
}
var totalMs: UInt64 = 0
for v in map.values { totalMs += v }
let svc0Ms = map["service_0"] ?? 0
let chk3 = totalMs * 1000 + (svc0Ms % 1000)
let t3 = nowMs()

func fmt2(_ v: Double) -> String {
    let scaled = Int64((v * 100.0).rounded())
    let intPart = scaled / 100
    let fracPart = abs(scaled % 100)
    return fracPart < 10 ? "\(intPart).0\(fracPart)" : "\(intPart).\(fracPart)"
}

print("RESULT|Swift|stage1=\(fmt2(t1 - t0))|stage2=\(fmt2(t2 - t1))|stage3=\(fmt2(t3 - t2))|total=\(fmt2(t3 - t0))|chk=\(chk1)-\(chk2)-\(chk3)")

// 実行例: node bench.mjs 123456789 access.log
import fs from "node:fs";
import { performance } from "node:perf_hooks";

const seed = (process.argv[2] ? Number(process.argv[2]) : 123456789) >>> 0;
const logPath = process.argv[3] || "access.log";

const t0 = performance.now();

// Stage 1
let x = seed;
let acc = 0;
for (let i = 0; i < 30_000_000; i++) {
  x = (x ^ (x << 13)) >>> 0;
  x = (x ^ (x >>> 17)) >>> 0;
  x = (x ^ (x << 5)) >>> 0;
  if ((x & 1) !== 0) {
    acc = (acc + ((x ^ 0x9e3779b9) >>> 0)) >>> 0;
  } else {
    acc = (acc ^ (x >>> 2)) >>> 0;
  }
}
const chk1 = acc >>> 0;
const t1 = performance.now();

// Stage 2
const m = 1_000_000;
const records = new Array(m);
let s = (seed ^ 0xa5a5a5a5) >>> 0;
for (let i = 0; i < m; i++) {
  s = (s ^ (s << 13)) >>> 0;
  s = (s ^ (s >>> 17)) >>> 0;
  s = (s ^ (s << 5)) >>> 0;
  records[i] = {
    id: i,
    category: s & 63,
    amount: s % 1_000_000,
  };
}
records.sort((a, b) => (a.amount !== b.amount ? a.amount - b.amount : a.id - b.id));
let chk2 = 0;
for (let i = 0; i < m; i++) {
  const r = records[i];
  chk2 += r.amount * ((i & 255) + 1) + r.category;
}
const t2 = performance.now();

// Stage 3: 64KBチャンク同期ストリーム読込
const map = new Map();
const fd = fs.openSync(logPath, "r");
const buf = Buffer.allocUnsafe(64 * 1024);
let leftover = "";
let bytesRead = 0;

function processLine(line) {
  if (line.endsWith("\r")) line = line.slice(0, -1);
  const p1 = line.indexOf("|");
  if (p1 < 0) return;
  const p2 = line.indexOf("|", p1 + 1);
  if (p2 < 0) return;
  const lvl = line.slice(p1 + 1, p2);
  if (lvl !== "ERROR" && lvl !== "WARN") return;
  const p3 = line.indexOf("|", p2 + 1);
  if (p3 < 0) return;
  const svc = line.slice(p2 + 1, p3);
  const p4 = line.indexOf("|", p3 + 1);
  if (p4 < 0) return;
  if (line.startsWith("ms=", p4 + 1)) {
    const msVal = Number(line.slice(p4 + 4));
    map.set(svc, (map.get(svc) || 0) + msVal);
  }
}

while ((bytesRead = fs.readSync(fd, buf, 0, buf.length, null)) > 0) {
  const chunk = leftover + buf.toString("utf8", 0, bytesRead);
  let start = 0;
  let nl;
  while ((nl = chunk.indexOf("\n", start)) !== -1) {
    processLine(chunk.slice(start, nl));
    start = nl + 1;
  }
  leftover = chunk.slice(start);
}
if (leftover.length > 0) processLine(leftover);
fs.closeSync(fd);

let totalMs = 0;
for (const v of map.values()) totalMs += v;
const svc0Ms = map.get("service_0") || 0;
const chk3 = totalMs * 1000 + (svc0Ms % 1000);
const t3 = performance.now();

console.log(
  `RESULT|JavaScript|stage1=${(t1 - t0).toFixed(2)}|stage2=${(t2 - t1).toFixed(2)}|stage3=${(t3 - t2).toFixed(2)}|total=${(t3 - t0).toFixed(2)}|chk=${chk1}-${chk2}-${chk3}`
);

// 直接実行例: node bench.ts 123456789 access.log
// 型検査ビルド例: npx tsc bench.ts --target ES2022 --module NodeNext --strict
import fs from "node:fs";
import { performance } from "node:perf_hooks";

interface RecordItem {
  id: number;
  category: number;
  amount: number;
}

const seed: number = (process.argv[2] ? Number(process.argv[2]) : 123456789) >>> 0;
const logPath: string = process.argv[3] || "access.log";

const t0: number = performance.now();

// Stage 1
let x: number = seed;
let acc: number = 0;
for (let i = 0; i < 30_000_000; i++) {
  x = (x ^ (x << 13)) >>> 0;
  x = (x ^ (x >>> 17)) >>> 0;
  x = (x ^ (x << 5)) >>> 0;
  if ((x & 1) !== 0) {
    acc = (acc + ((x ^ 0x9e3779b9) >>> 0)) >>> 0;
  } else {
    acc = (acc ^ (x >>> 2)) >>> 0;
  }
}
const chk1: number = acc >>> 0;
const t1: number = performance.now();

// Stage 2
const m = 1_000_000;
const records: RecordItem[] = new Array<RecordItem>(m);
let s: number = (seed ^ 0xa5a5a5a5) >>> 0;
for (let i = 0; i < m; i++) {
  s = (s ^ (s << 13)) >>> 0;
  s = (s ^ (s >>> 17)) >>> 0;
  s = (s ^ (s << 5)) >>> 0;
  records[i] = {
    id: i,
    category: s & 63,
    amount: s % 1_000_000,
  };
}
records.sort((a: RecordItem, b: RecordItem): number =>
  a.amount !== b.amount ? a.amount - b.amount : a.id - b.id
);
let chk2 = 0;
for (let i = 0; i < m; i++) {
  const r: RecordItem = records[i];
  chk2 += r.amount * ((i & 255) + 1) + r.category;
}
const t2: number = performance.now();

// Stage 3
const map = new Map<string, number>();
const fd: number = fs.openSync(logPath, "r");
const buf: Buffer = Buffer.allocUnsafe(64 * 1024);
let leftover = "";
let bytesRead = 0;

function processLine(line: string): void {
  if (line.endsWith("\r")) line = line.slice(0, -1);
  const p1: number = line.indexOf("|");
  if (p1 < 0) return;
  const p2: number = line.indexOf("|", p1 + 1);
  if (p2 < 0) return;
  const lvl: string = line.slice(p1 + 1, p2);
  if (lvl !== "ERROR" && lvl !== "WARN") return;
  const p3: number = line.indexOf("|", p2 + 1);
  if (p3 < 0) return;
  const svc: string = line.slice(p2 + 1, p3);
  const p4: number = line.indexOf("|", p3 + 1);
  if (p4 < 0) return;
  if (line.startsWith("ms=", p4 + 1)) {
    const msVal: number = Number(line.slice(p4 + 4));
    map.set(svc, (map.get(svc) || 0) + msVal);
  }
}

while ((bytesRead = fs.readSync(fd, buf, 0, buf.length, null)) > 0) {
  const chunk: string = leftover + buf.toString("utf8", 0, bytesRead);
  let start = 0;
  let nl: number;
  while ((nl = chunk.indexOf("\n", start)) !== -1) {
    processLine(chunk.slice(start, nl));
    start = nl + 1;
  }
  leftover = chunk.slice(start);
}
if (leftover.length > 0) processLine(leftover);
fs.closeSync(fd);

let totalMs = 0;
for (const v of map.values()) totalMs += v;
const svc0Ms: number = map.get("service_0") || 0;
const chk3: number = totalMs * 1000 + (svc0Ms % 1000);
const t3: number = performance.now();

console.log(
  `RESULT|TypeScript|stage1=${(t1 - t0).toFixed(2)}|stage2=${(t2 - t1).toFixed(2)}|stage3=${(t3 - t2).toFixed(2)}|total=${(t3 - t0).toFixed(2)}|chk=${chk1}-${chk2}-${chk3}`
);

# 実行例: ruby bench.rb 123456789 access.log
Record = Struct.new(:id, :category, :amount)

seed = (ARGV[0] ? ARGV[0].to_i : 123_456_789) & 0xFFFFFFFF
log_path = ARGV[1] || "access.log"

t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)

# Stage 1
x = seed
acc = 0
mask = 0xFFFFFFFF
i = 0
while i < 30_000_000
  x = (x ^ (x << 13)) & mask
  x = (x ^ (x >> 17)) & mask
  x = (x ^ (x << 5)) & mask
  if (x & 1) != 0
    acc = (acc + (x ^ 0x9E3779B9)) & mask
  else
    acc = (acc ^ (x >> 2)) & mask
  end
  i += 1
end
chk1 = acc
t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)

# Stage 2
m = 1_000_000
records = Array.new(m)
s = (seed ^ 0xA5A5A5A5) & mask
j = 0
while j < m
  s = (s ^ (s << 13)) & mask
  s = (s ^ (s >> 17)) & mask
  s = (s ^ (s << 5)) & mask
  records[j] = Record.new(j, s & 63, s % 1_000_000)
  j += 1
end
records.sort_by! { |r| [r.amount, r.id] }
chk2 = 0
records.each_with_index do |r, idx|
  chk2 += r.amount * ((idx & 255) + 1) + r.category
end
t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)

# Stage 3
counts = Hash.new(0)
File.open(log_path, "r") do |f|
  f.each_line do |line|
    line.chomp!
    parts = line.split("|")
    if parts.length >= 5
      lvl = parts[1]
      if lvl == "ERROR" || lvl == "WARN"
        svc = parts[2]
        ms_field = parts[4]
        if ms_field.start_with?("ms=")
          counts[svc] += ms_field[3..-1].to_i
        end
      end
    end
  end
end
total_ms = 0
counts.each_value { |v| total_ms += v }
svc0_ms = counts["service_0"]
chk3 = total_ms * 1000 + (svc0_ms % 1000)
t3 = Process.clock_gettime(Process::CLOCK_MONOTONIC)

s1 = (t1 - t0) * 1000.0
s2 = (t2 - t1) * 1000.0
s3 = (t3 - t2) * 1000.0
tot = (t3 - t0) * 1000.0

puts format("RESULT|Ruby|stage1=%.2f|stage2=%.2f|stage3=%.2f|total=%.2f|chk=%d-%d-%d",
            s1, s2, s3, tot, chk1, chk2, chk3)

# 実行例: python3 bench.py 123456789 access.log
import sys
import time


class Record:
    __slots__ = ("id", "category", "amount")

    def __init__(self, id_: int, category: int, amount: int):
        self.id = id_
        self.category = category
        self.amount = amount


def main() -> None:
    seed = int(sys.argv[1]) & 0xFFFFFFFF if len(sys.argv) > 1 else 123456789
    log_path = sys.argv[2] if len(sys.argv) > 2 else "access.log"

    t0 = time.perf_counter()

    # Stage 1
    x = seed
    acc = 0
    mask = 0xFFFFFFFF
    for _ in range(30_000_000):
        x = (x ^ (x << 13)) & mask
        x = (x ^ (x >> 17)) & mask
        x = (x ^ (x << 5)) & mask
        if x & 1:
            acc = (acc + (x ^ 0x9E3779B9)) & mask
        else:
            acc = (acc ^ (x >> 2)) & mask
    chk1 = acc
    t1 = time.perf_counter()

    # Stage 2
    m = 1_000_000
    records = [None] * m
    s = (seed ^ 0xA5A5A5A5) & mask
    for i in range(m):
        s = (s ^ (s << 13)) & mask
        s = (s ^ (s >> 17)) & mask
        s = (s ^ (s << 5)) & mask
        records[i] = Record(i, s & 63, s % 1_000_000)

    records.sort(key=lambda r: (r.amount, r.id))
    chk2 = 0
    for i, r in enumerate(records):
        chk2 += r.amount * ((i & 255) + 1) + r.category
    t2 = time.perf_counter()

    # Stage 3
    counts: dict[str, int] = {}
    with open(log_path, "r", encoding="utf-8", buffering=65536) as f:
        for line in f:
            parts = line.rstrip("\r\n").split("|")
            if len(parts) >= 5:
                lvl = parts[1]
                if lvl == "ERROR" or lvl == "WARN":
                    svc = parts[2]
                    ms_field = parts[4]
                    if ms_field.startswith("ms="):
                        val = int(ms_field[3:])
                        counts[svc] = counts.get(svc, 0) + val

    total_ms = sum(counts.values())
    svc0_ms = counts.get("service_0", 0)
    chk3 = total_ms * 1000 + (svc0_ms % 1000)
    t3 = time.perf_counter()

    s1 = (t1 - t0) * 1000.0
    s2 = (t2 - t1) * 1000.0
    s3 = (t3 - t2) * 1000.0
    tot = (t3 - t0) * 1000.0

    print(
        f"RESULT|Python|stage1={s1:.2f}|stage2={s2:.2f}|stage3={s3:.2f}|total={tot:.2f}|chk={chk1}-{chk2}-{chk3}"
    )


if __name__ == "__main__":
    main()

// 同一の20万行テストログ（access.log / 13.14MB）を生成するワンライナー用スクリプト (gen_log.mjs)
import fs from "node:fs";
const levels = ["INFO", "INFO", "DEBUG", "WARN", "INFO", "ERROR", "INFO", "WARN"];
let s = 987654321 >>> 0;
const lines = new Array(200_000);
for (let i = 0; i < 200_000; i++) {
  s = (s ^ (s << 13)) >>> 0;
  s = (s ^ (s >>> 17)) >>> 0;
  s = (s ^ (s << 5)) >>> 0;
  lines[i] = `2026-11-03T12:00:00Z|${levels[s & 7]}|service_${(s >>> 3) & 63}|path=/api/v1/items/${(s >>> 9) % 100000}|ms=${((s >>> 16) % 950) + 5}\n`;
}
fs.writeFileSync("access.log", lines.join(""), "utf8");