NATIVE ANER · SEQUENTIAL / PARALLEL / CLUSTER

One task.
Three ways to run it.

Start with “pick a number between 1 and 10.” Keep the same native task and seed, then run it on one worker, four local workers or two collaborating computers.

See the code and results GitHub repository

Measured October 20, 2026 · By Alfonso G Bastias

MEASURED NATIVE CPU EXECUTIONAbout 100 million draws. Same seed.

C
Sequential1 computer · 1 worker
52.434seconds
D
Local parallel1 computer · 4 workers
15.884seconds
E
Cluster + parallel2 computers · 4 workers each
+
14.066seconds

Median of 12 trials per policy. Squares represent configured CPU worker slots.

CASES C, D AND E · THE NATIVE COMPUTATION

Write the task once.
Choose the resources.

Generate 100,000,003 integers from 1 to 10 and count each value. Aner runs the same checked function under three execution policies. The task, inputs, root seed and global draw identities stay the same.

01 · DEFINE THE WORK

A draw has a stable address.

Each block counts up to 10,000 draws; the final block contains three. The extra three draws exercise that partial block. The seed and global draw index identify every observation, so moving a block to another CPU or computer preserves the computation.

Each block returns ten counts. The runtime transports those compact results.

Read the complete runnable example

let draw = block * size + offset
if draw < count {
    let choice = random.integer(low: 1, high: 10, seed: seed, draw: draw)
    counts[choice - 1] += 1
}

Read the complete checked task

fn count_block(parameters: List, block: Int64, task_seed: Int64) -> List {
    let count = cast<Int64>(parameters.get(0))
    let size = cast<Int64>(parameters.get(1))
    let seed = cast<Int64>(parameters.get(2))
    let counts = Array<Int64>(10, 0)
    for offset in Range(size) {
        let draw = block * size + offset
        if draw < count {
            let choice = random.integer(low: 1, high: 10, seed: seed, draw: draw)
            counts[choice - 1] += 1
        }
    }
    let output = List()
    for face in Range(10) { output.append(counts[face]) }
    return output
}

02 · SELECT THE EXECUTION POLICY

One worker, local workers, or a cluster.

Choose one declaration. The checked task and repetition call stay the same.

Sequential

let execution = parallel.local(workers: 1)

One local CPU worker executes all blocks.

52.434seconds · median call wall time12 trials · 51.729 to 52.678 s

Local parallel

let execution = parallel.local(workers: 4)

Four local CPU workers share the blocks on one computer.

15.884seconds · median call wall time12 trials · 15.679 to 16.290 s

Cluster + parallel

let execution = parallel.cluster(config: "config/cluster.private")

Two enrolled computers each run four local CPU workers.

14.066seconds · median call wall time12 trials · 13.858 to 14.417 s

03 · RUN THE SAME CALL

The execution policy carries the resource choice.

This excerpt is shared by the complete C, D and E programs. Native Aner handles the selected workers and returns ordered block results.

let results = parallel.repeat(iterations: blocks, task: count_block,
    parameters: List(draw_count, block_size, root_seed), execution: execution,
    seed: root_seed, max_bytes: 67_108_864)

Two computers, one coordinated computation.Case E · the coordinator also contributes four local workers.

COORDINATOROne checked task

Inputs, root seed and global block identities.

Local process · Atlas-01Computer 014 CPU workers

SSH session · Atlas-02Computer 024 CPU workers

ORDERED RESULTSTen counts per block

Combine and validate against the serial reference.

01
The coordinator sends checked batches to available nodes.
02
Each node runs its batches with its own parallel CPU workers.
03
Ready nodes receive more work; compact counts and execution metadata return.

Enroll the computers once.

Install compatible native runtimes, verify SSH access and save a private cluster file. Each node has its own executable path and CPU worker budget. Add enrolled computers as your research group grows.

The topology below is an example; executable paths and SSH aliases come from your setup.

Follow the cluster connection guide

ANER_CLUSTER 1
worker "Atlas-01" local "-" "/opt/aner/bin/aner" 4
worker "Atlas-02" ssh "node-02" "/opt/aner/bin/aner" 4

RECORDED PERFORMANCE · 12 TRIALS PER POLICY

