Gitea vs Forgejo vs GitLab: RAM and git speed

# lab/stacks/gitea/compose.yml plus INSTALL_LOCK, so the installer page is skipped and the server runs configured.
services:
  gitea:
    image: gitea/gitea:28.3.0
    restart: unless-stopped
    environment:
      USER_UID: "1000"
      USER_GID: "1000"
      GITEA__security__INSTALL_LOCK: "true"
      GITEA__server__ROOT_URL: http://127.0.0.1:8080/
    ports:
      - "127.0.0.1:8080:3000"
    volumes:
      - gitea_data:/data
volumes:
  gitea_data:

# lab/stacks/gitlab/compose.yml plus a fixed initial root password.
services:
  gitlab:
    image: gitlab/gitlab-ce:19.4.5-ce.0
    restart: unless-stopped
    shm_size: 256m
    hostname: gitlab.lab.internal
    environment:
      GITLAB_OMNIBUS_CONFIG: "gitlab_rails['initial_root_password'] = 'lab-only-not-a-secret'"
    ports:
      - "127.0.0.1:8080:80"
    volumes:
      - gitlab_config:/etc/gitlab
      - gitlab_logs:/var/log/gitlab
      - gitlab_data:/var/opt/gitlab
volumes:
  gitlab_config:
  gitlab_logs:
  gitlab_data:

