Solana VDS: pinned cores, isolated RAM, zero CPU steal time

# After provisioning a vds.performance, SSH in and verify topology
lscpu | grep -E '^(CPU\(s\)|Thread|Core|Socket)'
# CPU(s):                  16
# Thread(s) per core:      1
# Core(s) per socket:      16
# Socket(s):               1

# Confirm steal-time stays at zero under load
mpstat -P ALL 1 5 | grep -E '%steal'
# all   0.00 (across all cores, all samples)

# NUMA affinity (RAM is on the same node as the cores)
numactl --hardware
# node 0 cpus: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
# node 0 size: 65536 MB
# node distances: node 0: 10

use core_affinity;
use yellowstone_grpc_client::GeyserGrpcClient;

fn main() -> anyhow::Result<()> {
    // vds.performance: cores 0-3 reserved for OS + IRQ, 4-15 for the bot
    let cores: Vec<_> = core_affinity::get_core_ids()
        .unwrap()
        .into_iter()
        .skip(4)
        .collect();

    let mut handles = vec![];
    for (i, core) in cores.into_iter().enumerate() {
        handles.push(std::thread::Builder::new()
            .name(format!("worker-{i}"))
            .spawn(move || {
                core_affinity::set_for_current(core);
                run_worker(i)
            })?);
    }

    for h in handles { h.join().unwrap(); }
    Ok(())
}

fn run_worker(_id: usize) {
    let rt = tokio::runtime::Builder::new_current_thread()
        .enable_all().build().unwrap();
    rt.block_on(async {
        let client = GeyserGrpcClient::build_from_shared(
            "https://grpc.nln.clr3.org:443"
        ).unwrap()
            .x_token(Some(std::env::var("NLN_API_KEY").unwrap())).unwrap()
            .connect().await.unwrap();
        let _ = client;
    })
}

import asyncio
import asyncpg
from yellowstone_grpc_proto import geyser_pb2, geyser_pb2_grpc
import grpc

# Postgres on the same VDS, same NUMA node, unix socket.
DB_URL = "postgresql:///nln_indexer?host=/var/run/postgresql"
GRPC_HOST = "grpc.nln.clr3.org:443"

async def ingest(pool):
    creds = grpc.composite_channel_credentials(
        grpc.ssl_channel_credentials(),
    )
    chan = grpc.aio.secure_channel(GRPC_HOST, creds)
    stub = geyser_pb2_grpc.GeyserStub(chan)

    async def reqs():
        yield geyser_pb2.SubscribeRequest(
            transactions={"ray": geyser_pb2.SubscribeRequestFilterTransactions(
                vote=False, failed=False,
                account_include=["675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"],
            )},
            commitment=geyser_pb2.PROCESSED,
        )

    async for upd in stub.Subscribe(reqs()):
        async with pool.acquire() as conn:
            await conn.execute(
                "INSERT INTO swaps_raw (slot, sig, payload) VALUES ($1, $2, $3)",
                upd.transaction.slot,
                bytes(upd.transaction.transaction.signature),
                upd.SerializeToString(),
            )

asyncio.run(ingest(asyncpg.create_pool(DB_URL, min_size=8, max_size=32)))

# On a VPS (shared vCPU):
mpstat -P ALL 1 30 | awk '/Average/ {print "CPU " $2 " steal=" $6}'
# CPU all  steal=1.82
# CPU 0    steal=2.41
# CPU 3    steal=3.67  <-- this core shares a busy neighbor

# On a VDS (pinned cores):
mpstat -P ALL 1 30 | awk '/Average/ {print "CPU " $2 " steal=" $6}'
# CPU all  steal=0.00
# Every core, every sample: 0.00. That is the contract.

# If you see non-zero steal time on a VDS, open a support ticket.
# It means a host configuration error and we fix it immediately.