More resources, measured rather than assumed.

Four local workers delivered 3.30× the serial throughput. Two computers, with four workers each, delivered 3.73×. Cluster elapsed time was 11.4% lower than local parallel execution in this setup.

The same computation, three execution policies.Repeat call wall time in seconds, lower is faster.

12 measured rounds per policy. Dots show individual trials, the marker shows the median, and the line shows the observed range. The spread is descriptive.

On narrow screens, scroll the table to read every column.

Same 100,000,003 draws and seed · CPU execution only
Execution	Computers	CPU workers	Median seconds	Draws / second	Speedup vs serial
C · Sequential	1	1	52.434	1,907,163	1.000×
D · Local parallel	1	4	15.884	6,295,696	3.301×
E · Cluster + parallel	2	4 + 4	14.066	7,109,230	3.728×

Two different computers, four selected workers each.

The local computer used an Apple M2 Max. The remote KVM guest reported an Intel Xeon Gold 6248 and 24 effective CPU slots. Four slots were selected on each node. Available capacity, performance per worker, transport and startup overhead all affect scaling; these are measurements for this setup.

Zero retained result mismatches across all 36 measured trials.

3,600,360 retained numeric cells and 360,036 task seed identities checked in total. Each trial compares every retained block histogram and task seed with the complete serial reference; individual generated draws are not retained or compared one by one.

Call wall time includes the selected repetition call. Cluster calls include worker process and SSH admission, transport and teardown. Local pools are created earlier and reused. Reference computation, warmups, validation, reduction and printing are outside these trial intervals. These timings compare the native C/D/E computation; people and model responses have separate collection protocols.

Inspect the shared distribution and seeded dataset

Choices from 1 to 10100,000,003 accepted answers

Bar height is the percentage of accepted answers, on the same 0 to 100% scale. The dashed line marks a uniform 10% reference.

Read the exact counts

Cases C, D and E: accepted answers by value
Value	1	2	3	4	5	6	7	8	9	10
Count	9,996,281	10,001,978	9,994,842	10,003,210	10,005,125	9,999,109	10,000,843	10,001,802	9,996,639	10,000,174
Share	10%	10%	10%	10%	10%	10%	10%	10%	10%	10%

CASE A · THE HUMAN CHOICES

What did people actually choose?

A public student survey supplies recorded answers to the motivating question. Source rows, filtering and exclusions are retained with the counts.

College Pulse student survey

College Pulse Survey 12-22-2018 (Responses)

Pick a random number from 1-10. [Asked by: Rutgers]

Choices from 1 to 108,557 accepted answers

Bar height is the percentage of accepted answers, on the same 0 to 100% scale. The dashed line marks a uniform 10% reference.

Most frequent accepted value: 72,405 of 8,557 accepted answers (28.1%).

Read the exact counts

College Pulse student survey: accepted answers by value
Value	1	2	3	4	5	6	7	8	9	10
Count	294	731	834	833	1,058	843	2,405	933	460	166
Share	3.4%	8.5%	9.7%	9.7%	12.4%	9.9%	28.1%	10.9%	5.4%	1.9%

CASE B · THE LOCAL MODEL CHOICES

A response has a distribution and a record.

1,250 actual Ollama requests across 5 installed local models. 1,000 replies met the requested answer format. Every attempted call, including each format failure, remains in the evidence.

Pick a number between 1 and 10. Return only the integer.

5 rounds × 50 fresh single message requests per model and round. Temperature 1; maximum output budget 256 tokens. An accepted reply must finish with stop and have its entire trimmed text equal one of the integer strings 1 through 10.

Read the complete request conditions

Requests run serially in balanced model order with fresh conversation context. No provider seed, top_p, top_k or thinking override was set. Installed defaults were retained. There is no excluded model warmup; provider load and cache state can affect call times. Records retain visible response text, normalized finish reasons and usage exposed by the native API.

On narrow screens, scroll the table to read every column.

Per installed model · token totals include accepted and rejected replies
Installed model	Accepted / attempted	Accepted values: counts	Input tokens	Output tokens
`llama3.1:latest`	250 / 250	7: 250	6,250	500
`llama3.2:latest`	250 / 250	5: 90 · 7: 160	10,000	500
`mistral:latest`	0 / 250	No accepted integer	5,000	14,592
`qwen2.5:14b-instruct`	250 / 250	7: 250	11,250	500
`qwen3.8:latest`	250 / 250	7: 250	6,500	8,929