#!/usr/bin/env bash
# git-bench: Gitea 28.3.0, Forgejo 17.0.1 and GitLab CE 19.4.5, each in its own fresh VM, configured (installer skipped).
# Creates repos through the API, pushes a generated 300-commit repo, clones it 3 times, times 5 API reads (20 calls each).
# Usage: run.sh [gitea] [forgejo] [gitlab]   (default: all three; GitLab runs alone with LAB_MEM=8192)
set -uo pipefail
source "$(dirname "$0")/../_dlib.sh"
T=git-bench; OUT="$ROOT/evidence/tests/$T"; RAW="$OUT/raw"; D="$ROOT/lab/tests/$T"
TOOLS=("$@"); [ ${#TOOLS[@]} -eq 0 ] && TOOLS=(gitea forgejo gitlab)
mkdir -p "$RAW"
one() { # one <tool>: runs in a subshell so the VM trap fires at its end
  local tool="$1"
  [ "$tool" = gitlab ] && export LAB_MEM=8192
  start_vm d-$T-$tool
  gx 'mkdir -p ~/gb' ; vm scp-to "$D/files/$tool.yml" gb/compose.yml >/dev/null
  vm scp-to "$D/genrepo.py" genrepo.py >/dev/null; vm scp-to "$D/bench.py" bench.py >/dev/null; vm scp-to "$ROOT/lab/tests/_dsample.py" sample.py >/dev/null
  cpull '~/gb' gb
  gx 'python3 ~/genrepo.py /tmp/repo && cd /tmp/repo && git rev-list --count HEAD && git count-objects -vH && du -sb /tmp/repo/.git /tmp/repo --exclude=.git' > "$RAW/$tool-repo.txt" 2>&1
  local t0; t0=$(date +%s)
  gx 'cd ~/gb && docker compose -p gb up -d 2>&1 | tail -1'
  local base=http://127.0.0.1:8080 user=lab token
  case $tool in
    gitea|forgejo)
      until gx "curl -sf $base/api/healthz >/dev/null"; do sleep 1; done; echo "ready_s=$(( $(date +%s) - t0 ))" > "$RAW/$tool-ready.txt"
      gx "docker exec -u git gb-$tool-1 $tool admin user create --admin --username lab --password lab-only-not-a-secret --email lab@lab.internal --must-change-password=false" > "$RAW/$tool-admin.txt" 2>&1
      token=$(gx "curl -s -u lab:lab-only-not-a-secret -H 'content-type: application/json' -d '{\"name\":\"bench\",\"scopes\":[\"all\"]}' $base/api/v1/users/lab/tokens" | python3 -c "import json,sys;print(json.load(sys.stdin)['sha1'])") ;;
    gitlab)
      until [ "$(gx 'docker inspect -f {{.State.Health.Status}} gb-gitlab-1' 2>/dev/null)" = healthy ] && gx "curl -s -o /dev/null -w '%{http_code}' $base/users/sign_in | grep -q 200"; do sleep 10; [ $(( $(date +%s) - t0 )) -gt 1500 ] && { echo "gitlab not ready in 1500 s" > "$RAW/gitlab-FAILED.txt"; return 1; }; done
      echo "ready_s=$(( $(date +%s) - t0 ))" > "$RAW/gitlab-ready.txt"; user=root
      token=lab-bench-token-0123456789
      gx "docker exec gb-gitlab-1 gitlab-rails runner \"u=User.find_by_username('root'); t=u.personal_access_tokens.create!(name: 'bench', scopes: [:api, :write_repository, :read_repository], expires_at: 30.days.from_now); t.set_token('$token'); t.save!; puts 'token ok'\"" > "$RAW/gitlab-token.txt" 2>&1 ;;
  esac
  sleep 120   # settle before the "after setup" RAM sample
  gx "python3 ~/sample.py gb-$tool-1" > "$RAW/$tool-ram-after-setup.json"
  gx "python3 ~/bench.py $([ $tool = gitlab ] && echo gitlab || echo gitea) $base $user $token /tmp/repo" > "$RAW/$tool-bench.json" 2> "$RAW/$tool-bench.err"
  gx "python3 ~/sample.py gb-$tool-1" > "$RAW/$tool-ram-after-bench.json"
  gx "sudo sh -c \"du -sb /var/lib/docker/volumes/gb_*/_data\" | sort -k2; docker inspect -f '{{.Name}} restarts={{.RestartCount}}' \$(docker ps -aq)" > "$RAW/$tool-disk.txt" 2>&1
  local S="$ROOT/public/shots/$T"
  if [ $tool = gitlab ]; then
    shot 8080 /root/bench-1 "$S/$tool.png" '[{"goto":"http://127.0.0.1:18391/users/sign_in"},{"fill":"#user_login","value":"root"},{"fill":"#user_password","value":"lab-only-not-a-secret"},{"press":"Enter"},{"wait":6000},{"goto":"http://127.0.0.1:18391/root/bench-1"}]'
  else
    shot 8080 /user/login "$S/$tool.png" '[{"fill":"#user_name","value":"lab"},{"fill":"#password","value":"lab-only-not-a-secret"},{"press":"Enter"},{"wait":3000},{"goto":"http://127.0.0.1:18391/lab/bench-1"},{"wait":3000}]'
  fi
  mkdir -p "$RAW/$tool-env"; collect_env "$RAW/$tool-env"
  gx "docker image inspect --format '{{index .RepoDigests 0}}' \$(docker compose -f ~/gb/compose.yml config --images)" > "$RAW/$tool-image.txt" 2>&1
}
for t in "${TOOLS[@]}"; do ( one "$t" ); done
for t in "${TOOLS[@]}"; do [ -f "$RAW/$t-bench.json" ] || echo "$t: no bench result"; done
cp "$D/files/"*.yml "$OUT/" 2>/dev/null
python3 "$D/summarize.py" "$RAW" "$OUT"

#!/usr/bin/env python3
"""Runs in the VM. Usage: bench.py <gitea|gitlab> <base_url> <user> <token> <repo_dir>. Prints JSON of timings (seconds)."""
import json, os, shutil, statistics as st, subprocess, sys, time, urllib.request
kind, base, user, token, repo = sys.argv[1:6]
def req(method, path, body=None):
    h = {"content-type": "application/json"}
    h.update({"PRIVATE-TOKEN": token} if kind == "gitlab" else {"Authorization": "token " + token})
    t = time.perf_counter()
    r = urllib.request.urlopen(urllib.request.Request(base + path, data=json.dumps(body).encode() if body is not None else None, headers=h, method=method), timeout=120)
    data = r.read(); return time.perf_counter() - t, json.loads(data) if data else None
out = {"kind": kind}
# create three repositories through the API
create = []; ids = []
for i in (1, 2, 3):
    if kind == "gitlab":
        t, d = req("POST", "/api/v4/projects", {"name": f"bench-{i}", "visibility": "private", "initialize_with_readme": False}); ids.append(d["id"])
    else:
        t, d = req("POST", "/api/v1/user/repos", {"name": f"bench-{i}", "private": True, "default_branch": "main"})
    create.append(round(t, 3))