These results describe this prompt, configuration and installed artifacts. Format failures are not automatic refusal labels. qwen3.8:latest is an installed local tag, not a verified official public release name; digests identify the tested artifacts.

llama3.1:latest250 accepted / 250 attemptedInspect response distribution

Choices from 1 to 10250 accepted answers

Bar height is the percentage of accepted answers, on the same 0 to 100% scale. The dashed line marks a uniform 10% reference.

Most frequent accepted value: 7250 of 250 accepted answers (100%).

Read the exact counts

llama3.1:latest: accepted answers by value
Value	1	2	3	4	5	6	7	8	9	10
Count	0	0	0	0	0	0	250	0	0	0
Share	0%	0%	0%	0%	0%	0%	100%	0%	0%	0%

0 replies excluded: 0 without a stop finish, 0 empty, and 0 other responses outside the exact integer format. These categories are mutually exclusive, and are not automatic refusal labels.

Model digest: 46e0c10c039e019119339687c3c1757cc81b9da49709a3b3924863ba87ca666e
Input tokens: 6,250
Output tokens: 500
Reasoning tokens: Not reported

Missing usage is unavailable, and a reported zero remains zero. Output counts are not converted into visible text length or an inferred reasoning count.

llama3.2:latest250 accepted / 250 attemptedInspect response distribution

Choices from 1 to 10250 accepted answers

Bar height is the percentage of accepted answers, on the same 0 to 100% scale. The dashed line marks a uniform 10% reference.

Most frequent accepted value: 7160 of 250 accepted answers (64%).

Read the exact counts

llama3.2:latest: accepted answers by value
Value	1	2	3	4	5	6	7	8	9	10
Count	0	0	0	0	90	0	160	0	0	0
Share	0%	0%	0%	0%	36%	0%	64%	0%	0%	0%

0 replies excluded: 0 without a stop finish, 0 empty, and 0 other responses outside the exact integer format. These categories are mutually exclusive, and are not automatic refusal labels.

Model digest: a80c4f17acd55265feec403c7aef86be0c25983ab279d83f3bcd3abbcb5b8b72
Input tokens: 10,000
Output tokens: 500
Reasoning tokens: Not reported

Missing usage is unavailable, and a reported zero remains zero. Output counts are not converted into visible text length or an inferred reasoning count.

mistral:latest0 accepted / 250 attemptedInspect response distribution

Choices from 1 to 100 accepted answers

No captured answer met the requested format.

No percentage distribution is defined because no responses were accepted. All attempts remain in the recorded evidence.

Read the exact counts

mistral:latest: accepted answers by value
Value	1	2	3	4	5	6	7	8	9	10
Count	0	0	0	0	0	0	0	0	0	0
Share	Undefined	Undefined	Undefined	Undefined	Undefined	Undefined	Undefined	Undefined	Undefined	Undefined

250 replies excluded: 0 without a stop finish, 0 empty, and 250 other responses outside the exact integer format. These categories are mutually exclusive, and are not automatic refusal labels.

Model digest: 6577803aa9a036369e481d648a2baebb381ebc6e897f2bb9a766a2aa7bfbc1cf
Input tokens: 5,000
Output tokens: 14,592
Reasoning tokens: Not reported

Missing usage is unavailable, and a reported zero remains zero. Output counts are not converted into visible text length or an inferred reasoning count.

qwen2.5:14b-instruct250 accepted / 250 attemptedInspect response distribution

Choices from 1 to 10250 accepted answers

Bar height is the percentage of accepted answers, on the same 0 to 100% scale. The dashed line marks a uniform 10% reference.

Most frequent accepted value: 7250 of 250 accepted answers (100%).

Read the exact counts

qwen2.5:14b-instruct: accepted answers by value
Value	1	2	3	4	5	6	7	8	9	10
Count	0	0	0	0	0	0	250	0	0	0
Share	0%	0%	0%	0%	0%	0%	100%	0%	0%	0%

0 replies excluded: 0 without a stop finish, 0 empty, and 0 other responses outside the exact integer format. These categories are mutually exclusive, and are not automatic refusal labels.

Model digest: 7cdf5a0187d5c58cc5d369b255592f7841d1c4696d45a8c8a9489440385b22f6
Input tokens: 11,250
Output tokens: 500
Reasoning tokens: Not reported

Missing usage is unavailable, and a reported zero remains zero. Output counts are not converted into visible text length or an inferred reasoning count.

qwen3.8:latest250 accepted / 250 attemptedInspect response distribution

Choices from 1 to 10250 accepted answers

Bar height is the percentage of accepted answers, on the same 0 to 100% scale. The dashed line marks a uniform 10% reference.

Most frequent accepted value: 7250 of 250 accepted answers (100%).

Read the exact counts

qwen3.8:latest: accepted answers by value
Value	1	2	3	4	5	6	7	8	9	10
Count	0	0	0	0	0	0	250	0	0	0
Share	0%	0%	0%	0%	0%	0%	100%	0%	0%	0%

0 replies excluded: 0 without a stop finish, 0 empty, and 0 other responses outside the exact integer format. These categories are mutually exclusive, and are not automatic refusal labels. Installed local tag; artifact pinned by digest, not a verified official public release name.

Model digest: 22130167c4c20e20c7b71454612966ca8e8171e9b3cc8ab6ce8aa6cbfec79643
Input tokens: 6,500
Output tokens: 8,929
Reasoning tokens: Not reported

Missing usage is unavailable, and a reported zero remains zero. Output counts are not converted into visible text length or an inferred reasoning count.

Token counts describe reported usage, with no measured dollar or energy costs. The trace retains visible response text, normalized finish reasons and usage exposed by the native API; full HTTP messages and unexposed reasoning are outside this record. The human survey and model prompt differ, so their histograms describe their own collection conditions.

THE RESEARCH WORKFLOW

Use more resources.
Keep the path to the result.

A research group can enroll colleagues' computers and select their worker budgets. The native runtime coordinates supported tasks; the study keeps the evidence needed to inspect what happened.

A · SOURCE

Replay the captured choices.

Survey export identity, row mapping, inclusion rules and counts connect every observation to the source.

B · GENERATION

Inspect each actual response.

Prompt, model digest, settings, raw replies, finish status and reported tokens make model behavior inspectable.

CDE · EXECUTION

Check the computation.

Executed sources, runtime identities, seeds, node contributions and trial records support the scaling comparison.

Inspect runtime and study provenance

Native draw identity: seed 20261019; global indices [0, 100000003)
Random engine: aner.philox4x32-10/v1
Native source contract: f3065a2dcade6e435c99eef098e3bc2d548a10a37ca7d74595236e87982c2294
Coordinator CPU and build: Apple M2 Max; Release; AppleClang 21.0.0.21000334
Worker CPU and build: Intel Xeon Gold 6248 CPU @ 2.50GHz (guest-reported); KVM guest; Release; GNU 15.2.0
Coordinator executable: 9ddd8a77265b18e8fc442166e2df95f8923ab218dd78be045f610552e327531e
Worker executable: cd3ed8a5cffbb4169149dba594bba1993b9f0b174b4e2bd316165198ef1986cf
Local model service: 0.40.6
Human projection: 87f9c8272314ee4b3c1599dbb8c51754dbfb24658fb6ff6b107dd181162a3e52

Worker counts and active task peaks describe admission and executor state. They do not reserve physical cores or measure CPU utilization. Exact node contributions and timing boundaries remain in the evidence report. This experiment measures CPU execution; GPU task distribution requires a separate contract and study.

RUN IT, READ IT, CHECK IT

Explore the complete study project.

Native Aner programs, interactive notebooks, cluster instructions and the evidence behind this study. Install a compatible runtime separately and keep real connection settings private.

GitHub repository

Case A · peoplesource Case B · llmsource Case C · serialsource Case D · parallelsource Case E · clustersource case A people notebooknotebook case B llm notebooknotebook native compute notebooknotebook results notebooknotebook Full native benchmarksource Full local model studysource Audit recorded model responsessource All model request recordsevidence All native trial recordsevidence Joined study summaryevidence