out["api_create_repo_s"] = create
auth_host = base.replace("http://", f"http://{'oauth2' if kind == 'gitlab' else user}:{token}@")
ns = "root" if kind == "gitlab" else user
sh = lambda *a, cwd=None: subprocess.run(a, cwd=cwd, check=True, capture_output=True, text=True)
push = []
for i in (1, 2, 3):
    t = time.perf_counter(); sh("git", "push", "-q", f"{auth_host}/{ns}/bench-{i}.git", "main", cwd=repo); push.append(round(time.perf_counter() - t, 2))
out["push_s"] = push
clone = []
for i in (1, 2, 3):
    dst = f"/tmp/clone{i}"; shutil.rmtree(dst, ignore_errors=True)
    t = time.perf_counter(); sh("git", "clone", "-q", f"{auth_host}/{ns}/bench-1.git", dst); clone.append(round(time.perf_counter() - t, 2))
out["clone_s"] = clone
out["clone_commits"] = int(sh("git", "rev-list", "--count", "HEAD", cwd="/tmp/clone3").stdout)
out["clone_checkout_bytes"] = int(subprocess.run("du -sb /tmp/clone3 | cut -f1", shell=True, capture_output=True, text=True).stdout)
if kind == "gitlab":
    pid = ids[0]
    calls = {"project info": f"/api/v4/projects/{pid}", "commit list (30)": f"/api/v4/projects/{pid}/repository/commits?per_page=30", "tree": f"/api/v4/projects/{pid}/repository/tree?per_page=100", "file contents": f"/api/v4/projects/{pid}/repository/files/src%2Fmod010.txt?ref=main", "branches": f"/api/v4/projects/{pid}/repository/branches"}
else:
    calls = {"project info": f"/api/v1/repos/{user}/bench-1", "commit list (30)": f"/api/v1/repos/{user}/bench-1/commits?limit=30&stat=false", "tree": f"/api/v1/repos/{user}/bench-1/git/trees/main?per_page=100", "file contents": f"/api/v1/repos/{user}/bench-1/contents/src/mod010.txt?ref=main", "branches": f"/api/v1/repos/{user}/bench-1/branches"}
api = {}
for name, path in calls.items():
    ts = []
    for _ in range(20):
        t, _d = req("GET", path); ts.append(t * 1000)
    api[name] = {"median_ms": round(st.median(ts), 1), "min_ms": round(min(ts), 1), "max_ms": round(max(ts), 1)}
out["api_get_ms"] = api
print(json.dumps(out, indent=1))

#!/usr/bin/env python3
"""Generates the benchmark repository: 300 commits on main. Each commit adds one ~5.5 KiB text file and edits one earlier file;
every 15th commit also adds a 1 MiB file of random bytes (20 in total, incompressible). Deterministic (seeded)."""
import os, random, subprocess, sys
d = sys.argv[1]; r = random.Random(42)
os.makedirs(d); sh = lambda *a: subprocess.run(a, cwd=d, check=True, capture_output=True)
sh("git", "init", "-q", "-b", "main"); sh("git", "config", "user.name", "Lab"); sh("git", "config", "user.email", "lab@lab.internal")
words = [w for w in "alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima mike november oscar papa quebec romeo sierra tango uniform victor whiskey xray yankee zulu".split()]
texts = []
for i in range(300):
    name = f"src/mod{i:03d}.txt"; os.makedirs(os.path.join(d, "src"), exist_ok=True)
    open(os.path.join(d, name), "w").write(" ".join(r.choice(words) + str(r.randrange(1000)) for _ in range(600)) + "\n")
    texts.append(name)
    if i:
        t = r.choice(texts[:-1]); open(os.path.join(d, t), "a").write(f"edit {i} " + " ".join(r.choice(words) for _ in range(20)) + "\n")
    if i % 15 == 0:
        os.makedirs(os.path.join(d, "blobs"), exist_ok=True); open(os.path.join(d, f"blobs/blob{i//15:02d}.bin"), "wb").write(r.randbytes(1 << 20))
    sh("git", "add", "-A"); sh("git", "commit", "-q", "-m", f"commit {i}")