Compare commits
118
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
f6af71138c | ||
|
|
8564ced65d | ||
|
|
78baeb8c31 | ||
|
|
a16a4385f8 | ||
|
|
79f492e5e8 | ||
|
|
b0d81b5d0e | ||
|
|
dccbefc8b7 | ||
|
|
894b22277f | ||
|
|
64e1a9ae2b | ||
|
|
2b07d27c67 | ||
|
|
42509a6383 | ||
|
|
5048156b74 | ||
|
|
5a1a7948b1 | ||
|
|
2c6535f948 | ||
|
|
e3e0dab0ec | ||
|
|
97ea7a4f65 | ||
|
|
b25d6b2a71 | ||
|
|
914fb8bef7 | ||
|
|
6ab645e731 | ||
|
|
b62d64adfb | ||
|
|
fe0c2d43ce | ||
|
|
96f84dc283 | ||
|
|
5aa6349e27 | ||
|
|
724b3da478 | ||
|
|
ef399d0ca5 | ||
|
|
4139576155 | ||
|
|
c616429669 | ||
|
|
9ed94bd01f | ||
|
|
3028ef29fb | ||
|
|
99fb12d725 | ||
|
|
367f07d956 | ||
|
|
29749fee4a | ||
|
|
1f558ef596 | ||
|
|
576f834169 | ||
|
|
093cb62212 | ||
|
|
2e42bedb84 | ||
|
|
0b785eebb5 | ||
|
|
885a71b6fe | ||
|
|
8672507fa4 | ||
|
|
37f1f8433b | ||
|
|
b703c757e4 | ||
|
|
98d891fc67 | ||
|
|
d6e043d79f | ||
|
|
ba286758c7 | ||
|
|
b65e6bc9f1 | ||
|
|
f7aeeaa2eb | ||
|
|
1b0607cbd8 | ||
|
|
7c361aecd9 | ||
|
|
212c9198eb | ||
|
|
be0a57a1d9 | ||
|
|
8bdcd8fb83 | ||
|
|
885a4571ff | ||
|
|
e746efcb94 | ||
|
|
16c9d4962a | ||
|
|
283287f74f | ||
|
|
98f3eb75c0 | ||
|
|
853cb845ff | ||
|
|
e9a3c3a669 | ||
|
|
895081e509 | ||
|
|
b76b74cb63 | ||
|
|
289ad40d86 | ||
|
|
f0c9d4d904 | ||
|
|
f6b5df831e | ||
|
|
d1d7c576cf | ||
|
|
8d19cdeae6 | ||
|
|
52e6093011 | ||
|
|
7fd9c8eee3 | ||
|
|
f302bbbb24 | ||
|
|
b22b494ede | ||
|
|
6c23ce847d | ||
|
|
6a466a611f | ||
|
|
1300d7e372 | ||
|
|
66e4f3d47a | ||
|
|
37028cc3eb | ||
|
|
0e6fd9269b | ||
|
|
3d63bbb3eb | ||
|
|
5d8f14c992 | ||
|
|
6f87f48dca | ||
|
|
7d398caa66 | ||
|
|
96dd7bf6d2 | ||
|
|
59249d44d3 | ||
|
|
f011557cd5 | ||
|
|
d52996c02a | ||
|
|
b59aa8d9c1 | ||
|
|
523ec5fd0b | ||
|
|
a1d8e34390 | ||
|
|
2d6233cdc7 | ||
|
|
eb9dcf830b | ||
|
|
af49d4905d | ||
|
|
8fa9e5d9e6 | ||
|
|
492fe68c9e | ||
|
|
f215cb3196 | ||
|
|
6e3b798273 | ||
|
|
16b55b58e3 | ||
|
|
90a2fe12d5 | ||
|
|
bc38a4a787 | ||
|
|
654b205e00 | ||
|
|
ece32ef55f | ||
|
|
5cd77eb5de | ||
|
|
e7a23faa5a | ||
|
|
e0f9b1ab50 | ||
|
|
323e45ab0e | ||
|
|
6fd329e047 | ||
|
|
7d602d2f03 | ||
|
|
78b9416985 | ||
|
|
d2afef19a9 | ||
|
|
e67ffcd204 | ||
|
|
6cf9ed1620 | ||
|
|
4f21677ae5 | ||
|
|
9f7d8ebb51 | ||
|
|
81d726cca2 | ||
|
|
74ba049b5c | ||
|
|
46a4f58019 | ||
|
|
e9d7200a05 | ||
|
|
544711885e | ||
|
|
7d3cebea79 | ||
|
|
1ce22d9d9f | ||
|
|
4eef88b5df |
@@ -0,0 +1,5 @@
|
||||
[source.crates-io]
|
||||
replace-with = "vendored-sources"
|
||||
|
||||
[source.vendored-sources]
|
||||
directory = "vendor"
|
||||
@@ -0,0 +1,36 @@
|
||||
name: public-benchmark-pages
|
||||
|
||||
on:
|
||||
schedule:
|
||||
- cron: '*/15 * * * *'
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
group: alkane-os-public-benchmark-pages
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
publish:
|
||||
runs-on: alkane-verify
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
|
||||
permissions:
|
||||
contents: read
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install SSH client
|
||||
run: |
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq --no-install-recommends openssh-client
|
||||
- name: Render measured benchmark history
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/bench_history.py render
|
||||
- name: Publish public benchmark page
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
BENCH_PAGES_DEPLOY_KEY: ${{ secrets.BENCH_PAGES_DEPLOY_KEY }}
|
||||
run: python3 ci/publish-bench-pages.py os
|
||||
- name: Clean generated page
|
||||
if: always()
|
||||
run: python3 ci/cleanup-generated.py
|
||||
@@ -0,0 +1,23 @@
|
||||
name: completed-ci-badge
|
||||
|
||||
on:
|
||||
schedule:
|
||||
- cron: '*/15 * * * *'
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
group: alkane-os-completed-ci-badge
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
publish:
|
||||
runs-on: alkane-ci
|
||||
permissions:
|
||||
actions: read
|
||||
contents: write
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Publish last completed attempts
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/last-attempt-badge.py
|
||||
@@ -4,19 +4,53 @@ on:
|
||||
push:
|
||||
branches: [main]
|
||||
|
||||
concurrency:
|
||||
group: alkane-os-main
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
verify-and-release:
|
||||
runs-on: alkane-ci
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
permissions:
|
||||
contents: write
|
||||
actions: write
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- name: Install Pages SSH client
|
||||
run: |
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq --no-install-recommends openssh-client
|
||||
- name: Install Rust quality tools
|
||||
run: rustup component add rustfmt clippy
|
||||
- name: Formatting
|
||||
run: cargo fmt --check
|
||||
- name: Last-attempt badge checks
|
||||
run: python3 ci/test-last-attempt-badge.py
|
||||
- name: Benchmark history checks
|
||||
run: python3 ci/test-bench-history.py
|
||||
- name: Metric badge checks
|
||||
run: python3 ci/test-metrics.py
|
||||
- name: Release evidence gate checks
|
||||
run: python3 ci/test-conformance.py
|
||||
- name: Research and experiment report checks
|
||||
run: |
|
||||
python3 ci/test-evidence-status.py
|
||||
python3 ci/test-experiment-priority.py
|
||||
python3 ci/test-pr-surface.py
|
||||
- name: Release publication checks
|
||||
run: python3 ci/test-release.py
|
||||
- name: Release version checks
|
||||
run: python3 ci/test-version.py
|
||||
- name: CI cleanup containment checks
|
||||
run: python3 ci/test-cleanup-generated.py
|
||||
- name: Quality
|
||||
run: cargo clippy --all-targets --locked -- -D warnings
|
||||
run: |
|
||||
cargo clippy --all-targets --locked -- -D warnings
|
||||
printf '{"format":true,"clippy_warnings_denied":true}\n' > quality-current.json
|
||||
- name: Build
|
||||
run: cargo build --release --locked
|
||||
- name: Unit and workflow tests
|
||||
@@ -26,7 +60,7 @@ jobs:
|
||||
- name: Microbenchmarks
|
||||
run: |
|
||||
set -o pipefail
|
||||
cargo test --release --locked -- --ignored --nocapture | tee bench-current.txt
|
||||
cargo test --release --locked -- --ignored --nocapture --test-threads=1 | tee bench-current.txt
|
||||
- name: Coverage tool
|
||||
run: |
|
||||
rustup component add llvm-tools-preview
|
||||
@@ -42,19 +76,42 @@ jobs:
|
||||
run: |
|
||||
CARGO_TARGET_DIR=target/coverage-bench cargo llvm-cov --json \
|
||||
--output-path coverage/bench.json --locked -- --ignored
|
||||
- name: Load previous main benchmark measurement
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/bench_history.py prepare
|
||||
- name: Generate measured badges
|
||||
run: |
|
||||
python3 ci/metrics.py --tests-output tests-current.txt \
|
||||
--tests-coverage coverage/tests.json --bench-output bench-current.txt \
|
||||
--bench-coverage coverage/bench.json
|
||||
- uses: actions/upload-artifact@v4
|
||||
--bench-coverage coverage/bench.json --quality-gate quality-current.json
|
||||
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
|
||||
with:
|
||||
name: alkane-os-metrics
|
||||
path: |
|
||||
badges/metrics.json
|
||||
quality-current.json
|
||||
coverage/tests.json
|
||||
coverage/bench.json
|
||||
bench-current.txt
|
||||
- name: Publish measured badges privately
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/publish-metrics.py
|
||||
- name: Record private benchmark history
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/bench_history.py publish
|
||||
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
|
||||
with:
|
||||
name: alkane-os-benchmark-site-preview
|
||||
path: bench-site/index.html
|
||||
- name: Separate research from release evidence
|
||||
run: python3 ci/evidence_status.py --output evidence-status-current.json
|
||||
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
|
||||
with:
|
||||
name: alkane-os-evidence-status
|
||||
path: evidence-status-current.json
|
||||
- name: Pairing and simulator conformance
|
||||
run: python3 ci/check-conformance.py
|
||||
- name: Select release version
|
||||
@@ -72,3 +129,6 @@ jobs:
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
run: python3 ci/release.py "${{ steps.version.outputs.tag }}" false "dist/alkane-os-${{ steps.version.outputs.version }}-source.tar.gz" dist/alkane-os dist/bench-current.txt
|
||||
- name: Clean generated build and benchmark work
|
||||
if: always()
|
||||
run: python3 ci/cleanup-generated.py
|
||||
|
||||
@@ -6,13 +6,17 @@ on:
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: alkane-ci
|
||||
runs-on: alkane-verify
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- name: Build release candidate
|
||||
run: cargo build --release --locked
|
||||
run: cargo build --release --offline --locked
|
||||
- name: Select candidate version
|
||||
id: version
|
||||
run: python3 ci/version.py next >> "$GITHUB_OUTPUT"
|
||||
@@ -27,3 +31,6 @@ jobs:
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
run: python3 ci/release.py "${{ steps.version.outputs.tag }}" true "dist/alkane-os-${{ steps.version.outputs.version }}-source.tar.gz" dist/alkane-os
|
||||
- name: Clean generated candidate build
|
||||
if: always()
|
||||
run: python3 ci/cleanup-generated.py
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
name: source-pr
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
branches: [next, main]
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
group: alkane-os-source-pr-${{ github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
jobs:
|
||||
source:
|
||||
runs-on: alkane-fast
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- name: Detect changed surface
|
||||
id: surface
|
||||
run: python3 ci/pr_surface.py >> "$GITHUB_OUTPUT"
|
||||
- name: Check patch whitespace
|
||||
run: |
|
||||
if [ "${GITHUB_EVENT_NAME:-}" = pull_request ]; then
|
||||
base="$(git merge-base HEAD "origin/$GITHUB_BASE_REF")"
|
||||
git diff --check "$base" HEAD
|
||||
else
|
||||
git diff --check HEAD^ HEAD
|
||||
fi
|
||||
- name: Check CI and evidence tools
|
||||
if: steps.surface.outputs.surface != 'documentation'
|
||||
run: |
|
||||
python3 -m compileall -q ci
|
||||
for test in ci/test-*.py; do python3 "$test"; done
|
||||
python3 ci/evidence_status.py
|
||||
python3 ci/experiment_priority.py
|
||||
- name: Install source formatter
|
||||
if: steps.surface.outputs.surface == 'rust'
|
||||
run: rustup component add rustfmt
|
||||
- name: Check source formatting
|
||||
if: steps.surface.outputs.surface == 'rust'
|
||||
run: cargo fmt --check
|
||||
- name: Check changed Rust source
|
||||
if: steps.surface.outputs.surface == 'rust'
|
||||
run: |
|
||||
if [ "${GITHUB_BASE_REF:-}" = main ]; then
|
||||
cargo build --release --offline --locked
|
||||
else
|
||||
cargo check --offline --locked
|
||||
fi
|
||||
- name: Clean generated build
|
||||
if: always()
|
||||
run: python3 ci/cleanup-generated.py
|
||||
@@ -0,0 +1,7 @@
|
||||
# Alkane OS working rules
|
||||
|
||||
- Keep the project MIT-licensed and preserve third-party licenses in vendored dependencies.
|
||||
- Use run-scoped Cargo output for one-off work. In CI, set `CARGO_TARGET_DIR=target` and remove generated target, coverage, benchmark, and release staging after artifact publication, including failed runs.
|
||||
- Keep the main release gate on all seven boards, all 64 same-vendor pairings, unmodified stock firmware evidence, and genuine pool acceptance from real captured silicon nonces. Do not promote host-only probes to board conformance.
|
||||
- Keep mining, tuning, HAL, API, protocol parsing, and on-device runtime logic in Rust. Use Python only for host tests, CI, release work, and disposable diagnostics unless a documented interface requires it.
|
||||
- No emojis in files or persisted text.
|
||||
Generated
+98
@@ -5,3 +5,101 @@ version = 4
|
||||
[[package]]
|
||||
name = "alkane-os"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.18"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.8.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.107"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.47"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
|
||||
dependencies = [
|
||||
"serde_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_core"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
|
||||
dependencies = [
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_derive"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_json"
|
||||
version = "1.0.154"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
|
||||
dependencies = [
|
||||
"itoa",
|
||||
"memchr",
|
||||
"serde",
|
||||
"serde_core",
|
||||
"zmij",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "3.0.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.27"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
|
||||
|
||||
[[package]]
|
||||
name = "zmij"
|
||||
version = "1.0.23"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
|
||||
|
||||
+3
-1
@@ -8,7 +8,9 @@ description = "Portable mining and tuning core for Alkane control boards"
|
||||
[lib]
|
||||
name = "alkane_os"
|
||||
|
||||
[dependencies]
|
||||
serde_json = { version = "=1.0.154", features = ["arbitrary_precision"] }
|
||||
|
||||
[profile.release]
|
||||
lto = true
|
||||
codegen-units = 1
|
||||
|
||||
|
||||
@@ -1,51 +1,65 @@
|
||||
# Alkane OS
|
||||
|
||||
[](https://gitea.bluefla.re/blueflare/alkane-os/actions)
|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||
[](https://gitea.bluefla.re/blueflare/alkane-os/actions)
|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||
|
||||
Portable mining, tuning, and management logic for Alkane control boards. The
|
||||
source is MIT licensed. `alkane-sdk` owns the board images and supplies the
|
||||
hardware backend at build time. This repository has no on-board web frontend;
|
||||
the intended management surfaces are SSH, cgminer-compatible port 4028, and a
|
||||
minimal API.
|
||||
Rust mining and tuning core for Alkane control boards. The
|
||||
[SDK](https://gitea.bluefla.re/blueflare/alkane-sdk) builds board images and
|
||||
provides the hardware backend. The miner has no on-board web frontend.
|
||||
|
||||
## Status
|
||||
|
||||
This is the initial interface and release tooling. It does not mine yet. A
|
||||
target in the matrix is an obligation to implement and validate, not a claim
|
||||
of support. All 64 theoretical same-vendor controller/chip pairings are in
|
||||
scope: 52 Bitmain and 12 WhatsMiner. For pairings a stock image rejects, the
|
||||
simulator must record the first genuine rejection gate and Alkane OS must mine.
|
||||
No live board is required by CI. Bench devices supply captures and independent
|
||||
validation of the simulator.
|
||||
The host miner supports BM1362 and BM1366 through the SDK's simulator HAL and
|
||||
Stratum V1. Tests have replayed 33 captured BM1366 shares and one BM1362
|
||||
share to a loopback pool with matching ACCEPT responses. Production board
|
||||
control is still under development.
|
||||
|
||||
The current executable lists target obligations (`alkane-os --list-targets`)
|
||||
and its version. It does not start a miner or a network service.
|
||||
The BM1370 module encodes a captured S21 Pro job and parses captured nonce
|
||||
frames. Work-ID mapping, chain control, and pool acceptance remain open.
|
||||
|
||||
The `main` branch has full tests and a conformance gate; releases are created
|
||||
only after every required cell passes. `next` runs a build check and produces
|
||||
release candidates. `ci/version-x.txt` is the manually edited major version.
|
||||
For this repository, Y changes when the mining protocol, HAL contract, tuning
|
||||
policy or API changes; Z changes for compatible fixes and packaging updates.
|
||||
The HAL client requests PSU shutdown on sensor faults and reserves work IDs
|
||||
until a confirmed reset or shutdown. A production backend still needs a
|
||||
power lease, watchdog, and validated temperature limits. SHA-256d and
|
||||
Litecoin Scrypt proof verification are implemented; Scrypt chip report
|
||||
handling and mining remain open.
|
||||
|
||||
Run `alkane-os --list-targets` for the target matrix. Set `POOL_PASSWORD` to
|
||||
the pool password, then mine with a simulator HAL socket and Stratum V1 pool:
|
||||
|
||||
```sh
|
||||
ALKANE_POOL_PASSWORD="$POOL_PASSWORD" alkane-os --mine-simulator HAL_SOCKET POOL_ADDRESS WORKER BM1366
|
||||
```
|
||||
|
||||
Use `BM1362` for that chip. Set `ALKANE_API_LISTEN=127.0.0.1:4028` for
|
||||
read-only `summary` and `version` commands; reach it remotely through SSH.
|
||||
|
||||
## Release gate
|
||||
|
||||
`main` runs tests, benchmarks, and conformance before release; `next` builds
|
||||
release candidates. The release gate is red. It requires all 64 same-vendor
|
||||
pairings (52 Bitmain, 12 WhatsMiner), unmodified stock firmware, captured
|
||||
silicon nonces, difficulty-1 pool acceptance, and bench-validated models.
|
||||
Stock firmware may faithfully reject a pairing; Alkane OS must mine it.
|
||||
See the [evidence contract](ci/CONFORMANCE.md).
|
||||
|
||||
Badges cover host code, not board conformance. See the public
|
||||
[benchmark history](https://blueflare.gitea.bluefla.re/alkane-benchmarks/os/).
|
||||
|
||||
## Local checks
|
||||
|
||||
```sh
|
||||
cargo fmt --check
|
||||
cargo clippy --all-targets -- -D warnings
|
||||
cargo test
|
||||
python3 ci/check-conformance.py
|
||||
CARGO_TARGET_DIR=/var/tmp/alkane-os-target cargo test --locked
|
||||
```
|
||||
|
||||
The last command currently fails because simulator and device evidence are
|
||||
still pending. It is a release gate, not a unit test.
|
||||
Use an executable target directory if the source mount is `noexec`.
|
||||
|
||||
The badges record measured host-side checks for this initial core. They do
|
||||
not imply that any board image or mining target has passed conformance.
|
||||
## License
|
||||
|
||||
[MIT](LICENSE). Vendored dependencies keep their own licenses.
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
# Release conformance evidence
|
||||
|
||||
`check-conformance.py` is a release gate for all 64 same-vendor cells. It
|
||||
currently fails because the simulator and bench evidence producer is not yet
|
||||
implemented. A green Rust build, host HAL replay probe, or rootfs archive does
|
||||
not fill any cell.
|
||||
|
||||
`research-evidence.json` records scoped historical observations with source
|
||||
hashes. `evidence_status.py` reports those separately from declarations in
|
||||
`conformance.json`. Neither research claims nor manifest declarations count
|
||||
as verified release cells. The current-run checker below is the only release
|
||||
validator. `experiment-queue.json` ranks the next protocol and controller
|
||||
experiments by the number of affected cells; blocked work stays visible.
|
||||
The status report names catalog, decoded protocol, stock simulator boot,
|
||||
captured-nonce pool acceptance, physical lifecycle, and complete-cell levels.
|
||||
It leaves current-run verified counts unset; the conformance checker certifies
|
||||
the full cells separately.
|
||||
|
||||
Each CI run must put a JSON report at
|
||||
`ci/evidence/<GITHUB_RUN_ID>/<board>/<chip>.json`. The report binds its
|
||||
`run_id`, `source_commit`, `os_binary_sha256`, `board`, and `chip` to the
|
||||
current workflow. It records `stock_firmware_modified: false`,
|
||||
`simulator_booted_stock: true`, and a `stock_result` of `mines` or `rejects`.
|
||||
For a rejection, `stock_first_rejection` names the first genuine firmware
|
||||
gate. Reports for stock mining also reference `stock_pool_accept_capture`.
|
||||
|
||||
The report references files under `ci/evidence/` with objects containing
|
||||
`path` and `sha256`: `sdk_image`, `stock_image`, `simulator_trace`,
|
||||
`simulator_model`, `control_capture`, `chip_capture`,
|
||||
`alkane_share_accept_capture`, and `bench_validation`.
|
||||
The checker opens and hashes each file. It loads the trace and capture JSON,
|
||||
checks the current run/image/cell identities, verifies SHA-256d or Litecoin
|
||||
Scrypt nonces against
|
||||
a pool target at difficulty 1 or higher, and requires a matching
|
||||
`mining.submit` and pool ACCEPT response ID. A SHA-256 capture must include
|
||||
the matching `subscription` (`extranonce1`, `extranonce2_size`), full
|
||||
`notify` message, exact decimal `difficulty`, and a `configure_response`
|
||||
with an accepted BIP310 mask when version bits were submitted. A later
|
||||
`version_mask_event` may supply the effective `mining.set_version_mask`.
|
||||
The checker reconstructs
|
||||
the coinbase, merkle root, and complete submitted header; its 80 bytes and
|
||||
calculated difficulty target must match the capture. The trace binds
|
||||
the capture digests.
|
||||
The Scrypt verifier uses [Litecoin's 80-byte, N=1024, r=1, p=1 proof hash](https://github.com/litecoin-project/litecoin/blob/master/src/crypto/scrypt.cpp).
|
||||
Equihash proof verification remains pending, so its cells fail closed.
|
||||
Scrypt cells also remain pending until real silicon reports, stock behavior,
|
||||
and pool acceptance are captured for those chips.
|
||||
Bench calibration names the physical control-board and chip devices, their
|
||||
capture digests, and the simulator model digest. It can be reused across OS
|
||||
commits until the model or a physical capture changes.
|
||||
The fixed digests and artifact paths also appear in `conformance.json` so
|
||||
source review can track what each cell claims.
|
||||
|
||||
The simulator runner must generate these reports by booting pristine stock
|
||||
firmware and Alkane OS in a machine model, with nonce data replayed from
|
||||
real-silicon captures. A rejected stock pairing must show its first rejection
|
||||
in the simulator trace while Alkane OS reaches pool ACCEPT. Bench devices
|
||||
provide independent observations for model validation, not CI dependencies.
|
||||
The checker verifies its input artifacts and reported nonce. It cannot prove
|
||||
that a self-asserted pool response came from a real pool or turn a report into
|
||||
physical evidence. The capture producer must preserve raw request/response
|
||||
bytes and independent provenance. Capture provenance and faithful machine
|
||||
models remain release blockers until the runner and bench validation are built.
|
||||
@@ -0,0 +1,54 @@
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Write small badge artifacts to the private Gitea CI badge branch."""
|
||||
|
||||
import base64
|
||||
import json
|
||||
from urllib.error import HTTPError
|
||||
from urllib.parse import quote
|
||||
from urllib.request import Request, urlopen
|
||||
|
||||
BADGE_BRANCH = "ci-badges"
|
||||
|
||||
|
||||
def request_json(url: str, token: str, method: str = "GET",
|
||||
payload: dict | None = None) -> dict:
|
||||
body = None if payload is None else json.dumps(payload).encode()
|
||||
request = Request(url, data=body, method=method,
|
||||
headers={"Authorization": f"token {token}",
|
||||
"Content-Type": "application/json"})
|
||||
with urlopen(request, timeout=20) as response:
|
||||
return json.load(response)
|
||||
|
||||
|
||||
def publish_file(api: str, repo: str, filename: str, data: bytes,
|
||||
token: str, message: str, max_bytes: int = 65_536) -> None:
|
||||
if not filename or filename.startswith("/") or any(
|
||||
part in ("", ".", "..") for part in filename.split("/")):
|
||||
raise ValueError("invalid badge path")
|
||||
if len(data) > max_bytes:
|
||||
raise ValueError("artifact exceeds size limit")
|
||||
path = f"{api}/repos/{repo}/contents/{quote(filename, safe='/')}"
|
||||
encoded = base64.b64encode(data).decode("ascii")
|
||||
for attempt in range(3):
|
||||
try:
|
||||
current = request_json(path + "?ref=" + BADGE_BRANCH, token)
|
||||
if base64.b64decode(current["content"]) == data:
|
||||
return
|
||||
sha = current["sha"]
|
||||
method = "PUT"
|
||||
except HTTPError as error:
|
||||
if error.code != 404:
|
||||
raise
|
||||
sha = None
|
||||
method = "POST"
|
||||
payload = {"branch": BADGE_BRANCH, "content": encoded,
|
||||
"message": message + " [skip ci]"}
|
||||
if sha is not None:
|
||||
payload["sha"] = sha
|
||||
try:
|
||||
request_json(path, token, method, payload)
|
||||
return
|
||||
except HTTPError as error:
|
||||
if error.code not in (409, 422) or attempt == 2:
|
||||
raise
|
||||
raise RuntimeError("badge write did not complete")
|
||||
@@ -0,0 +1,159 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Keep measured main-branch benchmarks in the private CI artifact branch."""
|
||||
|
||||
import argparse
|
||||
import base64
|
||||
from datetime import datetime, timezone
|
||||
import html
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import subprocess
|
||||
from urllib.error import HTTPError
|
||||
from urllib.parse import quote
|
||||
|
||||
from badge_store import BADGE_BRANCH, publish_file, request_json
|
||||
from bench_host import identity as benchmark_host
|
||||
|
||||
INDEX = "history/index.json"
|
||||
MAX_INDEX_ENTRIES = 50
|
||||
|
||||
|
||||
def read_artifact(api: str, repo: str, token: str, filename: str):
|
||||
url = f"{api}/repos/{repo}/contents/{quote(filename, safe='/')}?ref={BADGE_BRANCH}"
|
||||
try:
|
||||
value = request_json(url, token)
|
||||
except HTTPError as error:
|
||||
if error.code == 404:
|
||||
return None
|
||||
raise
|
||||
return json.loads(base64.b64decode(value["content"]))
|
||||
|
||||
|
||||
def valid_benches(metrics: dict) -> dict[str, float]:
|
||||
values = metrics.get("bench_ns_per_op")
|
||||
if not isinstance(values, dict) or not values:
|
||||
raise ValueError("benchmark measurements are missing")
|
||||
if any(not isinstance(key, str) or not re.fullmatch(r"[A-Za-z0-9_]+", key)
|
||||
or not isinstance(value, (float, int)) or isinstance(value, bool)
|
||||
or not math.isfinite(value) or value <= 0 for key, value in values.items()):
|
||||
raise ValueError("benchmark measurements are invalid")
|
||||
return values
|
||||
|
||||
|
||||
def git_distance(ancestor: str, sha: str) -> int | None:
|
||||
result = subprocess.run(("git", "rev-list", "--count", f"{ancestor}..{sha}"),
|
||||
capture_output=True, text=True, check=False)
|
||||
if result.returncode != 0:
|
||||
return None
|
||||
ancestor_check = subprocess.run(("git", "merge-base", "--is-ancestor", ancestor, sha),
|
||||
capture_output=True, check=False)
|
||||
return int(result.stdout.strip()) if ancestor_check.returncode == 0 else None
|
||||
|
||||
|
||||
def previous_measurement(index: dict, sha: str, distance=None, host=None) -> dict:
|
||||
distance = distance or git_distance
|
||||
choices = []
|
||||
for entry in index.get("entries", []):
|
||||
ancestor = entry.get("sha")
|
||||
if ancestor == sha or not isinstance(ancestor, str):
|
||||
continue
|
||||
if host is not None and entry.get("metrics", {}).get("bench_host") != host:
|
||||
continue
|
||||
gap = distance(ancestor, sha)
|
||||
if gap is not None and gap > 0:
|
||||
choices.append((gap, entry))
|
||||
if not choices:
|
||||
return {}
|
||||
return valid_benches(min(choices, key=lambda item: item[0])[1]["metrics"])
|
||||
|
||||
|
||||
def updated_index(index: dict, sha: str, metrics: dict, timestamp: str) -> dict:
|
||||
if not re.fullmatch(r"[0-9a-f]{40}", sha):
|
||||
raise ValueError("invalid commit SHA")
|
||||
valid_benches(metrics)
|
||||
entries = [entry for entry in index.get("entries", []) if entry.get("sha") != sha]
|
||||
entries.append({"sha": sha, "timestamp": timestamp, "metrics": metrics})
|
||||
return {"schema": 1, "entries": entries[-MAX_INDEX_ENTRIES:]}
|
||||
|
||||
|
||||
def render_html(index: dict) -> str:
|
||||
entries = list(reversed(index.get("entries", [])))
|
||||
names = sorted({name for entry in entries
|
||||
for name in valid_benches(entry["metrics"])})
|
||||
rows = []
|
||||
for entry in entries:
|
||||
sha = entry["sha"]
|
||||
if not re.fullmatch(r"[0-9a-f]{40}", sha):
|
||||
raise ValueError("invalid commit SHA in history")
|
||||
cells = [f'<td><a href="https://gitea.bluefla.re/blueflare/alkane-os/commit/{sha}">{sha[:10]}</a></td>',
|
||||
f'<td>{html.escape(entry["timestamp"])}</td>']
|
||||
values = valid_benches(entry["metrics"])
|
||||
host = entry["metrics"].get("bench_host", {})
|
||||
host_label = host.get("cpu_model", "unknown") if isinstance(host, dict) else "unknown"
|
||||
cells.append(f'<td>{html.escape(str(host_label))}</td>')
|
||||
cells += [f'<td>{values[name]:.3f}</td>' if name in values else '<td>new</td>'
|
||||
for name in names]
|
||||
rows.append("<tr>" + "".join(cells) + "</tr>")
|
||||
headings = "".join(f"<th scope=\"col\">{html.escape(name)} (ns/op)</th>" for name in names)
|
||||
return ("<!doctype html>\n<html lang=\"en\"><head><meta charset=\"utf-8\">"
|
||||
"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">"
|
||||
"<title>Alkane OS benchmarks</title><style>"
|
||||
"body{font:16px system-ui,sans-serif;max-width:1100px;margin:2rem auto;padding:0 1rem;color:#17212b}"
|
||||
"h1{font-size:2rem}p{max-width:70ch;line-height:1.5}"
|
||||
"table{border-collapse:collapse;min-width:100%}th,td{padding:.5rem;border-bottom:1px solid #ccd3da;text-align:right}"
|
||||
"th:first-child,td:first-child{text-align:left}th:nth-child(2),td:nth-child(2){text-align:left}"
|
||||
"th{background:#edf2f6;position:sticky;top:0}a{color:#145a9a}"
|
||||
".scroll{overflow-x:auto}small{color:#55616d}</style></head><body>"
|
||||
"<h1>Alkane OS microbenchmarks</h1>"
|
||||
"<p>Measured on main CI. Lower ns/op is faster. Results depend on runner load and are "
|
||||
"not board performance. A new benchmark has no earlier comparison.</p>"
|
||||
f"<p><small>Most recent {len(entries)} measured commits. Full per-commit JSON is retained "
|
||||
"in the private ci-badges branch.</small></p>"
|
||||
f"<div class=\"scroll\"><table><thead><tr><th scope=\"col\">Commit</th>"
|
||||
f"<th scope=\"col\">UTC</th><th scope=\"col\">CPU</th>{headings}</tr></thead><tbody>{''.join(rows)}"
|
||||
"</tbody></table></div></body></html>\n")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("action", choices=("prepare", "publish", "render"))
|
||||
args = parser.parse_args()
|
||||
api = os.environ["GITHUB_API_URL"].rstrip("/")
|
||||
repo = os.environ["GITHUB_REPOSITORY"]
|
||||
token = os.environ["GITEA_TOKEN"]
|
||||
sha = os.environ["GITHUB_SHA"]
|
||||
index = read_artifact(api, repo, token, INDEX) or {"schema": 1, "entries": []}
|
||||
if index.get("schema") != 1 or not isinstance(index.get("entries"), list):
|
||||
raise ValueError("unsupported benchmark history index")
|
||||
if args.action == "prepare":
|
||||
baseline = previous_measurement(index, sha, host=benchmark_host())
|
||||
Path("badges").mkdir(exist_ok=True)
|
||||
Path("badges/bench-baseline.json").write_text(json.dumps(baseline) + "\n")
|
||||
print(f"Loaded {len(baseline)} prior benchmark measurements")
|
||||
return
|
||||
if args.action == "render":
|
||||
if not index["entries"]:
|
||||
raise ValueError("no measured benchmark history to publish")
|
||||
Path("bench-site").mkdir(exist_ok=True)
|
||||
Path("bench-site/index.html").write_text(render_html(index))
|
||||
print(f"Rendered {len(index['entries'])} measured benchmark commits")
|
||||
return
|
||||
metrics = json.loads(Path("badges/metrics.json").read_text())
|
||||
timestamp = datetime.now(timezone.utc).isoformat(timespec="seconds")
|
||||
index = updated_index(index, sha, metrics, timestamp)
|
||||
record = json.dumps(index["entries"][-1], indent=2).encode() + b"\n"
|
||||
publish_file(api, repo, f"history/{sha}.json", record, token,
|
||||
"Record Alkane OS benchmarks", max_bytes=1_048_576)
|
||||
publish_file(api, repo, INDEX, json.dumps(index, indent=2).encode() + b"\n",
|
||||
token, "Update Alkane OS benchmark index", max_bytes=1_048_576)
|
||||
Path("bench-site").mkdir(exist_ok=True)
|
||||
Path("bench-site/index.html").write_text(render_html(index))
|
||||
print(f"Recorded benchmarks for {sha[:10]}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,19 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Identify the CPU class used for comparable CI microbenchmark baselines."""
|
||||
|
||||
import os
|
||||
import platform
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def identity() -> dict[str, object]:
|
||||
model = "unknown"
|
||||
cpuinfo = Path("/proc/cpuinfo")
|
||||
if cpuinfo.is_file():
|
||||
for line in cpuinfo.read_text(errors="replace").splitlines():
|
||||
if line.startswith(("model name\t", "Hardware\t", "Processor\t")):
|
||||
model = line.partition(":")[2].strip()[:160]
|
||||
break
|
||||
return {"architecture": platform.machine(), "cpu_model": model,
|
||||
"logical_cpus": os.cpu_count() or 1}
|
||||
+394
-26
@@ -1,33 +1,401 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Fail the final release gate until every target has traceable evidence."""
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Require the binary target matrix and traceable per-cell release evidence."""
|
||||
|
||||
import argparse
|
||||
from decimal import Decimal, InvalidOperation
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import pathlib
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
manifest = json.loads(pathlib.Path("ci/conformance.json").read_text())
|
||||
rows = manifest["targets"]
|
||||
expected = {(board, chip) for board in manifest["boards"] for chip in manifest["chips"]
|
||||
if manifest["vendors"][board] == manifest["vendors"][chip]}
|
||||
actual = {(row["board"], row["chip"]) for row in rows}
|
||||
if actual != expected or len(rows) != len(expected):
|
||||
sys.exit(f"matrix mismatch: {len(actual)} present, {len(expected)} expected")
|
||||
|
||||
required = ("sdk_image_sha256", "stock_image_sha256", "stock_result",
|
||||
"alkane_share_accept_capture", "simulator_trace_sha256",
|
||||
"bench_validation")
|
||||
incomplete = []
|
||||
for row in rows:
|
||||
missing = [field for field in required if not row.get(field)]
|
||||
if row.get("stock_result") not in (None, "mines", "rejects"):
|
||||
missing.append("stock_result invalid")
|
||||
if row.get("stock_result") == "rejects" and not row.get("stock_first_rejection"):
|
||||
missing.append("stock_first_rejection")
|
||||
if missing:
|
||||
incomplete.append((row["board"], row["chip"], missing))
|
||||
if incomplete:
|
||||
print(f"Conformance pending: {len(incomplete)}/{len(rows)} targets")
|
||||
for board, chip, missing in incomplete[:8]:
|
||||
print(f" {board} x {chip}: {', '.join(missing)}")
|
||||
sys.exit(1)
|
||||
print(f"Conformance complete: {len(rows)} targets")
|
||||
REQUIRED_BOARDS = {
|
||||
"am335x-bb": "bitmain",
|
||||
"zynq-7010": "bitmain",
|
||||
"cv1835": "bitmain",
|
||||
"a113d": "bitmain",
|
||||
"allwinner-h3": "whatsminer",
|
||||
"allwinner-h6": "whatsminer",
|
||||
"allwinner-h616": "whatsminer",
|
||||
}
|
||||
REQUIRED_CHIPS = {
|
||||
**{chip: "bitmain" for chip in (
|
||||
"BM1384", "BM1387", "BM1360", "BM1362", "BM1366", "BM1368",
|
||||
"BM1370", "BM1396", "BM1397", "BM1398", "BM1489", "BM1491", "BM1746",
|
||||
)},
|
||||
**{chip: "whatsminer" for chip in (
|
||||
"KF1950", "ID-1968", "ID-1980", "ID-1990",
|
||||
)},
|
||||
}
|
||||
REQUIRED_ALGORITHMS = {
|
||||
**{chip: "Sha256" for chip in REQUIRED_CHIPS if chip not in
|
||||
("BM1489", "BM1491", "BM1746")},
|
||||
"BM1489": "Scrypt", "BM1491": "Scrypt", "BM1746": "Equihash",
|
||||
}
|
||||
DIGEST = re.compile(r"[0-9a-f]{64}\Z")
|
||||
COMMIT = re.compile(r"[0-9a-f]{40}\Z")
|
||||
DIFF_ONE_TARGET = 0xffff << (8 * (0x1d - 3))
|
||||
MAX_REPORT_BYTES = 1_048_576
|
||||
|
||||
|
||||
def sha256_file(path: pathlib.Path) -> str:
|
||||
digest = hashlib.sha256()
|
||||
with path.open("rb") as source:
|
||||
for chunk in iter(lambda: source.read(1_048_576), b""):
|
||||
digest.update(chunk)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def load_report(path: pathlib.Path) -> dict:
|
||||
if path.stat().st_size > MAX_REPORT_BYTES:
|
||||
raise ValueError("evidence report exceeds 1 MiB")
|
||||
value = json.loads(path.read_text())
|
||||
if not isinstance(value, dict):
|
||||
raise ValueError("evidence report is not an object")
|
||||
return value
|
||||
|
||||
|
||||
def artifact(root: pathlib.Path, value: object) -> pathlib.Path:
|
||||
if not isinstance(value, dict) or not isinstance(value.get("path"), str):
|
||||
raise ValueError("artifact reference is missing")
|
||||
digest = value.get("sha256")
|
||||
if not isinstance(digest, str) or not DIGEST.fullmatch(digest):
|
||||
raise ValueError("artifact digest is invalid")
|
||||
path = (root / value["path"]).resolve()
|
||||
if not path.is_relative_to(root.resolve()) or not path.is_file():
|
||||
raise ValueError("artifact is missing or outside evidence directory")
|
||||
if sha256_file(path) != digest:
|
||||
raise ValueError("artifact digest mismatch")
|
||||
return path
|
||||
|
||||
|
||||
def hex_field(value: object, size: int | None = None) -> bytes:
|
||||
if (not isinstance(value, str) or len(value) & 1
|
||||
or len(value) > 131_072 or not re.fullmatch(r"[0-9a-fA-F]*", value)
|
||||
or (size is not None and len(value) != size * 2)):
|
||||
raise ValueError("invalid Stratum hex field")
|
||||
return bytes.fromhex(value)
|
||||
|
||||
|
||||
def u32_hex(value: object) -> int:
|
||||
return int.from_bytes(hex_field(value, 4), "big")
|
||||
|
||||
|
||||
def reconstructed_header(capture: dict, params: list[str]) -> tuple[bytes, int]:
|
||||
subscription = capture.get("subscription")
|
||||
notify = capture.get("notify")
|
||||
if not isinstance(subscription, dict) or not isinstance(notify, dict):
|
||||
raise ValueError("subscription and notify are required to bind the share")
|
||||
extra1 = hex_field(subscription.get("extranonce1"))
|
||||
extra_size = subscription.get("extranonce2_size")
|
||||
if (len(extra1) > 32 or type(extra_size) is not int
|
||||
or not 0 <= extra_size <= 32):
|
||||
raise ValueError("invalid subscription extranonce")
|
||||
extra2 = hex_field(params[2], extra_size)
|
||||
job = notify.get("params")
|
||||
if (notify.get("method") != "mining.notify" or not isinstance(job, list)
|
||||
or len(job) != 9 or job[0] != params[1]
|
||||
or not isinstance(job[4], list) or len(job[4]) > 64
|
||||
or type(job[8]) is not bool):
|
||||
raise ValueError("submission is not bound to a matching notify")
|
||||
prevhash = hex_field(job[1], 32)
|
||||
coinbase = hex_field(job[2]) + extra1 + extra2 + hex_field(job[3])
|
||||
if len(coinbase) > 65_536:
|
||||
raise ValueError("coinbase exceeds supported size")
|
||||
root = hashlib.sha256(hashlib.sha256(coinbase).digest()).digest()
|
||||
for branch in job[4]:
|
||||
pair = root + hex_field(branch, 32)
|
||||
root = hashlib.sha256(hashlib.sha256(pair).digest()).digest()
|
||||
base_version = u32_hex(job[5])
|
||||
nbits = u32_hex(job[6])
|
||||
u32_hex(job[7])
|
||||
submitted_ntime = u32_hex(params[3])
|
||||
submitted_nonce = u32_hex(params[4])
|
||||
if len(params) == 6:
|
||||
configure = capture.get("configure_response")
|
||||
result = configure.get("result") if isinstance(configure, dict) else None
|
||||
if not isinstance(result, dict) or result.get("version-rolling") is not True:
|
||||
raise ValueError("version rolling was not negotiated")
|
||||
mask_text = result.get("version-rolling.mask")
|
||||
mask_event = capture.get("version_mask_event")
|
||||
if mask_event is not None:
|
||||
fields = mask_event.get("params") if isinstance(mask_event, dict) else None
|
||||
if (not isinstance(mask_event, dict)
|
||||
or mask_event.get("method") != "mining.set_version_mask"
|
||||
or not isinstance(fields, list) or len(fields) != 1):
|
||||
raise ValueError("invalid effective version mask event")
|
||||
mask_text = fields[0]
|
||||
mask = u32_hex(mask_text)
|
||||
bits = u32_hex(params[5])
|
||||
if bits & ~mask:
|
||||
raise ValueError("submitted version bits exceed negotiated mask")
|
||||
version = (base_version & ~mask) | bits
|
||||
else:
|
||||
if capture.get("configure_response") is not None or capture.get("version_mask_event") is not None:
|
||||
raise ValueError("negotiated version mask requires submission bits")
|
||||
version = base_version
|
||||
header = bytearray()
|
||||
header.extend(version.to_bytes(4, "little"))
|
||||
for offset in range(0, 32, 4):
|
||||
header.extend(prevhash[offset:offset + 4][::-1])
|
||||
header.extend(root)
|
||||
header.extend(submitted_ntime.to_bytes(4, "little"))
|
||||
header.extend(nbits.to_bytes(4, "little"))
|
||||
header.extend(submitted_nonce.to_bytes(4, "little"))
|
||||
return bytes(header), submitted_nonce
|
||||
|
||||
|
||||
def proof_digest(header: bytes, algorithm: str) -> bytes:
|
||||
if algorithm == "Sha256":
|
||||
return hashlib.sha256(hashlib.sha256(header).digest()).digest()
|
||||
if algorithm == "Scrypt":
|
||||
return hashlib.scrypt(header, salt=header, n=1024, r=1, p=1, dklen=32)
|
||||
raise ValueError(f"{algorithm} share verifier is not implemented")
|
||||
|
||||
|
||||
def verify_accept(capture: dict, algorithm: str) -> None:
|
||||
if algorithm not in ("Sha256", "Scrypt"):
|
||||
raise ValueError(f"{algorithm} share verifier is not implemented")
|
||||
if capture.get("nonce_source") != "real_silicon_capture":
|
||||
raise ValueError("share was not sourced from captured silicon")
|
||||
header_hex = capture.get("header80")
|
||||
target_hex = capture.get("pool_target_le")
|
||||
nonce = capture.get("nonce")
|
||||
if (not isinstance(header_hex, str) or len(header_hex) != 160
|
||||
or not isinstance(target_hex, str) or not DIGEST.fullmatch(target_hex)
|
||||
or type(nonce) is not int or not 0 <= nonce <= 0xffffffff):
|
||||
raise ValueError("invalid accepted share work")
|
||||
try:
|
||||
header = bytearray.fromhex(header_hex)
|
||||
except ValueError as error:
|
||||
raise ValueError("invalid accepted share header") from error
|
||||
if int.from_bytes(header[76:80], "little") != nonce:
|
||||
raise ValueError("nonce differs from submitted header")
|
||||
submission = capture.get("submission")
|
||||
response = capture.get("pool_response")
|
||||
params = submission.get("params") if isinstance(submission, dict) else None
|
||||
if (not isinstance(params, list) or len(params) not in (5, 6)
|
||||
or not all(isinstance(value, str) for value in params)
|
||||
or not params[0] or not params[1]
|
||||
or params[3].lower() != f"{int.from_bytes(header[68:72], 'little'):08x}"
|
||||
or params[4].lower() != f"{nonce:08x}"
|
||||
or (len(params) == 6 and not re.fullmatch(r"[0-9a-f]{8}", params[5].lower()))
|
||||
or not isinstance(response, dict)
|
||||
or submission.get("method") != "mining.submit"
|
||||
or type(submission.get("id")) is not int
|
||||
or response.get("id") != submission["id"]
|
||||
or response.get("result") is not True
|
||||
or response.get("error") is not None):
|
||||
raise ValueError("no matching pool ACCEPT for submitted nonce")
|
||||
target = int.from_bytes(bytes.fromhex(target_hex), "little")
|
||||
if not 0 < target <= DIFF_ONE_TARGET:
|
||||
raise ValueError("pool target is below difficulty one")
|
||||
difficulty_text = capture.get("difficulty")
|
||||
if not isinstance(difficulty_text, str) or len(difficulty_text) > 128:
|
||||
raise ValueError("effective pool difficulty is missing")
|
||||
try:
|
||||
difficulty = Decimal(difficulty_text)
|
||||
except InvalidOperation as error:
|
||||
raise ValueError("invalid pool difficulty") from error
|
||||
if not difficulty.is_finite() or difficulty < 1:
|
||||
raise ValueError("pool difficulty is below one")
|
||||
if abs(difficulty.as_tuple().exponent) > 64:
|
||||
raise ValueError("pool difficulty exceeds supported range")
|
||||
numerator, denominator = difficulty.as_integer_ratio()
|
||||
expected_target = DIFF_ONE_TARGET * denominator // numerator
|
||||
if target != expected_target:
|
||||
raise ValueError("pool target differs from effective difficulty")
|
||||
rebuilt, submitted_nonce = reconstructed_header(capture, params)
|
||||
if submitted_nonce != nonce or rebuilt != header:
|
||||
raise ValueError("submitted Stratum job differs from captured header")
|
||||
hash_bytes = proof_digest(header, algorithm)
|
||||
if int.from_bytes(hash_bytes, "little") > target:
|
||||
raise ValueError("captured nonce misses the pool target")
|
||||
|
||||
|
||||
def verify_cell(row: dict, root: pathlib.Path, run_id: str,
|
||||
source_commit: str, binary_digest: str,
|
||||
algorithm: str) -> None:
|
||||
board, chip = row["board"], row["chip"]
|
||||
report_path = (root / run_id / board / f"{chip}.json").resolve()
|
||||
if not report_path.is_relative_to(root.resolve()):
|
||||
raise ValueError("evidence report is outside evidence directory")
|
||||
report = load_report(report_path)
|
||||
identity = {"schema": 1, "run_id": run_id, "source_commit": source_commit,
|
||||
"os_binary_sha256": binary_digest, "board": board, "chip": chip,
|
||||
"stock_firmware_modified": False, "algorithm": algorithm}
|
||||
if any(report.get(key) != value for key, value in identity.items()):
|
||||
raise ValueError("evidence belongs to a different run, source, binary, or cell")
|
||||
if report.get("stock_result") != row.get("stock_result"):
|
||||
raise ValueError("stock result differs from manifest")
|
||||
if report.get("stock_first_rejection") != row.get("stock_first_rejection"):
|
||||
raise ValueError("stock rejection differs from manifest")
|
||||
if report["stock_result"] == "rejects" and not report.get("stock_first_rejection"):
|
||||
raise ValueError("stock rejection gate is missing")
|
||||
if report.get("simulator_booted_stock") is not True:
|
||||
raise ValueError("unmodified stock boot is unverified")
|
||||
paths = {}
|
||||
for field, digest_field in (("sdk_image", "sdk_image_sha256"),
|
||||
("stock_image", "stock_image_sha256"),
|
||||
("simulator_trace", "simulator_trace_sha256")):
|
||||
paths[field] = artifact(root, report.get(field))
|
||||
if report[field]["sha256"] != row.get(digest_field):
|
||||
raise ValueError(f"{field} digest differs from manifest")
|
||||
artifact(root, report.get("simulator_model"))
|
||||
model_digest = report["simulator_model"]["sha256"]
|
||||
for field in ("control_capture", "chip_capture"):
|
||||
artifact(root, report.get(field))
|
||||
trace = load_report(paths["simulator_trace"])
|
||||
trace_identity = {"run_id": run_id, "source_commit": source_commit,
|
||||
"board": board, "chip": chip,
|
||||
"sdk_image_sha256": row["sdk_image_sha256"],
|
||||
"stock_image_sha256": row["stock_image_sha256"],
|
||||
"stock_firmware_modified": False,
|
||||
"stock_result": row["stock_result"],
|
||||
"algorithm": algorithm,
|
||||
"simulator_model_sha256": model_digest}
|
||||
if any(trace.get(key) != value for key, value in trace_identity.items()):
|
||||
raise ValueError("simulator trace does not bind stock image and current run")
|
||||
if report["stock_result"] == "rejects":
|
||||
if trace.get("first_rejection") != row["stock_first_rejection"]:
|
||||
raise ValueError("stock rejection gate is absent from simulator trace")
|
||||
else:
|
||||
stock_capture = load_report(artifact(root, report.get("stock_pool_accept_capture")))
|
||||
if trace.get("stock_pool_accept_capture_sha256") != report["stock_pool_accept_capture"]["sha256"]:
|
||||
raise ValueError("stock pool acceptance is not linked to simulator trace")
|
||||
if (stock_capture.get("board") != board or stock_capture.get("chip") != chip
|
||||
or stock_capture.get("firmware") != "stock"):
|
||||
raise ValueError("stock pool acceptance belongs to another firmware or cell")
|
||||
verify_accept(stock_capture, algorithm)
|
||||
capture = load_report(artifact(root, report.get("alkane_share_accept_capture")))
|
||||
if report["alkane_share_accept_capture"]["path"] != row.get("alkane_share_accept_capture"):
|
||||
raise ValueError("accepted share artifact differs from manifest")
|
||||
if trace.get("alkane_share_accept_capture_sha256") != report["alkane_share_accept_capture"]["sha256"]:
|
||||
raise ValueError("Alkane pool acceptance is not linked to simulator trace")
|
||||
if (capture.get("board") != board or capture.get("chip") != chip
|
||||
or capture.get("firmware") != "alkane"):
|
||||
raise ValueError("accepted share belongs to another cell")
|
||||
verify_accept(capture, algorithm)
|
||||
bench = load_report(artifact(root, report.get("bench_validation")))
|
||||
if report["bench_validation"]["path"] != row.get("bench_validation"):
|
||||
raise ValueError("bench artifact differs from manifest")
|
||||
if (bench.get("board") != board or bench.get("chip") != chip
|
||||
or bench.get("validated") is not True
|
||||
or bench.get("simulator_model_sha256") != model_digest
|
||||
or any(bench.get(f"{field}_sha256") != report[field]["sha256"]
|
||||
for field in ("control_capture", "chip_capture"))
|
||||
or any(not isinstance(bench.get(f"{name}_device_id"), str)
|
||||
or not bench[f"{name}_device_id"]
|
||||
for name in ("control", "chip"))):
|
||||
raise ValueError("bench validation is missing or belongs to another cell")
|
||||
|
||||
|
||||
def binary_targets(path: pathlib.Path) -> dict[tuple[str, str], str]:
|
||||
output = subprocess.run(
|
||||
[str(path), "--list-targets"],
|
||||
check=True, capture_output=True, text=True, timeout=15,
|
||||
).stdout.splitlines()
|
||||
if not output or output[0] != "control_board,hash_chip,algorithm":
|
||||
raise ValueError("Alkane OS binary has no target matrix header")
|
||||
targets = {}
|
||||
for line in output[1:]:
|
||||
parts = line.split(",")
|
||||
if len(parts) != 3 or not all(parts):
|
||||
raise ValueError(f"invalid binary target row: {line!r}")
|
||||
cell = (parts[0], parts[1])
|
||||
if cell in targets:
|
||||
raise ValueError("duplicate binary target")
|
||||
targets[cell] = parts[2]
|
||||
return targets
|
||||
|
||||
|
||||
def validate(manifest: dict, built_targets: dict[tuple[str, str], str],
|
||||
evidence_root: pathlib.Path = pathlib.Path("ci/evidence"),
|
||||
run_id: str = "", source_commit: str = "",
|
||||
binary_digest: str = "") -> list[str]:
|
||||
errors = []
|
||||
if manifest.get("schema") != 1:
|
||||
errors.append("unsupported conformance manifest schema")
|
||||
boards = set(manifest["boards"])
|
||||
chips = set(manifest["chips"])
|
||||
vendors = manifest["vendors"]
|
||||
if len(boards) != len(manifest["boards"]) or len(chips) != len(manifest["chips"]):
|
||||
errors.append("duplicate board or chip in manifest")
|
||||
for name, vendor in {**REQUIRED_BOARDS, **REQUIRED_CHIPS}.items():
|
||||
if name not in boards | chips or vendors.get(name) != vendor:
|
||||
errors.append(f"required target identity changed: {name}")
|
||||
if set(vendors) != boards | chips:
|
||||
errors.append("vendor map differs from board and chip lists")
|
||||
expected = {(board, chip) for board in boards for chip in chips
|
||||
if vendors.get(board) == vendors.get(chip)}
|
||||
rows = manifest["targets"]
|
||||
actual = {(row["board"], row["chip"]) for row in rows}
|
||||
if len(expected) < 64 or actual != expected or len(rows) != len(expected):
|
||||
errors.append(f"manifest matrix mismatch: {len(actual)} present, {len(expected)} expected")
|
||||
if set(built_targets) != expected:
|
||||
errors.append(f"binary matrix mismatch: {len(built_targets)} built, {len(expected)} expected")
|
||||
for (board, chip), algorithm in built_targets.items():
|
||||
if chip in REQUIRED_ALGORITHMS and algorithm != REQUIRED_ALGORITHMS[chip]:
|
||||
errors.append(f"binary algorithm mismatch: {board} x {chip}")
|
||||
if (not run_id.isdecimal() or not COMMIT.fullmatch(source_commit)
|
||||
or not DIGEST.fullmatch(binary_digest)):
|
||||
errors.append("current run, source commit, or binary digest is unbound")
|
||||
required = ("sdk_image_sha256", "stock_image_sha256", "stock_result",
|
||||
"alkane_share_accept_capture", "simulator_trace_sha256",
|
||||
"bench_validation")
|
||||
for row in rows:
|
||||
cell = f"{row['board']} x {row['chip']}"
|
||||
missing = [field for field in required if not row.get(field)]
|
||||
if row.get("stock_result") not in (None, "mines", "rejects"):
|
||||
missing.append("stock_result invalid")
|
||||
if row.get("stock_result") == "rejects" and not row.get("stock_first_rejection"):
|
||||
missing.append("stock_first_rejection")
|
||||
for field in ("sdk_image_sha256", "stock_image_sha256", "simulator_trace_sha256"):
|
||||
value = row.get(field)
|
||||
if value and (not isinstance(value, str) or not DIGEST.fullmatch(value)):
|
||||
missing.append(f"{field} invalid")
|
||||
if missing:
|
||||
errors.append(f"{cell}: {', '.join(missing)}")
|
||||
elif run_id.isdecimal() and COMMIT.fullmatch(source_commit) and DIGEST.fullmatch(binary_digest):
|
||||
try:
|
||||
verify_cell(row, evidence_root, run_id, source_commit, binary_digest,
|
||||
built_targets.get((row["board"], row["chip"]), "unknown"))
|
||||
except (OSError, ValueError, KeyError, TypeError, json.JSONDecodeError) as error:
|
||||
errors.append(f"{cell}: evidence invalid: {error}")
|
||||
return errors
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--manifest", type=pathlib.Path,
|
||||
default=pathlib.Path("ci/conformance.json"))
|
||||
parser.add_argument("--binary", type=pathlib.Path,
|
||||
default=pathlib.Path(os.environ.get("CARGO_TARGET_DIR", "target"))
|
||||
/ "release/alkane-os")
|
||||
parser.add_argument("--evidence-dir", type=pathlib.Path,
|
||||
default=pathlib.Path("ci/evidence"))
|
||||
parser.add_argument("--run-id", default=os.environ.get("GITHUB_RUN_ID", ""))
|
||||
args = parser.parse_args()
|
||||
manifest = json.loads(args.manifest.read_text())
|
||||
try:
|
||||
built_targets = binary_targets(args.binary.resolve())
|
||||
except (OSError, subprocess.SubprocessError, ValueError) as error:
|
||||
sys.exit(f"cannot verify Alkane OS binary target matrix: {error}")
|
||||
source_commit = subprocess.run(["git", "rev-parse", "HEAD"], check=True,
|
||||
capture_output=True, text=True).stdout.strip()
|
||||
errors = validate(manifest, built_targets, args.evidence_dir, args.run_id,
|
||||
source_commit, sha256_file(args.binary.resolve()))
|
||||
if errors:
|
||||
print(f"Conformance pending: {len(errors)} issues across {len(manifest['targets'])} targets")
|
||||
for error in errors[:8]:
|
||||
print(f" {error}")
|
||||
sys.exit(1)
|
||||
print(f"Conformance complete: {len(manifest['targets'])} targets")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Remove generated Alkane OS CI files after tests and release upload."""
|
||||
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import sys
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
DIRECTORIES = ("target", "coverage", "dist", "bench-site")
|
||||
FILES = ("tests-current.txt", "bench-current.txt", "quality-current.json",
|
||||
"evidence-status-current.json")
|
||||
|
||||
|
||||
def cleanup() -> None:
|
||||
if not os.environ.get("GITHUB_RUN_ID"):
|
||||
raise ValueError("cleanup is restricted to CI runs")
|
||||
for name in DIRECTORIES:
|
||||
path = ROOT / name
|
||||
if path.is_symlink() or path.parent.resolve() != ROOT.resolve():
|
||||
raise ValueError(f"unsafe generated directory: {path}")
|
||||
if path.is_dir():
|
||||
shutil.rmtree(path)
|
||||
print(f"Removed generated directory: {name}")
|
||||
elif path.exists():
|
||||
raise ValueError(f"expected a generated directory: {path}")
|
||||
for name in FILES:
|
||||
path = ROOT / name
|
||||
if path.is_symlink() or path.parent.resolve() != ROOT.resolve():
|
||||
raise ValueError(f"unsafe generated file: {path}")
|
||||
if path.is_file():
|
||||
path.unlink()
|
||||
print(f"Removed generated file: {name}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
cleanup()
|
||||
except (OSError, ValueError) as error:
|
||||
print(f"ERROR: Alkane OS cleanup: {error}", file=sys.stderr)
|
||||
raise SystemExit(1)
|
||||
@@ -0,0 +1,84 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Summarize research separately from current-run release conformance."""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
from pathlib import Path
|
||||
import re
|
||||
|
||||
|
||||
LEVELS = {"catalogued", "protocol_decoded"}
|
||||
DIGEST = re.compile(r"[0-9a-f]{64}\Z")
|
||||
|
||||
|
||||
def summarize(matrix: dict, research: dict) -> dict:
|
||||
if matrix.get("schema") != 1 or research.get("schema") != 1:
|
||||
raise ValueError("unsupported evidence schema")
|
||||
boards = matrix["boards"]
|
||||
chips = matrix["chips"]
|
||||
vendors = matrix["vendors"]
|
||||
expected = {(board, chip) for board in boards for chip in chips
|
||||
if vendors[board] == vendors[chip]}
|
||||
rows = matrix["targets"]
|
||||
actual = [(row["board"], row["chip"]) for row in rows]
|
||||
if set(actual) != expected or len(actual) != len(expected) or len(actual) != 64:
|
||||
raise ValueError("release target matrix is incomplete or duplicated")
|
||||
levels = {"catalogued": set(), "protocol_decoded": set()}
|
||||
for claim in research["claims"]:
|
||||
cell = claim["board"], claim["chip"]
|
||||
level = claim["level"]
|
||||
if cell not in expected or level not in LEVELS:
|
||||
raise ValueError("research claim is outside target matrix or level")
|
||||
if not isinstance(claim.get("scope"), str) or not claim["scope"].strip():
|
||||
raise ValueError("research claim lacks scope")
|
||||
if not isinstance(claim.get("source"), str) or not claim["source"].strip():
|
||||
raise ValueError("research claim lacks provenance")
|
||||
if not isinstance(claim.get("sha256"), str) or not DIGEST.fullmatch(claim["sha256"]):
|
||||
raise ValueError("research claim lacks a source digest")
|
||||
levels[level].add(cell)
|
||||
declared = {
|
||||
"stock_result": sum(row.get("stock_result") in {"mines", "rejects"} for row in rows),
|
||||
"alkane_share_capture": sum(bool(row.get("alkane_share_accept_capture")) for row in rows),
|
||||
"bench_validation": sum(bool(row.get("bench_validation")) for row in rows),
|
||||
}
|
||||
evidence_levels = {
|
||||
"catalogued": {"research_claims": len(levels["catalogued"])},
|
||||
"protocol_decoded": {"research_claims": len(levels["protocol_decoded"])},
|
||||
"stock_simulator_boot": {"manifest_claims_unverified": declared["stock_result"],
|
||||
"current_run_verified": None},
|
||||
"captured_nonce_pool_accept": {
|
||||
"manifest_claims_unverified": declared["alkane_share_capture"],
|
||||
"current_run_verified": None},
|
||||
"physical_install_update_uninstall_recovery": {
|
||||
"manifest_claims_unverified": declared["bench_validation"],
|
||||
"current_run_verified": None},
|
||||
"full_release_cell": {"current_run_verified": None},
|
||||
}
|
||||
return {
|
||||
"schema": 1,
|
||||
"target_cells": len(expected),
|
||||
"research_only": {key: len(value) for key, value in levels.items()},
|
||||
"evidence_levels": evidence_levels,
|
||||
"release_manifest_declarations_unverified": declared,
|
||||
"verified_release_cells": None,
|
||||
"note": "Only check-conformance.py may verify current-run artifacts; research claims never satisfy a release cell",
|
||||
}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--matrix", type=Path, default=Path("ci/conformance.json"))
|
||||
parser.add_argument("--research", type=Path, default=Path("ci/research-evidence.json"))
|
||||
parser.add_argument("--output", type=Path)
|
||||
args = parser.parse_args()
|
||||
report = summarize(json.loads(args.matrix.read_text()), json.loads(args.research.read_text()))
|
||||
output = json.dumps(report, indent=2, sort_keys=True) + "\n"
|
||||
if args.output:
|
||||
args.output.write_text(output)
|
||||
else:
|
||||
print(output, end="")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,65 @@
|
||||
{
|
||||
"schema": 1,
|
||||
"experiments": [
|
||||
{
|
||||
"id": "am335x-original-nand-boot",
|
||||
"kind": "controller",
|
||||
"board": "am335x-bb",
|
||||
"chip": null,
|
||||
"psu": null,
|
||||
"state": "ready_local",
|
||||
"next_evidence": "Boot hash-pinned stock NAND through the original ROM and SPL path; record the first failing register",
|
||||
"blocker": null
|
||||
},
|
||||
{
|
||||
"id": "bm1368-command-and-nonce",
|
||||
"kind": "chip",
|
||||
"board": null,
|
||||
"chip": "BM1368",
|
||||
"psu": null,
|
||||
"state": "needs_machine",
|
||||
"next_evidence": "Capture real BM1368 enumeration, job, and nonce frames on a recovered test unit",
|
||||
"blocker": "No verified BM1368 silicon candidate in the current inventory"
|
||||
},
|
||||
{
|
||||
"id": "zynq-bm1366-fpga-window",
|
||||
"kind": "transport",
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1366",
|
||||
"psu": "APW121215d/e",
|
||||
"state": "needs_identity",
|
||||
"next_evidence": "Read a bounded FPGA register/FIFO trace on a verified rooted test unit",
|
||||
"blocker": "Historical mule 10.1.2.137 now reports BTM_S21PRO; do not infer BM1366 from its address"
|
||||
},
|
||||
{
|
||||
"id": "a113d-bm1370-apw17-voltage",
|
||||
"kind": "psu",
|
||||
"board": "a113d",
|
||||
"chip": "BM1370",
|
||||
"psu": "APW171215a/c",
|
||||
"state": "needs_identity",
|
||||
"next_evidence": "Decode captured GPIO bit-bang command and read-only voltage response against an independent meter",
|
||||
"blocker": "Historical 10.4.0.192 unit is not currently reachable for confirmation"
|
||||
},
|
||||
{
|
||||
"id": "h6-kf1950-power-and-asic",
|
||||
"kind": "chip_psu",
|
||||
"board": "allwinner-h6",
|
||||
"chip": "KF1950",
|
||||
"psu": "unknown",
|
||||
"state": "needs_machine",
|
||||
"next_evidence": "Observe actual ASIC and PSU bus frames on a matched miner before modeling either device",
|
||||
"blocker": "Current H6 bench board is bare and its recovery RX path is unproven"
|
||||
},
|
||||
{
|
||||
"id": "s19-88-chain-enumeration",
|
||||
"kind": "topology_psu",
|
||||
"board": "a113d",
|
||||
"chip": "BM1362",
|
||||
"psu": "APW121417b",
|
||||
"state": "needs_identity",
|
||||
"next_evidence": "Capture the 88-chip address walk and read-only PSU identity on a rooted matched test unit",
|
||||
"blocker": "10.7.1.190 reports BTM_S19_88, but its SSH key and physical recovery are unverified"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Rank representative experiments without changing the 64-cell release gate."""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
STATES = {"ready_local", "needs_identity", "needs_machine"}
|
||||
|
||||
|
||||
def rank(matrix: dict, queue: dict) -> list[dict]:
|
||||
if queue.get("schema") != 1 or matrix.get("schema") != 1:
|
||||
raise ValueError("unsupported experiment schema")
|
||||
targets = {(row["board"], row["chip"]) for row in matrix["targets"]}
|
||||
if len(targets) != 64 or len(matrix["targets"]) != 64:
|
||||
raise ValueError("expected 64 unique release targets")
|
||||
seen = set()
|
||||
result = []
|
||||
for experiment in queue["experiments"]:
|
||||
ident = experiment["id"]
|
||||
if ident in seen:
|
||||
raise ValueError("duplicate experiment id")
|
||||
seen.add(ident)
|
||||
state = experiment["state"]
|
||||
if state not in STATES:
|
||||
raise ValueError("unknown experiment state")
|
||||
board, chip = experiment["board"], experiment["chip"]
|
||||
if board is None and chip is None:
|
||||
raise ValueError("experiment has no target selector")
|
||||
affected = sorted((b, c) for b, c in targets
|
||||
if (board is None or board == b) and (chip is None or chip == c))
|
||||
if not affected:
|
||||
raise ValueError("experiment selects no same-vendor target")
|
||||
if not experiment.get("next_evidence"):
|
||||
raise ValueError("experiment lacks a measurable next result")
|
||||
if state != "ready_local" and not experiment.get("blocker"):
|
||||
raise ValueError("blocked experiment lacks a blocker")
|
||||
result.append({"id": ident, "kind": experiment["kind"], "state": state,
|
||||
"affected_release_cells": len(affected), "board": board,
|
||||
"chip": chip, "psu": experiment["psu"],
|
||||
"next_evidence": experiment["next_evidence"],
|
||||
"blocker": experiment["blocker"]})
|
||||
return sorted(result, key=lambda row: (row["state"] != "ready_local",
|
||||
-row["affected_release_cells"], row["id"]))
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--matrix", type=Path, default=Path("ci/conformance.json"))
|
||||
parser.add_argument("--queue", type=Path, default=Path("ci/experiment-queue.json"))
|
||||
args = parser.parse_args()
|
||||
for item in rank(json.loads(args.matrix.read_text()), json.loads(args.queue.read_text())):
|
||||
print(f"{item['id']}: {item['state']}, {item['affected_release_cells']} cells")
|
||||
print(f" next: {item['next_evidence']}")
|
||||
if item["blocker"]:
|
||||
print(f" blocked: {item['blocker']}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,73 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Publish the last completed main/next CI result to a private badge branch."""
|
||||
|
||||
import os
|
||||
from urllib.parse import quote, urlencode
|
||||
|
||||
from badge_store import publish_file, request_json
|
||||
|
||||
|
||||
WORKFLOWS = {"main.yml": "main", "next.yml": "next"}
|
||||
|
||||
|
||||
def badge(branch: str, conclusion: str, run_id: int) -> bytes:
|
||||
passed = conclusion == "success"
|
||||
word = "pass" if passed else "fail"
|
||||
color = "#2ea043" if passed else "#d1242f"
|
||||
title = f"CI {branch}: last completed attempt {word} (run {run_id})"
|
||||
return (f'<svg xmlns="http://www.w3.org/2000/svg" width="102" height="20" '
|
||||
f'role="img" aria-label="{title}"><title>{title}</title>'
|
||||
'<rect width="102" height="20" rx="3" fill="#555"/>'
|
||||
f'<path d="M39 0h60a3 3 0 0 1 3 3v14a3 3 0 0 1-3 3H39z" fill="{color}"/>'
|
||||
'<text x="20" y="14" fill="#fff" text-anchor="middle" '
|
||||
'font-family="sans-serif" font-size="11">CI</text>'
|
||||
f'<text x="70" y="14" fill="#fff" text-anchor="middle" '
|
||||
f'font-family="sans-serif" font-size="11">{word}</text></svg>\n').encode()
|
||||
|
||||
|
||||
def latest_completed(api: str, repo: str, workflow: str, branch: str,
|
||||
token: str) -> tuple[int, str]:
|
||||
path = quote(workflow, safe="")
|
||||
latest = None
|
||||
for page in range(1, 21):
|
||||
query = urlencode({"branch": branch, "limit": 50, "page": page})
|
||||
url = f"{api}/repos/{repo}/actions/workflows/{path}/runs?{query}"
|
||||
runs = request_json(url, token).get("workflow_runs", [])
|
||||
for run in runs:
|
||||
if run.get("head_branch") != branch or run.get("status") != "completed":
|
||||
continue
|
||||
if run.get("conclusion") not in ("success", "failure"):
|
||||
continue
|
||||
candidate = (int(run["id"]), run["conclusion"])
|
||||
if latest is None or candidate[0] > latest[0]:
|
||||
latest = candidate
|
||||
if len(runs) < 50:
|
||||
break
|
||||
if latest is None:
|
||||
raise RuntimeError(f"no completed {branch} run found for {workflow}")
|
||||
return latest
|
||||
|
||||
|
||||
def publish(api: str, repo: str, branch: str, data: bytes, token: str) -> None:
|
||||
publish_file(api, repo, f"{branch}.svg", data, token,
|
||||
f"Record completed {branch} CI attempt")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
if os.environ["GITHUB_EVENT_NAME"] not in ("schedule", "workflow_dispatch"):
|
||||
raise RuntimeError("badge publisher must run on a timer or manual dispatch")
|
||||
if os.environ["GITHUB_REF"] != "refs/heads/main":
|
||||
raise RuntimeError("badge publisher must use the main branch")
|
||||
repo = os.environ["GITHUB_REPOSITORY"]
|
||||
api = os.environ["GITHUB_API_URL"].rstrip("/")
|
||||
token = os.environ["GITEA_TOKEN"]
|
||||
completed = {branch: latest_completed(api, repo, workflow, branch, token)
|
||||
for workflow, branch in WORKFLOWS.items()}
|
||||
for branch, (run_id, conclusion) in completed.items():
|
||||
publish(api, repo, branch, badge(branch, conclusion, run_id), token)
|
||||
print(f"{branch} badge records completed run {run_id}: {conclusion}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+61
-10
@@ -4,9 +4,25 @@
|
||||
import argparse
|
||||
import html
|
||||
import json
|
||||
import math
|
||||
import pathlib
|
||||
import re
|
||||
import tomllib
|
||||
from bench_host import identity as benchmark_host
|
||||
|
||||
EXPECTED_BENCHES = frozenset({
|
||||
"target_matrix", "power_policy", "share_verification",
|
||||
"scrypt_share_verification", "bm1366_work_encoding", "bm1362_commands",
|
||||
"bm1362_job_encoding", "bm1366_report_decode", "stratum_header",
|
||||
"stratum_submission", "stratum_authorize_format", "stratum_notify_parse",
|
||||
"stratum_control_parse", "stratum_configure_parse", "difficulty_target",
|
||||
"stratum_job_issue", "bm1366_session_cycle", "bm1362_work_encoding",
|
||||
"stratum_configure_format", "stratum_subscribe_format",
|
||||
"stratum_subscription_parse", "stratum_accept_parse",
|
||||
"hal_socket_exchange", "stratum_socket_round_trip",
|
||||
"bm13xx_crc5", "bm13xx_crc16", "bm1366_captured_report_poll",
|
||||
})
|
||||
BENCH_LINE = re.compile(r"\bBENCH ([A-Za-z0-9_]+) ([0-9]+(?:\.[0-9]+)?) ns/op\Z")
|
||||
|
||||
|
||||
def coverage(path):
|
||||
@@ -15,8 +31,40 @@ def coverage(path):
|
||||
|
||||
|
||||
def bench_results(path):
|
||||
text = pathlib.Path(path).read_text()
|
||||
return {name: float(ns) for name, ns in re.findall(r"BENCH (\w+) ([0-9.]+) ns/op", text)}
|
||||
results = {}
|
||||
for line in pathlib.Path(path).read_text().splitlines():
|
||||
if "BENCH " not in line:
|
||||
continue
|
||||
match = BENCH_LINE.search(line)
|
||||
if match is None:
|
||||
raise ValueError("malformed microbenchmark result")
|
||||
name, value = match.groups()
|
||||
measurement = float(value)
|
||||
if name in results or not math.isfinite(measurement) or measurement <= 0:
|
||||
raise ValueError("duplicate or invalid microbenchmark result")
|
||||
results[name] = measurement
|
||||
return results
|
||||
|
||||
|
||||
def benchmark_delta(current, baseline):
|
||||
if set(current) != EXPECTED_BENCHES:
|
||||
raise ValueError("microbenchmark set differs from the declared suite")
|
||||
if not isinstance(baseline, dict) or not set(baseline).issubset(current):
|
||||
raise ValueError("baseline contains retired or invalid benchmarks")
|
||||
if any(not isinstance(value, (int, float)) or isinstance(value, bool)
|
||||
or not math.isfinite(value) or value <= 0 for value in baseline.values()):
|
||||
raise ValueError("baseline contains invalid measurements")
|
||||
if not baseline:
|
||||
return None
|
||||
return sum((baseline[name] - current[name]) / baseline[name]
|
||||
for name in baseline) / len(baseline) * 100
|
||||
|
||||
|
||||
def quality_grade(path):
|
||||
checks = json.loads(pathlib.Path(path).read_text())
|
||||
if checks != {"format": True, "clippy_warnings_denied": True}:
|
||||
raise ValueError("format and strict Clippy must pass before publishing quality")
|
||||
return "A"
|
||||
|
||||
|
||||
def compact(number):
|
||||
@@ -51,19 +99,17 @@ def main():
|
||||
parser.add_argument("--tests-coverage", required=True)
|
||||
parser.add_argument("--bench-output", required=True)
|
||||
parser.add_argument("--bench-coverage", required=True)
|
||||
parser.add_argument("--quality-gate", required=True)
|
||||
parser.add_argument("--bench-baseline", default="badges/bench-baseline.json")
|
||||
args = parser.parse_args()
|
||||
test_output = pathlib.Path(args.tests_output).read_text()
|
||||
tests = sum(map(int, re.findall(r"test result: ok\. (\d+) passed", test_output)))
|
||||
if tests < 1:
|
||||
raise SystemExit("no passing tests parsed")
|
||||
current = bench_results(args.bench_output)
|
||||
if not current or any(value <= 0 for value in current.values()):
|
||||
raise SystemExit("microbenchmark result missing or zero")
|
||||
base_path = pathlib.Path("badges/bench-baseline.json")
|
||||
base_path = pathlib.Path(args.bench_baseline)
|
||||
baseline = json.loads(base_path.read_text()) if base_path.exists() else {}
|
||||
common = [name for name in current if name in baseline and baseline[name] > 0]
|
||||
delta = (sum((baseline[name] - current[name]) / baseline[name] for name in common)
|
||||
/ len(common) * 100) if common else None
|
||||
delta = benchmark_delta(current, baseline)
|
||||
line_coverage = coverage(args.tests_coverage)
|
||||
bench_coverage = coverage(args.bench_coverage)
|
||||
loc = sum(len(path.read_text().splitlines()) for parent in (pathlib.Path("src"), pathlib.Path("ci"))
|
||||
@@ -73,8 +119,11 @@ def main():
|
||||
metrics = {"tests": tests, "line_coverage_pct": round(line_coverage, 1),
|
||||
"bench_coverage_pct": round(bench_coverage, 1),
|
||||
"bench_ns_per_op": current, "bench_improvement_pct": delta,
|
||||
"bench_host": benchmark_host(),
|
||||
"lines_of_code": loc, "dependencies": dependencies,
|
||||
"code_quality": "A", "license": "MIT"}
|
||||
"code_quality": quality_grade(args.quality_gate),
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"}
|
||||
pathlib.Path("badges").mkdir(exist_ok=True)
|
||||
pathlib.Path("badges/metrics.json").write_text(json.dumps(metrics, indent=2) + "\n")
|
||||
badges = {
|
||||
@@ -84,7 +133,9 @@ def main():
|
||||
"bench": ("bench", "baseline set" if delta is None else f"{delta:+.1f}% vs prev", "#007ec6"),
|
||||
"loc": ("lines of code", compact(loc), "#007ec6"),
|
||||
"dependencies": ("dependencies", str(dependencies), "#007ec6"),
|
||||
"quality": ("code quality", "A", "#4c1"),
|
||||
"quality": ("code quality", metrics["code_quality"],
|
||||
{"A": "#4c1", "B": "#97ca00", "C": "#dfb317",
|
||||
"D": "#fe7d37", "F": "#e05d44"}[metrics["code_quality"]]),
|
||||
"license": ("license", "MIT", "#007ec6"),
|
||||
}
|
||||
for name, (label, value, color) in badges.items():
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Select a safe fast PR check from the exact merge-base diff."""
|
||||
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
def classify(paths: list[str]) -> str:
|
||||
if not paths:
|
||||
return "rust"
|
||||
docs = {"README.md", "LICENSE", "AGENTS.md", "ci/CONFORMANCE.md"}
|
||||
def is_doc(path: str) -> bool:
|
||||
return path in docs or path.startswith("docs/") and path.endswith(".md")
|
||||
def is_tool(path: str) -> bool:
|
||||
return (path.startswith("ci/") and Path(path).suffix in {".py", ".json"}
|
||||
or path.startswith(".gitea/workflows/") and path.endswith(".yml"))
|
||||
if all(is_doc(path) for path in paths):
|
||||
return "documentation"
|
||||
if all(is_doc(path) or is_tool(path) for path in paths):
|
||||
return "tooling"
|
||||
return "rust"
|
||||
|
||||
|
||||
def changed_paths() -> list[str]:
|
||||
if os.environ.get("GITHUB_EVENT_NAME") != "pull_request":
|
||||
return []
|
||||
base = os.environ.get("GITHUB_BASE_REF")
|
||||
if base not in {"next", "main"}:
|
||||
return []
|
||||
try:
|
||||
merge_base = subprocess.check_output(
|
||||
["git", "merge-base", "HEAD", f"origin/{base}"], cwd=ROOT).strip()
|
||||
diff = subprocess.check_output(
|
||||
["git", "diff", "--name-only", "-z", merge_base, "HEAD"], cwd=ROOT)
|
||||
return [path.decode() for path in diff.split(b"\0") if path]
|
||||
except (OSError, UnicodeError, subprocess.CalledProcessError):
|
||||
return []
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
with open(os.environ["GITHUB_OUTPUT"], "a") as output:
|
||||
output.write(f"surface={classify(changed_paths())}\n")
|
||||
@@ -0,0 +1,121 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Publish a measured benchmark page to the public, data-only Pages repo."""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shlex
|
||||
import subprocess
|
||||
import tempfile
|
||||
from urllib.request import Request, urlopen
|
||||
|
||||
PAGES_REPO = "ssh://git@gitea.bluefla.re:2222/blueflare/alkane-benchmarks.git"
|
||||
GUARD_REPO = "https://gitea.bluefla.re/blueflare/alkane-benchmarks.git"
|
||||
GUARD_COMMIT = "ea160545c49bc419a245692deda8dd7db7a611eb"
|
||||
PAGES_HOST = "gitea.bluefla.re"
|
||||
PAGES_HOST_FINGERPRINT = "SHA256:lqB5cmC9E5HNeg/lkzdOwQ++I8A70Wx7lnNs6liN24g"
|
||||
PAGES_HOST_KEY = "[gitea.bluefla.re]:2222 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIO1II6NkmRW+QAd+Wj+7qbNrA8Oo+/N/WRog4hELskn/"
|
||||
|
||||
|
||||
def run(*args: str, env: dict[str, str] | None = None,
|
||||
cwd: Path | None = None) -> subprocess.CompletedProcess[str]:
|
||||
return subprocess.run(args, env=env, cwd=cwd, text=True,
|
||||
capture_output=True, check=True)
|
||||
|
||||
|
||||
def current_main_sha() -> str:
|
||||
api = os.environ["GITHUB_API_URL"].rstrip("/")
|
||||
repo = os.environ["GITHUB_REPOSITORY"]
|
||||
token = os.environ["GITEA_TOKEN"]
|
||||
request = Request(f"{api}/repos/{repo}/branches/main",
|
||||
headers={"Authorization": f"token {token}"})
|
||||
with urlopen(request, timeout=20) as response:
|
||||
branch = json.load(response)
|
||||
return branch["commit"]["id"]
|
||||
|
||||
|
||||
def publish(site: str) -> None:
|
||||
if os.environ.get("GITHUB_REF") != "refs/heads/main":
|
||||
raise ValueError("benchmark Pages publication requires main")
|
||||
sha = os.environ["GITHUB_SHA"]
|
||||
if current_main_sha() != sha:
|
||||
print("Skipping benchmark page from a superseded main commit")
|
||||
return
|
||||
page = Path("bench-site/index.html").read_bytes()
|
||||
if not page.startswith(b"<!doctype html>") or len(page) > 1_048_576:
|
||||
raise ValueError("invalid benchmark page")
|
||||
with tempfile.TemporaryDirectory(prefix="alkane-pages-") as directory:
|
||||
temporary = Path(directory)
|
||||
guard_checkout = temporary / "guard"
|
||||
run("git", "clone", "--quiet", "--single-branch", "--branch", "next",
|
||||
GUARD_REPO, str(guard_checkout))
|
||||
guard_source = run("git", "show", f"{GUARD_COMMIT}:ci/validate_site.py",
|
||||
cwd=guard_checkout).stdout
|
||||
guard_script = temporary / "validate_site.py"
|
||||
guard_script.write_text(guard_source)
|
||||
run("python3", str(guard_script), "--page", site,
|
||||
str(Path("bench-site/index.html").resolve()))
|
||||
key = os.environ["BENCH_PAGES_DEPLOY_KEY"]
|
||||
if not key.startswith("-----BEGIN OPENSSH PRIVATE KEY-----"):
|
||||
raise ValueError("missing benchmark Pages deploy key")
|
||||
key_path = temporary / "deploy_key"
|
||||
key_path.write_text(key.rstrip("\n") + "\n")
|
||||
key_path.chmod(0o600)
|
||||
known_hosts = temporary / "known_hosts"
|
||||
known_hosts.write_text(PAGES_HOST_KEY + "\n")
|
||||
fingerprint = run("ssh-keygen", "-lf", str(known_hosts)).stdout.split()[1]
|
||||
if fingerprint != PAGES_HOST_FINGERPRINT:
|
||||
raise ValueError("benchmark Pages SSH host key changed")
|
||||
git_env = os.environ.copy()
|
||||
ssh_command = (f"ssh -i {shlex.quote(str(key_path))} -o IdentitiesOnly=yes "
|
||||
f"-o UserKnownHostsFile={shlex.quote(str(known_hosts))} "
|
||||
"-o StrictHostKeyChecking=yes -o ConnectTimeout=10")
|
||||
git_env["GIT_SSH_COMMAND"] = ssh_command
|
||||
git_env["GIT_TERMINAL_PROMPT"] = "0"
|
||||
checkout = temporary / "site"
|
||||
run("git", "clone", "--quiet", "--single-branch", "--branch", "gh-pages",
|
||||
PAGES_REPO, str(checkout), env=git_env)
|
||||
run("git", "config", "user.name", "Alkane CI", cwd=checkout)
|
||||
run("git", "config", "user.email", "ci@bluefla.re", cwd=checkout)
|
||||
for attempt in range(3):
|
||||
if current_main_sha() != sha:
|
||||
print("Skipping benchmark page from a superseded main commit")
|
||||
return
|
||||
run("git", "fetch", "--quiet", "origin", "gh-pages", env=git_env,
|
||||
cwd=checkout)
|
||||
run("git", "checkout", "-q", "-B", "bench-publish", "origin/gh-pages",
|
||||
cwd=checkout)
|
||||
destination = checkout / site / "index.html"
|
||||
destination.parent.mkdir(exist_ok=True)
|
||||
destination.write_bytes(page)
|
||||
run("git", "add", f"{site}/index.html", cwd=checkout)
|
||||
changed = subprocess.run(("git", "diff", "--cached", "--quiet"),
|
||||
cwd=checkout, check=False)
|
||||
if changed.returncode == 0:
|
||||
print(f"{site} benchmark page is already current")
|
||||
return
|
||||
if changed.returncode != 1:
|
||||
raise RuntimeError("cannot compare benchmark page")
|
||||
run("git", "commit", "-q", "-m",
|
||||
f"Update {site} benchmarks for {sha[:10]} [skip ci]", cwd=checkout)
|
||||
pushed = subprocess.run(("git", "push", "--quiet", "origin",
|
||||
"HEAD:gh-pages"), env=git_env, cwd=checkout,
|
||||
text=True, capture_output=True, check=False)
|
||||
if pushed.returncode == 0:
|
||||
print(f"Published {site} benchmark page for {sha[:10]}")
|
||||
return
|
||||
if attempt == 2:
|
||||
raise RuntimeError(f"benchmark Pages push failed: {pushed.stderr.strip()}")
|
||||
raise RuntimeError("benchmark Pages publication did not complete")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("site", choices=("sdk", "os", "toolkit"))
|
||||
publish(parser.parse_args().site)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,32 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Publish measured main-branch metric badges to the private badge branch."""
|
||||
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from badge_store import publish_file
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
NAMES = ("tests", "coverage", "bench", "bench-coverage", "loc",
|
||||
"dependencies", "quality", "license")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
api = os.environ["GITHUB_API_URL"].rstrip("/")
|
||||
repo = os.environ["GITHUB_REPOSITORY"]
|
||||
token = os.environ["GITEA_TOKEN"]
|
||||
for name in NAMES:
|
||||
data = (ROOT / "badges" / f"{name}.svg").read_bytes()
|
||||
if not data.lstrip().startswith(b"<svg"):
|
||||
raise ValueError(f"invalid {name} SVG")
|
||||
publish_file(api, repo, f"badges/{name}.svg", data, token,
|
||||
f"Update measured {name} badge")
|
||||
data = (ROOT / "badges/metrics.json").read_bytes()
|
||||
publish_file(api, repo, "badges/metrics.json", data, token,
|
||||
"Update measured badge data")
|
||||
print(f"Published {len(NAMES)} measured badge SVGs and metrics.json")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+138
-33
@@ -1,7 +1,9 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Create one Gitea release and attach files using the runner's scoped token."""
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Publish a complete Gitea release after all assets are attached to a draft."""
|
||||
|
||||
import json
|
||||
import hashlib
|
||||
import os
|
||||
import pathlib
|
||||
import sys
|
||||
@@ -10,45 +12,148 @@ import urllib.parse
|
||||
import urllib.request
|
||||
|
||||
|
||||
def request(url, payload, content_type):
|
||||
headers = {
|
||||
"Authorization": "token " + os.environ["GITEA_TOKEN"],
|
||||
"Content-Type": content_type,
|
||||
def request(url, method="GET", payload=None, content_type=None):
|
||||
headers = {"Authorization": "token " + os.environ["GITEA_TOKEN"]}
|
||||
if content_type:
|
||||
headers["Content-Type"] = content_type
|
||||
operation = urllib.request.Request(url, data=payload, headers=headers, method=method)
|
||||
with urllib.request.urlopen(operation, timeout=60) as response:
|
||||
body = response.read()
|
||||
return json.loads(body) if body else None
|
||||
|
||||
|
||||
def json_request(url, method, value):
|
||||
return request(url, method, json.dumps(value).encode(), "application/json")
|
||||
|
||||
|
||||
def files_to_publish(names):
|
||||
paths = [pathlib.Path(name) for name in names]
|
||||
if not paths or len({path.name for path in paths}) != len(paths):
|
||||
raise ValueError("release assets must have distinct basenames")
|
||||
for path in paths:
|
||||
if not path.is_file() or path.stat().st_size == 0:
|
||||
raise ValueError(f"release asset missing or empty: {path}")
|
||||
return paths
|
||||
|
||||
|
||||
def sha256_file(path):
|
||||
digest = hashlib.sha256()
|
||||
with path.open("rb") as source:
|
||||
for chunk in iter(lambda: source.read(1_048_576), b""):
|
||||
digest.update(chunk)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
class NoRedirect(urllib.request.HTTPRedirectHandler):
|
||||
def redirect_request(self, request, fp, code, message, headers, new_url):
|
||||
return None
|
||||
|
||||
|
||||
def asset_digest(asset, api):
|
||||
url = asset["browser_download_url"]
|
||||
remote = urllib.parse.urlsplit(url)
|
||||
expected = urllib.parse.urlsplit(api)
|
||||
if remote.scheme != "https" or remote.netloc != expected.netloc:
|
||||
raise ValueError("asset download is outside the trusted Gitea host")
|
||||
operation = urllib.request.Request(
|
||||
url, headers={"Authorization": "token " + os.environ["GITEA_TOKEN"]})
|
||||
digest = hashlib.sha256()
|
||||
with urllib.request.build_opener(NoRedirect).open(operation, timeout=60) as response:
|
||||
for chunk in iter(lambda: response.read(1_048_576), b""):
|
||||
digest.update(chunk)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def get_release(url):
|
||||
try:
|
||||
return request(url)
|
||||
except urllib.error.HTTPError as error:
|
||||
if error.code == 404:
|
||||
return None
|
||||
raise
|
||||
|
||||
|
||||
def check_tag_commit(api, repo, tag, sha):
|
||||
url = f"{api}/repos/{repo}/tags/{urllib.parse.quote(tag, safe='')}"
|
||||
try:
|
||||
remote_tag = request(url)
|
||||
except urllib.error.HTTPError as error:
|
||||
if error.code == 404:
|
||||
return False
|
||||
raise
|
||||
if not isinstance(remote_tag, dict) or remote_tag.get("commit", {}).get("sha") != sha:
|
||||
raise ValueError("Git tag points to a different or unknown commit")
|
||||
return True
|
||||
|
||||
|
||||
def publish(tag, prerelease, paths, api, repo, sha):
|
||||
base = f"{api}/repos/{repo}/releases"
|
||||
tag_url = f"{base}/tags/{urllib.parse.quote(tag, safe='')}"
|
||||
metadata = {
|
||||
"tag_name": tag,
|
||||
"target_commitish": sha,
|
||||
"name": tag,
|
||||
"body": f"Automated Alkane OS build from {sha}. Conformance results are in the repository.",
|
||||
"prerelease": prerelease,
|
||||
}
|
||||
req = urllib.request.Request(url, data=payload, headers=headers, method="POST")
|
||||
with urllib.request.urlopen(req, timeout=60) as response:
|
||||
return json.load(response)
|
||||
check_tag_commit(api, repo, tag, sha)
|
||||
release = get_release(tag_url)
|
||||
if release is None:
|
||||
release = json_request(base, "POST", {**metadata, "draft": True})
|
||||
elif release.get("target_commitish") != sha:
|
||||
raise ValueError("release tag already belongs to another source revision")
|
||||
release_url = f"{base}/{release['id']}"
|
||||
assets_url = f"{release_url}/assets"
|
||||
existing = request(assets_url)
|
||||
wanted = {path.name: path.stat().st_size for path in paths}
|
||||
digests = {path.name: sha256_file(path) for path in paths}
|
||||
present = {asset["name"]: asset for asset in existing}
|
||||
if not release.get("draft") and all(
|
||||
(asset := present.get(name)) is not None and asset["size"] == size
|
||||
and asset_digest(asset, api) == digests[name]
|
||||
for name, size in wanted.items()
|
||||
):
|
||||
if not check_tag_commit(api, repo, tag, sha):
|
||||
raise ValueError("published release has no Git tag")
|
||||
print(f"Release {tag} is already complete")
|
||||
return
|
||||
if not release.get("draft"):
|
||||
release = json_request(release_url, "PATCH", {**metadata, "draft": True})
|
||||
if not release.get("draft"):
|
||||
raise ValueError("incomplete release could not be returned to draft")
|
||||
for asset in existing:
|
||||
if asset["name"] in wanted:
|
||||
request(f"{assets_url}/{asset['id']}", "DELETE")
|
||||
for path in paths:
|
||||
query = urllib.parse.urlencode({"name": path.name})
|
||||
request(f"{assets_url}?{query}", "POST", path.read_bytes(),
|
||||
"application/octet-stream")
|
||||
uploaded = request(assets_url)
|
||||
actual = {asset["name"]: asset for asset in uploaded}
|
||||
if any((asset := actual.get(name)) is None or asset["size"] != size
|
||||
or asset_digest(asset, api) != digests[name]
|
||||
for name, size in wanted.items()):
|
||||
raise ValueError("draft release asset verification failed")
|
||||
check_tag_commit(api, repo, tag, sha)
|
||||
release = json_request(release_url, "PATCH", {**metadata, "draft": False})
|
||||
if release.get("draft"):
|
||||
raise ValueError("release remained a draft after publishing")
|
||||
if not check_tag_commit(api, repo, tag, sha):
|
||||
raise ValueError("published release did not create the expected Git tag")
|
||||
print(f"Published {tag} with {len(paths)} assets")
|
||||
|
||||
|
||||
def main():
|
||||
if len(sys.argv) < 4:
|
||||
sys.exit("usage: release.py TAG PRERELEASE FILE [FILE ...]")
|
||||
tag, prerelease, *files = sys.argv[1:]
|
||||
api = os.environ.get("GITHUB_API_URL", "https://gitea.bluefla.re/api/v1").rstrip("/")
|
||||
repo = os.environ["GITHUB_REPOSITORY"]
|
||||
sha = os.environ["GITHUB_SHA"]
|
||||
body = f"Automated Alkane OS build from {sha}. Conformance results are in the repository."
|
||||
metadata = {
|
||||
"tag_name": tag,
|
||||
"target_commitish": sha,
|
||||
"name": tag,
|
||||
"body": body,
|
||||
"prerelease": prerelease.lower() == "true",
|
||||
}
|
||||
tag, prerelease, *names = sys.argv[1:]
|
||||
try:
|
||||
release = request(f"{api}/repos/{repo}/releases", json.dumps(metadata).encode(), "application/json")
|
||||
except urllib.error.HTTPError as exc:
|
||||
sys.exit(f"release creation failed: HTTP {exc.code}")
|
||||
release_id = release["id"]
|
||||
for name in files:
|
||||
path = pathlib.Path(name)
|
||||
query = urllib.parse.urlencode({"name": path.name})
|
||||
try:
|
||||
request(f"{api}/repos/{repo}/releases/{release_id}/assets?{query}",
|
||||
path.read_bytes(), "application/octet-stream")
|
||||
except urllib.error.HTTPError as exc:
|
||||
sys.exit(f"asset upload failed for {path.name}: HTTP {exc.code}")
|
||||
print(f"Created {tag} with {len(files)} assets")
|
||||
paths = files_to_publish(names)
|
||||
api = os.environ.get("GITHUB_API_URL", "https://gitea.bluefla.re/api/v1").rstrip("/")
|
||||
publish(tag, prerelease.lower() == "true", paths, api,
|
||||
os.environ["GITHUB_REPOSITORY"], os.environ["GITHUB_SHA"])
|
||||
except (ValueError, OSError, urllib.error.HTTPError) as error:
|
||||
sys.exit(f"release publication failed: {error}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
{
|
||||
"schema": 1,
|
||||
"claims": [
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1366",
|
||||
"level": "protocol_decoded",
|
||||
"source": "miner-firmware/firmware-analysis/prong-b/aml-112/fullcov/capC1.strace",
|
||||
"sha256": "05303e93f6d00433a6db5a9ee973b6cdb0351f3efa35d293dd172ede7da89d54",
|
||||
"scope": "Historical BM1366 UART enumeration and nonce frames on an A113D S19k Pro"
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1366",
|
||||
"level": "catalogued",
|
||||
"source": "miner-firmware/firmware-analysis/prong-b/xil-137/fullcov/capC1.strace",
|
||||
"sha256": "3daa3f7381580ef87f3b5925d5a03fdb4d2e7cd93a82b943ef2578da3d545607",
|
||||
"scope": "Historical sensor and board observations; FPGA chip data path was not captured"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Exercise benchmark history selection and safe site rendering."""
|
||||
|
||||
import sys
|
||||
from pathlib import Path
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
||||
from bench_history import previous_measurement, render_html, updated_index
|
||||
|
||||
|
||||
class HistoryTests(unittest.TestCase):
|
||||
def test_retry_uses_previous_commit(self):
|
||||
first = "a" * 40
|
||||
second = "b" * 40
|
||||
index = {"schema": 1, "entries": [
|
||||
{"sha": first, "timestamp": "2026-01-01T00:00:00+00:00",
|
||||
"metrics": {"bench_ns_per_op": {"hash": 10.0}}},
|
||||
{"sha": second, "timestamp": "2026-01-02T00:00:00+00:00",
|
||||
"metrics": {"bench_ns_per_op": {"hash": 8.0}}}]}
|
||||
self.assertEqual(previous_measurement(index, second,
|
||||
lambda ancestor, sha: 1 if ancestor == first else None),
|
||||
{"hash": 10.0})
|
||||
updated = updated_index(index, second, {"bench_ns_per_op": {"hash": 7.5}},
|
||||
"2026-01-03T00:00:00+00:00")
|
||||
self.assertEqual(len(updated["entries"]), 2)
|
||||
self.assertEqual(updated["entries"][-1]["metrics"]["bench_ns_per_op"]["hash"], 7.5)
|
||||
|
||||
def test_invalid_measurement_and_sha_rejected(self):
|
||||
with self.assertRaises(ValueError):
|
||||
updated_index({}, "bad", {"bench_ns_per_op": {"hash": 1}}, "now")
|
||||
with self.assertRaises(ValueError):
|
||||
updated_index({}, "a" * 40, {"bench_ns_per_op": {"hash": -1}}, "now")
|
||||
|
||||
def test_baseline_must_match_cpu_class(self):
|
||||
first = "a" * 40
|
||||
host = {"architecture": "x86_64", "cpu_model": "A", "logical_cpus": 8}
|
||||
other = {"architecture": "x86_64", "cpu_model": "B", "logical_cpus": 8}
|
||||
index = {"entries": [{"sha": first, "metrics": {
|
||||
"bench_ns_per_op": {"hash": 10.0}, "bench_host": host}}]}
|
||||
distance = lambda _ancestor, _sha: 1
|
||||
self.assertEqual(previous_measurement(index, "b" * 40, distance, host),
|
||||
{"hash": 10.0})
|
||||
self.assertEqual(previous_measurement(index, "b" * 40, distance, other), {})
|
||||
|
||||
def test_site_escapes_history_content(self):
|
||||
entry = {"sha": "a" * 40, "timestamp": "<script>alert(1)</script>",
|
||||
"metrics": {"bench_ns_per_op": {"hash": 10.0},
|
||||
"bench_host": {"cpu_model": "<script>cpu</script>"}}}
|
||||
page = render_html({"entries": [entry]})
|
||||
self.assertIn("<script>", page)
|
||||
self.assertNotIn("<script>", page)
|
||||
self.assertIn("10.000", page)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,50 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Verify cleanup removes only generated files inside the CI checkout."""
|
||||
|
||||
import importlib.util
|
||||
import os
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
from unittest.mock import patch
|
||||
|
||||
|
||||
SPEC = importlib.util.spec_from_file_location(
|
||||
"cleanup_generated", Path(__file__).resolve().with_name("cleanup-generated.py"))
|
||||
CLEANUP = importlib.util.module_from_spec(SPEC)
|
||||
SPEC.loader.exec_module(CLEANUP)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
with tempfile.TemporaryDirectory(prefix="alkane-os-cleanup-") as temporary:
|
||||
root = Path(temporary)
|
||||
outside = root.parent / (root.name + "-outside")
|
||||
outside.mkdir()
|
||||
(outside / "keep").write_bytes(b"safe")
|
||||
previous = CLEANUP.ROOT
|
||||
CLEANUP.ROOT = root
|
||||
try:
|
||||
with patch.dict(os.environ, {"GITHUB_RUN_ID": "123"}):
|
||||
(root / "target").mkdir()
|
||||
(root / "target/build").write_bytes(b"generated")
|
||||
(root / "bench-current.txt").write_bytes(b"generated")
|
||||
CLEANUP.cleanup()
|
||||
assert not (root / "target").exists()
|
||||
assert not (root / "bench-current.txt").exists()
|
||||
(root / "target").symlink_to(outside, target_is_directory=True)
|
||||
try:
|
||||
CLEANUP.cleanup()
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
raise AssertionError("cleanup followed a symlink")
|
||||
assert (outside / "keep").read_bytes() == b"safe"
|
||||
finally:
|
||||
CLEANUP.ROOT = previous
|
||||
(outside / "keep").unlink()
|
||||
outside.rmdir()
|
||||
print("Alkane OS CI cleanup containment: PASS")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,115 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Regression checks for the fail-closed release evidence gate."""
|
||||
|
||||
import copy
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
from tempfile import TemporaryDirectory
|
||||
import unittest
|
||||
|
||||
|
||||
SCRIPT = Path(__file__).with_name("check-conformance.py")
|
||||
spec = importlib.util.spec_from_file_location("check_conformance", SCRIPT)
|
||||
gate = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(gate)
|
||||
MANIFEST = json.loads(Path(__file__).with_name("conformance.json").read_text())
|
||||
TARGETS = {(row["board"], row["chip"]): gate.REQUIRED_ALGORITHMS[row["chip"]]
|
||||
for row in MANIFEST["targets"]}
|
||||
|
||||
|
||||
class ConformanceGateTest(unittest.TestCase):
|
||||
def test_placeholder_matrix_cannot_pass_without_current_run_artifacts(self):
|
||||
manifest = copy.deepcopy(MANIFEST)
|
||||
for row in manifest["targets"]:
|
||||
row.update(sdk_image_sha256="0" * 64,
|
||||
stock_image_sha256="0" * 64,
|
||||
simulator_trace_sha256="0" * 64,
|
||||
stock_result="mines",
|
||||
alkane_share_accept_capture="does-not-exist.json",
|
||||
bench_validation="not-run")
|
||||
with TemporaryDirectory() as directory:
|
||||
errors = gate.validate(manifest, TARGETS, Path(directory), "123",
|
||||
"a" * 40, "b" * 64)
|
||||
self.assertEqual(len(errors), 64)
|
||||
self.assertTrue(all("evidence invalid" in error for error in errors))
|
||||
|
||||
def test_stale_source_identity_is_rejected(self):
|
||||
row = copy.deepcopy(MANIFEST["targets"][0])
|
||||
row["stock_result"] = "mines"
|
||||
with TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
report = root / "123" / row["board"] / f"{row['chip']}.json"
|
||||
report.parent.mkdir(parents=True)
|
||||
report.write_text(json.dumps({"schema": 1, "run_id": "123",
|
||||
"source_commit": "f" * 40,
|
||||
"os_binary_sha256": "b" * 64,
|
||||
"board": row["board"], "chip": row["chip"],
|
||||
"stock_firmware_modified": False}))
|
||||
with self.assertRaisesRegex(ValueError, "different run, source"):
|
||||
gate.verify_cell(row, root, "123", "a" * 40, "b" * 64,
|
||||
TARGETS[(row["board"], row["chip"])])
|
||||
|
||||
def test_share_accept_requires_real_difficulty_one_work(self):
|
||||
capture = {"nonce_source": "real_silicon_capture",
|
||||
"header80": "00" * 80,
|
||||
"pool_target_le": "ff" * 32, "nonce": 0,
|
||||
"submission": {"id": 4, "method": "mining.submit",
|
||||
"params": ["worker", "job", "", "00000000", "00000000"]},
|
||||
"pool_response": {"id": 4, "result": True, "error": None}}
|
||||
with self.assertRaisesRegex(ValueError, "below difficulty one"):
|
||||
gate.verify_accept(capture, "Sha256")
|
||||
capture["submission"]["params"][4] = "00000001"
|
||||
with self.assertRaisesRegex(ValueError, "submitted nonce"):
|
||||
gate.verify_accept(capture, "Sha256")
|
||||
|
||||
def test_scrypt_proof_matches_litecoin_and_independent_vectors(self):
|
||||
header = bytes.fromhex(
|
||||
"01000000f615f7ce3b4fc6b8f61e8f89aedb1d0852507650533a9e3b10b9bbcc30639f27"
|
||||
"9fcaa86746e1ef52d3edb3c4ad8259920d509bd073605c9bf1d59983752a6b06b817bb4"
|
||||
"ea78e011d012d59d4"
|
||||
)
|
||||
self.assertEqual(len(header), 80)
|
||||
self.assertEqual(
|
||||
gate.proof_digest(header, "Scrypt")[::-1].hex(),
|
||||
"0000000110c8357966576df46f3b802ca897deb7ad18b12f1c24ecff6386ebd9",
|
||||
)
|
||||
self.assertEqual(
|
||||
gate.proof_digest(bytes(range(80)), "Scrypt").hex(),
|
||||
"bc540a1a801df96e493005c71e010e2d387607fbf0fec416fd3c2645aa1ba9d2",
|
||||
)
|
||||
|
||||
def test_equihash_cells_still_need_an_algorithm_specific_verifier(self):
|
||||
with self.assertRaisesRegex(ValueError, "Equihash share verifier"):
|
||||
gate.verify_accept({}, "Equihash")
|
||||
|
||||
def test_submitted_header_reconstruction_rejects_version_and_extranonce_changes(self):
|
||||
capture = {
|
||||
"subscription": {"extranonce1": "aa", "extranonce2_size": 1},
|
||||
"notify": {"method": "mining.notify", "params": [
|
||||
"job", "11" * 32, "01", "02", [],
|
||||
"20000000", "1d00ffff", "12345678", True]},
|
||||
"configure_response": {"result": {
|
||||
"version-rolling": True, "version-rolling.mask": "1fffe000"}},
|
||||
}
|
||||
params = ["worker", "job", "bb", "12345678", "00000001", "00002000"]
|
||||
header, _ = gate.reconstructed_header(capture, params)
|
||||
self.assertEqual(len(header), 80)
|
||||
self.assertEqual(header[:4], (0x20002000).to_bytes(4, "little"))
|
||||
self.assertEqual(header[4:8], b"\x11" * 4)
|
||||
changed = params.copy()
|
||||
changed[5] = "ffffffff"
|
||||
with self.assertRaisesRegex(ValueError, "version bits"):
|
||||
gate.reconstructed_header(capture, changed)
|
||||
changed[5] = params[5]
|
||||
changed[2] = "f"
|
||||
with self.assertRaisesRegex(ValueError, "Stratum hex"):
|
||||
gate.reconstructed_header(capture, changed)
|
||||
changed[2] = "cc"
|
||||
rebuilt, _ = gate.reconstructed_header(capture, changed)
|
||||
self.assertNotEqual(rebuilt, header)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,43 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Research observations cannot promote a target into release conformance."""
|
||||
|
||||
import copy
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parent
|
||||
spec = importlib.util.spec_from_file_location("evidence_status", ROOT / "evidence_status.py")
|
||||
status = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(status)
|
||||
MATRIX = json.loads((ROOT / "conformance.json").read_text())
|
||||
RESEARCH = json.loads((ROOT / "research-evidence.json").read_text())
|
||||
|
||||
|
||||
class EvidenceStatusTest(unittest.TestCase):
|
||||
def test_historical_protocol_does_not_satisfy_release(self):
|
||||
report = status.summarize(MATRIX, RESEARCH)
|
||||
self.assertEqual(report["target_cells"], 64)
|
||||
self.assertEqual(report["research_only"], {"catalogued": 1, "protocol_decoded": 1})
|
||||
self.assertIsNone(report["verified_release_cells"])
|
||||
self.assertEqual(sum(report["release_manifest_declarations_unverified"].values()), 0)
|
||||
for level in ("stock_simulator_boot", "captured_nonce_pool_accept",
|
||||
"physical_install_update_uninstall_recovery", "full_release_cell"):
|
||||
self.assertIsNone(report["evidence_levels"][level]["current_run_verified"])
|
||||
|
||||
def test_rejects_missing_cell_and_unsupported_claim(self):
|
||||
matrix = copy.deepcopy(MATRIX)
|
||||
matrix["targets"].pop()
|
||||
with self.assertRaisesRegex(ValueError, "incomplete"):
|
||||
status.summarize(matrix, RESEARCH)
|
||||
research = copy.deepcopy(RESEARCH)
|
||||
research["claims"][0]["level"] = "pool_accept"
|
||||
with self.assertRaisesRegex(ValueError, "outside target matrix or level"):
|
||||
status.summarize(MATRIX, research)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,41 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Representative experiments preserve the full release target set."""
|
||||
|
||||
import copy
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parent
|
||||
spec = importlib.util.spec_from_file_location("experiment_priority", ROOT / "experiment_priority.py")
|
||||
priority = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(priority)
|
||||
MATRIX = json.loads((ROOT / "conformance.json").read_text())
|
||||
QUEUE = json.loads((ROOT / "experiment-queue.json").read_text())
|
||||
|
||||
|
||||
class ExperimentPriorityTest(unittest.TestCase):
|
||||
def test_local_boot_model_ranks_first_without_reducing_gate(self):
|
||||
ordered = priority.rank(MATRIX, QUEUE)
|
||||
self.assertEqual(ordered[0]["id"], "am335x-original-nand-boot")
|
||||
self.assertEqual(ordered[0]["affected_release_cells"], 13)
|
||||
self.assertEqual(len(MATRIX["targets"]), 64)
|
||||
self.assertEqual(next(row for row in ordered if row["id"] == "bm1368-command-and-nonce")
|
||||
["affected_release_cells"], 4)
|
||||
|
||||
def test_no_selector_or_unexplained_blocker(self):
|
||||
queue = copy.deepcopy(QUEUE)
|
||||
queue["experiments"][0]["board"] = None
|
||||
with self.assertRaisesRegex(ValueError, "no target selector"):
|
||||
priority.rank(MATRIX, queue)
|
||||
queue = copy.deepcopy(QUEUE)
|
||||
queue["experiments"][1]["blocker"] = None
|
||||
with self.assertRaisesRegex(ValueError, "lacks a blocker"):
|
||||
priority.rank(MATRIX, queue)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,67 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Check that queued CI runs do not displace the last completed result."""
|
||||
|
||||
import importlib.util
|
||||
import os
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
import xml.etree.ElementTree as ET
|
||||
|
||||
from badge_store import publish_file
|
||||
|
||||
path = Path(__file__).with_name("last-attempt-badge.py")
|
||||
spec = importlib.util.spec_from_file_location("last_attempt_badge", path)
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
|
||||
|
||||
def runs(_url, _token):
|
||||
return {"workflow_runs": [
|
||||
{"id": 105, "head_branch": "main", "status": "completed", "conclusion": "cancelled"},
|
||||
{"id": 104, "head_branch": "main", "status": "queued", "conclusion": None},
|
||||
{"id": 103, "head_branch": "main", "status": "completed", "conclusion": "failure"},
|
||||
{"id": 102, "head_branch": "main", "status": "completed", "conclusion": "success"},
|
||||
]}
|
||||
|
||||
|
||||
with patch.object(module, "request_json", runs):
|
||||
assert module.latest_completed("https://example.invalid/api/v1", "owner/repo",
|
||||
"main.yml", "main", "token") == (103, "failure")
|
||||
|
||||
svg = module.badge("main", "failure", 103)
|
||||
root = ET.fromstring(svg)
|
||||
assert root.attrib["aria-label"] == "CI main: last completed attempt fail (run 103)"
|
||||
assert b">fail</text>" in svg
|
||||
assert b"#d1242f" in svg
|
||||
assert b">pass</text>" in module.badge("next", "success", 108)
|
||||
environment = {
|
||||
"GITHUB_EVENT_NAME": "schedule",
|
||||
"GITHUB_REF": "refs/heads/main",
|
||||
"GITHUB_REPOSITORY": "owner/repo",
|
||||
"GITHUB_API_URL": "https://example.invalid/api/v1",
|
||||
"GITEA_TOKEN": "test-token",
|
||||
}
|
||||
with patch.dict(os.environ, environment), \
|
||||
patch.object(module, "latest_completed", side_effect=[(201, "success"),
|
||||
(202, "failure")]) as latest, \
|
||||
patch.object(module, "publish") as published:
|
||||
module.main()
|
||||
assert latest.call_count == 2
|
||||
assert [call.args[2] for call in published.call_args_list] == ["main", "next"]
|
||||
with patch.dict(os.environ, {**environment, "GITHUB_EVENT_NAME": "workflow_run"}):
|
||||
try:
|
||||
module.main()
|
||||
except RuntimeError as error:
|
||||
assert "timer or manual dispatch" in str(error)
|
||||
else:
|
||||
raise AssertionError("workflow_run event entered badge publisher")
|
||||
for invalid in ("", "/main.svg", "../main.svg", "badges//main.svg"):
|
||||
try:
|
||||
publish_file("https://example.invalid/api/v1", "owner/repo", invalid,
|
||||
b"<svg/>", "token", "test")
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
raise AssertionError(f"unsafe badge path accepted: {invalid}")
|
||||
print("last completed CI badge: queued run ignored, pass/fail SVGs valid")
|
||||
@@ -0,0 +1,51 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Regression checks for measured benchmark and quality badges."""
|
||||
|
||||
import sys
|
||||
import json
|
||||
from pathlib import Path
|
||||
from tempfile import TemporaryDirectory
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
||||
from metrics import EXPECTED_BENCHES, bench_results, benchmark_delta, compact, quality_grade
|
||||
|
||||
|
||||
class MetricTests(unittest.TestCase):
|
||||
def test_quality_requires_both_static_checks(self):
|
||||
with TemporaryDirectory() as directory:
|
||||
path = Path(directory) / "quality.json"
|
||||
path.write_text(json.dumps({"format": True, "clippy_warnings_denied": True}))
|
||||
self.assertEqual(quality_grade(path), "A")
|
||||
path.write_text(json.dumps({"format": True, "clippy_warnings_denied": False}))
|
||||
with self.assertRaises(ValueError):
|
||||
quality_grade(path)
|
||||
|
||||
def test_benchmark_parser_and_short_si_badge(self):
|
||||
with TemporaryDirectory() as directory:
|
||||
path = Path(directory) / "bench.txt"
|
||||
path.write_text("test bench_sha ... BENCH sha 42.125 ns/op\n")
|
||||
self.assertEqual(bench_results(path), {"sha": 42.125})
|
||||
path.write_text("BENCH sha 42.125 ns/op\nBENCH sha 40.000 ns/op\n")
|
||||
with self.assertRaisesRegex(ValueError, "duplicate"):
|
||||
bench_results(path)
|
||||
path.write_text("BENCH sha 42.125 ns/op\nBENCH broken nan ns/op\n")
|
||||
with self.assertRaisesRegex(ValueError, "malformed"):
|
||||
bench_results(path)
|
||||
self.assertEqual(compact(1234567), "1.23M")
|
||||
|
||||
def test_benchmark_suite_and_baseline_must_be_complete(self):
|
||||
current = {name: 10.0 for name in EXPECTED_BENCHES}
|
||||
self.assertIsNone(benchmark_delta(current, {}))
|
||||
self.assertEqual(benchmark_delta(current, {"target_matrix": 20.0}), 50.0)
|
||||
with self.assertRaisesRegex(ValueError, "declared suite"):
|
||||
benchmark_delta({"target_matrix": 10.0}, {})
|
||||
with self.assertRaisesRegex(ValueError, "retired"):
|
||||
benchmark_delta(current, {"removed_bench": 20.0})
|
||||
with self.assertRaisesRegex(ValueError, "invalid measurements"):
|
||||
benchmark_delta(current, {"target_matrix": float("inf")})
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,28 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Unknown PR paths must retain compiled source checks."""
|
||||
|
||||
import importlib.util
|
||||
from pathlib import Path
|
||||
import unittest
|
||||
|
||||
|
||||
spec = importlib.util.spec_from_file_location("pr_surface", Path(__file__).with_name("pr_surface.py"))
|
||||
surface = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(surface)
|
||||
|
||||
|
||||
class PrSurfaceTest(unittest.TestCase):
|
||||
def test_documentation_and_tooling(self):
|
||||
self.assertEqual(surface.classify(["README.md", "docs/boards.md"]), "documentation")
|
||||
self.assertEqual(surface.classify(["ci/evidence_status.py", "ci/CONFORMANCE.md"]), "tooling")
|
||||
|
||||
def test_unknown_and_rust_paths_fail_open_to_build(self):
|
||||
for paths in ([], ["src/main.rs"], ["Cargo.toml"], ["unknown/file"],
|
||||
["ci/evidence_status.py", "src/main.rs"]):
|
||||
with self.subTest(paths=paths):
|
||||
self.assertEqual(surface.classify(paths), "rust")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,133 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Check draft release recovery without making network requests."""
|
||||
|
||||
import importlib.util
|
||||
import hashlib
|
||||
import urllib.error
|
||||
from pathlib import Path
|
||||
from tempfile import TemporaryDirectory
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
|
||||
SCRIPT = Path(__file__).with_name("release.py")
|
||||
spec = importlib.util.spec_from_file_location("release", SCRIPT)
|
||||
release = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(release)
|
||||
|
||||
|
||||
class FakeGitea:
|
||||
def __init__(self):
|
||||
self.release = None
|
||||
self.assets = []
|
||||
self.blobs = {}
|
||||
self.fail_second_upload = True
|
||||
self.uploads = 0
|
||||
self.tag_sha = None
|
||||
|
||||
def request(self, url, method="GET", payload=None, content_type=None):
|
||||
if "/tags/" in url and "/releases/" not in url:
|
||||
if self.tag_sha is None:
|
||||
raise urllib.error.HTTPError(url, 404, "missing", {}, None)
|
||||
return {"commit": {"sha": self.tag_sha}}
|
||||
if "/assets" in url:
|
||||
if method == "GET":
|
||||
return list(self.assets)
|
||||
if method == "DELETE":
|
||||
asset_id = int(url.rsplit("/", 1)[1])
|
||||
self.assets = [item for item in self.assets if item["id"] != asset_id]
|
||||
self.blobs.pop(asset_id, None)
|
||||
return None
|
||||
self.uploads += 1
|
||||
if self.fail_second_upload and self.uploads == 2:
|
||||
raise OSError("injected upload failure")
|
||||
name = release.urllib.parse.parse_qs(url.split("?", 1)[1])["name"][0]
|
||||
item = {"id": self.uploads, "name": name, "size": len(payload),
|
||||
"browser_download_url": f"https://api/download/{self.uploads}"}
|
||||
self.assets.append(item)
|
||||
self.blobs[self.uploads] = payload
|
||||
return item
|
||||
if method == "GET":
|
||||
return self.release
|
||||
if method == "POST":
|
||||
assert self.release is None
|
||||
self.release = {**release.json.loads(payload), "id": 7}
|
||||
return dict(self.release)
|
||||
if method == "PATCH":
|
||||
self.release.update(release.json.loads(payload))
|
||||
if not self.release["draft"] and self.tag_sha is None:
|
||||
self.tag_sha = self.release["target_commitish"]
|
||||
return dict(self.release)
|
||||
raise AssertionError((method, url))
|
||||
|
||||
|
||||
class ReleaseTest(unittest.TestCase):
|
||||
def test_retry_after_partial_upload_keeps_release_draft_until_complete(self):
|
||||
with TemporaryDirectory() as directory:
|
||||
paths = [Path(directory) / "source.tar.gz", Path(directory) / "bench.txt"]
|
||||
for path in paths:
|
||||
path.write_bytes(path.name.encode())
|
||||
fake = FakeGitea()
|
||||
def digest(asset, _api):
|
||||
return hashlib.sha256(fake.blobs[asset["id"]]).hexdigest()
|
||||
|
||||
with patch.object(release, "request", fake.request), \
|
||||
patch.object(release, "asset_digest", digest):
|
||||
with self.assertRaisesRegex(OSError, "injected upload failure"):
|
||||
release.publish("v1.2.3", False, paths, "https://api", "org/repo", "a" * 40)
|
||||
self.assertTrue(fake.release["draft"])
|
||||
self.assertEqual(len(fake.assets), 1)
|
||||
fake.fail_second_upload = False
|
||||
release.publish("v1.2.3", False, paths, "https://api", "org/repo", "a" * 40)
|
||||
self.assertFalse(fake.release["draft"])
|
||||
self.assertEqual({item["name"] for item in fake.assets},
|
||||
{path.name for path in paths})
|
||||
fake.assets[0]["size"] = len(fake.blobs[fake.assets[0]["id"]])
|
||||
fake.blobs[fake.assets[0]["id"]] = b"x" * fake.assets[0]["size"]
|
||||
release.publish("v1.2.3", False, paths, "https://api", "org/repo", "a" * 40)
|
||||
self.assertFalse(fake.release["draft"])
|
||||
self.assertEqual(digest(fake.assets[0], "https://api"),
|
||||
release.sha256_file(paths[0]))
|
||||
|
||||
def test_preflight_rejects_missing_and_duplicate_assets(self):
|
||||
with TemporaryDirectory() as directory:
|
||||
path = Path(directory) / "one"
|
||||
with self.assertRaisesRegex(ValueError, "missing or empty"):
|
||||
release.files_to_publish([str(path)])
|
||||
path.write_bytes(b"x")
|
||||
with self.assertRaisesRegex(ValueError, "distinct"):
|
||||
release.files_to_publish([str(path), str(path)])
|
||||
|
||||
def test_existing_git_tag_mismatch_blocks_release_without_changes(self):
|
||||
with TemporaryDirectory() as directory:
|
||||
path = Path(directory) / "image.tar.gz"
|
||||
path.write_bytes(b"image")
|
||||
fake = FakeGitea()
|
||||
fake.tag_sha = "b" * 40
|
||||
fake.release = {"id": 7, "tag_name": "v1.2.3",
|
||||
"target_commitish": "a" * 40, "draft": False}
|
||||
with patch.object(release, "request", fake.request):
|
||||
with self.assertRaisesRegex(ValueError, "Git tag points"):
|
||||
release.publish("v1.2.3", False, [path], "https://api",
|
||||
"org/repo", "a" * 40)
|
||||
self.assertEqual(fake.uploads, 0)
|
||||
self.assertFalse(fake.release["draft"])
|
||||
|
||||
def test_complete_release_without_git_tag_is_not_accepted(self):
|
||||
with TemporaryDirectory() as directory:
|
||||
path = Path(directory) / "image.tar.gz"
|
||||
path.write_bytes(b"image")
|
||||
fake = FakeGitea()
|
||||
fake.release = {"id": 7, "tag_name": "v1.2.3",
|
||||
"target_commitish": "a" * 40, "draft": False}
|
||||
fake.assets = [{"id": 1, "name": path.name, "size": path.stat().st_size}]
|
||||
with patch.object(release, "request", fake.request), \
|
||||
patch.object(release, "asset_digest", lambda *_: release.sha256_file(path)):
|
||||
with self.assertRaisesRegex(ValueError, "no Git tag"):
|
||||
release.publish("v1.2.3", False, [path], "https://api",
|
||||
"org/repo", "a" * 40)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,59 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Check candidate numbering and covered-commit reruns with real Git tags."""
|
||||
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
|
||||
|
||||
VERSION = Path(__file__).with_name("version.py")
|
||||
|
||||
|
||||
def git(root: Path, *args: str) -> str:
|
||||
result = subprocess.run(
|
||||
["git", *args], cwd=root, text=True, check=True, capture_output=True
|
||||
)
|
||||
return result.stdout.strip()
|
||||
|
||||
|
||||
def selected(root: Path, branch: str) -> dict[str, str]:
|
||||
result = subprocess.run(
|
||||
["python3", str(VERSION), branch], cwd=root,
|
||||
text=True, check=True, capture_output=True
|
||||
)
|
||||
return dict(line.split("=", 1) for line in result.stdout.splitlines())
|
||||
|
||||
|
||||
def main() -> None:
|
||||
with tempfile.TemporaryDirectory(prefix="alkane-os-version-") as path:
|
||||
root = Path(path)
|
||||
(root / "ci").mkdir()
|
||||
(root / "ci/version-x.txt").write_text("0\n")
|
||||
git(root, "init", "-q")
|
||||
git(root, "config", "user.name", "Alkane CI")
|
||||
git(root, "config", "user.email", "ci@example.invalid")
|
||||
git(root, "add", ".")
|
||||
git(root, "commit", "-qm", "First source")
|
||||
first = git(root, "rev-parse", "HEAD")
|
||||
assert selected(root, "next") == {
|
||||
"release": "true", "tag": "v0.1.0-rc.1", "version": "0.1.0-rc.1"
|
||||
}
|
||||
git(root, "tag", "v0.1.0-rc.1")
|
||||
assert selected(root, "next") == {"release": "false"}
|
||||
|
||||
(root / "README.md").write_text("A later merge.\n")
|
||||
git(root, "add", ".")
|
||||
git(root, "commit", "-qm", "Later source")
|
||||
assert selected(root, "next") == {
|
||||
"release": "true", "tag": "v0.1.0-rc.2", "version": "0.1.0-rc.2"
|
||||
}
|
||||
git(root, "tag", "v0.1.0-rc.2")
|
||||
assert selected(root, "next") == {"release": "false"}
|
||||
git(root, "checkout", "-q", first)
|
||||
assert selected(root, "next") == {"release": "false"}
|
||||
print("PASS: exact and superseded candidate reruns do not publish")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -27,6 +27,13 @@ def main():
|
||||
parser.add_argument("branch", choices=("main", "next"))
|
||||
args = parser.parse_args()
|
||||
major = int(pathlib.Path("ci/version-x.txt").read_text().strip())
|
||||
# A rerun of a commit already covered by a published tag must not issue
|
||||
# a newer candidate number for older source.
|
||||
tagged_descendants = set(git("tag", "--contains", "HEAD", "-l", "v*").splitlines())
|
||||
known_tags = {tag for _, tag in versions("main") + versions("next")}
|
||||
if tagged_descendants & known_tags:
|
||||
print("release=false")
|
||||
return
|
||||
finals = versions("main")
|
||||
previous = finals[-1] if finals else None
|
||||
if previous and previous[0][0] > major:
|
||||
|
||||
@@ -0,0 +1,116 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Bounded host-only check: captured BM13xx report through HAL to a strict pool.
|
||||
|
||||
use alkane_os::hal_wire::HalClient;
|
||||
use alkane_os::miner::Bm1366Miner;
|
||||
use alkane_os::stratum_client::{PoolConnection, PoolEvent, ReportEvent};
|
||||
use std::error::Error;
|
||||
use std::io;
|
||||
use std::net::SocketAddr;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const CAPTURED_HEADER: [u8; 80] = [
|
||||
0x00, 0x00, 0x00, 0x20, 0xfc, 0x3a, 0xb8, 0xd4, 0x30, 0x21, 0xf4, 0x5e, 0xb6, 0x62, 0x38, 0x9d,
|
||||
0x0f, 0x79, 0x1f, 0x65, 0x7d, 0xbf, 0x75, 0xa5, 0xcb, 0x93, 0x67, 0x0b, 0x57, 0xb6, 0xc2, 0x25,
|
||||
0x03, 0xb4, 0x21, 0x3a, 0x43, 0xae, 0x10, 0x52, 0xeb, 0xd4, 0x44, 0x43, 0x06, 0x8f, 0xe1, 0x78,
|
||||
0xe2, 0xc6, 0x1c, 0xa4, 0x99, 0x48, 0x46, 0xfd, 0x13, 0x3a, 0xdd, 0xb0, 0x4a, 0xab, 0x2b, 0x38,
|
||||
0x2c, 0x5b, 0x4c, 0x74, 0xc1, 0x01, 0x2e, 0x6a, 0x8f, 0x06, 0x02, 0x17, 0x00, 0x00, 0x00, 0x00,
|
||||
];
|
||||
|
||||
const BM1362_HEADER_HEX: &str = concat!(
|
||||
"00000020fc3ab8d43021f45eb662389d0f791f657dbf75a5cb93670b57b6c22503",
|
||||
"b4213a0503969b7384e1215aace8cfc65dae22d8493ad48fec0b7ac3b0ad7b4e7",
|
||||
"fb0c5c0012e6a8f06021700000000"
|
||||
);
|
||||
|
||||
fn bm1362_header() -> Result<[u8; 80], io::Error> {
|
||||
let mut header = [0_u8; 80];
|
||||
for (index, pair) in BM1362_HEADER_HEX.as_bytes().chunks_exact(2).enumerate() {
|
||||
let digits = std::str::from_utf8(pair).map_err(io::Error::other)?;
|
||||
header[index] = u8::from_str_radix(digits, 16).map_err(io::Error::other)?;
|
||||
}
|
||||
Ok(header)
|
||||
}
|
||||
|
||||
fn failure(message: impl Into<String>) -> io::Error {
|
||||
io::Error::other(message.into())
|
||||
}
|
||||
|
||||
fn main() -> Result<(), Box<dyn Error>> {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let socket = args.next().ok_or_else(|| {
|
||||
failure("usage: simulator_pool_replay_probe HAL_SOCKET POOL_ADDRESS [SHARES] [CHIP]")
|
||||
})?;
|
||||
let address: SocketAddr = args
|
||||
.next()
|
||||
.ok_or_else(|| failure("missing pool address"))?
|
||||
.parse()?;
|
||||
let expected_accepts: usize = args.next().map_or(Ok(1), |value| value.parse())?;
|
||||
if !(1..=64).contains(&expected_accepts) {
|
||||
return Err(failure("SHARES must be between 1 and 64").into());
|
||||
}
|
||||
let chip = args.next().unwrap_or_else(|| "BM1366".to_owned());
|
||||
let first_header = match chip.as_str() {
|
||||
"BM1366" => CAPTURED_HEADER,
|
||||
"BM1362" if expected_accepts == 1 => bm1362_header()?,
|
||||
"BM1362" => return Err(failure("BM1362 has one captured header").into()),
|
||||
_ => return Err(failure("unsupported captured chip").into()),
|
||||
};
|
||||
if args.next().is_some() {
|
||||
return Err(failure("unexpected argument").into());
|
||||
}
|
||||
if !address.ip().is_loopback() {
|
||||
return Err(failure("probe pool must be on loopback").into());
|
||||
}
|
||||
|
||||
let mut backend = HalClient::connect(socket)?;
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000)
|
||||
.ok_or_else(|| failure("invalid simulator configuration"))?;
|
||||
let mut pool = PoolConnection::connect(
|
||||
address,
|
||||
"alkane-simulator-probe",
|
||||
"alkane.test",
|
||||
"x",
|
||||
Duration::from_secs(2),
|
||||
Duration::from_secs(5),
|
||||
)
|
||||
.map_err(|error| failure(format!("pool handshake: {error:?}")))?;
|
||||
miner.start()?;
|
||||
let deadline = Instant::now() + Duration::from_secs(10 + 2 * expected_accepts as u64);
|
||||
let mut issued = 0;
|
||||
let mut submitted = 0;
|
||||
let mut accepted = 0;
|
||||
while Instant::now() < deadline {
|
||||
let (event, reports) = pool
|
||||
.cycle(&mut miner)
|
||||
.map_err(|error| failure(format!("mining cycle: {error:?}")))?;
|
||||
submitted += reports
|
||||
.iter()
|
||||
.filter(|report| matches!(report, ReportEvent::Submitted(_)))
|
||||
.count();
|
||||
match event {
|
||||
PoolEvent::Work(work) => {
|
||||
if issued == 0 && work.header != first_header {
|
||||
return Err(failure("pool job differs from real-silicon capture").into());
|
||||
}
|
||||
issued += 1;
|
||||
}
|
||||
PoolEvent::ShareAccepted(_) => {
|
||||
if accepted >= submitted || accepted >= issued {
|
||||
return Err(failure("unattributed pool acceptance").into());
|
||||
}
|
||||
accepted += 1;
|
||||
if accepted == expected_accepts {
|
||||
miner.stop()?;
|
||||
println!(
|
||||
"{chip} real captured nonce accepted by strict loopback pool ({accepted} shares)"
|
||||
);
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
PoolEvent::ShareRejected(_) => return Err(failure("pool rejected share").into()),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
Err(failure("captured share was not accepted before deadline").into())
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Exercise the SDK's host-only BM13xx HAL simulator with a captured job.
|
||||
|
||||
use alkane_os::hal_wire::HalClient;
|
||||
use alkane_os::miner::{Bm1366Miner, ChipModel};
|
||||
use std::error::Error;
|
||||
use std::io;
|
||||
|
||||
const HEADER: [u8; 80] = [
|
||||
0x00, 0x00, 0x00, 0x20, 0xfc, 0x3a, 0xb8, 0xd4, 0x30, 0x21, 0xf4, 0x5e, 0xb6, 0x62, 0x38, 0x9d,
|
||||
0x0f, 0x79, 0x1f, 0x65, 0x7d, 0xbf, 0x75, 0xa5, 0xcb, 0x93, 0x67, 0x0b, 0x57, 0xb6, 0xc2, 0x25,
|
||||
0x03, 0xb4, 0x21, 0x3a, 0x43, 0xae, 0x10, 0x52, 0xeb, 0xd4, 0x44, 0x43, 0x06, 0x8f, 0xe1, 0x78,
|
||||
0xe2, 0xc6, 0x1c, 0xa4, 0x99, 0x48, 0x46, 0xfd, 0x13, 0x3a, 0xdd, 0xb0, 0x4a, 0xab, 0x2b, 0x38,
|
||||
0x2c, 0x5b, 0x4c, 0x74, 0xc1, 0x01, 0x2e, 0x6a, 0x8f, 0x06, 0x02, 0x17, 0x00, 0x00, 0x00, 0x00,
|
||||
];
|
||||
|
||||
const BM1362_HEADER_HEX: &str = concat!(
|
||||
"00000020fc3ab8d43021f45eb662389d0f791f657dbf75a5cb93670b57b6c22503",
|
||||
"b4213a0503969b7384e1215aace8cfc65dae22d8493ad48fec0b7ac3b0ad7b4e7",
|
||||
"fb0c5c0012e6a8f06021700000000"
|
||||
);
|
||||
|
||||
fn bm1362_header() -> Result<[u8; 80], io::Error> {
|
||||
let mut header = [0_u8; 80];
|
||||
for (index, pair) in BM1362_HEADER_HEX.as_bytes().chunks_exact(2).enumerate() {
|
||||
let digits = std::str::from_utf8(pair).map_err(io::Error::other)?;
|
||||
header[index] = u8::from_str_radix(digits, 16).map_err(io::Error::other)?;
|
||||
}
|
||||
Ok(header)
|
||||
}
|
||||
|
||||
fn main() -> Result<(), Box<dyn Error>> {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let path = args
|
||||
.next()
|
||||
.ok_or("usage: simulator_replay_probe SOCKET_PATH [BM1366|BM1362]")?;
|
||||
let chip = args.next().unwrap_or_else(|| "BM1366".to_owned());
|
||||
if args.next().is_some() {
|
||||
return Err("unexpected argument".into());
|
||||
}
|
||||
let (header, nonce, model) = match chip.as_str() {
|
||||
"BM1366" => (HEADER, 0xedad_ff38, ChipModel::Bm1366),
|
||||
"BM1362" => (bm1362_header()?, 0x630b_2533, ChipModel::Bm1362),
|
||||
_ => return Err("unsupported captured chip".into()),
|
||||
};
|
||||
let mut backend = HalClient::connect(path)?;
|
||||
// Chip initialization is outside this host-only check.
|
||||
let mut miner = Bm1366Miner::new_for_chip(&mut backend, model, 0, 0, 0, 100, 80_000)
|
||||
.ok_or("invalid simulator probe configuration")?;
|
||||
miner.start()?;
|
||||
let mut target = [0_u8; 32];
|
||||
target[26..28].fill(0xff);
|
||||
miner.submit(header, target, 0x18)?;
|
||||
let share = miner.poll()?.ok_or("missing captured nonce report")?;
|
||||
miner.stop()?;
|
||||
assert_eq!(share.nonce, nonce);
|
||||
println!("{chip} captured report verified at difficulty 1");
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"schema": 1,
|
||||
"profiles": [
|
||||
{
|
||||
"name": "s19jpro-bm1362-pic",
|
||||
"chip": "bm1362",
|
||||
"sensor": "pic",
|
||||
"chains": 3,
|
||||
"envelope": {"v_min_mv": 1100, "v_max_mv": 1500, "f_min_mhz": 300, "f_max_mhz": 700}
|
||||
},
|
||||
{
|
||||
"name": "s19kpro-bm1366-nopic",
|
||||
"chip": "bm1366",
|
||||
"sensor": "nopic",
|
||||
"chains": 3,
|
||||
"envelope": {"v_min_mv": 1100, "v_max_mv": 1500, "f_min_mhz": 300, "f_max_mhz": 700}
|
||||
}
|
||||
]
|
||||
}
|
||||
+589
@@ -0,0 +1,589 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Process wiring: start the API and UI servers and publish the hardware snapshot.
|
||||
//!
|
||||
//! The binary and the tests use the same function, so the wiring that CI exercises is the wiring
|
||||
//! that runs on a board. Servers are bound before they are spawned, which lets a caller discover
|
||||
//! ephemeral ports instead of guessing them.
|
||||
|
||||
use crate::detect::{
|
||||
run_detection, DetectionBackend, DetectionFailure, DetectionRequest, FanZone, ProbeBudget,
|
||||
SensorTopology,
|
||||
};
|
||||
use crate::fanmap::{FanMap, MapThresholds, SweepConfig};
|
||||
use crate::fanmap_store::ensure_map;
|
||||
use crate::fault::FaultPolicy;
|
||||
use crate::hal_wire::{HalClient, HalError};
|
||||
use crate::management::{bind_local, serve, HardwareSnapshot, MiningStatus};
|
||||
use crate::profiles::{ProfileDb, ProfileError};
|
||||
use crate::runtime::MinerRuntime;
|
||||
use crate::tuning::{PidConfig, TuningTarget};
|
||||
use crate::web;
|
||||
use std::fmt;
|
||||
use std::io;
|
||||
use std::net::{SocketAddr, TcpListener, TcpStream};
|
||||
use std::path::Path;
|
||||
use std::sync::Arc;
|
||||
use std::thread::JoinHandle;
|
||||
use std::time::Duration;
|
||||
|
||||
/// Bound servers and their worker threads.
|
||||
pub struct Servers {
|
||||
pub api: Option<SocketAddr>,
|
||||
pub web: Option<SocketAddr>,
|
||||
handles: Vec<JoinHandle<()>>,
|
||||
}
|
||||
|
||||
impl Servers {
|
||||
/// Addresses actually bound, which matters when port 0 was requested.
|
||||
pub fn addresses(&self) -> (Option<SocketAddr>, Option<SocketAddr>) {
|
||||
(self.api, self.web)
|
||||
}
|
||||
|
||||
/// Wait for the workers. Only useful in tests; the binary runs until it is killed.
|
||||
pub fn join(self) {
|
||||
for handle in self.handles {
|
||||
let _ = handle.join();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Bind and start the cgminer-style API and the web UI, each when an address is given.
|
||||
pub fn start(
|
||||
status: Arc<MiningStatus>,
|
||||
api: Option<SocketAddr>,
|
||||
web_bind: Option<SocketAddr>,
|
||||
) -> io::Result<Servers> {
|
||||
let api_listener = match api {
|
||||
Some(address) => Some(bind_local(address)?),
|
||||
None => None,
|
||||
};
|
||||
let api_address = api_listener
|
||||
.as_ref()
|
||||
.map(|listener| listener.local_addr())
|
||||
.transpose()?;
|
||||
let web_listener = match web_bind {
|
||||
Some(address) => Some(TcpListener::bind(address)?),
|
||||
None => None,
|
||||
};
|
||||
let web_address = web_listener
|
||||
.as_ref()
|
||||
.map(|listener| listener.local_addr())
|
||||
.transpose()?;
|
||||
|
||||
let mut handles = Vec::new();
|
||||
if let Some(listener) = api_listener {
|
||||
let snapshot = Arc::clone(&status);
|
||||
handles.push(std::thread::spawn(move || {
|
||||
if let Err(error) = serve(listener, snapshot) {
|
||||
eprintln!("management API stopped: {error}");
|
||||
}
|
||||
}));
|
||||
}
|
||||
if let Some(listener) = web_listener {
|
||||
let snapshot = Arc::clone(&status);
|
||||
handles.push(std::thread::spawn(move || {
|
||||
if let Err(error) = web::serve_listener(listener, snapshot) {
|
||||
eprintln!("web UI stopped: {error}");
|
||||
}
|
||||
}));
|
||||
}
|
||||
Ok(Servers {
|
||||
api: api_address,
|
||||
web: web_address,
|
||||
handles,
|
||||
})
|
||||
}
|
||||
|
||||
/// Build the API snapshot from the live runtime.
|
||||
pub fn snapshot(runtime: &MinerRuntime, target: &str) -> HardwareSnapshot {
|
||||
let plan = runtime.plan();
|
||||
HardwareSnapshot {
|
||||
plan: plan.clone(),
|
||||
active_chains: runtime.active_chains(),
|
||||
stopped: runtime.stop_reason().map(|reason| match reason {
|
||||
crate::fault::StopReason::Temperature => "temperature",
|
||||
crate::fault::StopReason::NoChainsLeft => "no chains left",
|
||||
}),
|
||||
frequency_mhz: runtime.operating_point().frequency_mhz,
|
||||
target: target.to_owned(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Everything a boot needs besides the backend.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct BootConfig {
|
||||
pub profile_db_json: String,
|
||||
pub chain_ports: Vec<u8>,
|
||||
pub sensor: SensorTopology,
|
||||
pub budget: ProbeBudget,
|
||||
pub fan_zones: Vec<FanZone>,
|
||||
pub target: TuningTarget,
|
||||
pub pid: PidConfig,
|
||||
pub ceiling_mc: i32,
|
||||
pub fault_policy: FaultPolicy,
|
||||
}
|
||||
|
||||
/// Why boot did not reach a running runtime.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum BootError<E> {
|
||||
Profile(ProfileError),
|
||||
Detection(DetectionFailure<E>),
|
||||
/// The board backend could not be reached or refused an operation.
|
||||
Backend(E),
|
||||
}
|
||||
|
||||
impl<E: fmt::Debug> fmt::Display for BootError<E> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Profile(error) => write!(f, "profile database rejected: {error:?}"),
|
||||
Self::Detection(error) => write!(f, "hardware detection refused: {error:?}"),
|
||||
Self::Backend(error) => write!(f, "hardware backend failed: {error:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: fmt::Debug> std::error::Error for BootError<E> {}
|
||||
|
||||
/// Operator target in the form the API and UI report.
|
||||
pub fn target_label(target: &TuningTarget) -> String {
|
||||
match *target {
|
||||
TuningTarget::PowerW(watts) => format!("power:{watts:.0}"),
|
||||
TuningTarget::HashrateThs(rate) => format!("hashrate:{rate:.0}"),
|
||||
TuningTarget::AmbientC { margin_mc } => format!("ambient:{margin_mc}"),
|
||||
TuningTarget::MaxFan { max_pwm } => format!("fan:{max_pwm}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Detect, decide, and publish: the sequence a family image runs at start-up.
|
||||
pub fn boot<B: DetectionBackend>(
|
||||
backend: &mut B,
|
||||
config: &BootConfig,
|
||||
status: &MiningStatus,
|
||||
) -> Result<MinerRuntime, BootError<B::Error>> {
|
||||
let db = ProfileDb::from_json(&config.profile_db_json).map_err(BootError::Profile)?;
|
||||
let request = DetectionRequest {
|
||||
chain_ports: &config.chain_ports,
|
||||
budget: config.budget,
|
||||
sensor: config.sensor,
|
||||
fan_zones: config.fan_zones.clone(),
|
||||
};
|
||||
let plan = run_detection(backend, &db, &request).map_err(BootError::Detection)?;
|
||||
let runtime = MinerRuntime::new(
|
||||
plan,
|
||||
config.fault_policy,
|
||||
config.target,
|
||||
config.pid,
|
||||
config.ceiling_mc,
|
||||
);
|
||||
status.set_hardware(snapshot(&runtime, &target_label(&config.target)));
|
||||
Ok(runtime)
|
||||
}
|
||||
|
||||
/// A boot over the real local HAL contract, including the one-time fan sweep.
|
||||
pub struct HalBoot<'a> {
|
||||
pub config: &'a BootConfig,
|
||||
pub sweep: SweepConfig,
|
||||
pub thresholds: MapThresholds,
|
||||
pub map_path: &'a Path,
|
||||
}
|
||||
|
||||
/// Connect the board backend, detect, map the fans once, and publish.
|
||||
///
|
||||
/// This is the path an image takes on real hardware; the fakes in the tests speak the same HAL
|
||||
/// protocol, so the wiring is exercised rather than assumed.
|
||||
pub fn boot_from_hal(
|
||||
socket: &Path,
|
||||
settings: &HalBoot<'_>,
|
||||
status: &MiningStatus,
|
||||
) -> Result<(MinerRuntime, FanMap), BootError<HalError>> {
|
||||
let mut client = HalClient::connect(socket).map_err(BootError::Backend)?;
|
||||
let zone_count = settings.sweep.zones;
|
||||
let map = if zone_count == 0 {
|
||||
FanMap::default()
|
||||
} else {
|
||||
ensure_map(
|
||||
&mut client,
|
||||
&settings.sweep,
|
||||
settings.thresholds,
|
||||
settings.map_path,
|
||||
|millis| std::thread::sleep(std::time::Duration::from_millis(u64::from(millis))),
|
||||
)
|
||||
.map_err(|error| match error {
|
||||
crate::fanmap_store::StoreError::Sweep(crate::fanmap::SweepError::Backend(error)) => {
|
||||
BootError::Backend(error)
|
||||
}
|
||||
crate::fanmap_store::StoreError::Sweep(_) => {
|
||||
BootError::Backend(HalError::Protocol("fan sweep configuration rejected"))
|
||||
}
|
||||
crate::fanmap_store::StoreError::Io(message) => {
|
||||
BootError::Backend(HalError::Protocol(message))
|
||||
}
|
||||
})?
|
||||
};
|
||||
let config = BootConfig {
|
||||
fan_zones: map.assignments.clone(),
|
||||
..settings.config.clone()
|
||||
};
|
||||
let runtime = boot(&mut client, &config, status)?;
|
||||
Ok((runtime, map))
|
||||
}
|
||||
|
||||
/// Read one HTTP response body from a bound server, for health checks and tests.
|
||||
pub fn http_get(address: SocketAddr, path: &str) -> io::Result<String> {
|
||||
use std::io::{Read, Write};
|
||||
let mut stream = TcpStream::connect_timeout(&address, Duration::from_secs(2))?;
|
||||
stream.set_read_timeout(Some(Duration::from_secs(2)))?;
|
||||
stream.write_all(format!("GET {path} HTTP/1.1\r\nHost: miner\r\n\r\n").as_bytes())?;
|
||||
let mut reply = String::new();
|
||||
stream.read_to_string(&mut reply)?;
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::detect::{
|
||||
ChainReport, ChipModel, EepromState, Envelope, FanZone, HardwarePlan, OperatingPoint,
|
||||
};
|
||||
use crate::detect::{ProbeOutcome, PsuCapability};
|
||||
use crate::fanmap::{MapThresholds, SweepConfig};
|
||||
use crate::fault::FaultPolicy;
|
||||
use crate::tuning::{PidConfig, TuningTarget};
|
||||
use std::io::{Read, Write};
|
||||
|
||||
fn runtime() -> MinerRuntime {
|
||||
MinerRuntime::new(
|
||||
HardwarePlan {
|
||||
profile: "s19jpro-bm1362-pic".into(),
|
||||
chip: ChipModel::Bm1362,
|
||||
chains: vec![ChainReport {
|
||||
index: 0,
|
||||
chip: ChipModel::Bm1362,
|
||||
chips_found: 126,
|
||||
eeprom: EepromState::Absent,
|
||||
response_per_mille: Some(950),
|
||||
}],
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
},
|
||||
operating_point: OperatingPoint {
|
||||
voltage_mv: 1200,
|
||||
frequency_mhz: 300,
|
||||
confirmed: false,
|
||||
},
|
||||
psu: "APW12".into(),
|
||||
fan_zones: vec![FanZone {
|
||||
fan: 0,
|
||||
zones: vec![0],
|
||||
}],
|
||||
},
|
||||
FaultPolicy::default(),
|
||||
TuningTarget::PowerW(2_400.0),
|
||||
PidConfig::default(),
|
||||
95_000,
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn both_servers_serve_the_published_snapshot() {
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
status.set_hardware(snapshot(&runtime(), "power:2400"));
|
||||
let servers = start(
|
||||
Arc::clone(&status),
|
||||
Some("127.0.0.1:0".parse().unwrap()),
|
||||
Some("127.0.0.1:0".parse().unwrap()),
|
||||
)
|
||||
.expect("start");
|
||||
let (api, web) = servers.addresses();
|
||||
let api = api.expect("api address");
|
||||
let web = web.expect("web address");
|
||||
|
||||
let page = http_get(web, "/api/hardware").expect("web");
|
||||
assert!(page.contains("s19jpro-bm1362-pic"));
|
||||
assert!(page.contains("power:2400"));
|
||||
|
||||
let mut client =
|
||||
TcpStream::connect_timeout(&api, Duration::from_secs(2)).expect("api connect");
|
||||
client
|
||||
.set_read_timeout(Some(Duration::from_secs(3)))
|
||||
.expect("timeout");
|
||||
client.write_all(b"summary").expect("api write");
|
||||
let mut summary = String::new();
|
||||
client.read_to_string(&mut summary).expect("api read");
|
||||
assert!(summary.contains("SUMMARY"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn servers_are_optional() {
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
let servers = start(status, None, None).expect("start");
|
||||
assert_eq!(servers.addresses(), (None, None));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_snapshot_reports_runtime_state_not_boot_defaults() {
|
||||
let mut runtime = runtime();
|
||||
runtime.tick(&crate::runtime::Tick {
|
||||
power_w: Some(1_000.0),
|
||||
hashrate_ths: None,
|
||||
hottest_mc: Some(60_000),
|
||||
ambient_mc: None,
|
||||
dt_s: 1.0,
|
||||
});
|
||||
let snapshot = snapshot(&runtime, "power:2400");
|
||||
assert_eq!(snapshot.target, "power:2400");
|
||||
assert_eq!(snapshot.active_chains, vec![0]);
|
||||
assert!(snapshot.frequency_mhz > 300);
|
||||
assert!(snapshot.stopped.is_none());
|
||||
}
|
||||
|
||||
struct BootBackend {
|
||||
outcome: ProbeOutcome,
|
||||
psu: Option<PsuCapability>,
|
||||
}
|
||||
|
||||
impl DetectionBackend for BootBackend {
|
||||
type Error = ();
|
||||
|
||||
fn probe(&mut self, _chain: u8, _attempt: u8) -> Result<ProbeOutcome, ()> {
|
||||
Ok(self.outcome)
|
||||
}
|
||||
|
||||
fn eeprom(&mut self, _chain: u8) -> Result<EepromState, ()> {
|
||||
Ok(EepromState::Absent)
|
||||
}
|
||||
|
||||
fn identify_psu(&mut self) -> Result<Option<PsuCapability>, ()> {
|
||||
Ok(self.psu.clone())
|
||||
}
|
||||
}
|
||||
|
||||
const DB: &str = r#"{"schema":1,"profiles":[{"name":"s19jpro-bm1362-pic",
|
||||
"chip":"bm1362","sensor":"pic","chains":3,
|
||||
"envelope":{"v_min_mv":1100,"v_max_mv":1500,"f_min_mhz":300,"f_max_mhz":700}}]}"#;
|
||||
|
||||
fn boot_config() -> BootConfig {
|
||||
BootConfig {
|
||||
profile_db_json: DB.into(),
|
||||
chain_ports: vec![0, 1, 2],
|
||||
sensor: SensorTopology::Pic,
|
||||
budget: ProbeBudget::default(),
|
||||
fan_zones: Vec::new(),
|
||||
target: TuningTarget::PowerW(2_400.0),
|
||||
pid: PidConfig::default(),
|
||||
ceiling_mc: 95_000,
|
||||
fault_policy: FaultPolicy::default(),
|
||||
}
|
||||
}
|
||||
|
||||
fn psu() -> PsuCapability {
|
||||
PsuCapability {
|
||||
name: "APW12".into(),
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1200,
|
||||
v_max_mv: 1600,
|
||||
f_min_mhz: 0,
|
||||
f_max_mhz: 1_000,
|
||||
},
|
||||
max_dc_watts: 3_600,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boot_detects_and_publishes() {
|
||||
let mut backend = BootBackend {
|
||||
outcome: ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
psu: Some(psu()),
|
||||
};
|
||||
let status = MiningStatus::new();
|
||||
let runtime = boot(&mut backend, &boot_config(), &status).expect("boot");
|
||||
assert_eq!(runtime.active_chains(), vec![0, 1, 2]);
|
||||
let document = status.hardware_document();
|
||||
assert_eq!(document["available"], true);
|
||||
assert_eq!(document["target"], "power:2400");
|
||||
assert_eq!(document["psu"], "APW12");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boot_refuses_an_unknown_chip() {
|
||||
let mut backend = BootBackend {
|
||||
outcome: ProbeOutcome::Silent,
|
||||
psu: Some(psu()),
|
||||
};
|
||||
let status = MiningStatus::new();
|
||||
assert!(matches!(
|
||||
boot(&mut backend, &boot_config(), &status),
|
||||
Err(BootError::Detection(DetectionFailure::Refused(_)))
|
||||
));
|
||||
assert_eq!(status.hardware_document()["available"], false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boot_refuses_a_bad_profile_database() {
|
||||
let mut backend = BootBackend {
|
||||
outcome: ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
psu: Some(psu()),
|
||||
};
|
||||
let mut config = boot_config();
|
||||
config.profile_db_json = "{\"schema\": 9}".into();
|
||||
assert!(matches!(
|
||||
boot(&mut backend, &config, &MiningStatus::new()),
|
||||
Err(BootError::Profile(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boot_refuses_a_missing_psu() {
|
||||
let mut backend = BootBackend {
|
||||
outcome: ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
psu: None,
|
||||
};
|
||||
assert!(matches!(
|
||||
boot(&mut backend, &boot_config(), &MiningStatus::new()),
|
||||
Err(BootError::Detection(DetectionFailure::Refused(_)))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn target_labels_are_stable() {
|
||||
assert_eq!(target_label(&TuningTarget::PowerW(3_000.0)), "power:3000");
|
||||
assert_eq!(
|
||||
target_label(&TuningTarget::HashrateThs(200.0)),
|
||||
"hashrate:200"
|
||||
);
|
||||
assert_eq!(
|
||||
target_label(&TuningTarget::AmbientC { margin_mc: 20_000 }),
|
||||
"ambient:20000"
|
||||
);
|
||||
assert_eq!(
|
||||
target_label(&TuningTarget::MaxFan { max_pwm: 100 }),
|
||||
"fan:100"
|
||||
);
|
||||
}
|
||||
|
||||
fn hal_server(socket: std::path::PathBuf) -> std::thread::JoinHandle<()> {
|
||||
use std::io::{Read, Write};
|
||||
use std::os::unix::net::UnixListener;
|
||||
let listener = UnixListener::bind(&socket).expect("bind hal");
|
||||
std::thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().expect("accept");
|
||||
loop {
|
||||
let mut header = [0_u8; 16];
|
||||
if stream.read_exact(&mut header).is_err() {
|
||||
return;
|
||||
}
|
||||
let opcode = header[5];
|
||||
let sequence = header[8..12].to_vec();
|
||||
let length =
|
||||
u32::from_le_bytes([header[12], header[13], header[14], header[15]]) as usize;
|
||||
let mut payload = vec![0_u8; length];
|
||||
if length > 0 && stream.read_exact(&mut payload).is_err() {
|
||||
return;
|
||||
}
|
||||
let body: Vec<u8> = match opcode {
|
||||
// CAPABILITIES: chain probe, EEPROM, PSU identity.
|
||||
7 => {
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&7_u32.to_le_bytes());
|
||||
body
|
||||
}
|
||||
// PROBE_CHAIN: identified, bm1362, 126 chips.
|
||||
8 => vec![0, 0, 1, 126, 0],
|
||||
// READ_EEPROM: absent.
|
||||
9 => vec![0, 1],
|
||||
// IDENTIFY_PSU: APW12 with its envelope.
|
||||
10 => {
|
||||
let name = b"APW12";
|
||||
let mut body = vec![0_u8, name.len() as u8];
|
||||
body.extend_from_slice(name);
|
||||
for word in [1200_u16, 1600, 0, 1000, 3600] {
|
||||
body.extend_from_slice(&word.to_le_bytes());
|
||||
}
|
||||
body
|
||||
}
|
||||
_ => vec![1],
|
||||
};
|
||||
let mut out = [0_u8; 16];
|
||||
out[..4].copy_from_slice(b"ALKH");
|
||||
out[4] = 1;
|
||||
out[5] = opcode;
|
||||
out[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
||||
out[8..12].copy_from_slice(&sequence);
|
||||
out[12..16].copy_from_slice(&(body.len() as u32).to_le_bytes());
|
||||
if stream.write_all(&out).is_err() || stream.write_all(&body).is_err() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boot_over_the_hal_socket_detects_and_publishes() {
|
||||
let base = std::env::temp_dir().join(format!("alkane-hal-{}", std::process::id()));
|
||||
let socket = base.with_extension("sock");
|
||||
let map_path = base.with_extension("map.json");
|
||||
let _ = std::fs::remove_file(&socket);
|
||||
let server = hal_server(socket.clone());
|
||||
let status = MiningStatus::new();
|
||||
let config = boot_config();
|
||||
let settings = HalBoot {
|
||||
config: &config,
|
||||
sweep: SweepConfig {
|
||||
fans: 0,
|
||||
zones: 0,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 1,
|
||||
settle_ms: 0,
|
||||
},
|
||||
thresholds: MapThresholds::default(),
|
||||
map_path: &map_path,
|
||||
};
|
||||
let (runtime, map) = boot_from_hal(&socket, &settings, &status).expect("boot over hal");
|
||||
assert_eq!(runtime.active_chains(), vec![0, 1, 2]);
|
||||
assert!(map.assignments.is_empty());
|
||||
let document = status.hardware_document();
|
||||
assert_eq!(document["available"], true);
|
||||
assert_eq!(document["psu"], "APW12");
|
||||
assert_eq!(document["chip"], "bm1362");
|
||||
let _ = std::fs::remove_file(&socket);
|
||||
let _ = server.join();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boot_over_a_missing_socket_is_a_backend_error() {
|
||||
let socket =
|
||||
std::env::temp_dir().join(format!("alkane-missing-{}.sock", std::process::id()));
|
||||
let status = MiningStatus::new();
|
||||
let config = boot_config();
|
||||
let settings = HalBoot {
|
||||
config: &config,
|
||||
sweep: SweepConfig {
|
||||
fans: 0,
|
||||
zones: 0,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 1,
|
||||
settle_ms: 0,
|
||||
},
|
||||
thresholds: MapThresholds::default(),
|
||||
map_path: &socket,
|
||||
};
|
||||
assert!(matches!(
|
||||
boot_from_hal(&socket, &settings, &status),
|
||||
Err(BootError::Backend(_))
|
||||
));
|
||||
}
|
||||
}
|
||||
+232
@@ -0,0 +1,232 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! BM1362 frame encoding from captured command and job traffic.
|
||||
//!
|
||||
//! These pure encoders do not initialize a chain. PLL fields, voltage, and
|
||||
//! model-specific operating points still require silicon-backed validation.
|
||||
|
||||
use crate::bm13xx::{crc16, crc5, reverse_words};
|
||||
|
||||
pub const JOB_BYTES: usize = 88;
|
||||
pub const CHIP_ADDRESS_STEP: u8 = 2;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ModelGeometry {
|
||||
chips_per_chain: u8,
|
||||
ticket_mask: u8,
|
||||
}
|
||||
|
||||
pub const S19J_PRO: ModelGeometry = ModelGeometry {
|
||||
chips_per_chain: 126,
|
||||
ticket_mask: 0x7f,
|
||||
};
|
||||
pub const S19J: ModelGeometry = ModelGeometry {
|
||||
chips_per_chain: 108,
|
||||
ticket_mask: 0x7f,
|
||||
};
|
||||
pub const S19_88: ModelGeometry = ModelGeometry {
|
||||
chips_per_chain: 88,
|
||||
ticket_mask: 0x3f,
|
||||
};
|
||||
|
||||
impl ModelGeometry {
|
||||
pub const fn new(chips_per_chain: u8, ticket_mask: u8) -> Option<Self> {
|
||||
if chips_per_chain == 0 || chips_per_chain > 128 {
|
||||
return None;
|
||||
}
|
||||
Some(Self {
|
||||
chips_per_chain,
|
||||
ticket_mask,
|
||||
})
|
||||
}
|
||||
|
||||
pub const fn chips_per_chain(self) -> u8 {
|
||||
self.chips_per_chain
|
||||
}
|
||||
|
||||
pub const fn ticket_mask(self) -> u8 {
|
||||
self.ticket_mask
|
||||
}
|
||||
|
||||
/// Addresses for an observed two-address-step enumeration walk.
|
||||
pub fn chip_addresses(self) -> impl Iterator<Item = u8> {
|
||||
(0..self.chips_per_chain).map(|index| index * CHIP_ADDRESS_STEP)
|
||||
}
|
||||
}
|
||||
|
||||
fn short_command(code: u8, address: u8, register: u8) -> [u8; 7] {
|
||||
let mut frame = [0x55, 0xaa, code, 0x05, address, register, 0];
|
||||
frame[6] = crc5(&frame[2..6]);
|
||||
frame
|
||||
}
|
||||
|
||||
fn long_command(code: u8, address: u8, register: u8, value: u32) -> [u8; 11] {
|
||||
let mut frame = [0_u8; 11];
|
||||
frame[..6].copy_from_slice(&[0x55, 0xaa, code, 0x09, address, register]);
|
||||
frame[6..10].copy_from_slice(&value.to_be_bytes());
|
||||
frame[10] = crc5(&frame[2..10]);
|
||||
frame
|
||||
}
|
||||
|
||||
pub fn chain_inactive() -> [u8; 7] {
|
||||
short_command(0x53, 0, 0)
|
||||
}
|
||||
|
||||
pub fn set_chip_address(address: u8) -> [u8; 7] {
|
||||
short_command(0x40, address, 0)
|
||||
}
|
||||
|
||||
pub fn read_register(address: u8, register: u8) -> [u8; 7] {
|
||||
short_command(0x42, address, register)
|
||||
}
|
||||
|
||||
pub fn read_register_all(register: u8) -> [u8; 7] {
|
||||
short_command(0x52, 0, register)
|
||||
}
|
||||
|
||||
pub fn write_register(address: u8, register: u8, value: u32) -> [u8; 11] {
|
||||
long_command(0x41, address, register, value)
|
||||
}
|
||||
|
||||
pub fn write_register_all(register: u8, value: u32) -> [u8; 11] {
|
||||
long_command(0x51, 0, register, value)
|
||||
}
|
||||
|
||||
/// Raw header fields in BM1362 wire order. The caller owns work-ID allocation
|
||||
/// and must supply roots and hashes in the order established by its capture.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct Job {
|
||||
pub work_id: u8,
|
||||
pub num_midstates: u8,
|
||||
pub start_nonce: u32,
|
||||
pub nbits: u32,
|
||||
pub ntime: u32,
|
||||
pub merkle_root: [u8; 32],
|
||||
pub previous_hash: [u8; 32],
|
||||
pub version: u32,
|
||||
}
|
||||
|
||||
/// Encode the 88-byte SEND_JOB form with the true-length tag observed on wire.
|
||||
pub fn encode_job(job: &Job) -> [u8; JOB_BYTES] {
|
||||
let mut frame = [0_u8; JOB_BYTES];
|
||||
frame[..6].copy_from_slice(&[0x55, 0xaa, 0x21, 0x56, job.work_id, job.num_midstates]);
|
||||
frame[6..10].copy_from_slice(&job.start_nonce.to_le_bytes());
|
||||
frame[10..14].copy_from_slice(&job.nbits.to_le_bytes());
|
||||
frame[14..18].copy_from_slice(&job.ntime.to_le_bytes());
|
||||
frame[18..50].copy_from_slice(&job.merkle_root);
|
||||
frame[50..82].copy_from_slice(&job.previous_hash);
|
||||
frame[82..86].copy_from_slice(&job.version.to_le_bytes());
|
||||
let checksum = crc16(&frame[2..86]);
|
||||
frame[86..88].copy_from_slice(&checksum.to_be_bytes());
|
||||
frame
|
||||
}
|
||||
|
||||
/// Encode one nonce-zero pool header in the observed raw-header job layout.
|
||||
/// This covers work delivery; chain initialization still needs board evidence.
|
||||
pub fn encode_work(header: &[u8; 80], work_id: u8) -> Option<[u8; JOB_BYTES]> {
|
||||
if header[76..80] != [0; 4] || work_id & 7 != 0 {
|
||||
return None;
|
||||
}
|
||||
Some(encode_job(&Job {
|
||||
work_id,
|
||||
num_midstates: 1,
|
||||
start_nonce: 0,
|
||||
nbits: u32::from_le_bytes(header[72..76].try_into().expect("nbits")),
|
||||
ntime: u32::from_le_bytes(header[68..72].try_into().expect("ntime")),
|
||||
merkle_root: reverse_words(&header[36..68]),
|
||||
previous_hash: reverse_words(&header[4..36]),
|
||||
version: u32::from_le_bytes(header[..4].try_into().expect("version")),
|
||||
}))
|
||||
}
|
||||
|
||||
/// BT8D for a 25 MHz input clock with BCLK_SEL=0. A model must still choose
|
||||
/// the actual target baud and confirm switching on silicon.
|
||||
pub fn bt8d_for_baud(baud: u32) -> Option<u8> {
|
||||
if baud == 0 || baud > 3_125_000 {
|
||||
return None;
|
||||
}
|
||||
let divider = 25_000_000_u64 / (8 * u64::from(baud));
|
||||
u8::try_from(divider - 1).ok()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn captured_command_frames() {
|
||||
assert_eq!(chain_inactive(), [0x55, 0xaa, 0x53, 5, 0, 0, 3]);
|
||||
assert_eq!(set_chip_address(0), [0x55, 0xaa, 0x40, 5, 0, 0, 0x1c]);
|
||||
assert_eq!(set_chip_address(8), [0x55, 0xaa, 0x40, 5, 8, 0, 7]);
|
||||
assert_eq!(read_register_all(0), [0x55, 0xaa, 0x52, 5, 0, 0, 0x0a]);
|
||||
assert_eq!(
|
||||
read_register(0x40, 0x1c),
|
||||
[0x55, 0xaa, 0x42, 5, 0x40, 0x1c, 0x0b]
|
||||
);
|
||||
assert_eq!(
|
||||
write_register_all(0x80, 0),
|
||||
[0x55, 0xaa, 0x51, 9, 0, 0x80, 0, 0, 0, 0, 0x1c]
|
||||
);
|
||||
assert_eq!(
|
||||
write_register(0x40, 0x18, 0x7a31),
|
||||
[0x55, 0xaa, 0x41, 9, 0x40, 0x18, 0, 0, 0x7a, 0x31, 0x11]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn model_address_limits() {
|
||||
assert_eq!(ModelGeometry::new(0, 0), None);
|
||||
assert_eq!(ModelGeometry::new(129, 0), None);
|
||||
assert_eq!(
|
||||
ModelGeometry::new(128, 0).unwrap().chip_addresses().last(),
|
||||
Some(0xfe)
|
||||
);
|
||||
assert_eq!(S19J_PRO.chip_addresses().last(), Some(0xfa));
|
||||
assert_eq!(S19J.chip_addresses().last(), Some(0xd6));
|
||||
assert_eq!(S19_88.chip_addresses().last(), Some(0xae));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn job_frame_layout() {
|
||||
let mut merkle_root = [0_u8; 32];
|
||||
let mut previous_hash = [0_u8; 32];
|
||||
for index in 0..32 {
|
||||
merkle_root[index] = 0xa0 + index as u8;
|
||||
previous_hash[index] = 0x10 + index as u8;
|
||||
}
|
||||
let frame = encode_job(&Job {
|
||||
work_id: 8,
|
||||
num_midstates: 1,
|
||||
start_nonce: 0,
|
||||
nbits: 0x1a1f_2c34,
|
||||
ntime: 0x5e9b_3cd4,
|
||||
merkle_root,
|
||||
previous_hash,
|
||||
version: 0x2000_0000,
|
||||
});
|
||||
assert_eq!(
|
||||
&frame[..18],
|
||||
&[
|
||||
0x55, 0xaa, 0x21, 0x56, 8, 1, 0, 0, 0, 0, 0x34, 0x2c, 0x1f, 0x1a, 0xd4, 0x3c, 0x9b,
|
||||
0x5e
|
||||
]
|
||||
);
|
||||
assert_eq!(&frame[18..50], &merkle_root);
|
||||
assert_eq!(&frame[50..82], &previous_hash);
|
||||
assert_eq!(&frame[82..86], &[0, 0, 0, 0x20]);
|
||||
assert_eq!(&frame[86..88], &[0xc2, 0xbd]);
|
||||
assert_eq!(
|
||||
u16::from_be_bytes([frame[86], frame[87]]),
|
||||
crc16(&frame[2..86])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn baud_dividers() {
|
||||
assert_eq!(bt8d_for_baud(0), None);
|
||||
assert_eq!(bt8d_for_baud(3_000_000), Some(0));
|
||||
assert_eq!(bt8d_for_baud(115_200), Some(26));
|
||||
assert_eq!(bt8d_for_baud(1), None);
|
||||
assert_eq!(bt8d_for_baud(3_125_001), None);
|
||||
assert_eq!(bt8d_for_baud(u32::MAX), None);
|
||||
}
|
||||
}
|
||||
+120
@@ -0,0 +1,120 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! BM1366 work and response framing. Nonces only come from a device or replay.
|
||||
|
||||
pub const WORK_BYTES: usize = 88;
|
||||
pub const REPORT_BYTES: usize = 11;
|
||||
|
||||
pub use crate::bm13xx::crc16;
|
||||
use crate::bm13xx::{crc5, reverse_words};
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct NonceReport {
|
||||
pub nonce: u32,
|
||||
pub work_id: u8,
|
||||
pub version_field: u16,
|
||||
pub chip_address: u8,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum ReportError {
|
||||
Length,
|
||||
Preamble,
|
||||
RegisterResponse,
|
||||
Checksum,
|
||||
}
|
||||
|
||||
/// Encode a nonce-zero Bitcoin header for the observed 88-byte SEND_JOB form.
|
||||
/// The low three work-ID bits are reserved by the BM1366 response format.
|
||||
pub fn encode_work(header: &[u8; 80], work_id: u8) -> Option<[u8; WORK_BYTES]> {
|
||||
if header[76..80] != [0; 4] || work_id & 7 != 0 {
|
||||
return None;
|
||||
}
|
||||
let mut frame = [0_u8; WORK_BYTES];
|
||||
frame[..4].copy_from_slice(&[0x55, 0xaa, 0x21, 0x54]);
|
||||
frame[4] = work_id;
|
||||
// The captured 88-byte on-die-midstate job uses one midstate.
|
||||
frame[5] = 1;
|
||||
frame[10..14].copy_from_slice(&header[72..76]);
|
||||
frame[14..18].copy_from_slice(&header[68..72]);
|
||||
frame[18..50].copy_from_slice(&reverse_words(&header[36..68]));
|
||||
frame[50..82].copy_from_slice(&reverse_words(&header[4..36]));
|
||||
frame[82..86].copy_from_slice(&header[..4]);
|
||||
let checksum = crc16(&frame[2..86]);
|
||||
frame[86..88].copy_from_slice(&checksum.to_be_bytes());
|
||||
Some(frame)
|
||||
}
|
||||
|
||||
/// Parse an observed nonce report; register replies must use a separate path.
|
||||
pub fn decode_nonce_report(frame: &[u8]) -> Result<NonceReport, ReportError> {
|
||||
if frame.len() != REPORT_BYTES {
|
||||
return Err(ReportError::Length);
|
||||
}
|
||||
if frame[..2] != [0xaa, 0x55] {
|
||||
return Err(ReportError::Preamble);
|
||||
}
|
||||
if frame[10] & 0x80 == 0 {
|
||||
return Err(ReportError::RegisterResponse);
|
||||
}
|
||||
if crc5(&frame[2..]) != 0 {
|
||||
return Err(ReportError::Checksum);
|
||||
}
|
||||
Ok(NonceReport {
|
||||
nonce: u32::from_le_bytes(frame[2..6].try_into().expect("four-byte nonce")),
|
||||
chip_address: frame[6],
|
||||
work_id: frame[7] & 0xf8,
|
||||
version_field: u16::from_be_bytes(frame[8..10].try_into().expect("version field")),
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn crc16_reference_vector() {
|
||||
assert_eq!(crc16(b"123456789"), 0x29b1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn captured_work_and_response() {
|
||||
let header: [u8; 80] = hex_header();
|
||||
let frame = encode_work(&header, 0x18).unwrap();
|
||||
assert_eq!(&frame[..5], &[0x55, 0xaa, 0x21, 0x54, 0x18]);
|
||||
assert_eq!(frame[5], 1);
|
||||
assert_eq!(
|
||||
crc16(&frame[2..86]),
|
||||
u16::from_be_bytes([frame[86], frame[87]])
|
||||
);
|
||||
assert_eq!(&frame[10..14], &header[72..76]);
|
||||
assert_eq!(&frame[82..86], &header[..4]);
|
||||
assert!(encode_work(&header, 0x19).is_none());
|
||||
let mut with_nonce = header;
|
||||
with_nonce[76] = 1;
|
||||
assert!(encode_work(&with_nonce, 0x18).is_none());
|
||||
|
||||
let report = [
|
||||
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
|
||||
];
|
||||
let parsed = decode_nonce_report(&report).unwrap();
|
||||
assert_eq!(parsed.nonce, 0xedad_ff38);
|
||||
assert_eq!(parsed.work_id, 0x18);
|
||||
assert_eq!(parsed.version_field, 0x04b3);
|
||||
let mut corrupt = report;
|
||||
corrupt[4] ^= 1;
|
||||
assert_eq!(decode_nonce_report(&corrupt), Err(ReportError::Checksum));
|
||||
}
|
||||
|
||||
fn hex_header() -> [u8; 80] {
|
||||
let input = concat!(
|
||||
"00000020fc3ab8d43021f45eb662389d0f791f657dbf75a5cb93670b57b6c22503",
|
||||
"b4213a43ae1052ebd44443068fe178e2c61ca4994846fd133addb04aab2b382c5",
|
||||
"b4c74c1012e6a8f06021700000000"
|
||||
);
|
||||
let mut header = [0_u8; 80];
|
||||
for (index, bytes) in input.as_bytes().chunks_exact(2).enumerate() {
|
||||
let pair = std::str::from_utf8(bytes).unwrap();
|
||||
header[index] = u8::from_str_radix(pair, 16).unwrap();
|
||||
}
|
||||
header
|
||||
}
|
||||
}
|
||||
+203
@@ -0,0 +1,203 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! BM1370 wire frames observed on an S21 Pro. This module does not control power.
|
||||
|
||||
use crate::bm13xx::{crc16, crc5};
|
||||
|
||||
pub use crate::bm1362::Job;
|
||||
|
||||
pub const JOB_BYTES: usize = 88;
|
||||
pub const REPORT_BYTES: usize = 11;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct NonceReport {
|
||||
pub nonce: u32,
|
||||
pub byte6: u8,
|
||||
pub byte7: u8,
|
||||
pub byte8: u8,
|
||||
pub byte9: u8,
|
||||
/// Raw trailer: bit 7 marks a nonce response; bits 4:0 carry CRC5.
|
||||
/// No chip identity is inferred from this byte.
|
||||
pub trailer: u8,
|
||||
}
|
||||
|
||||
impl NonceReport {
|
||||
/// Work ID observed in the Braiins S21 Pro capture. Chip and version
|
||||
/// attribution remain unknown, and this has no accepted-share proof.
|
||||
pub fn observed_work_id(&self) -> u8 {
|
||||
(self.byte7 & 0xf0) >> 1
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum ReportError {
|
||||
Length,
|
||||
Preamble,
|
||||
RegisterResponse,
|
||||
Checksum,
|
||||
}
|
||||
|
||||
/// Encode only the job shape observed in the S21 Pro capture. `Job` fields
|
||||
/// are in wire order; this does not validate a pool header or start a chain.
|
||||
pub fn encode_job(job: &Job) -> Option<[u8; JOB_BYTES]> {
|
||||
if job.work_id & 7 != 0 || job.num_midstates != 1 || job.start_nonce != 0 {
|
||||
return None;
|
||||
}
|
||||
let mut frame = crate::bm1362::encode_job(job);
|
||||
frame[3] = 0x36;
|
||||
let checksum = crc16(&frame[2..86]);
|
||||
frame[86..88].copy_from_slice(&checksum.to_be_bytes());
|
||||
Some(frame)
|
||||
}
|
||||
|
||||
/// Keep the five trailing bytes raw. The work-ID expression is correlated with
|
||||
/// same-UART jobs in one capture; chip and version mapping remain unverified.
|
||||
/// The marker bit distinguishes nonce reports from register replies.
|
||||
pub fn decode_nonce_report(frame: &[u8]) -> Result<NonceReport, ReportError> {
|
||||
if frame.len() != REPORT_BYTES {
|
||||
return Err(ReportError::Length);
|
||||
}
|
||||
if frame[..2] != [0xaa, 0x55] {
|
||||
return Err(ReportError::Preamble);
|
||||
}
|
||||
if frame[10] & 0x80 == 0 {
|
||||
return Err(ReportError::RegisterResponse);
|
||||
}
|
||||
if crc5(&frame[2..]) != 0 {
|
||||
return Err(ReportError::Checksum);
|
||||
}
|
||||
Ok(NonceReport {
|
||||
nonce: u32::from_le_bytes(frame[2..6].try_into().expect("four-byte nonce")),
|
||||
byte6: frame[6],
|
||||
byte7: frame[7],
|
||||
byte8: frame[8],
|
||||
byte9: frame[9],
|
||||
trailer: frame[10],
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
// firmware-analysis/prong-b/s21-192/c2-steady.strace, SHA-256
|
||||
// c0aac1222e05e95bdcbd1de5a8ee244a581256e8f28e3dadf5300df6110229c7.
|
||||
const CAPTURED_JOB: &str = concat!(
|
||||
"55aa21366001000000008f060217834f276af0f09aafc588165b7fbfc56f8f09a55d3d0de5",
|
||||
"798bd87460278af180c4696fc200000000000000008af701003acc10cdebe5bc3c90f095e5",
|
||||
"03c6b7de69ca8b5d00000020e769"
|
||||
);
|
||||
|
||||
fn captured_bytes<const N: usize>(hex: &str) -> [u8; N] {
|
||||
assert_eq!(hex.len(), N * 2);
|
||||
let mut bytes = [0; N];
|
||||
for (index, pair) in hex.as_bytes().chunks_exact(2).enumerate() {
|
||||
bytes[index] = u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap();
|
||||
}
|
||||
bytes
|
||||
}
|
||||
|
||||
fn with_valid_crc(mut frame: [u8; REPORT_BYTES]) -> [u8; REPORT_BYTES] {
|
||||
for checksum in 0..32 {
|
||||
frame[10] = (frame[10] & 0xe0) | checksum;
|
||||
if crc5(&frame[2..]) == 0 {
|
||||
return frame;
|
||||
}
|
||||
}
|
||||
panic!("no valid CRC5 trailer");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn live_job_matches_all_88_bytes() {
|
||||
let captured = captured_bytes::<JOB_BYTES>(CAPTURED_JOB);
|
||||
let mut merkle_root = [0; 32];
|
||||
merkle_root.copy_from_slice(&captured[18..50]);
|
||||
let mut previous_hash = [0; 32];
|
||||
previous_hash.copy_from_slice(&captured[50..82]);
|
||||
let job = Job {
|
||||
work_id: captured[4],
|
||||
num_midstates: captured[5],
|
||||
start_nonce: u32::from_le_bytes(captured[6..10].try_into().unwrap()),
|
||||
nbits: u32::from_le_bytes(captured[10..14].try_into().unwrap()),
|
||||
ntime: u32::from_le_bytes(captured[14..18].try_into().unwrap()),
|
||||
merkle_root,
|
||||
previous_hash,
|
||||
version: u32::from_le_bytes(captured[82..86].try_into().unwrap()),
|
||||
};
|
||||
assert_eq!(encode_job(&job), Some(captured));
|
||||
let mut invalid = job;
|
||||
invalid.work_id |= 1;
|
||||
assert_eq!(encode_job(&invalid), None);
|
||||
invalid = job;
|
||||
invalid.num_midstates = 2;
|
||||
assert_eq!(encode_job(&invalid), None);
|
||||
invalid = job;
|
||||
invalid.start_nonce = 1;
|
||||
assert_eq!(encode_job(&invalid), None);
|
||||
assert_eq!(
|
||||
crc16(&captured[2..86]),
|
||||
u16::from_be_bytes([captured[86], captured[87]])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn live_nonce_reports_preserve_raw_tags() {
|
||||
for hex in [
|
||||
"aa555804a92a041e133e86",
|
||||
"aa55771def23001c16fc82",
|
||||
"aa5574480ae6021417b492",
|
||||
] {
|
||||
let frame = captured_bytes::<REPORT_BYTES>(hex);
|
||||
let report = decode_nonce_report(&frame).unwrap();
|
||||
assert_eq!(
|
||||
report.nonce,
|
||||
u32::from_le_bytes(frame[2..6].try_into().unwrap())
|
||||
);
|
||||
assert_eq!(report.byte6, frame[6]);
|
||||
assert_eq!(report.byte7, frame[7]);
|
||||
assert_eq!(report.byte8, frame[8]);
|
||||
assert_eq!(report.byte9, frame[9]);
|
||||
assert_eq!(report.trailer, frame[10]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn observed_work_id_matches_same_uart_job() {
|
||||
// c2-steady.strace lines 1287 and 1352: job byte 4 is 0x10.
|
||||
let frame = captured_bytes::<REPORT_BYTES>("aa554a3488c70022013291");
|
||||
let report = decode_nonce_report(&frame).unwrap();
|
||||
assert_eq!(report.observed_work_id(), 0x10);
|
||||
assert_eq!(report.byte7, 0x22);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_report_fails_closed() {
|
||||
let mut frame = captured_bytes::<REPORT_BYTES>("aa555804a92a041e133e86");
|
||||
assert_eq!(decode_nonce_report(&frame[..10]), Err(ReportError::Length));
|
||||
frame[0] = 0;
|
||||
assert_eq!(decode_nonce_report(&frame), Err(ReportError::Preamble));
|
||||
frame[0] = 0xaa;
|
||||
frame[10] &= 0x60;
|
||||
frame = with_valid_crc(frame);
|
||||
assert_eq!(crc5(&frame[2..]), 0);
|
||||
assert_eq!(
|
||||
decode_nonce_report(&frame),
|
||||
Err(ReportError::RegisterResponse)
|
||||
);
|
||||
frame[10] |= 0x80;
|
||||
frame = with_valid_crc(frame);
|
||||
frame[4] ^= 1;
|
||||
assert_eq!(decode_nonce_report(&frame), Err(ReportError::Checksum));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trailer_low_bits_are_checksum_not_chip_identity() {
|
||||
let original = captured_bytes::<REPORT_BYTES>("aa555804a92a041e133e86");
|
||||
let mut changed_nonce = original;
|
||||
changed_nonce[2] ^= 1;
|
||||
changed_nonce = with_valid_crc(changed_nonce);
|
||||
assert_eq!(crc5(&changed_nonce[2..]), 0);
|
||||
assert_ne!(changed_nonce[10] & 0x1f, original[10] & 0x1f);
|
||||
assert_eq!(changed_nonce[10] & 0xe0, original[10] & 0xe0);
|
||||
assert!(decode_nonce_report(&changed_nonce).is_ok());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Shared BM13xx wire checksums. This module never generates mining nonces.
|
||||
|
||||
/// Reverse the eight 32-bit header words for the observed SEND_JOB layout.
|
||||
pub(crate) fn reverse_words(input: &[u8]) -> [u8; 32] {
|
||||
let mut output = [0_u8; 32];
|
||||
for index in 0..8 {
|
||||
output[index * 4..index * 4 + 4].copy_from_slice(&input[(7 - index) * 4..(8 - index) * 4]);
|
||||
}
|
||||
output
|
||||
}
|
||||
|
||||
/// CRC5 used by command and nonce-report frames, initial value 0x1f.
|
||||
pub fn crc5(bytes: &[u8]) -> u8 {
|
||||
let mut state = 0x1f_u8;
|
||||
for &byte in bytes {
|
||||
for bit in (0..8).rev() {
|
||||
let feedback = ((state >> 4) ^ (byte >> bit)) & 1;
|
||||
state = ((state << 1) | feedback) & 0x1f;
|
||||
state ^= feedback << 2;
|
||||
}
|
||||
}
|
||||
state
|
||||
}
|
||||
|
||||
/// CRC16-CCITT-FALSE used by 88-byte SEND_JOB frames.
|
||||
pub fn crc16(bytes: &[u8]) -> u16 {
|
||||
let mut state = 0xffff_u16;
|
||||
for &byte in bytes {
|
||||
state ^= u16::from(byte) << 8;
|
||||
for _ in 0..8 {
|
||||
state = if state & 0x8000 == 0 {
|
||||
state << 1
|
||||
} else {
|
||||
(state << 1) ^ 0x1021
|
||||
};
|
||||
}
|
||||
}
|
||||
state
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn captured_command_checksums() {
|
||||
let vectors: &[(&[u8], u8)] = &[
|
||||
(&[0x53, 0x05, 0, 0], 0x03),
|
||||
(&[0x40, 0x05, 0, 0], 0x1c),
|
||||
(&[0x52, 0x05, 0, 0], 0x0a),
|
||||
(&[0x40, 0x05, 8, 0], 0x07),
|
||||
(&[0x42, 0x05, 0x40, 0x1c], 0x0b),
|
||||
(&[0x51, 0x09, 0, 0x80, 0, 0, 0, 0], 0x1c),
|
||||
(&[0x41, 0x09, 0x40, 0x18, 0, 0, 0x7a, 0x31], 0x11),
|
||||
];
|
||||
for &(body, expected) in vectors {
|
||||
assert_eq!(crc5(body), expected);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn standard_crc16_check() {
|
||||
assert_eq!(crc16(b"123456789"), 0x29b1);
|
||||
}
|
||||
}
|
||||
+761
@@ -0,0 +1,761 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Hardware detection model.
|
||||
//!
|
||||
//! The detection core decides what is physically attached to a control board and whether that
|
||||
//! combination is safe to run. It never talks to a chain directly; backends report what they
|
||||
//! probed, and this module turns that into a `HardwarePlan` the miner can execute.
|
||||
//!
|
||||
//! Identification deliberately does not require a hashboard EEPROM. The EEPROM, when present and
|
||||
//! valid, confirms a board revision; a chain probe alone is enough to select a chip profile.
|
||||
|
||||
/// Chip families the detection core can name. `Unknown` is a real answer, not a placeholder.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum ChipModel {
|
||||
Bm1362,
|
||||
Bm1366,
|
||||
Bm1368,
|
||||
Bm1370,
|
||||
Bm1398,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
impl ChipModel {
|
||||
/// Stable wire/API name for this chip family.
|
||||
pub fn name(self) -> &'static str {
|
||||
match self {
|
||||
Self::Bm1362 => "bm1362",
|
||||
Self::Bm1366 => "bm1366",
|
||||
Self::Bm1368 => "bm1368",
|
||||
Self::Bm1370 => "bm1370",
|
||||
Self::Bm1398 => "bm1398",
|
||||
Self::Unknown => "unknown",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// How a chain reports temperature. PIC boards proxy telemetry through the power MCU.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum SensorTopology {
|
||||
Pic,
|
||||
NoPic,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
/// State of a hashboard EEPROM. Absence is normal and must never block detection.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum EepromState {
|
||||
Present { model: String },
|
||||
Absent,
|
||||
Invalid,
|
||||
}
|
||||
|
||||
/// What a backend observed on one physical chain.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct ChainReport {
|
||||
pub index: u8,
|
||||
pub chip: ChipModel,
|
||||
pub chips_found: u16,
|
||||
pub eeprom: EepromState,
|
||||
/// Nonce responses per mille of dispatched work, when the backend could measure it.
|
||||
pub response_per_mille: Option<u16>,
|
||||
}
|
||||
|
||||
impl ChainReport {
|
||||
pub fn is_identified(&self) -> bool {
|
||||
self.chip != ChipModel::Unknown && self.chips_found > 0
|
||||
}
|
||||
}
|
||||
|
||||
/// Safe operating envelope for one hashboard/chip profile, from the profile database.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct Envelope {
|
||||
pub v_min_mv: u16,
|
||||
pub v_max_mv: u16,
|
||||
pub f_min_mhz: u16,
|
||||
pub f_max_mhz: u16,
|
||||
}
|
||||
|
||||
impl Envelope {
|
||||
/// Voltage that pairs with a frequency across this envelope.
|
||||
///
|
||||
/// Voltage follows frequency linearly between the profile's floor and ceiling and is clamped
|
||||
/// outside it. Boards do not run at a fixed voltage across their frequency range, so reporting
|
||||
/// one voltage while the frequency moves would describe a machine that does not exist.
|
||||
pub fn voltage_for(self, frequency_mhz: u16) -> u16 {
|
||||
if frequency_mhz <= self.f_min_mhz {
|
||||
return self.v_min_mv;
|
||||
}
|
||||
if frequency_mhz >= self.f_max_mhz {
|
||||
return self.v_max_mv;
|
||||
}
|
||||
let span_f = u32::from(self.f_max_mhz - self.f_min_mhz);
|
||||
let span_v = u32::from(self.v_max_mv - self.v_min_mv);
|
||||
let offset = u32::from(frequency_mhz - self.f_min_mhz);
|
||||
let voltage = u32::from(self.v_min_mv) + (span_v * offset) / span_f;
|
||||
voltage.min(u32::from(u16::MAX)) as u16
|
||||
}
|
||||
|
||||
pub fn intersect(self, other: Envelope) -> Option<Envelope> {
|
||||
let v_min_mv = self.v_min_mv.max(other.v_min_mv);
|
||||
let v_max_mv = self.v_max_mv.min(other.v_max_mv);
|
||||
let f_min_mhz = self.f_min_mhz.max(other.f_min_mhz);
|
||||
let f_max_mhz = self.f_max_mhz.min(other.f_max_mhz);
|
||||
if v_min_mv > v_max_mv || f_min_mhz > f_max_mhz {
|
||||
return None;
|
||||
}
|
||||
Some(Envelope {
|
||||
v_min_mv,
|
||||
v_max_mv,
|
||||
f_min_mhz,
|
||||
f_max_mhz,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// A hashboard profile from the database.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct BoardProfile {
|
||||
pub name: String,
|
||||
pub chip: ChipModel,
|
||||
pub sensor: SensorTopology,
|
||||
pub chains: u8,
|
||||
pub envelope: Envelope,
|
||||
}
|
||||
|
||||
/// What the PSU reports about itself and what it can deliver.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct PsuCapability {
|
||||
pub name: String,
|
||||
pub envelope: Envelope,
|
||||
pub max_dc_watts: u16,
|
||||
}
|
||||
|
||||
/// Which fans cool which thermal zones, learned by active probing.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct FanZone {
|
||||
pub fan: u8,
|
||||
pub zones: Vec<u8>,
|
||||
}
|
||||
|
||||
/// Why detection refused a combination.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum DetectionError {
|
||||
NoChains,
|
||||
UnknownChip,
|
||||
ChipProfileMismatch,
|
||||
PsuUnidentified,
|
||||
EnvelopeEmpty,
|
||||
}
|
||||
|
||||
/// Operating point chosen for the machine.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct OperatingPoint {
|
||||
pub voltage_mv: u16,
|
||||
pub frequency_mhz: u16,
|
||||
/// True when the profile was confirmed by an EEPROM or a full chain identification.
|
||||
pub confirmed: bool,
|
||||
}
|
||||
|
||||
/// The result of detection: everything the miner needs and nothing it has to guess.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct HardwarePlan {
|
||||
pub profile: String,
|
||||
pub chip: ChipModel,
|
||||
pub chains: Vec<ChainReport>,
|
||||
pub envelope: Envelope,
|
||||
pub operating_point: OperatingPoint,
|
||||
pub psu: String,
|
||||
pub fan_zones: Vec<FanZone>,
|
||||
}
|
||||
|
||||
impl HardwarePlan {
|
||||
/// Chains that identified but reported no nonces, or fewer than expected chips.
|
||||
pub fn degraded_chains(&self, expected: u16) -> Vec<u8> {
|
||||
self.chains
|
||||
.iter()
|
||||
.filter(|chain| {
|
||||
chain.chips_found < expected
|
||||
|| chain.response_per_mille.is_some_and(|ratio| ratio == 0)
|
||||
})
|
||||
.map(|chain| chain.index)
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
/// Turn observations into a plan, or refuse.
|
||||
///
|
||||
/// Refusal is a feature: an unverified or out-of-envelope combination must not mine silently.
|
||||
pub fn plan(
|
||||
chains: &[ChainReport],
|
||||
profile: &BoardProfile,
|
||||
psu: Option<&PsuCapability>,
|
||||
fan_zones: Vec<FanZone>,
|
||||
) -> Result<HardwarePlan, DetectionError> {
|
||||
if chains.is_empty() {
|
||||
return Err(DetectionError::NoChains);
|
||||
}
|
||||
if chains.iter().all(|chain| chain.chip == ChipModel::Unknown) {
|
||||
return Err(DetectionError::UnknownChip);
|
||||
}
|
||||
if chains
|
||||
.iter()
|
||||
.filter(|chain| chain.is_identified())
|
||||
.any(|chain| chain.chip != profile.chip)
|
||||
{
|
||||
return Err(DetectionError::ChipProfileMismatch);
|
||||
}
|
||||
let psu = psu.ok_or(DetectionError::PsuUnidentified)?;
|
||||
let envelope = profile
|
||||
.envelope
|
||||
.intersect(psu.envelope)
|
||||
.ok_or(DetectionError::EnvelopeEmpty)?;
|
||||
let confirmed = chains
|
||||
.iter()
|
||||
.any(|chain| matches!(chain.eeprom, EepromState::Present { .. }))
|
||||
&& chains.iter().all(ChainReport::is_identified);
|
||||
let operating_point = if confirmed {
|
||||
OperatingPoint {
|
||||
voltage_mv: envelope.v_max_mv.min(profile.envelope.v_max_mv),
|
||||
frequency_mhz: envelope.f_max_mhz.min(profile.envelope.f_max_mhz),
|
||||
confirmed: true,
|
||||
}
|
||||
} else {
|
||||
// Unverified hardware runs at the conservative floor of the usable envelope.
|
||||
OperatingPoint {
|
||||
voltage_mv: envelope.v_min_mv,
|
||||
frequency_mhz: envelope.f_min_mhz,
|
||||
confirmed: false,
|
||||
}
|
||||
};
|
||||
Ok(HardwarePlan {
|
||||
profile: profile.name.clone(),
|
||||
chip: profile.chip,
|
||||
chains: chains.to_vec(),
|
||||
envelope,
|
||||
operating_point,
|
||||
psu: psu.name.clone(),
|
||||
fan_zones,
|
||||
})
|
||||
}
|
||||
|
||||
/// Outcome of one chip-identification attempt on a chain.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum ProbeOutcome {
|
||||
/// Chips answered: the model and how many responded.
|
||||
Identified { chip: ChipModel, chips: u16 },
|
||||
/// The port is electrically silent (no signal at all).
|
||||
Silent,
|
||||
/// Bytes arrived but did not frame as a chip response: wrong baud, noise, or a dead TX.
|
||||
Garbled,
|
||||
}
|
||||
|
||||
/// Backend contract for identification.
|
||||
///
|
||||
/// Framing, baud switching and electrical detail stay in the SDK image for that family; the OS
|
||||
/// only decides how many attempts to spend and what the results mean.
|
||||
pub trait DetectionBackend {
|
||||
type Error;
|
||||
|
||||
/// Attempt one identification on `chain`. `attempt` lets the backend cycle its candidate
|
||||
/// interface/baud set deterministically. A transport failure is an error, never `Silent`.
|
||||
fn probe(&mut self, chain: u8, attempt: u8) -> Result<ProbeOutcome, Self::Error>;
|
||||
/// Read the hashboard EEPROM, or report that it is absent or unreadable.
|
||||
fn eeprom(&mut self, chain: u8) -> Result<EepromState, Self::Error>;
|
||||
/// Identify the PSU, if this backend can. `None` means "cannot tell", which refuses later.
|
||||
fn identify_psu(&mut self) -> Result<Option<PsuCapability>, Self::Error>;
|
||||
}
|
||||
|
||||
/// How many identification attempts to spend per chain before declaring it unidentified.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ProbeBudget {
|
||||
pub attempts: u8,
|
||||
}
|
||||
|
||||
impl Default for ProbeBudget {
|
||||
fn default() -> Self {
|
||||
Self { attempts: 4 }
|
||||
}
|
||||
}
|
||||
|
||||
/// Probe one chain until it identifies or the budget is spent.
|
||||
///
|
||||
/// A chain that never identifies is reported as `ChipModel::Unknown` with zero chips rather than
|
||||
/// being dropped, so the plan can refuse explicitly and the API can show why.
|
||||
pub fn probe_chain<B: DetectionBackend>(
|
||||
backend: &mut B,
|
||||
chain: u8,
|
||||
budget: ProbeBudget,
|
||||
) -> Result<ChainReport, B::Error> {
|
||||
let mut outcome = ProbeOutcome::Silent;
|
||||
for attempt in 0..budget.attempts.max(1) {
|
||||
outcome = backend.probe(chain, attempt)?;
|
||||
if matches!(outcome, ProbeOutcome::Identified { .. }) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
let (chip, chips_found) = match outcome {
|
||||
ProbeOutcome::Identified { chip, chips } => (chip, chips),
|
||||
_ => (ChipModel::Unknown, 0),
|
||||
};
|
||||
Ok(ChainReport {
|
||||
index: chain,
|
||||
chip,
|
||||
chips_found,
|
||||
eeprom: backend.eeprom(chain)?,
|
||||
response_per_mille: None,
|
||||
})
|
||||
}
|
||||
|
||||
/// Probe every declared chain port.
|
||||
pub fn detect_chains<B: DetectionBackend>(
|
||||
backend: &mut B,
|
||||
chains: &[u8],
|
||||
budget: ProbeBudget,
|
||||
) -> Result<Vec<ChainReport>, B::Error> {
|
||||
let mut reports = Vec::with_capacity(chains.len());
|
||||
for &chain in chains {
|
||||
reports.push(probe_chain(backend, chain, budget)?);
|
||||
}
|
||||
Ok(reports)
|
||||
}
|
||||
|
||||
/// Everything the caller knows before probing: which ports exist, how hard to try, and how the
|
||||
/// hashboards report temperature.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct DetectionRequest<'a> {
|
||||
pub chain_ports: &'a [u8],
|
||||
pub budget: ProbeBudget,
|
||||
pub sensor: SensorTopology,
|
||||
pub fan_zones: Vec<FanZone>,
|
||||
}
|
||||
|
||||
/// Why a detection run did not produce a plan.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum DetectionFailure<E> {
|
||||
Backend(E),
|
||||
Refused(DetectionError),
|
||||
NoProfile,
|
||||
}
|
||||
|
||||
/// Detect, select a profile, and decide whether the machine may run.
|
||||
///
|
||||
/// The profile is selected by chip, sensor wiring and the number of physical chain ports, so a
|
||||
/// machine with a dead chain still matches its profile and runs degraded instead of being
|
||||
/// reclassified as a different model.
|
||||
pub fn run_detection<B: DetectionBackend>(
|
||||
backend: &mut B,
|
||||
db: &crate::profiles::ProfileDb,
|
||||
request: &DetectionRequest<'_>,
|
||||
) -> Result<HardwarePlan, DetectionFailure<B::Error>> {
|
||||
let reports = detect_chains(backend, request.chain_ports, request.budget)
|
||||
.map_err(DetectionFailure::Backend)?;
|
||||
let chip = reports
|
||||
.iter()
|
||||
.find(|report| report.is_identified())
|
||||
.map(|report| report.chip)
|
||||
.ok_or(DetectionFailure::Refused(DetectionError::UnknownChip))?;
|
||||
let chains = u8::try_from(request.chain_ports.len()).unwrap_or(u8::MAX);
|
||||
let profile = db
|
||||
.find(chip, chains, request.sensor)
|
||||
.ok_or(DetectionFailure::NoProfile)?;
|
||||
let psu = backend.identify_psu().map_err(DetectionFailure::Backend)?;
|
||||
plan(&reports, profile, psu.as_ref(), request.fan_zones.clone())
|
||||
.map_err(DetectionFailure::Refused)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn profile() -> BoardProfile {
|
||||
BoardProfile {
|
||||
name: "s19jpro-bm1362".into(),
|
||||
chip: ChipModel::Bm1362,
|
||||
sensor: SensorTopology::Pic,
|
||||
chains: 3,
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn psu() -> PsuCapability {
|
||||
PsuCapability {
|
||||
name: "APW12".into(),
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1200,
|
||||
v_max_mv: 1600,
|
||||
f_min_mhz: 0,
|
||||
f_max_mhz: 1000,
|
||||
},
|
||||
max_dc_watts: 3600,
|
||||
}
|
||||
}
|
||||
|
||||
fn chain(index: u8, eeprom: EepromState) -> ChainReport {
|
||||
ChainReport {
|
||||
index,
|
||||
chip: ChipModel::Bm1362,
|
||||
chips_found: 126,
|
||||
eeprom,
|
||||
response_per_mille: Some(980),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn confirmed_plan_uses_verified_ceiling() {
|
||||
let chains = [chain(
|
||||
0,
|
||||
EepromState::Present {
|
||||
model: "BHB42601".into(),
|
||||
},
|
||||
)];
|
||||
let plan = plan(&chains, &profile(), Some(&psu()), Vec::new()).expect("plan");
|
||||
assert!(plan.operating_point.confirmed);
|
||||
assert_eq!(plan.operating_point.voltage_mv, 1500);
|
||||
assert_eq!(plan.operating_point.frequency_mhz, 700);
|
||||
assert_eq!(plan.envelope.v_min_mv, 1200);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn absent_eeprom_still_yields_a_conservative_plan() {
|
||||
let chains = [chain(0, EepromState::Absent)];
|
||||
let plan = plan(&chains, &profile(), Some(&psu()), Vec::new()).expect("plan");
|
||||
assert!(!plan.operating_point.confirmed);
|
||||
assert_eq!(plan.operating_point.voltage_mv, plan.envelope.v_min_mv);
|
||||
assert_eq!(plan.operating_point.frequency_mhz, plan.envelope.f_min_mhz);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_chip_refuses() {
|
||||
let mut chains = [chain(0, EepromState::Absent)];
|
||||
chains[0].chip = ChipModel::Unknown;
|
||||
assert_eq!(
|
||||
plan(&chains, &profile(), Some(&psu()), Vec::new()),
|
||||
Err(DetectionError::UnknownChip)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrong_chip_refuses() {
|
||||
let mut chains = [chain(0, EepromState::Absent)];
|
||||
chains[0].chip = ChipModel::Bm1366;
|
||||
assert_eq!(
|
||||
plan(&chains, &profile(), Some(&psu()), Vec::new()),
|
||||
Err(DetectionError::ChipProfileMismatch)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_psu_refuses() {
|
||||
let chains = [chain(0, EepromState::Absent)];
|
||||
assert_eq!(
|
||||
plan(&chains, &profile(), None, Vec::new()),
|
||||
Err(DetectionError::PsuUnidentified)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn incompatible_psu_refuses() {
|
||||
let chains = [chain(0, EepromState::Absent)];
|
||||
let weak = PsuCapability {
|
||||
name: "APW3".into(),
|
||||
envelope: Envelope {
|
||||
v_min_mv: 700,
|
||||
v_max_mv: 1090,
|
||||
f_min_mhz: 0,
|
||||
f_max_mhz: 1000,
|
||||
},
|
||||
max_dc_watts: 1600,
|
||||
};
|
||||
assert_eq!(
|
||||
plan(&chains, &profile(), Some(&weak), Vec::new()),
|
||||
Err(DetectionError::EnvelopeEmpty)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_chain_set_refuses() {
|
||||
assert_eq!(
|
||||
plan(&[], &profile(), Some(&psu()), Vec::new()),
|
||||
Err(DetectionError::NoChains)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn degraded_chains_are_reported_not_fatal() {
|
||||
let mut silent = chain(1, EepromState::Absent);
|
||||
silent.response_per_mille = Some(0);
|
||||
let chains = [chain(0, EepromState::Absent), silent];
|
||||
let plan = plan(&chains, &profile(), Some(&psu()), Vec::new()).expect("plan");
|
||||
assert_eq!(plan.degraded_chains(126), vec![1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fan_zones_are_carried_into_the_plan() {
|
||||
let chains = [chain(0, EepromState::Absent)];
|
||||
let zones = vec![FanZone {
|
||||
fan: 0,
|
||||
zones: vec![0, 1],
|
||||
}];
|
||||
let plan = plan(&chains, &profile(), Some(&psu()), zones.clone()).expect("plan");
|
||||
assert_eq!(plan.fan_zones, zones);
|
||||
}
|
||||
|
||||
struct ScriptedProbe {
|
||||
plan: std::collections::VecDeque<ProbeOutcome>,
|
||||
eeprom: EepromState,
|
||||
calls: usize,
|
||||
fail_at: u8,
|
||||
psu: Option<PsuCapability>,
|
||||
}
|
||||
|
||||
impl ScriptedProbe {
|
||||
fn new(plan: &[ProbeOutcome], eeprom: EepromState) -> Self {
|
||||
Self {
|
||||
plan: plan.iter().copied().collect(),
|
||||
eeprom,
|
||||
calls: 0,
|
||||
fail_at: u8::MAX,
|
||||
psu: Some(psu()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl DetectionBackend for ScriptedProbe {
|
||||
type Error = ();
|
||||
|
||||
fn probe(&mut self, _chain: u8, attempt: u8) -> Result<ProbeOutcome, ()> {
|
||||
self.calls += 1;
|
||||
if attempt == self.fail_at {
|
||||
return Err(());
|
||||
}
|
||||
Ok(self.plan.pop_front().unwrap_or(ProbeOutcome::Silent))
|
||||
}
|
||||
|
||||
fn eeprom(&mut self, _chain: u8) -> Result<EepromState, ()> {
|
||||
Ok(self.eeprom.clone())
|
||||
}
|
||||
|
||||
fn identify_psu(&mut self) -> Result<Option<PsuCapability>, ()> {
|
||||
Ok(self.psu.clone())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn probe_retries_until_the_chain_identifies() {
|
||||
let mut backend = ScriptedProbe::new(
|
||||
&[
|
||||
ProbeOutcome::Silent,
|
||||
ProbeOutcome::Garbled,
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
],
|
||||
EepromState::Absent,
|
||||
);
|
||||
let report = probe_chain(&mut backend, 0, ProbeBudget { attempts: 4 }).expect("probe");
|
||||
assert_eq!(backend.calls, 3);
|
||||
assert_eq!(report.chip, ChipModel::Bm1362);
|
||||
assert_eq!(report.chips_found, 126);
|
||||
assert!(report.is_identified());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn probe_exhaustion_is_reported_not_hidden() {
|
||||
let mut backend = ScriptedProbe::new(&[ProbeOutcome::Silent; 4], EepromState::Absent);
|
||||
let report = probe_chain(&mut backend, 1, ProbeBudget { attempts: 4 }).expect("probe");
|
||||
assert_eq!(backend.calls, 4);
|
||||
assert_eq!(report.chip, ChipModel::Unknown);
|
||||
assert_eq!(report.chips_found, 0);
|
||||
assert!(!report.is_identified());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn probe_keeps_the_eeprom_state_even_when_unidentified() {
|
||||
let mut backend = ScriptedProbe::new(
|
||||
&[ProbeOutcome::Garbled; 2],
|
||||
EepromState::Present {
|
||||
model: "BHB42601".into(),
|
||||
},
|
||||
);
|
||||
let report = probe_chain(&mut backend, 2, ProbeBudget { attempts: 2 }).expect("probe");
|
||||
assert_eq!(report.chip, ChipModel::Unknown);
|
||||
assert_eq!(
|
||||
report.eeprom,
|
||||
EepromState::Present {
|
||||
model: "BHB42601".into()
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn detection_covers_every_declared_chain_port() {
|
||||
let mut backend = ScriptedProbe::new(
|
||||
&[
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
],
|
||||
EepromState::Absent,
|
||||
);
|
||||
let reports =
|
||||
detect_chains(&mut backend, &[0, 1, 2], ProbeBudget::default()).expect("detect");
|
||||
assert_eq!(reports.len(), 3);
|
||||
assert_eq!(
|
||||
reports.iter().map(|r| r.index).collect::<Vec<_>>(),
|
||||
vec![0, 1, 2]
|
||||
);
|
||||
assert!(reports.iter().all(ChainReport::is_identified));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transport_failure_is_not_reported_as_a_silent_port() {
|
||||
let mut backend = ScriptedProbe::new(&[ProbeOutcome::Silent; 4], EepromState::Absent);
|
||||
backend.fail_at = 1;
|
||||
assert_eq!(
|
||||
probe_chain(&mut backend, 0, ProbeBudget::default()),
|
||||
Err(())
|
||||
);
|
||||
assert_eq!(backend.calls, 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unidentified_chain_makes_the_plan_refuse() {
|
||||
let mut backend = ScriptedProbe::new(&[ProbeOutcome::Silent; 4], EepromState::Absent);
|
||||
let reports = detect_chains(&mut backend, &[0], ProbeBudget::default()).expect("detect");
|
||||
assert_eq!(
|
||||
plan(&reports, &profile(), Some(&psu()), Vec::new()),
|
||||
Err(DetectionError::UnknownChip)
|
||||
);
|
||||
}
|
||||
|
||||
fn db() -> crate::profiles::ProfileDb {
|
||||
crate::profiles::ProfileDb::new(vec![profile()]).expect("db")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn run_detection_emits_a_plan_end_to_end() {
|
||||
let mut backend = ScriptedProbe::new(
|
||||
&[
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
],
|
||||
EepromState::Absent,
|
||||
);
|
||||
let request = DetectionRequest {
|
||||
chain_ports: &[0, 1, 2],
|
||||
budget: ProbeBudget::default(),
|
||||
sensor: SensorTopology::Pic,
|
||||
fan_zones: vec![FanZone {
|
||||
fan: 0,
|
||||
zones: vec![0],
|
||||
}],
|
||||
};
|
||||
let plan = run_detection(&mut backend, &db(), &request).expect("plan");
|
||||
assert_eq!(plan.chains.len(), 3);
|
||||
assert_eq!(plan.psu, "APW12");
|
||||
assert!(!plan.operating_point.confirmed);
|
||||
assert_eq!(plan.operating_point.voltage_mv, 1200);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn run_detection_refuses_when_no_profile_matches() {
|
||||
let mut backend = ScriptedProbe::new(
|
||||
&[ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
}],
|
||||
EepromState::Absent,
|
||||
);
|
||||
let request = DetectionRequest {
|
||||
chain_ports: &[0],
|
||||
budget: ProbeBudget::default(),
|
||||
sensor: SensorTopology::Pic,
|
||||
fan_zones: Vec::new(),
|
||||
};
|
||||
assert_eq!(
|
||||
run_detection(&mut backend, &db(), &request),
|
||||
Err(DetectionFailure::NoProfile)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn run_detection_runs_degraded_with_a_dead_chain() {
|
||||
let mut backend = ScriptedProbe::new(
|
||||
&[
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
ProbeOutcome::Silent,
|
||||
ProbeOutcome::Silent,
|
||||
ProbeOutcome::Silent,
|
||||
ProbeOutcome::Silent,
|
||||
],
|
||||
EepromState::Absent,
|
||||
);
|
||||
let request = DetectionRequest {
|
||||
chain_ports: &[0, 1, 2],
|
||||
budget: ProbeBudget::default(),
|
||||
sensor: SensorTopology::Pic,
|
||||
fan_zones: Vec::new(),
|
||||
};
|
||||
let plan = run_detection(&mut backend, &db(), &request).expect("plan");
|
||||
assert_eq!(plan.degraded_chains(126), vec![2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn voltage_follows_frequency_and_clamps_outside_the_envelope() {
|
||||
let envelope = Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
};
|
||||
assert_eq!(envelope.voltage_for(200), 1100);
|
||||
assert_eq!(envelope.voltage_for(300), 1100);
|
||||
assert_eq!(envelope.voltage_for(500), 1300);
|
||||
assert_eq!(envelope.voltage_for(700), 1500);
|
||||
assert_eq!(envelope.voltage_for(900), 1500);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_single_frequency_envelope_reports_its_floor() {
|
||||
let envelope = Envelope {
|
||||
v_min_mv: 1200,
|
||||
v_max_mv: 1400,
|
||||
f_min_mhz: 500,
|
||||
f_max_mhz: 500,
|
||||
};
|
||||
assert_eq!(envelope.voltage_for(500), 1200);
|
||||
assert_eq!(envelope.voltage_for(600), 1400);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Exact Bitcoin Stratum share target conversion; no floating point or nonce search.
|
||||
|
||||
use serde_json::Number;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum DifficultyError {
|
||||
Invalid,
|
||||
OutOfRange,
|
||||
}
|
||||
|
||||
/// A positive decimal difficulty represented exactly as numerator/denominator.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct PoolDifficulty {
|
||||
numerator: u64,
|
||||
denominator: u64,
|
||||
}
|
||||
|
||||
impl PoolDifficulty {
|
||||
pub fn from_json_number(number: &Number) -> Result<Self, DifficultyError> {
|
||||
let text = number.as_str();
|
||||
if text.len() > 128 || text.starts_with('-') {
|
||||
return Err(DifficultyError::OutOfRange);
|
||||
}
|
||||
let (mantissa, exponent) = match text.split_once(['e', 'E']) {
|
||||
Some((base, exponent)) => (
|
||||
base,
|
||||
exponent
|
||||
.parse::<i32>()
|
||||
.map_err(|_| DifficultyError::OutOfRange)?,
|
||||
),
|
||||
None => (text, 0),
|
||||
};
|
||||
let mut digits = Vec::with_capacity(mantissa.len());
|
||||
let mut fractional = 0_i32;
|
||||
let mut after_dot = false;
|
||||
for byte in mantissa.bytes() {
|
||||
match byte {
|
||||
b'.' if !after_dot => after_dot = true,
|
||||
b'0'..=b'9' => {
|
||||
digits.push(byte - b'0');
|
||||
if after_dot {
|
||||
fractional += 1;
|
||||
}
|
||||
}
|
||||
_ => return Err(DifficultyError::Invalid),
|
||||
}
|
||||
}
|
||||
let first = digits
|
||||
.iter()
|
||||
.position(|digit| *digit != 0)
|
||||
.ok_or(DifficultyError::Invalid)?;
|
||||
let last = digits
|
||||
.iter()
|
||||
.rposition(|digit| *digit != 0)
|
||||
.expect("nonzero digit");
|
||||
let trailing = (digits.len() - last - 1) as i32;
|
||||
let mut numerator = 0_u64;
|
||||
for digit in &digits[first..=last] {
|
||||
numerator = numerator
|
||||
.checked_mul(10)
|
||||
.and_then(|value| value.checked_add(u64::from(*digit)))
|
||||
.ok_or(DifficultyError::OutOfRange)?;
|
||||
}
|
||||
let shift = exponent
|
||||
.checked_sub(fractional)
|
||||
.and_then(|value| value.checked_add(trailing))
|
||||
.ok_or(DifficultyError::OutOfRange)?;
|
||||
if !(-19..=19).contains(&shift) {
|
||||
return Err(DifficultyError::OutOfRange);
|
||||
}
|
||||
let mut denominator = 1_u64;
|
||||
if shift >= 0 {
|
||||
for _ in 0..shift {
|
||||
numerator = numerator
|
||||
.checked_mul(10)
|
||||
.ok_or(DifficultyError::OutOfRange)?;
|
||||
}
|
||||
} else {
|
||||
for _ in 0..-shift {
|
||||
denominator = denominator
|
||||
.checked_mul(10)
|
||||
.ok_or(DifficultyError::OutOfRange)?;
|
||||
}
|
||||
}
|
||||
Ok(Self {
|
||||
numerator,
|
||||
denominator,
|
||||
})
|
||||
}
|
||||
|
||||
/// floor((0xFFFF << 208) / difficulty), capped at the 256-bit maximum.
|
||||
/// The 320-bit intermediate permits all supported decimal denominators.
|
||||
pub fn target_le(self) -> [u8; 32] {
|
||||
let mut product = [0_u8; 40];
|
||||
let mut carry = 0_u128;
|
||||
for (index, byte) in product.iter_mut().enumerate() {
|
||||
let diff_one_byte = if index == 26 || index == 27 { 0xff } else { 0 };
|
||||
let value = (diff_one_byte as u128) * u128::from(self.denominator) + carry;
|
||||
*byte = value as u8;
|
||||
carry = value >> 8;
|
||||
}
|
||||
debug_assert_eq!(carry, 0);
|
||||
|
||||
let mut quotient = [0_u8; 40];
|
||||
let mut remainder = 0_u128;
|
||||
for index in (0..320).rev() {
|
||||
let bit = (product[index / 8] >> (index % 8)) & 1;
|
||||
remainder = (remainder << 1) | u128::from(bit);
|
||||
if remainder >= u128::from(self.numerator) {
|
||||
remainder -= u128::from(self.numerator);
|
||||
quotient[index / 8] |= 1 << (index % 8);
|
||||
}
|
||||
}
|
||||
if quotient[32..].iter().any(|byte| *byte != 0) {
|
||||
return [0xff; 32];
|
||||
}
|
||||
quotient[..32].try_into().expect("256-bit quotient")
|
||||
}
|
||||
}
|
||||
+469
@@ -0,0 +1,469 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Active fan-to-thermal-zone mapping.
|
||||
//!
|
||||
//! Antminer chassis wire fans to zones in a way that is not reported by the hardware: a fan may
|
||||
//! cool one hashboard heavily and another barely, and the front/back, top/bottom labels are
|
||||
//! physical. The mapping is learned by stepping one fan at a time and watching which zone's
|
||||
//! temperature responds, which is why this module takes measurements rather than configuration.
|
||||
|
||||
use crate::detect::FanZone;
|
||||
|
||||
/// One sensor reading taken while a fan was held at a given duty.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ZoneReading {
|
||||
pub zone: u8,
|
||||
pub temp_mc: i32,
|
||||
}
|
||||
|
||||
/// One measurement step: a fan duty and the temperatures observed during it.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct ProbeSample {
|
||||
pub fan: u8,
|
||||
pub pwm: u8,
|
||||
pub readings: Vec<ZoneReading>,
|
||||
}
|
||||
|
||||
/// Thresholds that decide when a response is real.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct MapThresholds {
|
||||
/// Minimum cooling (millidegrees) between the low and high duty to count as a response.
|
||||
pub min_drop_mc: i32,
|
||||
/// Minimum margin over the next-best fan, in parts per thousand of the best response.
|
||||
pub min_margin_per_mille: u16,
|
||||
}
|
||||
|
||||
impl Default for MapThresholds {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
min_drop_mc: 500,
|
||||
min_margin_per_mille: 250,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The learned mapping.
|
||||
#[derive(Clone, Debug, Default, Eq, PartialEq)]
|
||||
pub struct FanMap {
|
||||
pub assignments: Vec<FanZone>,
|
||||
/// Zones whose response was ambiguous and were therefore left unassigned.
|
||||
pub unresolved: Vec<u8>,
|
||||
/// Per assigned zone, the margin over the runner-up in parts per thousand.
|
||||
pub confidence_per_mille: Vec<u16>,
|
||||
}
|
||||
|
||||
impl FanMap {
|
||||
/// Zones a fan was confidently assigned to.
|
||||
pub fn zones_for(&self, fan: u8) -> Vec<u8> {
|
||||
self.assignments
|
||||
.iter()
|
||||
.find(|assignment| assignment.fan == fan)
|
||||
.map(|assignment| assignment.zones.clone())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
}
|
||||
|
||||
/// Response per (fan, zone): positive means the zone cooled when that fan sped up.
|
||||
fn responses(samples: &[ProbeSample], zones: &[u8]) -> Vec<(u8, Vec<(u8, i32)>)> {
|
||||
let mut fans: Vec<u8> = samples.iter().map(|sample| sample.fan).collect();
|
||||
fans.sort_unstable();
|
||||
fans.dedup();
|
||||
let mut out = Vec::new();
|
||||
for fan in fans {
|
||||
let fan_samples: Vec<&ProbeSample> =
|
||||
samples.iter().filter(|sample| sample.fan == fan).collect();
|
||||
let min_pwm = fan_samples.iter().map(|sample| sample.pwm).min();
|
||||
let max_pwm = fan_samples.iter().map(|sample| sample.pwm).max();
|
||||
let (Some(low), Some(high)) = (min_pwm, max_pwm) else {
|
||||
continue;
|
||||
};
|
||||
if low == high {
|
||||
continue;
|
||||
}
|
||||
let mut per_zone = Vec::with_capacity(zones.len());
|
||||
for &zone in zones {
|
||||
let mean_at = |pwm: u8| -> Option<i32> {
|
||||
let values: Vec<i32> = fan_samples
|
||||
.iter()
|
||||
.filter(|sample| sample.pwm == pwm)
|
||||
.flat_map(|sample| {
|
||||
sample
|
||||
.readings
|
||||
.iter()
|
||||
.filter(|reading| reading.zone == zone)
|
||||
.map(|reading| reading.temp_mc)
|
||||
})
|
||||
.collect();
|
||||
if values.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let sum: i64 = values.iter().map(|value| *value as i64).sum();
|
||||
Some((sum / values.len() as i64) as i32)
|
||||
};
|
||||
// Duty goes up, temperature should come down: response = warm-run minus fast-run.
|
||||
if let (Some(slow_temp), Some(fast_temp)) = (mean_at(low), mean_at(high)) {
|
||||
per_zone.push((zone, slow_temp - fast_temp));
|
||||
}
|
||||
}
|
||||
out.push((fan, per_zone));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Learn which fans cool which zones from a stepped measurement run.
|
||||
///
|
||||
/// Every zone goes to the fan with the strongest cooling response, provided that response clears
|
||||
/// `min_drop_mc` and beats the runner-up by `min_margin_per_mille`. Anything weaker stays
|
||||
/// unresolved instead of being guessed, so a noisy run cannot invent a fan map.
|
||||
pub fn map_fans(samples: &[ProbeSample], zones: &[u8], thresholds: MapThresholds) -> FanMap {
|
||||
let responses = responses(samples, zones);
|
||||
let mut map = FanMap::default();
|
||||
for &zone in zones {
|
||||
let mut ranked: Vec<(i32, u8)> = responses
|
||||
.iter()
|
||||
.filter_map(|(fan, per_zone)| {
|
||||
per_zone
|
||||
.iter()
|
||||
.find(|(candidate, _)| *candidate == zone)
|
||||
.map(|(_, drop)| (*drop, *fan))
|
||||
})
|
||||
.collect();
|
||||
ranked.sort_unstable_by_key(|entry| std::cmp::Reverse(entry.0));
|
||||
let Some(&(best_drop, best_fan)) = ranked.first() else {
|
||||
map.unresolved.push(zone);
|
||||
continue;
|
||||
};
|
||||
let runner_up = ranked.get(1).map(|(drop, _)| *drop).unwrap_or(0);
|
||||
let margin = best_drop - runner_up.max(0);
|
||||
let margin_per_mille = if best_drop > 0 {
|
||||
((margin as i64 * 1000) / best_drop as i64) as u16
|
||||
} else {
|
||||
0
|
||||
};
|
||||
if best_drop < thresholds.min_drop_mc || margin_per_mille < thresholds.min_margin_per_mille
|
||||
{
|
||||
map.unresolved.push(zone);
|
||||
continue;
|
||||
}
|
||||
match map
|
||||
.assignments
|
||||
.iter_mut()
|
||||
.find(|assignment| assignment.fan == best_fan)
|
||||
{
|
||||
Some(assignment) => assignment.zones.push(zone),
|
||||
None => map.assignments.push(FanZone {
|
||||
fan: best_fan,
|
||||
zones: vec![zone],
|
||||
}),
|
||||
}
|
||||
map.confidence_per_mille.push(margin_per_mille);
|
||||
}
|
||||
map
|
||||
}
|
||||
|
||||
/// Safe limits for a fan-mapping sweep.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct SweepConfig {
|
||||
pub fans: u8,
|
||||
pub zones: u8,
|
||||
/// Lowest duty used during probing. Never zero: the boards must keep airflow.
|
||||
pub low_pwm: u8,
|
||||
pub high_pwm: u8,
|
||||
/// Readings taken per (fan, duty) step; the mapper averages them.
|
||||
pub repeats: u8,
|
||||
/// Time to wait after a duty change before reading temperatures.
|
||||
pub settle_ms: u32,
|
||||
}
|
||||
|
||||
impl Default for SweepConfig {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
fans: 4,
|
||||
zones: 3,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 2,
|
||||
settle_ms: 20_000,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Minimum duty a sweep may use. Airflow is never removed to make a measurement.
|
||||
pub const MIN_PROBE_PWM: u8 = 20;
|
||||
|
||||
/// Why a sweep did not run.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum SweepError<E> {
|
||||
Backend(E),
|
||||
InvalidConfig(&'static str),
|
||||
}
|
||||
|
||||
/// The two backend actions a sweep needs.
|
||||
pub trait FanProbe {
|
||||
type Error;
|
||||
|
||||
fn set_fan(&mut self, fan: u8, pwm: u8) -> Result<(), Self::Error>;
|
||||
fn read_zone(&mut self, zone: u8) -> Result<i32, Self::Error>;
|
||||
}
|
||||
|
||||
/// Step every fan between the low and high duty and record what the zones do.
|
||||
///
|
||||
/// One fan is moved at a time while the others hold their previous duty, so the response belongs
|
||||
/// to that fan. The run ends with every fan back at `high_pwm`: leaving a fan low after probing
|
||||
/// would be a thermal hazard for whatever runs next.
|
||||
pub fn sweep<B: FanProbe, S: FnMut(u32)>(
|
||||
backend: &mut B,
|
||||
config: &SweepConfig,
|
||||
mut settle: S,
|
||||
) -> Result<Vec<ProbeSample>, SweepError<B::Error>> {
|
||||
if config.fans == 0 {
|
||||
return Err(SweepError::InvalidConfig("no fans to sweep"));
|
||||
}
|
||||
if config.zones == 0 {
|
||||
return Err(SweepError::InvalidConfig("no zones to read"));
|
||||
}
|
||||
if config.low_pwm < MIN_PROBE_PWM {
|
||||
return Err(SweepError::InvalidConfig(
|
||||
"probe duty below the safe minimum",
|
||||
));
|
||||
}
|
||||
if config.high_pwm > 100 {
|
||||
return Err(SweepError::InvalidConfig("probe duty above 100 percent"));
|
||||
}
|
||||
if config.low_pwm >= config.high_pwm {
|
||||
return Err(SweepError::InvalidConfig("probe duty range is empty"));
|
||||
}
|
||||
if config.repeats == 0 {
|
||||
return Err(SweepError::InvalidConfig("no readings requested"));
|
||||
}
|
||||
|
||||
let mut samples = Vec::new();
|
||||
for fan in 0..config.fans {
|
||||
for pwm in [config.low_pwm, config.high_pwm] {
|
||||
backend.set_fan(fan, pwm).map_err(SweepError::Backend)?;
|
||||
settle(config.settle_ms);
|
||||
for _ in 0..config.repeats {
|
||||
let mut readings = Vec::with_capacity(config.zones as usize);
|
||||
for zone in 0..config.zones {
|
||||
readings.push(ZoneReading {
|
||||
zone,
|
||||
temp_mc: backend.read_zone(zone).map_err(SweepError::Backend)?,
|
||||
});
|
||||
}
|
||||
samples.push(ProbeSample { fan, pwm, readings });
|
||||
}
|
||||
}
|
||||
}
|
||||
for fan in 0..config.fans {
|
||||
backend
|
||||
.set_fan(fan, config.high_pwm)
|
||||
.map_err(SweepError::Backend)?;
|
||||
}
|
||||
Ok(samples)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn sample(fan: u8, pwm: u8, zone_temps: &[(u8, i32)]) -> ProbeSample {
|
||||
ProbeSample {
|
||||
fan,
|
||||
pwm,
|
||||
readings: zone_temps
|
||||
.iter()
|
||||
.map(|(zone, temp)| ZoneReading {
|
||||
zone: *zone,
|
||||
temp_mc: *temp,
|
||||
})
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn each_zone_is_assigned_to_the_fan_that_cools_it() {
|
||||
let samples = vec![
|
||||
sample(0, 30, &[(0, 70_000), (1, 60_000)]),
|
||||
sample(0, 100, &[(0, 50_000), (1, 59_000)]),
|
||||
sample(1, 30, &[(0, 69_000), (1, 60_000)]),
|
||||
sample(1, 100, &[(0, 68_000), (1, 40_000)]),
|
||||
];
|
||||
let map = map_fans(&samples, &[0, 1], MapThresholds::default());
|
||||
assert_eq!(map.zones_for(0), vec![0]);
|
||||
assert_eq!(map.zones_for(1), vec![1]);
|
||||
assert!(map.unresolved.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ambiguity_leaves_a_zone_unresolved() {
|
||||
let samples = vec![
|
||||
sample(0, 30, &[(0, 70_000)]),
|
||||
sample(0, 100, &[(0, 60_000)]),
|
||||
sample(1, 30, &[(0, 70_500)]),
|
||||
sample(1, 100, &[(0, 60_500)]),
|
||||
];
|
||||
let map = map_fans(&samples, &[0], MapThresholds::default());
|
||||
assert!(map.assignments.is_empty());
|
||||
assert_eq!(map.unresolved, vec![0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_fan_that_does_not_change_temperature_is_not_assigned() {
|
||||
let samples = vec![
|
||||
sample(0, 30, &[(0, 60_000)]),
|
||||
sample(0, 100, &[(0, 59_900)]),
|
||||
];
|
||||
let map = map_fans(&samples, &[0], MapThresholds::default());
|
||||
assert!(map.assignments.is_empty());
|
||||
assert_eq!(map.unresolved, vec![0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_fan_without_duty_range_is_skipped() {
|
||||
let samples = vec![sample(0, 50, &[(0, 60_000)]), sample(0, 50, &[(0, 60_000)])];
|
||||
let map = map_fans(&samples, &[0], MapThresholds::default());
|
||||
assert!(map.assignments.is_empty());
|
||||
assert_eq!(map.unresolved, vec![0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_fan_can_own_several_zones() {
|
||||
let samples = vec![
|
||||
sample(0, 30, &[(0, 70_000), (1, 71_000), (2, 55_000)]),
|
||||
sample(0, 100, &[(0, 55_000), (1, 56_000), (2, 54_000)]),
|
||||
sample(1, 30, &[(0, 70_000), (1, 71_000), (2, 54_000)]),
|
||||
sample(1, 100, &[(0, 69_000), (1, 70_000), (2, 50_000)]),
|
||||
];
|
||||
let map = map_fans(&samples, &[0, 1, 2], MapThresholds::default());
|
||||
assert_eq!(map.zones_for(0), vec![0, 1]);
|
||||
assert_eq!(map.zones_for(1), vec![2]);
|
||||
}
|
||||
|
||||
struct ThermalMock {
|
||||
duty: Vec<u8>,
|
||||
owners: Vec<(u8, u8)>,
|
||||
fail: bool,
|
||||
}
|
||||
|
||||
impl ThermalMock {
|
||||
fn new(owners: &[(u8, u8)]) -> Self {
|
||||
let fans = owners.iter().map(|(fan, _)| *fan).max().unwrap_or(0) + 1;
|
||||
Self {
|
||||
duty: vec![100; fans as usize],
|
||||
owners: owners.to_vec(),
|
||||
fail: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FanProbe for ThermalMock {
|
||||
type Error = &'static str;
|
||||
|
||||
fn set_fan(&mut self, fan: u8, pwm: u8) -> Result<(), Self::Error> {
|
||||
if self.fail {
|
||||
return Err("fan bus down");
|
||||
}
|
||||
self.duty[fan as usize] = pwm;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_zone(&mut self, zone: u8) -> Result<i32, Self::Error> {
|
||||
if self.fail {
|
||||
return Err("sensor bus down");
|
||||
}
|
||||
let owner = self
|
||||
.owners
|
||||
.iter()
|
||||
.find(|(_, candidate)| *candidate == zone)
|
||||
.map(|(fan, _)| *fan)
|
||||
.expect("zone has an owner");
|
||||
let cooled = self.duty[owner as usize] >= 100;
|
||||
Ok(if cooled { 50_000 } else { 70_000 })
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sweep_then_map_resolves_each_zone() {
|
||||
let mut backend = ThermalMock::new(&[(0, 0), (1, 1)]);
|
||||
let config = SweepConfig {
|
||||
fans: 2,
|
||||
zones: 2,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 2,
|
||||
settle_ms: 0,
|
||||
};
|
||||
let samples = sweep(&mut backend, &config, |_| {}).expect("sweep");
|
||||
assert_eq!(samples.len(), 2 * 2 * 2);
|
||||
let map = map_fans(&samples, &[0, 1], MapThresholds::default());
|
||||
assert_eq!(map.zones_for(0), vec![0]);
|
||||
assert_eq!(map.zones_for(1), vec![1]);
|
||||
assert!(map.unresolved.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sweep_restores_every_fan_to_high_duty() {
|
||||
let mut backend = ThermalMock::new(&[(0, 0), (1, 1)]);
|
||||
let config = SweepConfig {
|
||||
fans: 2,
|
||||
zones: 2,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 1,
|
||||
settle_ms: 0,
|
||||
};
|
||||
sweep(&mut backend, &config, |_| {}).expect("sweep");
|
||||
assert_eq!(backend.duty, vec![100, 100]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sweep_refuses_an_unsafe_duty() {
|
||||
let mut backend = ThermalMock::new(&[(0, 0)]);
|
||||
let config = SweepConfig {
|
||||
fans: 1,
|
||||
zones: 1,
|
||||
low_pwm: 10,
|
||||
high_pwm: 100,
|
||||
repeats: 1,
|
||||
settle_ms: 0,
|
||||
};
|
||||
assert_eq!(
|
||||
sweep(&mut backend, &config, |_| {}),
|
||||
Err(SweepError::InvalidConfig(
|
||||
"probe duty below the safe minimum"
|
||||
))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sweep_refuses_an_empty_range_and_zero_reads() {
|
||||
let mut backend = ThermalMock::new(&[(0, 0)]);
|
||||
let flat = SweepConfig {
|
||||
fans: 1,
|
||||
zones: 1,
|
||||
low_pwm: 60,
|
||||
high_pwm: 60,
|
||||
repeats: 1,
|
||||
settle_ms: 0,
|
||||
};
|
||||
assert!(matches!(
|
||||
sweep(&mut backend, &flat, |_| {}),
|
||||
Err(SweepError::InvalidConfig(_))
|
||||
));
|
||||
let no_reads = SweepConfig { repeats: 0, ..flat };
|
||||
assert!(matches!(
|
||||
sweep(&mut backend, &no_reads, |_| {}),
|
||||
Err(SweepError::InvalidConfig(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sweep_propagates_backend_failures() {
|
||||
let mut backend = ThermalMock::new(&[(0, 0)]);
|
||||
backend.fail = true;
|
||||
let config = SweepConfig::default();
|
||||
assert_eq!(
|
||||
sweep(&mut backend, &config, |_| {}),
|
||||
Err(SweepError::Backend("fan bus down"))
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,318 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Persisting the learned fan map.
|
||||
//!
|
||||
//! Mapping fans means heating and cooling the machine deliberately, so it is done once, stored, and
|
||||
//! reused until the fan or sensor set changes. A stored map that does not match the current set is
|
||||
//! ignored rather than trusted: silently applying a map learned on four fans to a machine with two
|
||||
//! would mis-control thermals.
|
||||
|
||||
use crate::detect::FanZone;
|
||||
use crate::fanmap::{map_fans, sweep, FanMap, FanProbe, MapThresholds, SweepConfig, SweepError};
|
||||
use serde_json::{json, Value};
|
||||
use std::fs;
|
||||
use std::io;
|
||||
use std::path::Path;
|
||||
|
||||
/// A stored map together with the hardware it was learned on.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct StoredMap {
|
||||
pub fans: u8,
|
||||
pub zones: u8,
|
||||
pub assignments: Vec<FanZone>,
|
||||
pub unresolved: Vec<u8>,
|
||||
}
|
||||
|
||||
impl StoredMap {
|
||||
pub fn from_map(map: &FanMap, fans: u8, zones: u8) -> Self {
|
||||
Self {
|
||||
fans,
|
||||
zones,
|
||||
assignments: map.assignments.clone(),
|
||||
unresolved: map.unresolved.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn to_map(&self) -> FanMap {
|
||||
FanMap {
|
||||
assignments: self.assignments.clone(),
|
||||
unresolved: self.unresolved.clone(),
|
||||
confidence_per_mille: vec![0; self.assignments.len()],
|
||||
}
|
||||
}
|
||||
|
||||
/// True when this map was learned on the same fan and zone counts.
|
||||
pub fn matches(&self, fans: u8, zones: u8) -> bool {
|
||||
self.fans == fans && self.zones == zones
|
||||
}
|
||||
|
||||
pub fn to_json(&self) -> String {
|
||||
json!({
|
||||
"schema": 1,
|
||||
"fans": self.fans,
|
||||
"zones": self.zones,
|
||||
"assignments": self.assignments.iter().map(|zone| json!({
|
||||
"fan": zone.fan,
|
||||
"zones": zone.zones,
|
||||
})).collect::<Vec<_>>(),
|
||||
"unresolved": self.unresolved,
|
||||
})
|
||||
.to_string()
|
||||
}
|
||||
|
||||
pub fn from_json(text: &str) -> Option<Self> {
|
||||
let root: Value = serde_json::from_str(text).ok()?;
|
||||
if root.get("schema")?.as_u64()? != 1 {
|
||||
return None;
|
||||
}
|
||||
let fans = u8::try_from(root.get("fans")?.as_u64()?).ok()?;
|
||||
let zones = u8::try_from(root.get("zones")?.as_u64()?).ok()?;
|
||||
let assignments = root
|
||||
.get("assignments")?
|
||||
.as_array()?
|
||||
.iter()
|
||||
.map(|entry| {
|
||||
Some(FanZone {
|
||||
fan: u8::try_from(entry.get("fan")?.as_u64()?).ok()?,
|
||||
zones: entry
|
||||
.get("zones")?
|
||||
.as_array()?
|
||||
.iter()
|
||||
.map(|zone| u8::try_from(zone.as_u64()?).ok())
|
||||
.collect::<Option<Vec<u8>>>()?,
|
||||
})
|
||||
})
|
||||
.collect::<Option<Vec<FanZone>>>()?;
|
||||
let unresolved = root
|
||||
.get("unresolved")?
|
||||
.as_array()?
|
||||
.iter()
|
||||
.map(|zone| u8::try_from(zone.as_u64()?).ok())
|
||||
.collect::<Option<Vec<u8>>>()?;
|
||||
Some(Self {
|
||||
fans,
|
||||
zones,
|
||||
assignments,
|
||||
unresolved,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Why mapping did not produce a stored map.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum StoreError<E> {
|
||||
Sweep(SweepError<E>),
|
||||
Io(&'static str),
|
||||
}
|
||||
|
||||
/// Read a stored map, if one exists and parses.
|
||||
pub fn load(path: &Path) -> Option<StoredMap> {
|
||||
let text = fs::read_to_string(path).ok()?;
|
||||
StoredMap::from_json(&text)
|
||||
}
|
||||
|
||||
/// Write a map, creating the parent directory when needed.
|
||||
pub fn save(path: &Path, stored: &StoredMap) -> io::Result<()> {
|
||||
if let Some(parent) = path.parent() {
|
||||
if !parent.as_os_str().is_empty() {
|
||||
fs::create_dir_all(parent)?;
|
||||
}
|
||||
}
|
||||
fs::write(path, stored.to_json())
|
||||
}
|
||||
|
||||
/// Return the stored map when it matches this machine, otherwise sweep, map, and store the result.
|
||||
pub fn ensure_map<B: FanProbe, S: FnMut(u32)>(
|
||||
backend: &mut B,
|
||||
config: &SweepConfig,
|
||||
thresholds: MapThresholds,
|
||||
path: &Path,
|
||||
settle: S,
|
||||
) -> Result<FanMap, StoreError<B::Error>> {
|
||||
if let Some(stored) = load(path) {
|
||||
if stored.matches(config.fans, config.zones) {
|
||||
return Ok(stored.to_map());
|
||||
}
|
||||
}
|
||||
let zones: Vec<u8> = (0..config.zones).collect();
|
||||
let samples = sweep(backend, config, settle).map_err(StoreError::Sweep)?;
|
||||
let map = map_fans(&samples, &zones, thresholds);
|
||||
let stored = StoredMap::from_map(&map, config.fans, config.zones);
|
||||
save(path, &stored).map_err(|_| StoreError::Io("cannot write the fan map"))?;
|
||||
Ok(map)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::fanmap::{ProbeSample, ZoneReading};
|
||||
|
||||
struct CountingBackend {
|
||||
duty: Vec<u8>,
|
||||
owners: Vec<(u8, u8)>,
|
||||
calls: usize,
|
||||
}
|
||||
|
||||
impl FanProbe for CountingBackend {
|
||||
type Error = ();
|
||||
|
||||
fn set_fan(&mut self, fan: u8, pwm: u8) -> Result<(), ()> {
|
||||
self.calls += 1;
|
||||
self.duty[fan as usize] = pwm;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_zone(&mut self, zone: u8) -> Result<i32, ()> {
|
||||
// Zones without an explicit owner follow fan 0, which keeps the mock usable when a
|
||||
// test asks for more zones than the fixture declares.
|
||||
let owner = self
|
||||
.owners
|
||||
.iter()
|
||||
.find(|(_, candidate)| *candidate == zone)
|
||||
.map(|(fan, _)| *fan)
|
||||
.unwrap_or(0);
|
||||
Ok(if self.duty[owner as usize] >= 100 {
|
||||
50_000
|
||||
} else {
|
||||
70_000
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn backend() -> CountingBackend {
|
||||
CountingBackend {
|
||||
duty: vec![100, 100],
|
||||
owners: vec![(0, 0), (1, 1)],
|
||||
calls: 0,
|
||||
}
|
||||
}
|
||||
|
||||
fn config(zones: u8) -> SweepConfig {
|
||||
SweepConfig {
|
||||
fans: 2,
|
||||
zones,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 1,
|
||||
settle_ms: 0,
|
||||
}
|
||||
}
|
||||
|
||||
fn path(name: &str) -> std::path::PathBuf {
|
||||
let mut dir = std::env::temp_dir();
|
||||
dir.push(format!("alkane-fanmap-{}-{name}.json", std::process::id()));
|
||||
dir
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_stored_map_round_trips() {
|
||||
let map = FanMap {
|
||||
assignments: vec![FanZone {
|
||||
fan: 0,
|
||||
zones: vec![0, 1],
|
||||
}],
|
||||
unresolved: vec![2],
|
||||
confidence_per_mille: vec![900],
|
||||
};
|
||||
let stored = StoredMap::from_map(&map, 4, 3);
|
||||
let text = stored.to_json();
|
||||
assert_eq!(StoredMap::from_json(&text).expect("parse"), stored);
|
||||
let back = stored.to_map();
|
||||
assert_eq!(back.assignments, map.assignments);
|
||||
assert_eq!(back.unresolved, map.unresolved);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn corrupt_or_foreign_json_is_ignored() {
|
||||
assert!(StoredMap::from_json("not json").is_none());
|
||||
assert!(StoredMap::from_json(r#"{"schema":2}"#).is_none());
|
||||
assert!(StoredMap::from_json(r#"{"schema":1,"fans":2}"#).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_matching_map_is_reused_without_sweeping() {
|
||||
let file = path("reuse");
|
||||
let first = ensure_map(
|
||||
&mut backend(),
|
||||
&config(2),
|
||||
MapThresholds::default(),
|
||||
&file,
|
||||
|_| {},
|
||||
)
|
||||
.expect("first");
|
||||
assert_eq!(first.zones_for(0), vec![0]);
|
||||
let mut reuse = backend();
|
||||
let second = ensure_map(
|
||||
&mut reuse,
|
||||
&config(2),
|
||||
MapThresholds::default(),
|
||||
&file,
|
||||
|_| {},
|
||||
)
|
||||
.expect("second");
|
||||
assert_eq!(second.zones_for(0), vec![0]);
|
||||
assert_eq!(reuse.calls, 0, "a stored map must not cause another sweep");
|
||||
let _ = std::fs::remove_file(&file);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_changed_sensor_set_forces_a_new_sweep() {
|
||||
let file = path("changed");
|
||||
ensure_map(
|
||||
&mut backend(),
|
||||
&config(2),
|
||||
MapThresholds::default(),
|
||||
&file,
|
||||
|_| {},
|
||||
)
|
||||
.expect("first");
|
||||
let mut fresh = backend();
|
||||
let map = ensure_map(
|
||||
&mut fresh,
|
||||
&config(2),
|
||||
MapThresholds::default(),
|
||||
&file,
|
||||
|_| {},
|
||||
)
|
||||
.expect("second");
|
||||
assert_eq!(map.zones_for(1), vec![1]);
|
||||
// The stored file describes two zones; asking for three must not reuse it.
|
||||
let mut three = CountingBackend {
|
||||
duty: vec![100, 100],
|
||||
owners: vec![(0, 0), (1, 1)],
|
||||
calls: 0,
|
||||
};
|
||||
let _ = ensure_map(
|
||||
&mut three,
|
||||
&config(3),
|
||||
MapThresholds::default(),
|
||||
&file,
|
||||
|_| {},
|
||||
);
|
||||
assert!(three.calls > 0);
|
||||
let _ = std::fs::remove_file(&file);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn samples_from_a_sweep_still_map_correctly() {
|
||||
let samples = vec![
|
||||
ProbeSample {
|
||||
fan: 0,
|
||||
pwm: 40,
|
||||
readings: vec![ZoneReading {
|
||||
zone: 0,
|
||||
temp_mc: 70_000,
|
||||
}],
|
||||
},
|
||||
ProbeSample {
|
||||
fan: 0,
|
||||
pwm: 100,
|
||||
readings: vec![ZoneReading {
|
||||
zone: 0,
|
||||
temp_mc: 50_000,
|
||||
}],
|
||||
},
|
||||
];
|
||||
let map = map_fans(&samples, &[0], MapThresholds::default());
|
||||
assert_eq!(map.zones_for(0), vec![0]);
|
||||
}
|
||||
}
|
||||
+332
@@ -0,0 +1,332 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Fault-tolerance supervisor.
|
||||
//!
|
||||
//! The goal is to keep hashing with as many dead chips or chains as possible. Faults therefore
|
||||
//! escalate in steps (retry, disable chip, disable chain) and only irreversible conditions stop the
|
||||
//! machine. This module owns that ladder; it does not talk to hardware and it does not choose
|
||||
//! thermal limits, which come from the profile envelope.
|
||||
|
||||
/// A single health observation from the mining loop.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum FaultEvent {
|
||||
/// A chain accepted work and reported nonces for it.
|
||||
NoncesReported { chain: u8, per_mille: u16 },
|
||||
/// A chain returned an error for a frame, reset or work dispatch.
|
||||
ChainError { chain: u8 },
|
||||
/// A chain produced nothing for a full observation window.
|
||||
ChainSilent { chain: u8 },
|
||||
/// One chip on a chain failed its identification or stopped responding.
|
||||
ChipFault { chain: u8, chip: u16 },
|
||||
/// A temperature reading left the profile envelope.
|
||||
TemperatureFault { zone: u8 },
|
||||
}
|
||||
|
||||
/// What the caller should do next.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum FaultAction {
|
||||
/// Keep hashing; nothing changed.
|
||||
None,
|
||||
/// Retry the chain before treating the fault as permanent.
|
||||
Retry { chain: u8 },
|
||||
/// Keep the machine running without this chain.
|
||||
DisableChain { chain: u8 },
|
||||
/// Keep the machine running without this chip.
|
||||
DisableChip { chain: u8, chip: u16 },
|
||||
/// Stop hashing entirely; the reason is carried for the API.
|
||||
Stop { reason: StopReason },
|
||||
}
|
||||
|
||||
/// Why the machine stopped.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum StopReason {
|
||||
Temperature,
|
||||
NoChainsLeft,
|
||||
}
|
||||
|
||||
/// Thresholds for escalation.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct FaultPolicy {
|
||||
/// Consecutive errors tolerated before the chain is disabled (retries included).
|
||||
pub retries: u8,
|
||||
/// Nonce-response ratio below which a chain is considered stalled.
|
||||
pub min_response_per_mille: u16,
|
||||
/// Consecutive weak windows before a stalled chain is disabled.
|
||||
pub weak_windows: u8,
|
||||
}
|
||||
|
||||
impl Default for FaultPolicy {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
retries: 2,
|
||||
min_response_per_mille: 100,
|
||||
weak_windows: 3,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
|
||||
struct ChainHealth {
|
||||
chain: u8,
|
||||
errors: u8,
|
||||
weak: u8,
|
||||
disabled: bool,
|
||||
}
|
||||
|
||||
/// Escalation state for one machine.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct FaultSupervisor {
|
||||
policy: FaultPolicy,
|
||||
chains: Vec<ChainHealth>,
|
||||
stopped: Option<StopReason>,
|
||||
}
|
||||
|
||||
impl FaultSupervisor {
|
||||
pub fn new(chains: &[u8], policy: FaultPolicy) -> Self {
|
||||
Self {
|
||||
policy,
|
||||
chains: chains
|
||||
.iter()
|
||||
.map(|&chain| ChainHealth {
|
||||
chain,
|
||||
..ChainHealth::default()
|
||||
})
|
||||
.collect(),
|
||||
stopped: None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_stopped(&self) -> bool {
|
||||
self.stopped.is_some()
|
||||
}
|
||||
|
||||
pub fn stop_reason(&self) -> Option<StopReason> {
|
||||
self.stopped
|
||||
}
|
||||
|
||||
/// Chains the miner may still dispatch work to.
|
||||
pub fn active_chains(&self) -> Vec<u8> {
|
||||
self.chains
|
||||
.iter()
|
||||
.filter(|health| !health.disabled)
|
||||
.map(|health| health.chain)
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Apply one observation and return the escalation step it implies.
|
||||
pub fn observe(&mut self, event: FaultEvent) -> FaultAction {
|
||||
if self.stopped.is_some() {
|
||||
return FaultAction::None;
|
||||
}
|
||||
match event {
|
||||
FaultEvent::NoncesReported { chain, per_mille } => {
|
||||
let min_response = self.policy.min_response_per_mille;
|
||||
let weak_windows = self.policy.weak_windows;
|
||||
let Some(health) = self.health_mut(chain) else {
|
||||
return FaultAction::None;
|
||||
};
|
||||
health.errors = 0;
|
||||
if per_mille >= min_response {
|
||||
health.weak = 0;
|
||||
return FaultAction::None;
|
||||
}
|
||||
health.weak = health.weak.saturating_add(1);
|
||||
if health.weak >= weak_windows {
|
||||
health.disabled = true;
|
||||
self.maybe_stop(chain)
|
||||
} else {
|
||||
FaultAction::None
|
||||
}
|
||||
}
|
||||
FaultEvent::ChainError { chain } | FaultEvent::ChainSilent { chain } => {
|
||||
let policy = self.policy;
|
||||
let Some(health) = self.health_mut(chain) else {
|
||||
return FaultAction::None;
|
||||
};
|
||||
if health.disabled {
|
||||
return FaultAction::None;
|
||||
}
|
||||
health.errors = health.errors.saturating_add(1);
|
||||
if health.errors > policy.retries {
|
||||
health.disabled = true;
|
||||
self.maybe_stop(chain)
|
||||
} else {
|
||||
FaultAction::Retry { chain }
|
||||
}
|
||||
}
|
||||
FaultEvent::ChipFault { chain, chip } => FaultAction::DisableChip { chain, chip },
|
||||
FaultEvent::TemperatureFault { .. } => {
|
||||
self.stopped = Some(StopReason::Temperature);
|
||||
FaultAction::Stop {
|
||||
reason: StopReason::Temperature,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn health_mut(&mut self, chain: u8) -> Option<&mut ChainHealth> {
|
||||
self.chains.iter_mut().find(|health| health.chain == chain)
|
||||
}
|
||||
|
||||
fn maybe_stop(&mut self, chain: u8) -> FaultAction {
|
||||
if self.chains.iter().all(|health| health.disabled) {
|
||||
self.stopped = Some(StopReason::NoChainsLeft);
|
||||
return FaultAction::Stop {
|
||||
reason: StopReason::NoChainsLeft,
|
||||
};
|
||||
}
|
||||
FaultAction::DisableChain { chain }
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn supervisor() -> FaultSupervisor {
|
||||
FaultSupervisor::new(&[0, 1, 2], FaultPolicy::default())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transient_errors_retry_then_disable_the_chain() {
|
||||
let mut faults = supervisor();
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainError { chain: 1 }),
|
||||
FaultAction::Retry { chain: 1 }
|
||||
);
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainError { chain: 1 }),
|
||||
FaultAction::Retry { chain: 1 }
|
||||
);
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainSilent { chain: 1 }),
|
||||
FaultAction::DisableChain { chain: 1 }
|
||||
);
|
||||
assert_eq!(faults.active_chains(), vec![0, 2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn healthy_nonces_reset_the_error_count() {
|
||||
let mut faults = supervisor();
|
||||
faults.observe(FaultEvent::ChainError { chain: 0 });
|
||||
faults.observe(FaultEvent::ChainError { chain: 0 });
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 900
|
||||
}),
|
||||
FaultAction::None
|
||||
);
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainError { chain: 0 }),
|
||||
FaultAction::Retry { chain: 0 }
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_stalled_chain_is_disabled_after_repeated_weak_windows() {
|
||||
let mut faults = supervisor();
|
||||
for _ in 0..2 {
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 2,
|
||||
per_mille: 10
|
||||
}),
|
||||
FaultAction::None
|
||||
);
|
||||
}
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 2,
|
||||
per_mille: 10
|
||||
}),
|
||||
FaultAction::DisableChain { chain: 2 }
|
||||
);
|
||||
assert_eq!(faults.active_chains(), vec![0, 1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_good_window_clears_weak_history() {
|
||||
let mut faults = supervisor();
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 10,
|
||||
});
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 10,
|
||||
});
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 900,
|
||||
});
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 10,
|
||||
});
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 10,
|
||||
});
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 10
|
||||
}),
|
||||
FaultAction::DisableChain { chain: 0 }
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_chip_fault_disables_only_that_chip() {
|
||||
let mut faults = supervisor();
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChipFault { chain: 1, chip: 42 }),
|
||||
FaultAction::DisableChip { chain: 1, chip: 42 }
|
||||
);
|
||||
assert_eq!(faults.active_chains(), vec![0, 1, 2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn temperature_fault_stops_the_machine() {
|
||||
let mut faults = supervisor();
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::TemperatureFault { zone: 2 }),
|
||||
FaultAction::Stop {
|
||||
reason: StopReason::Temperature
|
||||
}
|
||||
);
|
||||
assert!(faults.is_stopped());
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainError { chain: 0 }),
|
||||
FaultAction::None
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn losing_every_chain_stops_instead_of_hanging() {
|
||||
let mut faults = FaultSupervisor::new(
|
||||
&[0],
|
||||
FaultPolicy {
|
||||
retries: 0,
|
||||
..FaultPolicy::default()
|
||||
},
|
||||
);
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainError { chain: 0 }),
|
||||
FaultAction::Stop {
|
||||
reason: StopReason::NoChainsLeft
|
||||
}
|
||||
);
|
||||
assert_eq!(faults.active_chains(), Vec::<u8>::new());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_chains_are_ignored() {
|
||||
let mut faults = supervisor();
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainError { chain: 9 }),
|
||||
FaultAction::None
|
||||
);
|
||||
assert_eq!(faults.active_chains(), vec![0, 1, 2]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! HAL conformance checks.
|
||||
//!
|
||||
//! A family backend is only useful if it answers the contract the OS expects. This module walks the
|
||||
//! contract in order and reports each check separately, so a backend author sees exactly which
|
||||
//! opcode is missing or wrong instead of a single opaque failure.
|
||||
//!
|
||||
//! Every check uses a fresh connection: a backend that desynchronises one exchange must not make
|
||||
//! the following checks meaningless.
|
||||
|
||||
use crate::hal_wire::{HalClient, CAP_CHAIN_PROBE, CAP_FREQUENCY, CAP_POWER, CAP_PSU_IDENTITY};
|
||||
use crate::HardwareBackend;
|
||||
use std::path::Path;
|
||||
|
||||
/// One check and its outcome.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct Check {
|
||||
pub name: &'static str,
|
||||
pub passed: bool,
|
||||
pub detail: String,
|
||||
}
|
||||
|
||||
impl Check {
|
||||
fn pass(name: &'static str, detail: impl Into<String>) -> Self {
|
||||
Self {
|
||||
name,
|
||||
passed: true,
|
||||
detail: detail.into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn fail(name: &'static str, detail: impl Into<String>) -> Self {
|
||||
Self {
|
||||
name,
|
||||
passed: false,
|
||||
detail: detail.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Run the contract checks against a backend socket.
|
||||
pub fn run(socket: &Path) -> Vec<Check> {
|
||||
vec![
|
||||
check_capabilities(socket),
|
||||
check_probe(socket),
|
||||
check_eeprom(socket),
|
||||
check_psu(socket),
|
||||
check_frequency_and_temperature(socket),
|
||||
check_power(socket),
|
||||
check_fan(socket),
|
||||
]
|
||||
}
|
||||
|
||||
fn connect(socket: &Path) -> Result<HalClient, String> {
|
||||
HalClient::connect(socket).map_err(|error| format!("{error:?}"))
|
||||
}
|
||||
|
||||
fn check_capabilities(socket: &Path) -> Check {
|
||||
const NAME: &str = "capabilities";
|
||||
match connect(socket)
|
||||
.and_then(|mut client| client.capabilities().map_err(|error| format!("{error:?}")))
|
||||
{
|
||||
Ok(mask) if mask & CAP_CHAIN_PROBE == 0 => {
|
||||
Check::fail(NAME, format!("mask {mask:#x} lacks chain probing"))
|
||||
}
|
||||
Ok(mask) => Check::pass(NAME, format!("mask {mask:#x}")),
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_probe(socket: &Path) -> Check {
|
||||
const NAME: &str = "probe chain 0";
|
||||
match connect(socket) {
|
||||
Ok(mut client) => match client.probe_chain(0, 0) {
|
||||
Ok(outcome) => Check::pass(NAME, format!("{outcome:?}")),
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
},
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_eeprom(socket: &Path) -> Check {
|
||||
const NAME: &str = "read EEPROM chain 0";
|
||||
match connect(socket) {
|
||||
Ok(mut client) => match client.read_eeprom(0) {
|
||||
Ok(state) => Check::pass(NAME, format!("{state:?}")),
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
},
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_psu(socket: &Path) -> Check {
|
||||
const NAME: &str = "identify PSU";
|
||||
match connect(socket) {
|
||||
Ok(mut client) => match client.capabilities() {
|
||||
Ok(mask) if mask & CAP_PSU_IDENTITY == 0 => {
|
||||
Check::fail(NAME, "backend does not advertise PSU identity")
|
||||
}
|
||||
Ok(_) => match client.identify_psu() {
|
||||
Ok(psu) if psu.envelope.v_min_mv <= psu.envelope.v_max_mv => {
|
||||
Check::pass(NAME, format!("{} {} mV", psu.name, psu.envelope.v_max_mv))
|
||||
}
|
||||
Ok(psu) => Check::fail(NAME, format!("inverted envelope from {}", psu.name)),
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
},
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
},
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_frequency_and_temperature(socket: &Path) -> Check {
|
||||
const NAME: &str = "frequency and temperature";
|
||||
match connect(socket) {
|
||||
Ok(mut client) => {
|
||||
let caps = match client.capabilities() {
|
||||
Ok(mask) => mask,
|
||||
Err(error) => return Check::fail(NAME, format!("{error:?}")),
|
||||
};
|
||||
if caps & CAP_FREQUENCY == 0 {
|
||||
return Check::fail(NAME, "backend does not advertise frequency control");
|
||||
}
|
||||
if let Err(error) = client.set_chain_frequency(0, 500) {
|
||||
return Check::fail(NAME, format!("set frequency: {error:?}"));
|
||||
}
|
||||
match client.read_temperature_mc(0) {
|
||||
Ok(value) if (-40_000..=150_000).contains(&value) => {
|
||||
Check::pass(NAME, format!("500 MHz, {} mC", value))
|
||||
}
|
||||
Ok(value) => Check::fail(NAME, format!("implausible temperature {value} mC")),
|
||||
Err(error) => Check::fail(NAME, format!("read temperature: {error:?}")),
|
||||
}
|
||||
}
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_power(socket: &Path) -> Check {
|
||||
const NAME: &str = "read power";
|
||||
match connect(socket) {
|
||||
Ok(mut client) => match client.capabilities() {
|
||||
Ok(mask) if mask & CAP_POWER == 0 => {
|
||||
Check::fail(NAME, "backend does not advertise power telemetry")
|
||||
}
|
||||
Ok(_) => {
|
||||
// Ask for a known operating point first: a backend that always reports 0 W would
|
||||
// otherwise pass a range check while being useless to a power-target loop.
|
||||
if let Err(error) = client.set_chain_frequency(0, 500) {
|
||||
return Check::fail(NAME, format!("set frequency: {error:?}"));
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
match client.read_power_w() {
|
||||
Ok(0) => Check::fail(NAME, "reports 0 W at 500 MHz"),
|
||||
Ok(watts) if watts <= 10_000 => {
|
||||
Check::pass(NAME, format!("{watts} W at 500 MHz"))
|
||||
}
|
||||
Ok(watts) => Check::fail(NAME, format!("implausible power {watts} W")),
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
}
|
||||
}
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
},
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_fan(socket: &Path) -> Check {
|
||||
const NAME: &str = "fan target";
|
||||
match connect(socket) {
|
||||
Ok(mut client) => match client.set_fan_target(0, 100) {
|
||||
Ok(()) => Check::pass(NAME, "100 percent accepted"),
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
},
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::hal_sim::{serve, SimConfig};
|
||||
|
||||
fn socket(name: &str) -> std::path::PathBuf {
|
||||
std::env::temp_dir().join(format!("alkane-conf-{}-{name}.sock", std::process::id()))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_reference_server_passes_every_check() {
|
||||
let path = socket("ok");
|
||||
let server_path = path.clone();
|
||||
let server = std::thread::spawn(move || {
|
||||
let _ = serve(&server_path, SimConfig::default());
|
||||
});
|
||||
// The reference server binds inside serve(); wait for the socket to exist.
|
||||
for _ in 0..100 {
|
||||
if path.exists() {
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(10));
|
||||
}
|
||||
let checks = run(&path);
|
||||
let failed: Vec<&Check> = checks.iter().filter(|check| !check.passed).collect();
|
||||
assert!(failed.is_empty(), "reference server failed: {failed:?}");
|
||||
assert_eq!(checks.len(), 7);
|
||||
let _ = std::fs::remove_file(&path);
|
||||
// The server thread is left to exit when the socket disappears.
|
||||
drop(server);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unreachable_socket_fails_every_check() {
|
||||
let path = socket("missing");
|
||||
let checks = run(&path);
|
||||
assert_eq!(checks.len(), 7);
|
||||
assert!(checks.iter().all(|check| !check.passed));
|
||||
}
|
||||
}
|
||||
+255
@@ -0,0 +1,255 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Reference HAL server.
|
||||
//!
|
||||
//! Speaks the same ALKH contract a family backend serves on a real board, but answers from a fixed
|
||||
//! description of a machine. Two uses: it lets the whole OS path run on any development machine, and
|
||||
//! it shows a backend author exactly what each opcode must return.
|
||||
|
||||
use std::io::{self, Read, Write};
|
||||
use std::os::unix::net::{UnixListener, UnixStream};
|
||||
use std::path::Path;
|
||||
|
||||
const MAGIC: [u8; 4] = *b"ALKH";
|
||||
const VERSION: u8 = 1;
|
||||
const RESPONSE: u16 = 1;
|
||||
const HEADER_LEN: usize = 16;
|
||||
|
||||
const SEND_FRAME: u8 = 1;
|
||||
const RECEIVE_FRAME: u8 = 2;
|
||||
const SET_CHAIN_RESET: u8 = 3;
|
||||
const SET_FAN_TARGET: u8 = 4;
|
||||
const READ_TEMPERATURE: u8 = 5;
|
||||
const SET_PSU_ENABLED: u8 = 6;
|
||||
const CAPABILITIES: u8 = 7;
|
||||
const PROBE_CHAIN: u8 = 8;
|
||||
const READ_EEPROM: u8 = 9;
|
||||
const IDENTIFY_PSU: u8 = 10;
|
||||
const SET_CHAIN_FREQUENCY: u8 = 11;
|
||||
const READ_POWER: u8 = 12;
|
||||
|
||||
const CAP_ALL: u32 = (1 << 5) - 1;
|
||||
|
||||
/// What the simulated machine looks like.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SimConfig {
|
||||
/// Chains that identify. Chains beyond this answer silent.
|
||||
pub chains: u8,
|
||||
/// Chips reported per chain.
|
||||
pub chips: u16,
|
||||
/// Chip identifier on the wire (1 = bm1362).
|
||||
pub chip: u8,
|
||||
/// Report a working EEPROM instead of an absent one.
|
||||
pub eeprom: bool,
|
||||
/// PSU name and envelope, or `None` to fail identification.
|
||||
pub psu: Option<(String, u16, u16, u16, u16, u16)>,
|
||||
/// Fans on the simulated chassis; zones are distributed over them.
|
||||
pub fans: u8,
|
||||
}
|
||||
|
||||
impl Default for SimConfig {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
chains: 3,
|
||||
chips: 126,
|
||||
chip: 1,
|
||||
eeprom: false,
|
||||
psu: Some(("APW12".into(), 1200, 1600, 0, 1000, 3600)),
|
||||
fans: 2,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct State {
|
||||
config: SimConfig,
|
||||
frequency_mhz: u16,
|
||||
/// Duty per fan, so a zone can respond to the fan that actually cools it.
|
||||
fan_pwm: [u8; 4],
|
||||
}
|
||||
|
||||
impl State {
|
||||
/// Which fan cools a zone. Zones are distributed over the fans round-robin.
|
||||
fn owner(&self, zone: u8) -> usize {
|
||||
let fans = usize::from(self.config.fans.max(1));
|
||||
usize::from(zone) % fans
|
||||
}
|
||||
}
|
||||
|
||||
/// Serve one socket path until the program exits.
|
||||
pub fn serve(path: &Path, config: SimConfig) -> io::Result<()> {
|
||||
let _ = std::fs::remove_file(path);
|
||||
let listener = UnixListener::bind(path)?;
|
||||
for stream in listener.incoming() {
|
||||
let Ok(stream) = stream else { continue };
|
||||
let mut state = State {
|
||||
config: config.clone(),
|
||||
frequency_mhz: 0,
|
||||
fan_pwm: [100; 4],
|
||||
};
|
||||
let _ = serve_connection(stream, &mut state);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn serve_connection(mut stream: UnixStream, state: &mut State) -> io::Result<()> {
|
||||
loop {
|
||||
let mut header = [0_u8; HEADER_LEN];
|
||||
if stream.read_exact(&mut header).is_err() {
|
||||
return Ok(());
|
||||
}
|
||||
if header[..4] != MAGIC {
|
||||
return Err(io::Error::new(io::ErrorKind::InvalidData, "bad HAL magic"));
|
||||
}
|
||||
let opcode = header[5];
|
||||
let sequence = header[8..12].to_vec();
|
||||
let length = u32::from_le_bytes([header[12], header[13], header[14], header[15]]) as usize;
|
||||
let mut payload = vec![0_u8; length];
|
||||
if length > 0 && stream.read_exact(&mut payload).is_err() {
|
||||
return Ok(());
|
||||
}
|
||||
let body = respond(opcode, &payload, state);
|
||||
let mut out = [0_u8; HEADER_LEN];
|
||||
out[..4].copy_from_slice(&MAGIC);
|
||||
out[4] = VERSION;
|
||||
out[5] = opcode;
|
||||
out[6..8].copy_from_slice(&RESPONSE.to_le_bytes());
|
||||
out[8..12].copy_from_slice(&sequence);
|
||||
out[12..16].copy_from_slice(&(body.len() as u32).to_le_bytes());
|
||||
stream.write_all(&out)?;
|
||||
stream.write_all(&body)?;
|
||||
stream.flush()?;
|
||||
}
|
||||
}
|
||||
|
||||
fn respond(opcode: u8, payload: &[u8], state: &mut State) -> Vec<u8> {
|
||||
match opcode {
|
||||
CAPABILITIES => {
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&CAP_ALL.to_le_bytes());
|
||||
body
|
||||
}
|
||||
PROBE_CHAIN => {
|
||||
let chain = payload.first().copied().unwrap_or(0);
|
||||
if chain >= state.config.chains {
|
||||
return vec![0, 1, 0, 0, 0]; // silent
|
||||
}
|
||||
let chips = state.config.chips.to_le_bytes();
|
||||
vec![0, 0, state.config.chip, chips[0], chips[1]]
|
||||
}
|
||||
READ_EEPROM => {
|
||||
if state.config.eeprom {
|
||||
let mut body = vec![0_u8, 0];
|
||||
body.extend_from_slice(b"BHB42601");
|
||||
body
|
||||
} else {
|
||||
vec![0, 1]
|
||||
}
|
||||
}
|
||||
IDENTIFY_PSU => match &state.config.psu {
|
||||
Some((name, v_min, v_max, f_min, f_max, watts)) => {
|
||||
let mut body = vec![0_u8, name.len() as u8];
|
||||
body.extend_from_slice(name.as_bytes());
|
||||
for word in [*v_min, *v_max, *f_min, *f_max, *watts] {
|
||||
body.extend_from_slice(&word.to_le_bytes());
|
||||
}
|
||||
body
|
||||
}
|
||||
None => vec![1],
|
||||
},
|
||||
SET_CHAIN_FREQUENCY => {
|
||||
if let Some(mhz) = payload.get(1..3) {
|
||||
state.frequency_mhz = u16::from_le_bytes([mhz[0], mhz[1]]);
|
||||
}
|
||||
vec![0]
|
||||
}
|
||||
SET_FAN_TARGET => {
|
||||
let fan = usize::from(payload.first().copied().unwrap_or(0)).min(3);
|
||||
state.fan_pwm[fan] = payload.get(1).copied().unwrap_or(0);
|
||||
vec![0]
|
||||
}
|
||||
READ_TEMPERATURE => {
|
||||
// Temperature rises with frequency so the tuner has something to regulate, and falls
|
||||
// when the fan that owns the zone is fast so the fan sweep can learn the mapping.
|
||||
let zone = payload.first().copied().unwrap_or(0);
|
||||
let rise = i32::from(state.frequency_mhz) * 20;
|
||||
let airflow = if state.fan_pwm[state.owner(zone)] >= 100 {
|
||||
0
|
||||
} else {
|
||||
20_000
|
||||
};
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&(45_000 + rise + airflow).to_le_bytes());
|
||||
body
|
||||
}
|
||||
READ_POWER => {
|
||||
// Four watts per MHz, so a power target has something to regulate.
|
||||
let watts = u16::try_from(u32::from(state.frequency_mhz) * 4).unwrap_or(u16::MAX);
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&watts.to_le_bytes());
|
||||
body
|
||||
}
|
||||
SET_CHAIN_RESET | SET_PSU_ENABLED => vec![0],
|
||||
SEND_FRAME => vec![0],
|
||||
RECEIVE_FRAME => {
|
||||
// No nonce traffic in the reference backend.
|
||||
let count: u16 = 0;
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&count.to_le_bytes());
|
||||
body
|
||||
}
|
||||
_ => vec![1],
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::fanmap::FanProbe;
|
||||
use crate::hal_wire::HalClient;
|
||||
use crate::HardwareBackend;
|
||||
|
||||
#[test]
|
||||
fn a_client_can_detect_against_the_reference_server() {
|
||||
let path = std::env::temp_dir().join(format!("alkane-sim-hal-{}.sock", std::process::id()));
|
||||
// Bind before spawning so the client cannot race the socket into existence.
|
||||
let listener = UnixListener::bind(&path).expect("bind");
|
||||
let server = std::thread::spawn(move || {
|
||||
let (stream, _) = listener.accept().expect("accept");
|
||||
let mut state = State {
|
||||
config: SimConfig::default(),
|
||||
frequency_mhz: 0,
|
||||
fan_pwm: [100; 4],
|
||||
};
|
||||
let _ = serve_connection(stream, &mut state);
|
||||
});
|
||||
let mut client = HalClient::connect(&path).expect("connect");
|
||||
assert_eq!(client.capabilities().expect("caps"), CAP_ALL);
|
||||
match client.probe_chain(0, 0).expect("probe") {
|
||||
crate::detect::ProbeOutcome::Identified { chip, chips } => {
|
||||
assert_eq!(chip, crate::detect::ChipModel::Bm1362);
|
||||
assert_eq!(chips, 126);
|
||||
}
|
||||
other => panic!("unexpected probe: {other:?}"),
|
||||
}
|
||||
assert_eq!(
|
||||
client.read_eeprom(0).expect("eeprom"),
|
||||
crate::detect::EepromState::Absent
|
||||
);
|
||||
let psu = client.identify_psu().expect("psu");
|
||||
assert_eq!(psu.name, "APW12");
|
||||
client.set_chain_frequency(0, 512).expect("freq");
|
||||
assert_eq!(client.read_power_w().expect("power"), 512 * 4);
|
||||
// Zone 1 is owned by fan 1: slowing fan 1 must heat zone 1 and not zone 0.
|
||||
let baseline_0 = client.read_temperature_mc(0).expect("temp");
|
||||
let baseline_1 = client.read_temperature_mc(1).expect("temp");
|
||||
client.set_fan(1, 40).expect("fan");
|
||||
assert_eq!(client.read_temperature_mc(0).expect("temp"), baseline_0);
|
||||
assert!(client.read_temperature_mc(1).expect("temp") > baseline_1);
|
||||
assert_eq!(
|
||||
client.read_temperature_mc(0).expect("temp"),
|
||||
45_000 + 512 * 20
|
||||
);
|
||||
drop(client);
|
||||
let _ = std::fs::remove_file(&path);
|
||||
server.join().expect("server");
|
||||
}
|
||||
}
|
||||
+691
@@ -0,0 +1,691 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Versioned local wire contract between Alkane OS and an SDK hardware backend.
|
||||
|
||||
use crate::detect::{
|
||||
ChipModel, DetectionBackend, EepromState, Envelope, ProbeOutcome, PsuCapability,
|
||||
};
|
||||
use crate::HardwareBackend;
|
||||
use std::fmt;
|
||||
use std::io::{self, Read, Write};
|
||||
use std::net::Shutdown;
|
||||
use std::os::fd::{AsRawFd, FromRawFd, OwnedFd};
|
||||
use std::os::unix::ffi::OsStrExt;
|
||||
use std::os::unix::net::UnixStream;
|
||||
use std::path::Path;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const MAGIC: [u8; 4] = *b"ALKH";
|
||||
const VERSION: u8 = 1;
|
||||
const RESPONSE: u16 = 1;
|
||||
const HEADER_LEN: usize = 16;
|
||||
const MAX_PAYLOAD: usize = 4096;
|
||||
const IO_TIMEOUT: Duration = Duration::from_secs(2);
|
||||
|
||||
const SEND_FRAME: u8 = 1;
|
||||
const RECEIVE_FRAME: u8 = 2;
|
||||
const SET_CHAIN_RESET: u8 = 3;
|
||||
const SET_FAN_TARGET: u8 = 4;
|
||||
const READ_TEMPERATURE: u8 = 5;
|
||||
const SET_PSU_ENABLED: u8 = 6;
|
||||
const CAPABILITIES: u8 = 7;
|
||||
const PROBE_CHAIN: u8 = 8;
|
||||
const READ_EEPROM: u8 = 9;
|
||||
const IDENTIFY_PSU: u8 = 10;
|
||||
const SET_CHAIN_FREQUENCY: u8 = 11;
|
||||
const READ_POWER: u8 = 12;
|
||||
|
||||
/// Backend feature bits reported by `CAPABILITIES`.
|
||||
pub const CAP_CHAIN_PROBE: u32 = 1 << 0;
|
||||
pub const CAP_EEPROM: u32 = 1 << 1;
|
||||
pub const CAP_PSU_IDENTITY: u32 = 1 << 2;
|
||||
pub const CAP_FREQUENCY: u32 = 1 << 3;
|
||||
pub const CAP_POWER: u32 = 1 << 4;
|
||||
|
||||
const PROBE_IDENTIFIED: u8 = 0;
|
||||
const PROBE_SILENT: u8 = 1;
|
||||
const PROBE_GARBLED: u8 = 2;
|
||||
|
||||
const EEPROM_PRESENT: u8 = 0;
|
||||
const EEPROM_ABSENT: u8 = 1;
|
||||
const EEPROM_INVALID: u8 = 2;
|
||||
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
compile_error!("Alkane HAL sockets require Linux");
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
mod sys {
|
||||
pub use std::ffi::{c_char as CChar, c_int as CInt, c_void as CVoid};
|
||||
pub type SaFamily = u16;
|
||||
pub type SocklenT = u32;
|
||||
|
||||
pub const AF_UNIX: CInt = 1;
|
||||
pub const SOCK_STREAM: CInt = 1;
|
||||
pub const SOCK_NONBLOCK: CInt = 0x800;
|
||||
pub const SOCK_CLOEXEC: CInt = 0x80000;
|
||||
pub const SOL_SOCKET: CInt = 1;
|
||||
pub const SO_ERROR: CInt = 4;
|
||||
pub const POLLOUT: i16 = 4;
|
||||
pub const EAGAIN: CInt = 11;
|
||||
pub const EISCONN: CInt = 106;
|
||||
pub const EINPROGRESS: CInt = 115;
|
||||
|
||||
#[repr(C)]
|
||||
pub struct SockaddrUn {
|
||||
pub sun_family: SaFamily,
|
||||
pub sun_path: [CChar; 108],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
pub struct PollFd {
|
||||
pub fd: CInt,
|
||||
pub events: i16,
|
||||
pub revents: i16,
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
pub fn socket(domain: CInt, socket_type: CInt, protocol: CInt) -> CInt;
|
||||
pub fn connect(fd: CInt, address: *const CVoid, length: SocklenT) -> CInt;
|
||||
pub fn poll(fds: *mut PollFd, count: usize, timeout_ms: CInt) -> CInt;
|
||||
pub fn getsockopt(
|
||||
fd: CInt,
|
||||
level: CInt,
|
||||
name: CInt,
|
||||
value: *mut CVoid,
|
||||
length: *mut SocklenT,
|
||||
) -> CInt;
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum HalError {
|
||||
Io(io::Error),
|
||||
Protocol(&'static str),
|
||||
Device(u8),
|
||||
FrameTooLong,
|
||||
InvalidFanPercent,
|
||||
}
|
||||
|
||||
impl fmt::Display for HalError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Io(error) => write!(f, "HAL I/O: {error}"),
|
||||
Self::Protocol(message) => write!(f, "HAL protocol: {message}"),
|
||||
Self::Device(code) => write!(f, "HAL device error: {code}"),
|
||||
Self::FrameTooLong => f.write_str("HAL frame exceeds the wire limit"),
|
||||
Self::InvalidFanPercent => f.write_str("HAL fan target exceeds 100 percent"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for HalError {}
|
||||
|
||||
impl From<io::Error> for HalError {
|
||||
fn from(error: io::Error) -> Self {
|
||||
Self::Io(error)
|
||||
}
|
||||
}
|
||||
|
||||
/// Local client for the privileged board backend supplied by the SDK image.
|
||||
pub struct HalClient {
|
||||
stream: UnixStream,
|
||||
sequence: u32,
|
||||
poisoned: bool,
|
||||
}
|
||||
|
||||
impl HalClient {
|
||||
fn poison(&mut self) {
|
||||
self.poisoned = true;
|
||||
let _ = self.stream.shutdown(Shutdown::Both);
|
||||
}
|
||||
|
||||
pub fn connect(path: impl AsRef<Path>) -> Result<Self, HalError> {
|
||||
let stream = connect_until(path.as_ref(), Instant::now() + IO_TIMEOUT)?;
|
||||
Self::from_stream(stream)
|
||||
}
|
||||
|
||||
pub fn from_stream(stream: UnixStream) -> Result<Self, HalError> {
|
||||
stream.set_read_timeout(Some(IO_TIMEOUT))?;
|
||||
stream.set_write_timeout(Some(IO_TIMEOUT))?;
|
||||
Ok(Self {
|
||||
stream,
|
||||
sequence: 0,
|
||||
poisoned: false,
|
||||
})
|
||||
}
|
||||
|
||||
fn exchange(&mut self, opcode: u8, payload: &[u8]) -> Result<Vec<u8>, HalError> {
|
||||
if self.poisoned {
|
||||
return Err(HalError::Protocol("connection is unusable"));
|
||||
}
|
||||
if payload.len() > MAX_PAYLOAD {
|
||||
return Err(HalError::FrameTooLong);
|
||||
}
|
||||
let result = self.exchange_inner(opcode, payload);
|
||||
if let Err(ref error) = result {
|
||||
if !matches!(error, HalError::Device(_)) {
|
||||
self.poison();
|
||||
// A backend power lease must expire on disconnect. Reusing a
|
||||
// desynchronized stream could silently discard an off request.
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn exchange_inner(&mut self, opcode: u8, payload: &[u8]) -> Result<Vec<u8>, HalError> {
|
||||
let deadline = Instant::now() + IO_TIMEOUT;
|
||||
self.sequence = self.sequence.wrapping_add(1);
|
||||
let sequence = self.sequence;
|
||||
let mut header = [0_u8; HEADER_LEN];
|
||||
header[..4].copy_from_slice(&MAGIC);
|
||||
header[4] = VERSION;
|
||||
header[5] = opcode;
|
||||
header[8..12].copy_from_slice(&sequence.to_le_bytes());
|
||||
header[12..16].copy_from_slice(&(payload.len() as u32).to_le_bytes());
|
||||
write_all_until(&mut self.stream, &header, deadline)?;
|
||||
write_all_until(&mut self.stream, payload, deadline)?;
|
||||
|
||||
read_exact_until(&mut self.stream, &mut header, deadline)?;
|
||||
if header[..4] != MAGIC || header[4] != VERSION || header[5] != opcode {
|
||||
return Err(HalError::Protocol("response identity mismatch"));
|
||||
}
|
||||
if u16::from_le_bytes([header[6], header[7]]) != RESPONSE {
|
||||
return Err(HalError::Protocol("response flag missing"));
|
||||
}
|
||||
if u32::from_le_bytes(header[8..12].try_into().unwrap()) != sequence {
|
||||
return Err(HalError::Protocol("response sequence mismatch"));
|
||||
}
|
||||
let length = u32::from_le_bytes(header[12..16].try_into().unwrap()) as usize;
|
||||
if !(1..=MAX_PAYLOAD).contains(&length) {
|
||||
return Err(HalError::Protocol("invalid response length"));
|
||||
}
|
||||
let mut body = vec![0_u8; length];
|
||||
read_exact_until(&mut self.stream, &mut body, deadline)?;
|
||||
if body[0] != 0 {
|
||||
if !matches!(body[0], 1..=3) || body.len() != 1 {
|
||||
return Err(HalError::Protocol("invalid error response"));
|
||||
}
|
||||
return Err(HalError::Device(body[0]));
|
||||
}
|
||||
Ok(body[1..].to_vec())
|
||||
}
|
||||
|
||||
fn empty_reply(&mut self, opcode: u8, payload: &[u8]) -> Result<(), HalError> {
|
||||
if !self.exchange(opcode, payload)?.is_empty() {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("unexpected response data"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn timeout_error() -> io::Error {
|
||||
io::Error::new(io::ErrorKind::TimedOut, "HAL operation timed out")
|
||||
}
|
||||
|
||||
fn remaining(deadline: Instant) -> io::Result<Duration> {
|
||||
deadline
|
||||
.checked_duration_since(Instant::now())
|
||||
.filter(|duration| !duration.is_zero())
|
||||
.ok_or_else(timeout_error)
|
||||
}
|
||||
|
||||
fn write_all_until(stream: &mut UnixStream, mut data: &[u8], deadline: Instant) -> io::Result<()> {
|
||||
while !data.is_empty() {
|
||||
stream.set_write_timeout(Some(remaining(deadline)?))?;
|
||||
match stream.write(data) {
|
||||
Ok(0) => {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::WriteZero,
|
||||
"HAL socket closed",
|
||||
))
|
||||
}
|
||||
Ok(count) => data = &data[count..],
|
||||
Err(error) if error.kind() == io::ErrorKind::Interrupted => continue,
|
||||
Err(error) => return Err(error),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_exact_until(
|
||||
stream: &mut UnixStream,
|
||||
mut data: &mut [u8],
|
||||
deadline: Instant,
|
||||
) -> io::Result<()> {
|
||||
while !data.is_empty() {
|
||||
stream.set_read_timeout(Some(remaining(deadline)?))?;
|
||||
match stream.read(data) {
|
||||
Ok(0) => {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::UnexpectedEof,
|
||||
"HAL socket closed",
|
||||
))
|
||||
}
|
||||
Ok(count) => data = &mut data[count..],
|
||||
Err(error) if error.kind() == io::ErrorKind::Interrupted => continue,
|
||||
Err(error) => return Err(error),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn connect_until(path: &Path, deadline: Instant) -> io::Result<UnixStream> {
|
||||
let bytes = path.as_os_str().as_bytes();
|
||||
let max_path =
|
||||
std::mem::size_of::<sys::SockaddrUn>() - std::mem::offset_of!(sys::SockaddrUn, sun_path);
|
||||
if bytes.is_empty() || bytes.len() >= max_path || bytes.contains(&0) {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
"invalid HAL socket path",
|
||||
));
|
||||
}
|
||||
let raw = unsafe {
|
||||
sys::socket(
|
||||
sys::AF_UNIX,
|
||||
sys::SOCK_STREAM | sys::SOCK_NONBLOCK | sys::SOCK_CLOEXEC,
|
||||
0,
|
||||
)
|
||||
};
|
||||
if raw < 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let fd = unsafe { OwnedFd::from_raw_fd(raw) };
|
||||
let mut address: sys::SockaddrUn = unsafe { std::mem::zeroed() };
|
||||
address.sun_family = sys::AF_UNIX as sys::SaFamily;
|
||||
for (destination, source) in address.sun_path.iter_mut().zip(bytes) {
|
||||
*destination = *source as sys::CChar;
|
||||
}
|
||||
let length =
|
||||
(std::mem::offset_of!(sys::SockaddrUn, sun_path) + bytes.len() + 1) as sys::SocklenT;
|
||||
loop {
|
||||
let result = unsafe {
|
||||
sys::connect(
|
||||
fd.as_raw_fd(),
|
||||
&address as *const _ as *const sys::CVoid,
|
||||
length,
|
||||
)
|
||||
};
|
||||
if result == 0 {
|
||||
break;
|
||||
}
|
||||
let error = io::Error::last_os_error();
|
||||
if error.raw_os_error() == Some(sys::EISCONN) {
|
||||
break;
|
||||
}
|
||||
if !matches!(
|
||||
error.raw_os_error(),
|
||||
Some(sys::EINPROGRESS) | Some(sys::EAGAIN)
|
||||
) {
|
||||
return Err(error);
|
||||
}
|
||||
let mut poll_fd = sys::PollFd {
|
||||
fd: fd.as_raw_fd(),
|
||||
events: sys::POLLOUT,
|
||||
revents: 0,
|
||||
};
|
||||
let wait = remaining(deadline)?.as_millis().min(i32::MAX as u128) as i32;
|
||||
let polled = unsafe { sys::poll(&mut poll_fd, 1, wait.max(1)) };
|
||||
if polled < 0 {
|
||||
let error = io::Error::last_os_error();
|
||||
if error.kind() == io::ErrorKind::Interrupted {
|
||||
continue;
|
||||
}
|
||||
return Err(error);
|
||||
}
|
||||
if polled == 0 {
|
||||
return Err(timeout_error());
|
||||
}
|
||||
let mut socket_error: sys::CInt = 0;
|
||||
let mut socket_error_len = std::mem::size_of_val(&socket_error) as sys::SocklenT;
|
||||
if unsafe {
|
||||
sys::getsockopt(
|
||||
fd.as_raw_fd(),
|
||||
sys::SOL_SOCKET,
|
||||
sys::SO_ERROR,
|
||||
&mut socket_error as *mut _ as *mut sys::CVoid,
|
||||
&mut socket_error_len,
|
||||
)
|
||||
} < 0
|
||||
{
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
if socket_error != 0 {
|
||||
return Err(io::Error::from_raw_os_error(socket_error));
|
||||
}
|
||||
if error.raw_os_error() == Some(sys::EINPROGRESS) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
let stream = UnixStream::from(fd);
|
||||
stream.set_nonblocking(false)?;
|
||||
Ok(stream)
|
||||
}
|
||||
|
||||
impl HalClient {
|
||||
/// Feature mask advertised by the backend. Old backends reject the opcode, which surfaces as
|
||||
/// a protocol error rather than a silent zero.
|
||||
pub fn capabilities(&mut self) -> Result<u32, HalError> {
|
||||
let body = self.exchange(CAPABILITIES, &[])?;
|
||||
let bytes: [u8; 4] = body
|
||||
.try_into()
|
||||
.map_err(|_| HalError::Protocol("invalid capability response"))?;
|
||||
Ok(u32::from_le_bytes(bytes))
|
||||
}
|
||||
|
||||
fn require(&mut self, capability: u32) -> Result<(), HalError> {
|
||||
if self.capabilities()? & capability == 0 {
|
||||
return Err(HalError::Protocol("backend lacks a detection capability"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn probe_chain(&mut self, chain: u8, attempt: u8) -> Result<ProbeOutcome, HalError> {
|
||||
self.require(CAP_CHAIN_PROBE)?;
|
||||
let body = self.exchange(PROBE_CHAIN, &[chain, attempt])?;
|
||||
if body.len() != 4 {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("invalid probe response"));
|
||||
}
|
||||
let chips = u16::from_le_bytes([body[2], body[3]]);
|
||||
match body[0] {
|
||||
PROBE_IDENTIFIED => match chip_from_wire(body[1]) {
|
||||
Some(chip) => Ok(ProbeOutcome::Identified { chip, chips }),
|
||||
None => {
|
||||
self.poison();
|
||||
Err(HalError::Protocol("unknown chip identifier"))
|
||||
}
|
||||
},
|
||||
PROBE_SILENT => Ok(ProbeOutcome::Silent),
|
||||
PROBE_GARBLED => Ok(ProbeOutcome::Garbled),
|
||||
_ => {
|
||||
self.poison();
|
||||
Err(HalError::Protocol("invalid probe outcome"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read_eeprom(&mut self, chain: u8) -> Result<EepromState, HalError> {
|
||||
self.require(CAP_EEPROM)?;
|
||||
let body = self.exchange(READ_EEPROM, &[chain])?;
|
||||
match body.first().copied() {
|
||||
Some(EEPROM_ABSENT) if body.len() == 1 => Ok(EepromState::Absent),
|
||||
Some(EEPROM_INVALID) if body.len() == 1 => Ok(EepromState::Invalid),
|
||||
Some(EEPROM_PRESENT) if body.len() > 1 => {
|
||||
let model = std::str::from_utf8(&body[1..])
|
||||
.map_err(|_| HalError::Protocol("invalid EEPROM model text"))?;
|
||||
Ok(EepromState::Present {
|
||||
model: model.to_owned(),
|
||||
})
|
||||
}
|
||||
_ => {
|
||||
self.poison();
|
||||
Err(HalError::Protocol("invalid EEPROM response"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply a chain frequency in MHz. The backend owns the PLL write; the OS owns the decision.
|
||||
pub fn set_chain_frequency(&mut self, chain: u8, mhz: u16) -> Result<(), HalError> {
|
||||
self.require(CAP_FREQUENCY)?;
|
||||
let mut payload = [0_u8; 3];
|
||||
payload[0] = chain;
|
||||
payload[1..].copy_from_slice(&mhz.to_le_bytes());
|
||||
self.empty_reply(SET_CHAIN_FREQUENCY, &payload)
|
||||
}
|
||||
|
||||
/// Measured DC input power in watts, when the board can read its PSU.
|
||||
pub fn read_power_w(&mut self) -> Result<u16, HalError> {
|
||||
self.require(CAP_POWER)?;
|
||||
let body = self.exchange(READ_POWER, &[])?;
|
||||
if body.len() != 2 {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("invalid power response"));
|
||||
}
|
||||
Ok(u16::from_le_bytes([body[0], body[1]]))
|
||||
}
|
||||
|
||||
pub fn identify_psu(&mut self) -> Result<PsuCapability, HalError> {
|
||||
self.require(CAP_PSU_IDENTITY)?;
|
||||
let body = self.exchange(IDENTIFY_PSU, &[])?;
|
||||
let name_len = *body
|
||||
.first()
|
||||
.ok_or(HalError::Protocol("empty PSU response"))? as usize;
|
||||
if body.len() != name_len + 1 + 10 {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("invalid PSU response"));
|
||||
}
|
||||
let name = std::str::from_utf8(&body[1..1 + name_len])
|
||||
.map_err(|_| HalError::Protocol("invalid PSU name"))?
|
||||
.to_owned();
|
||||
let at = 1 + name_len;
|
||||
let word = |offset: usize| u16::from_le_bytes([body[at + offset], body[at + offset + 1]]);
|
||||
Ok(PsuCapability {
|
||||
name,
|
||||
envelope: Envelope {
|
||||
v_min_mv: word(0),
|
||||
v_max_mv: word(2),
|
||||
f_min_mhz: word(4),
|
||||
f_max_mhz: word(6),
|
||||
},
|
||||
max_dc_watts: word(8),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl DetectionBackend for HalClient {
|
||||
type Error = HalError;
|
||||
|
||||
fn probe(&mut self, chain: u8, attempt: u8) -> Result<ProbeOutcome, Self::Error> {
|
||||
self.probe_chain(chain, attempt)
|
||||
}
|
||||
|
||||
fn eeprom(&mut self, chain: u8) -> Result<EepromState, Self::Error> {
|
||||
self.read_eeprom(chain)
|
||||
}
|
||||
|
||||
fn identify_psu(&mut self) -> Result<Option<PsuCapability>, Self::Error> {
|
||||
self.identify_psu().map(Some)
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::fanmap::FanProbe for HalClient {
|
||||
type Error = HalError;
|
||||
|
||||
fn set_fan(&mut self, fan: u8, pwm: u8) -> Result<(), Self::Error> {
|
||||
self.set_fan_target(fan, pwm)
|
||||
}
|
||||
|
||||
fn read_zone(&mut self, zone: u8) -> Result<i32, Self::Error> {
|
||||
self.read_temperature_mc(zone)
|
||||
}
|
||||
}
|
||||
|
||||
fn chip_from_wire(value: u8) -> Option<ChipModel> {
|
||||
match value {
|
||||
1 => Some(ChipModel::Bm1362),
|
||||
2 => Some(ChipModel::Bm1366),
|
||||
3 => Some(ChipModel::Bm1368),
|
||||
4 => Some(ChipModel::Bm1370),
|
||||
5 => Some(ChipModel::Bm1398),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
impl HardwareBackend for HalClient {
|
||||
type Error = HalError;
|
||||
|
||||
fn send_frame(&mut self, chain: u8, frame: &[u8]) -> Result<(), Self::Error> {
|
||||
if frame.len() > MAX_PAYLOAD - 3 {
|
||||
return Err(HalError::FrameTooLong);
|
||||
}
|
||||
let mut body = Vec::with_capacity(frame.len() + 3);
|
||||
body.push(chain);
|
||||
body.extend_from_slice(&(frame.len() as u16).to_le_bytes());
|
||||
body.extend_from_slice(frame);
|
||||
self.empty_reply(SEND_FRAME, &body)
|
||||
}
|
||||
|
||||
fn receive_frame(&mut self, chain: u8, frame: &mut [u8]) -> Result<usize, Self::Error> {
|
||||
if frame.len() > MAX_PAYLOAD - 3 {
|
||||
return Err(HalError::FrameTooLong);
|
||||
}
|
||||
let mut request = [0_u8; 3];
|
||||
request[0] = chain;
|
||||
request[1..].copy_from_slice(&(frame.len() as u16).to_le_bytes());
|
||||
let body = self.exchange(RECEIVE_FRAME, &request)?;
|
||||
if body.len() < 2 {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("missing receive length"));
|
||||
}
|
||||
let count = u16::from_le_bytes([body[0], body[1]]) as usize;
|
||||
if count > frame.len() || body.len() != count + 2 {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("invalid received frame size"));
|
||||
}
|
||||
frame[..count].copy_from_slice(&body[2..]);
|
||||
Ok(count)
|
||||
}
|
||||
|
||||
fn set_chain_reset(&mut self, chain: u8, asserted: bool) -> Result<(), Self::Error> {
|
||||
self.empty_reply(SET_CHAIN_RESET, &[chain, u8::from(asserted)])
|
||||
}
|
||||
|
||||
fn set_fan_target(&mut self, fan: u8, percent: u8) -> Result<(), Self::Error> {
|
||||
if percent > 100 {
|
||||
return Err(HalError::InvalidFanPercent);
|
||||
}
|
||||
self.empty_reply(SET_FAN_TARGET, &[fan, percent])
|
||||
}
|
||||
|
||||
fn read_temperature_mc(&mut self, sensor: u8) -> Result<i32, Self::Error> {
|
||||
let body = self.exchange(READ_TEMPERATURE, &[sensor])?;
|
||||
let bytes: [u8; 4] = match body.try_into() {
|
||||
Ok(bytes) => bytes,
|
||||
Err(_) => {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("invalid temperature response"));
|
||||
}
|
||||
};
|
||||
Ok(i32::from_le_bytes(bytes))
|
||||
}
|
||||
|
||||
fn set_psu_enabled(&mut self, enabled: bool) -> Result<(), Self::Error> {
|
||||
let result = self.empty_reply(SET_PSU_ENABLED, &[u8::from(enabled)]);
|
||||
if !enabled && result.is_err() {
|
||||
self.poison();
|
||||
}
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::fanmap::FanProbe;
|
||||
use std::os::unix::net::UnixStream;
|
||||
|
||||
fn mock_backend(mut server: UnixStream) {
|
||||
loop {
|
||||
let mut header = [0_u8; 16];
|
||||
if server.read_exact(&mut header).is_err() {
|
||||
return;
|
||||
}
|
||||
let opcode = header[5];
|
||||
let sequence = [header[8], header[9], header[10], header[11]];
|
||||
let length = u32::from_le_bytes(header[12..16].try_into().unwrap()) as usize;
|
||||
let mut payload = vec![0_u8; length];
|
||||
if length > 0 && server.read_exact(&mut payload).is_err() {
|
||||
return;
|
||||
}
|
||||
let body: Vec<u8> = match opcode {
|
||||
CAPABILITIES => {
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(
|
||||
&(CAP_CHAIN_PROBE
|
||||
| CAP_EEPROM
|
||||
| CAP_PSU_IDENTITY
|
||||
| CAP_FREQUENCY
|
||||
| CAP_POWER)
|
||||
.to_le_bytes(),
|
||||
);
|
||||
body
|
||||
}
|
||||
PROBE_CHAIN => vec![0, PROBE_IDENTIFIED, 1, 126, 0],
|
||||
READ_EEPROM => {
|
||||
let mut body = vec![0, EEPROM_PRESENT];
|
||||
body.extend_from_slice(b"BHB42601");
|
||||
body
|
||||
}
|
||||
IDENTIFY_PSU => {
|
||||
let name = b"APW12";
|
||||
let mut body = vec![0_u8];
|
||||
body.push(name.len() as u8);
|
||||
body.extend_from_slice(name);
|
||||
for word in [1200_u16, 1600, 0, 1000, 3600] {
|
||||
body.extend_from_slice(&word.to_le_bytes());
|
||||
}
|
||||
body
|
||||
}
|
||||
SET_FAN_TARGET | SET_CHAIN_FREQUENCY => vec![0],
|
||||
READ_POWER => {
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&0_u16.to_le_bytes());
|
||||
body
|
||||
}
|
||||
READ_TEMPERATURE => {
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&42_000_i32.to_le_bytes());
|
||||
body
|
||||
}
|
||||
_ => vec![1],
|
||||
};
|
||||
let mut out = [0_u8; 16];
|
||||
out[..4].copy_from_slice(&MAGIC);
|
||||
out[4] = VERSION;
|
||||
out[5] = opcode;
|
||||
out[6..8].copy_from_slice(&RESPONSE.to_le_bytes());
|
||||
out[8..12].copy_from_slice(&sequence);
|
||||
out[12..16].copy_from_slice(&(body.len() as u32).to_le_bytes());
|
||||
if server.write_all(&out).is_err() || server.write_all(&body).is_err() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn detection_verbs_round_trip_over_the_wire() {
|
||||
let (client_stream, server_stream) = UnixStream::pair().expect("socket pair");
|
||||
let server = std::thread::spawn(move || mock_backend(server_stream));
|
||||
let mut client = HalClient::from_stream(client_stream).expect("client");
|
||||
|
||||
assert_eq!(
|
||||
client.capabilities().expect("capabilities"),
|
||||
CAP_CHAIN_PROBE | CAP_EEPROM | CAP_PSU_IDENTITY | CAP_FREQUENCY | CAP_POWER
|
||||
);
|
||||
match client.probe_chain(0, 0).expect("probe") {
|
||||
ProbeOutcome::Identified { chip, chips } => {
|
||||
assert_eq!(chip, ChipModel::Bm1362);
|
||||
assert_eq!(chips, 126);
|
||||
}
|
||||
other => panic!("unexpected probe outcome: {other:?}"),
|
||||
}
|
||||
assert_eq!(
|
||||
client.read_eeprom(0).expect("eeprom"),
|
||||
EepromState::Present {
|
||||
model: "BHB42601".into()
|
||||
}
|
||||
);
|
||||
let psu = client.identify_psu().expect("psu");
|
||||
assert_eq!(psu.name, "APW12");
|
||||
assert_eq!(psu.envelope.v_min_mv, 1200);
|
||||
assert_eq!(psu.envelope.v_max_mv, 1600);
|
||||
assert_eq!(psu.max_dc_watts, 3600);
|
||||
|
||||
client.set_chain_frequency(2, 512).expect("set frequency");
|
||||
client.set_fan(1, 60).expect("set fan");
|
||||
assert_eq!(client.read_zone(2).expect("read zone"), 42_000);
|
||||
|
||||
drop(client);
|
||||
server.join().expect("server thread");
|
||||
}
|
||||
}
|
||||
+32
@@ -3,6 +3,38 @@
|
||||
//! An entry in the target matrix is a development obligation, not a claim that
|
||||
//! the pairing already mines. Hardware backends are supplied by SDK images.
|
||||
|
||||
pub mod app;
|
||||
pub mod bm1362;
|
||||
pub mod bm1366;
|
||||
pub mod bm1370;
|
||||
pub mod bm13xx;
|
||||
pub mod detect;
|
||||
pub mod difficulty;
|
||||
pub mod fanmap;
|
||||
pub mod fanmap_store;
|
||||
pub mod fault;
|
||||
pub mod hal_conformance;
|
||||
pub mod hal_sim;
|
||||
pub mod hal_wire;
|
||||
pub mod management;
|
||||
pub mod miner;
|
||||
pub mod pow;
|
||||
pub mod profiles;
|
||||
pub mod runtime;
|
||||
pub mod scrypt_pow;
|
||||
pub mod split;
|
||||
pub mod stratum_client;
|
||||
pub mod stratum_link;
|
||||
pub mod stratum_session;
|
||||
pub mod stratum_submit;
|
||||
pub mod stratum_v1;
|
||||
pub mod stratum_v2;
|
||||
pub mod stratum_v2_session;
|
||||
pub mod stratum_wire;
|
||||
pub mod stratum_work;
|
||||
pub mod tuning;
|
||||
pub mod web;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum Vendor {
|
||||
Bitmain,
|
||||
|
||||
+393
-2
@@ -1,7 +1,311 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::app;
|
||||
use alkane_os::detect::{
|
||||
ChipModel as DetectedChip, DetectionBackend, EepromState, Envelope, ProbeBudget, ProbeOutcome,
|
||||
PsuCapability, SensorTopology,
|
||||
};
|
||||
use alkane_os::hal_wire::HalClient;
|
||||
use alkane_os::management::MiningStatus;
|
||||
use alkane_os::miner::{Bm1366Miner, ChipModel};
|
||||
use alkane_os::runtime::{Tick, TickOutcome};
|
||||
use alkane_os::stratum_client::{PoolConnection, PoolEvent};
|
||||
use alkane_os::target_matrix;
|
||||
use alkane_os::tuning::{PidConfig, TuningTarget};
|
||||
use alkane_os::HardwareBackend;
|
||||
use std::error::Error;
|
||||
use std::io;
|
||||
use std::net::SocketAddr;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
fn sim_mine(mut args: impl Iterator<Item = String>) -> Result<(), Box<dyn Error>> {
|
||||
let socket = args.next().ok_or("missing HAL socket")?;
|
||||
let address: SocketAddr = args.next().ok_or("missing pool address")?.parse()?;
|
||||
let worker = args.next().ok_or("missing pool worker")?;
|
||||
let chip = match args.next().as_deref() {
|
||||
Some("BM1362") => ChipModel::Bm1362,
|
||||
Some("BM1366") => ChipModel::Bm1366,
|
||||
_ => return Err("select BM1362 or BM1366".into()),
|
||||
};
|
||||
let max_accepts: Option<u64> = args.next().map(|value| value.parse()).transpose()?;
|
||||
if args.next().is_some() || worker.is_empty() || max_accepts == Some(0) {
|
||||
return Err("invalid simulator mining arguments".into());
|
||||
}
|
||||
let password = std::env::var("ALKANE_POOL_PASSWORD")
|
||||
.map_err(|_| "set ALKANE_POOL_PASSWORD in the environment")?;
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
let api = std::env::var("ALKANE_API_LISTEN")
|
||||
.ok()
|
||||
.map(|bind| bind.parse())
|
||||
.transpose()?;
|
||||
let web = std::env::var("ALKANE_WEB_LISTEN")
|
||||
.ok()
|
||||
.map(|bind| bind.parse())
|
||||
.transpose()?;
|
||||
let servers = app::start(Arc::clone(&status), api, web)?;
|
||||
let (api_address, web_address) = servers.addresses();
|
||||
if let Some(address) = api_address {
|
||||
println!("management API on {address}");
|
||||
}
|
||||
if let Some(address) = web_address {
|
||||
println!("web UI on http://{address}/");
|
||||
}
|
||||
|
||||
// Connect to the pool before enabling power. The SDK HAL server owns the
|
||||
// power lease and cuts power if this process stalls or disconnects.
|
||||
let mut pool = PoolConnection::connect(
|
||||
address,
|
||||
concat!("alkane-os/", env!("CARGO_PKG_VERSION")),
|
||||
&worker,
|
||||
&password,
|
||||
Duration::from_secs(2),
|
||||
Duration::from_secs(5),
|
||||
)
|
||||
.map_err(|error| io::Error::other(format!("pool handshake: {error:?}")))?;
|
||||
let mut backend = HalClient::connect(socket)?;
|
||||
let mut miner = Bm1366Miner::new_for_chip(&mut backend, chip, 0, 0, 0, 100, 80_000)
|
||||
.ok_or("invalid simulator safety configuration")?;
|
||||
miner.start()?;
|
||||
status.set_running(true);
|
||||
let mut accepted = 0_u64;
|
||||
loop {
|
||||
let (event, reports) = pool
|
||||
.cycle(&mut miner)
|
||||
.map_err(|error| io::Error::other(format!("mining cycle: {error:?}")))?;
|
||||
match event {
|
||||
PoolEvent::ShareAccepted(_) => {
|
||||
accepted += 1;
|
||||
status.share_accepted();
|
||||
if max_accepts == Some(accepted) {
|
||||
miner.stop()?;
|
||||
status.set_running(false);
|
||||
println!("simulator shares accepted: {accepted}");
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
PoolEvent::ShareRejected(id) => {
|
||||
status.share_rejected();
|
||||
eprintln!("pool rejected share request {id}");
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
if matches!(event, PoolEvent::Idle) && reports.is_empty() {
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A backend that answers without hardware, so the boot path can be exercised on any machine.
|
||||
struct SelfCheckBackend;
|
||||
|
||||
impl DetectionBackend for SelfCheckBackend {
|
||||
type Error = ();
|
||||
|
||||
fn probe(&mut self, _chain: u8, _attempt: u8) -> Result<ProbeOutcome, ()> {
|
||||
Ok(ProbeOutcome::Identified {
|
||||
chip: DetectedChip::Bm1362,
|
||||
chips: 126,
|
||||
})
|
||||
}
|
||||
|
||||
fn eeprom(&mut self, _chain: u8) -> Result<EepromState, ()> {
|
||||
Ok(EepromState::Absent)
|
||||
}
|
||||
|
||||
fn identify_psu(&mut self) -> Result<Option<PsuCapability>, ()> {
|
||||
Ok(Some(PsuCapability {
|
||||
name: "APW12".into(),
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1200,
|
||||
v_max_mv: 1600,
|
||||
f_min_mhz: 0,
|
||||
f_max_mhz: 1000,
|
||||
},
|
||||
max_dc_watts: 3600,
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
/// Run detection, the runtime loop and the API document against the self-check backend.
|
||||
///
|
||||
/// This is the smoke test an image can run on a bench machine before any hashboard is attached:
|
||||
/// it proves the profile database parses, detection produces a plan, the tuner moves within the
|
||||
/// envelope and the published document is well formed.
|
||||
fn self_check() -> Result<(), Box<dyn Error>> {
|
||||
let status = MiningStatus::new();
|
||||
let config = app::BootConfig {
|
||||
profile_db_json: include_str!("../profiles.example.json").to_owned(),
|
||||
chain_ports: vec![0, 1, 2],
|
||||
sensor: SensorTopology::Pic,
|
||||
budget: ProbeBudget::default(),
|
||||
fan_zones: Vec::new(),
|
||||
target: TuningTarget::PowerW(2_400.0),
|
||||
pid: PidConfig::default(),
|
||||
ceiling_mc: 95_000,
|
||||
fault_policy: Default::default(),
|
||||
};
|
||||
let mut backend = SelfCheckBackend;
|
||||
let mut runtime = app::boot(&mut backend, &config, &status)?;
|
||||
let start = runtime.operating_point().frequency_mhz;
|
||||
for _ in 0..20 {
|
||||
let power = 4.0 * f32::from(runtime.operating_point().frequency_mhz);
|
||||
runtime.tick(&Tick {
|
||||
power_w: Some(power),
|
||||
hashrate_ths: None,
|
||||
hottest_mc: Some(70_000),
|
||||
ambient_mc: None,
|
||||
dt_s: 1.0,
|
||||
});
|
||||
}
|
||||
let end = runtime.operating_point().frequency_mhz;
|
||||
if end <= start {
|
||||
return Err("self-check: frequency did not move toward the target".into());
|
||||
}
|
||||
if runtime.active_chains().len() != 3 {
|
||||
return Err("self-check: detection did not expose three chains".into());
|
||||
}
|
||||
status.set_hardware(app::snapshot(&runtime, &app::target_label(&config.target)));
|
||||
let document = status.hardware_document();
|
||||
if document["available"] != true {
|
||||
return Err("self-check: hardware document is not available".into());
|
||||
}
|
||||
println!("{}", serde_json::to_string_pretty(&document)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn parse_target(text: &str) -> Result<TuningTarget, Box<dyn Error>> {
|
||||
let (kind, value) = text
|
||||
.split_once(':')
|
||||
.ok_or("target must look like power:2400")?;
|
||||
let value: f32 = value.parse()?;
|
||||
Ok(match kind {
|
||||
"power" => TuningTarget::PowerW(value),
|
||||
"hashrate" => TuningTarget::HashrateThs(value),
|
||||
"ambient" => TuningTarget::AmbientC {
|
||||
margin_mc: value as i32,
|
||||
},
|
||||
"fan" => TuningTarget::MaxFan {
|
||||
max_pwm: value as u8,
|
||||
},
|
||||
_ => return Err("target must be power, hashrate, ambient or fan".into()),
|
||||
})
|
||||
}
|
||||
|
||||
/// Boot a real board through the HAL socket, then run a bounded tuning loop.
|
||||
fn boot_hal(mut args: impl Iterator<Item = String>) -> Result<(), Box<dyn Error>> {
|
||||
let socket = args.next().ok_or("missing HAL socket")?;
|
||||
let profiles = args.next().ok_or("missing profile database path")?;
|
||||
let target = parse_target(&args.next().ok_or("missing target")?)?;
|
||||
let sensor = match args.next().as_deref() {
|
||||
Some("nopic") => SensorTopology::NoPic,
|
||||
Some("pic") | None => SensorTopology::Pic,
|
||||
Some(_) => return Err("sensor must be pic or nopic".into()),
|
||||
};
|
||||
let ticks: usize = args
|
||||
.next()
|
||||
.map(|value| value.parse())
|
||||
.transpose()?
|
||||
.unwrap_or(30);
|
||||
let profile_db_json = std::fs::read_to_string(&profiles)?;
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
let api = std::env::var("ALKANE_API_LISTEN")
|
||||
.ok()
|
||||
.map(|bind| bind.parse())
|
||||
.transpose()?;
|
||||
let web = std::env::var("ALKANE_WEB_LISTEN")
|
||||
.ok()
|
||||
.map(|bind| bind.parse())
|
||||
.transpose()?;
|
||||
let servers = app::start(Arc::clone(&status), api, web)?;
|
||||
|
||||
let config = app::BootConfig {
|
||||
profile_db_json,
|
||||
chain_ports: vec![0, 1, 2],
|
||||
sensor,
|
||||
budget: ProbeBudget::default(),
|
||||
fan_zones: Vec::new(),
|
||||
target,
|
||||
pid: PidConfig::default(),
|
||||
ceiling_mc: 95_000,
|
||||
fault_policy: Default::default(),
|
||||
};
|
||||
let map_path = std::path::PathBuf::from(
|
||||
std::env::var("ALKANE_FANMAP").unwrap_or_else(|_| "/var/lib/alkane/fanmap.json".into()),
|
||||
);
|
||||
// Fan mapping is opt-in: it perturbs the machine and takes minutes, so a plain boot skips it.
|
||||
let fans: u8 = std::env::var("ALKANE_FAN_FANS")
|
||||
.ok()
|
||||
.and_then(|v| v.parse().ok())
|
||||
.unwrap_or(0);
|
||||
let zones: u8 = std::env::var("ALKANE_FAN_ZONES")
|
||||
.ok()
|
||||
.and_then(|v| v.parse().ok())
|
||||
.unwrap_or(0);
|
||||
let settings = app::HalBoot {
|
||||
config: &config,
|
||||
sweep: alkane_os::fanmap::SweepConfig {
|
||||
fans,
|
||||
zones,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 1,
|
||||
settle_ms: std::env::var("ALKANE_FAN_SETTLE_MS")
|
||||
.ok()
|
||||
.and_then(|v| v.parse().ok())
|
||||
.unwrap_or(20_000),
|
||||
},
|
||||
thresholds: Default::default(),
|
||||
map_path: &map_path,
|
||||
};
|
||||
let (mut runtime, _map) =
|
||||
app::boot_from_hal(std::path::Path::new(&socket), &settings, &status)?;
|
||||
println!(
|
||||
"detected {} with {} active chains",
|
||||
runtime.plan().profile,
|
||||
runtime.active_chains().len()
|
||||
);
|
||||
|
||||
let mut client = HalClient::connect(std::path::Path::new(&socket))?;
|
||||
let label = app::target_label(&config.target);
|
||||
for _ in 0..ticks {
|
||||
let hottest = client.read_temperature_mc(0).ok();
|
||||
let power_w = client.read_power_w().ok().map(f32::from);
|
||||
let outcome = runtime.tick(&Tick {
|
||||
power_w,
|
||||
hashrate_ths: None,
|
||||
hottest_mc: hottest,
|
||||
ambient_mc: None,
|
||||
dt_s: 1.0,
|
||||
});
|
||||
if let TickOutcome::Run(command) = outcome {
|
||||
for chain in runtime.active_chains() {
|
||||
client.set_chain_frequency(chain, command.frequency_mhz)?;
|
||||
}
|
||||
if let Some(pwm) = command.fan_pwm {
|
||||
client.set_fan_target(0, pwm)?;
|
||||
}
|
||||
}
|
||||
// Publish every period: a client watching the API must see the live operating point,
|
||||
// not the boot-time snapshot.
|
||||
status.set_hardware(app::snapshot(&runtime, &label));
|
||||
if let Some(reason) = runtime.stop_reason() {
|
||||
println!("stopped: {reason:?}");
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(50));
|
||||
}
|
||||
status.set_hardware(app::snapshot(&runtime, &app::target_label(&config.target)));
|
||||
println!(
|
||||
"{}",
|
||||
serde_json::to_string_pretty(&status.hardware_document())?
|
||||
);
|
||||
let _ = servers;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn main() {
|
||||
match std::env::args().nth(1).as_deref() {
|
||||
let mut args = std::env::args().skip(1);
|
||||
match args.next().as_deref() {
|
||||
Some("--list-targets") => {
|
||||
println!("control_board,hash_chip,algorithm");
|
||||
for target in target_matrix() {
|
||||
@@ -12,8 +316,95 @@ fn main() {
|
||||
}
|
||||
}
|
||||
Some("--version") => println!("alkane-os {}", env!("CARGO_PKG_VERSION")),
|
||||
Some("--boot") => {
|
||||
if let Err(error) = boot_hal(args) {
|
||||
eprintln!("boot failed: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
Some("--sim-hal") => {
|
||||
let socket = match args.next() {
|
||||
Some(path) => path,
|
||||
None => {
|
||||
eprintln!("usage: alkane-os --sim-hal SOCKET");
|
||||
std::process::exit(2);
|
||||
}
|
||||
};
|
||||
if let Err(error) = alkane_os::hal_sim::serve(
|
||||
std::path::Path::new(&socket),
|
||||
alkane_os::hal_sim::SimConfig::default(),
|
||||
) {
|
||||
eprintln!("reference HAL stopped: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
Some("--check-profiles") => {
|
||||
let path = match args.next() {
|
||||
Some(path) => path,
|
||||
None => {
|
||||
eprintln!("usage: alkane-os --check-profiles PATH");
|
||||
std::process::exit(2);
|
||||
}
|
||||
};
|
||||
let text = match std::fs::read_to_string(&path) {
|
||||
Ok(text) => text,
|
||||
Err(error) => {
|
||||
eprintln!("cannot read {path}: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
};
|
||||
match alkane_os::profiles::ProfileDb::from_json(&text) {
|
||||
Ok(db) => {
|
||||
println!("{} profiles, schema 1, validated", db.len());
|
||||
}
|
||||
Err(error) => {
|
||||
eprintln!("profile database rejected: {error:?}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
Some("--check-hal") => {
|
||||
let socket = match args.next() {
|
||||
Some(path) => path,
|
||||
None => {
|
||||
eprintln!("usage: alkane-os --check-hal SOCKET");
|
||||
std::process::exit(2);
|
||||
}
|
||||
};
|
||||
let checks = alkane_os::hal_conformance::run(std::path::Path::new(&socket));
|
||||
let mut failed = 0;
|
||||
for check in &checks {
|
||||
println!(
|
||||
"{:<28} {:<4} {}",
|
||||
check.name,
|
||||
if check.passed { "PASS" } else { "FAIL" },
|
||||
check.detail
|
||||
);
|
||||
if !check.passed {
|
||||
failed += 1;
|
||||
}
|
||||
}
|
||||
if failed > 0 {
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
Some("--self-check") => {
|
||||
if let Err(error) = self_check() {
|
||||
eprintln!("self-check failed: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
Some("--mine-simulator") => {
|
||||
if let Err(error) = sim_mine(args) {
|
||||
eprintln!("simulator mining failed: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
eprintln!("usage: alkane-os --list-targets | --version");
|
||||
eprintln!("usage: alkane-os --list-targets | --version | --self-check | --boot HAL_SOCKET PROFILES.json TARGET [PIC|NOPIC] [TICKS] | --sim-hal SOCKET | --check-hal SOCKET | --check-profiles PATH | --mine-simulator HAL_SOCKET POOL_ADDRESS WORKER BM1362|BM1366 [MAX_ACCEPTS]");
|
||||
eprintln!(
|
||||
"env: ALKANE_API_LISTEN=ADDR ALKANE_WEB_LISTEN=ADDR ALKANE_POOL_PASSWORD=..."
|
||||
);
|
||||
std::process::exit(2);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,445 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Bounded, read-only cgminer-style status for a local management client.
|
||||
|
||||
use crate::detect::{EepromState, HardwarePlan};
|
||||
use serde_json::{json, Value};
|
||||
use std::io::{self, Read, Write};
|
||||
use std::net::{SocketAddr, TcpListener, TcpStream};
|
||||
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
|
||||
use std::sync::Arc;
|
||||
use std::sync::Mutex;
|
||||
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
|
||||
|
||||
const MAX_REQUEST_BYTES: usize = 2048;
|
||||
const CLIENT_TIMEOUT: Duration = Duration::from_millis(500);
|
||||
const REQUEST_DEADLINE: Duration = Duration::from_secs(2);
|
||||
|
||||
/// Everything the extended API exposes beyond share counters.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct HardwareSnapshot {
|
||||
pub plan: HardwarePlan,
|
||||
/// Chains the supervisor still allows work on.
|
||||
pub active_chains: Vec<u8>,
|
||||
/// `None` while hashing; otherwise why the machine stopped.
|
||||
pub stopped: Option<&'static str>,
|
||||
pub frequency_mhz: u16,
|
||||
/// Operator target in the form `power:3000`, `hashrate:200`, `ambient:20000`, `fan:100`.
|
||||
pub target: String,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct MiningStatus {
|
||||
started: Instant,
|
||||
running: AtomicBool,
|
||||
accepted: AtomicU64,
|
||||
rejected: AtomicU64,
|
||||
hardware: Mutex<Option<HardwareSnapshot>>,
|
||||
}
|
||||
|
||||
impl Default for MiningStatus {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl MiningStatus {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
started: Instant::now(),
|
||||
running: AtomicBool::new(false),
|
||||
accepted: AtomicU64::new(0),
|
||||
rejected: AtomicU64::new(0),
|
||||
hardware: Mutex::new(None),
|
||||
}
|
||||
}
|
||||
|
||||
/// Publish the current hardware view for the API.
|
||||
pub fn set_hardware(&self, snapshot: HardwareSnapshot) {
|
||||
if let Ok(mut slot) = self.hardware.lock() {
|
||||
*slot = Some(snapshot);
|
||||
}
|
||||
}
|
||||
|
||||
/// The `hardware` document, for the on-box UI and local clients.
|
||||
pub fn hardware_document(&self) -> Value {
|
||||
hardware_json(self.hardware())
|
||||
}
|
||||
|
||||
/// The `summary` document, for the on-box UI and local clients.
|
||||
pub fn summary_document(&self) -> Value {
|
||||
self.response("summary")
|
||||
}
|
||||
|
||||
fn hardware(&self) -> Option<HardwareSnapshot> {
|
||||
self.hardware.lock().ok().and_then(|slot| slot.clone())
|
||||
}
|
||||
|
||||
pub fn set_running(&self, running: bool) {
|
||||
self.running.store(running, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
pub fn share_accepted(&self) {
|
||||
self.accepted.fetch_add(1, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
pub fn share_rejected(&self) {
|
||||
self.rejected.fetch_add(1, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
fn response(&self, command: &str) -> Value {
|
||||
let now = SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.unwrap_or_default()
|
||||
.as_secs();
|
||||
let (code, description, payload) = match command {
|
||||
"summary" => (
|
||||
"S",
|
||||
"Summary",
|
||||
json!({"SUMMARY": [{
|
||||
"Elapsed": self.started.elapsed().as_secs(),
|
||||
"Accepted": self.accepted.load(Ordering::Relaxed),
|
||||
"Rejected": self.rejected.load(Ordering::Relaxed),
|
||||
"Status": if self.running.load(Ordering::Relaxed) { "Mining" } else { "Stopped" }
|
||||
}]}),
|
||||
),
|
||||
"version" => (
|
||||
"S",
|
||||
"Version",
|
||||
json!({"VERSION": [{
|
||||
"Miner": concat!("alkane-os/", env!("CARGO_PKG_VERSION")),
|
||||
"API": "1.0"
|
||||
}]}),
|
||||
),
|
||||
"hardware" => (
|
||||
"S",
|
||||
"Hardware",
|
||||
json!({"HARDWARE": [hardware_json(self.hardware())]}),
|
||||
),
|
||||
"stats" => (
|
||||
"S",
|
||||
"Stats",
|
||||
json!({"STATS": [stats_json(self.hardware())]}),
|
||||
),
|
||||
_ => ("E", "Unknown command", json!({})),
|
||||
};
|
||||
let mut response = json!({"STATUS": [{
|
||||
"STATUS": code,
|
||||
"When": now,
|
||||
"Code": if code == "S" { 0 } else { 14 },
|
||||
"Msg": description,
|
||||
"Description": "alkane-os"
|
||||
}]});
|
||||
response
|
||||
.as_object_mut()
|
||||
.unwrap()
|
||||
.extend(payload.as_object().unwrap().clone());
|
||||
response
|
||||
}
|
||||
}
|
||||
|
||||
fn eeprom_json(state: &EepromState) -> Value {
|
||||
match state {
|
||||
EepromState::Present { model } => json!({"state": "present", "model": model}),
|
||||
EepromState::Absent => json!({"state": "absent"}),
|
||||
EepromState::Invalid => json!({"state": "invalid"}),
|
||||
}
|
||||
}
|
||||
|
||||
fn hardware_json(snapshot: Option<HardwareSnapshot>) -> Value {
|
||||
let Some(snapshot) = snapshot else {
|
||||
return json!({"available": false});
|
||||
};
|
||||
let plan = &snapshot.plan;
|
||||
json!({
|
||||
"available": true,
|
||||
"profile": plan.profile,
|
||||
"chip": plan.chip.name(),
|
||||
"psu": plan.psu,
|
||||
"envelope": {
|
||||
"v_min_mv": plan.envelope.v_min_mv,
|
||||
"v_max_mv": plan.envelope.v_max_mv,
|
||||
"f_min_mhz": plan.envelope.f_min_mhz,
|
||||
"f_max_mhz": plan.envelope.f_max_mhz,
|
||||
},
|
||||
"operating_point": {
|
||||
"voltage_mv": plan.envelope.voltage_for(snapshot.frequency_mhz),
|
||||
"frequency_mhz": snapshot.frequency_mhz,
|
||||
"confirmed": plan.operating_point.confirmed,
|
||||
},
|
||||
"chains": plan.chains.iter().map(|chain| json!({
|
||||
"index": chain.index,
|
||||
"chip": chain.chip.name(),
|
||||
"chips_found": chain.chips_found,
|
||||
"eeprom": eeprom_json(&chain.eeprom),
|
||||
"response_per_mille": chain.response_per_mille,
|
||||
})).collect::<Vec<_>>(),
|
||||
"fan_zones": plan.fan_zones.iter().map(|zone| json!({
|
||||
"fan": zone.fan,
|
||||
"zones": zone.zones,
|
||||
})).collect::<Vec<_>>(),
|
||||
"active_chains": snapshot.active_chains,
|
||||
"stopped": snapshot.stopped,
|
||||
"target": snapshot.target,
|
||||
"frequency_mhz": snapshot.frequency_mhz,
|
||||
})
|
||||
}
|
||||
|
||||
fn stats_json(snapshot: Option<HardwareSnapshot>) -> Value {
|
||||
let Some(snapshot) = snapshot else {
|
||||
return json!({"available": false});
|
||||
};
|
||||
json!({
|
||||
"Profile": snapshot.plan.profile,
|
||||
"Chip": snapshot.plan.chip.name(),
|
||||
"PSU": snapshot.plan.psu,
|
||||
"FrequencyMHz": snapshot.frequency_mhz,
|
||||
"VoltageMV": snapshot.plan.envelope.voltage_for(snapshot.frequency_mhz),
|
||||
"Target": snapshot.target,
|
||||
"ActiveChains": snapshot.active_chains.len(),
|
||||
"Stopped": snapshot.stopped,
|
||||
})
|
||||
}
|
||||
|
||||
fn request_command(bytes: &[u8]) -> Option<&str> {
|
||||
let request = std::str::from_utf8(bytes).ok()?.trim();
|
||||
if request.starts_with('{') {
|
||||
let value: Value = serde_json::from_str(request).ok()?;
|
||||
let command = value.get("command")?.as_str()?;
|
||||
match command {
|
||||
"summary" => Some("summary"),
|
||||
"version" => Some("version"),
|
||||
"hardware" => Some("hardware"),
|
||||
"stats" => Some("stats"),
|
||||
_ => Some("unknown"),
|
||||
}
|
||||
} else {
|
||||
match request {
|
||||
"summary" => Some("summary"),
|
||||
"version" => Some("version"),
|
||||
"hardware" => Some("hardware"),
|
||||
"stats" => Some("stats"),
|
||||
_ => Some("unknown"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn handle(mut stream: TcpStream, status: &MiningStatus) -> io::Result<()> {
|
||||
stream.set_write_timeout(Some(CLIENT_TIMEOUT))?;
|
||||
let mut request = Vec::new();
|
||||
let mut chunk = [0_u8; 256];
|
||||
let deadline = Instant::now() + REQUEST_DEADLINE;
|
||||
loop {
|
||||
let remaining = deadline.saturating_duration_since(Instant::now());
|
||||
if remaining.is_zero() {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::TimedOut,
|
||||
"management request deadline",
|
||||
));
|
||||
}
|
||||
stream.set_read_timeout(Some(CLIENT_TIMEOUT.min(remaining)))?;
|
||||
let count = match stream.read(&mut chunk) {
|
||||
Ok(count) => count,
|
||||
Err(error) if error.kind() == io::ErrorKind::TimedOut && !request.is_empty() => break,
|
||||
Err(error) if error.kind() == io::ErrorKind::WouldBlock && !request.is_empty() => break,
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
if count == 0 {
|
||||
break;
|
||||
}
|
||||
if request.len() + count > MAX_REQUEST_BYTES {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidData,
|
||||
"management request too large",
|
||||
));
|
||||
}
|
||||
request.extend_from_slice(&chunk[..count]);
|
||||
if request.contains(&b'\n') || request.contains(&0) {
|
||||
break;
|
||||
}
|
||||
if matches!(request_command(&request), Some("summary" | "version"))
|
||||
|| serde_json::from_slice::<Value>(&request).is_ok()
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
let end = request
|
||||
.iter()
|
||||
.position(|byte| *byte == 0 || *byte == b'\n')
|
||||
.unwrap_or(request.len());
|
||||
let command = request_command(&request[..end]).unwrap_or("unknown");
|
||||
let mut reply = serde_json::to_vec(&status.response(command)).map_err(io::Error::other)?;
|
||||
reply.push(0);
|
||||
stream.write_all(&reply)
|
||||
}
|
||||
|
||||
/// Bind only to loopback. The board management plane can be reached through SSH.
|
||||
pub fn bind_local(address: SocketAddr) -> io::Result<TcpListener> {
|
||||
if !address.ip().is_loopback() {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
"management API requires loopback address",
|
||||
));
|
||||
}
|
||||
TcpListener::bind(address)
|
||||
}
|
||||
|
||||
pub fn serve(listener: TcpListener, status: Arc<MiningStatus>) -> io::Result<()> {
|
||||
for stream in listener.incoming() {
|
||||
let stream = stream?;
|
||||
if let Err(error) = handle(stream, &status) {
|
||||
eprintln!("management request failed: {error}");
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::net::TcpStream;
|
||||
|
||||
#[test]
|
||||
fn refuses_nonlocal_bind() {
|
||||
let address = "0.0.0.0:0".parse().unwrap();
|
||||
assert_eq!(
|
||||
bind_local(address).unwrap_err().kind(),
|
||||
io::ErrorKind::InvalidInput
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reports_only_observed_share_counts() {
|
||||
let status = MiningStatus::new();
|
||||
status.set_running(true);
|
||||
status.share_accepted();
|
||||
status.share_rejected();
|
||||
let reply = status.response("summary");
|
||||
assert_eq!(reply["SUMMARY"][0]["Accepted"], 1);
|
||||
assert_eq!(reply["SUMMARY"][0]["Rejected"], 1);
|
||||
assert_eq!(reply["SUMMARY"][0]["Status"], "Mining");
|
||||
assert!(reply["SUMMARY"][0].get("MHS av").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn local_socket_uses_nul_terminated_cgminer_envelope() {
|
||||
let listener = bind_local("127.0.0.1:0".parse().unwrap()).unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
let worker = std::thread::spawn(move || {
|
||||
let (stream, _) = listener.accept().unwrap();
|
||||
handle(stream, &status).unwrap();
|
||||
});
|
||||
let mut client = TcpStream::connect(address).unwrap();
|
||||
client.write_all(b"{\"command\":\"summary\"}\n").unwrap();
|
||||
let mut reply = Vec::new();
|
||||
client.read_to_end(&mut reply).unwrap();
|
||||
assert_eq!(reply.pop(), Some(0));
|
||||
let parsed: Value = serde_json::from_slice(&reply).unwrap();
|
||||
assert_eq!(parsed["STATUS"][0]["STATUS"], "S");
|
||||
assert_eq!(parsed["SUMMARY"][0]["Status"], "Stopped");
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fragmented_plain_command_is_not_answered_early() {
|
||||
let listener = bind_local("127.0.0.1:0".parse().unwrap()).unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
let worker = std::thread::spawn(move || {
|
||||
let (stream, _) = listener.accept().unwrap();
|
||||
handle(stream, &status).unwrap();
|
||||
});
|
||||
let mut client = TcpStream::connect(address).unwrap();
|
||||
client.write_all(b"sum").unwrap();
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
client.write_all(b"mary").unwrap();
|
||||
let mut reply = Vec::new();
|
||||
client.read_to_end(&mut reply).unwrap();
|
||||
assert_eq!(reply.pop(), Some(0));
|
||||
let parsed: Value = serde_json::from_slice(&reply).unwrap();
|
||||
assert_eq!(parsed["STATUS"][0]["STATUS"], "S");
|
||||
assert!(parsed.get("SUMMARY").is_some());
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
fn snapshot() -> HardwareSnapshot {
|
||||
HardwareSnapshot {
|
||||
plan: HardwarePlan {
|
||||
profile: "s19jpro-bm1362-pic".into(),
|
||||
chip: crate::detect::ChipModel::Bm1362,
|
||||
chains: vec![crate::detect::ChainReport {
|
||||
index: 0,
|
||||
chip: crate::detect::ChipModel::Bm1362,
|
||||
chips_found: 126,
|
||||
eeprom: EepromState::Absent,
|
||||
response_per_mille: Some(950),
|
||||
}],
|
||||
envelope: crate::detect::Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
},
|
||||
operating_point: crate::detect::OperatingPoint {
|
||||
voltage_mv: 1200,
|
||||
frequency_mhz: 500,
|
||||
confirmed: false,
|
||||
},
|
||||
psu: "APW12".into(),
|
||||
fan_zones: vec![crate::detect::FanZone {
|
||||
fan: 0,
|
||||
zones: vec![0, 1],
|
||||
}],
|
||||
},
|
||||
active_chains: vec![0],
|
||||
stopped: None,
|
||||
frequency_mhz: 512,
|
||||
target: "power:3000".into(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hardware_is_unavailable_until_published() {
|
||||
let status = MiningStatus::new();
|
||||
let reply = status.response("hardware");
|
||||
assert_eq!(reply["HARDWARE"][0]["available"], false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hardware_command_exposes_detection_and_fault_state() {
|
||||
let status = MiningStatus::new();
|
||||
status.set_hardware(snapshot());
|
||||
let reply = status.response("hardware");
|
||||
let hardware = &reply["HARDWARE"][0];
|
||||
assert_eq!(hardware["available"], true);
|
||||
assert_eq!(hardware["profile"], "s19jpro-bm1362-pic");
|
||||
assert_eq!(hardware["chip"], "bm1362");
|
||||
assert_eq!(hardware["psu"], "APW12");
|
||||
assert_eq!(hardware["chains"][0]["chips_found"], 126);
|
||||
assert_eq!(hardware["chains"][0]["eeprom"]["state"], "absent");
|
||||
assert_eq!(hardware["operating_point"]["confirmed"], false);
|
||||
assert_eq!(hardware["active_chains"][0], 0);
|
||||
assert_eq!(hardware["target"], "power:3000");
|
||||
assert_eq!(hardware["fan_zones"][0]["zones"][1], 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stats_command_keeps_cgminer_shape() {
|
||||
let status = MiningStatus::new();
|
||||
status.set_hardware(snapshot());
|
||||
let reply = status.response("stats");
|
||||
let stats = &reply["STATS"][0];
|
||||
assert_eq!(stats["Profile"], "s19jpro-bm1362-pic");
|
||||
assert_eq!(stats["FrequencyMHz"], 512);
|
||||
assert_eq!(stats["VoltageMV"], 1312);
|
||||
assert_eq!(stats["ActiveChains"], 1);
|
||||
assert!(stats["Stopped"].is_null());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_commands_still_refuse() {
|
||||
let status = MiningStatus::new();
|
||||
let reply = status.response("reboot");
|
||||
assert_eq!(reply["STATUS"][0]["STATUS"], "E");
|
||||
}
|
||||
}
|
||||
+327
@@ -0,0 +1,327 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! One-chain BM13xx mining control built on the SDK hardware backend.
|
||||
//! This module never searches for nonces or chooses board safety thresholds.
|
||||
|
||||
use crate::bm1362;
|
||||
use crate::bm1366::{decode_nonce_report, encode_work, ReportError, REPORT_BYTES};
|
||||
use crate::pow::verify_sha256_report;
|
||||
use crate::{power_decision, HardwareBackend, PowerDecision};
|
||||
use std::fmt;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum ChipModel {
|
||||
Bm1362,
|
||||
Bm1366,
|
||||
}
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub enum MinerError<E> {
|
||||
Backend(E),
|
||||
AlreadyRunning,
|
||||
NotRunning,
|
||||
Faulted,
|
||||
WorkIdInUse(u8),
|
||||
UnsafeTemperature(i32),
|
||||
InvalidWork,
|
||||
InvalidReport(ReportError),
|
||||
StaleReport,
|
||||
BelowTarget,
|
||||
}
|
||||
|
||||
impl<E: fmt::Display> fmt::Display for MinerError<E> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Backend(error) => write!(f, "hardware backend: {error}"),
|
||||
Self::AlreadyRunning => f.write_str("miner is already running"),
|
||||
Self::NotRunning => f.write_str("miner is not running"),
|
||||
Self::Faulted => f.write_str("miner shutdown is unconfirmed"),
|
||||
Self::WorkIdInUse(id) => write!(f, "BM13xx work ID {id} is still in use"),
|
||||
Self::UnsafeTemperature(value) => write!(f, "unsafe temperature: {value} mC"),
|
||||
Self::InvalidWork => f.write_str("invalid BM13xx work"),
|
||||
Self::InvalidReport(error) => write!(f, "invalid BM13xx report: {error:?}"),
|
||||
Self::StaleReport => f.write_str("stale BM13xx work ID"),
|
||||
Self::BelowTarget => f.write_str("nonce is below the pool target"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: std::error::Error + 'static> std::error::Error for MinerError<E> {}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ValidShare {
|
||||
pub nonce: u32,
|
||||
pub work_id: u8,
|
||||
pub rolled_version: u32,
|
||||
pub hash_le: [u8; 32],
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
struct Work {
|
||||
header: [u8; 80],
|
||||
target_le: [u8; 32],
|
||||
id: u8,
|
||||
}
|
||||
|
||||
pub struct Bm1366Miner<'a, B: HardwareBackend> {
|
||||
backend: &'a mut B,
|
||||
chip: ChipModel,
|
||||
chain: u8,
|
||||
sensor: u8,
|
||||
fan: u8,
|
||||
fan_percent: u8,
|
||||
max_temperature_mc: i32,
|
||||
running: bool,
|
||||
faulted: bool,
|
||||
work: [Option<Work>; 32],
|
||||
used_work_ids: [bool; 32],
|
||||
}
|
||||
|
||||
impl<'a, B: HardwareBackend> Bm1366Miner<'a, B> {
|
||||
/// The caller supplies a threshold validated for this board revision.
|
||||
pub fn new(
|
||||
backend: &'a mut B,
|
||||
chain: u8,
|
||||
sensor: u8,
|
||||
fan: u8,
|
||||
fan_percent: u8,
|
||||
max_temperature_mc: i32,
|
||||
) -> Option<Self> {
|
||||
Self::new_for_chip(
|
||||
backend,
|
||||
ChipModel::Bm1366,
|
||||
chain,
|
||||
sensor,
|
||||
fan,
|
||||
fan_percent,
|
||||
max_temperature_mc,
|
||||
)
|
||||
}
|
||||
|
||||
/// Select the captured BM1362 or BM1366 work format explicitly.
|
||||
pub fn new_for_chip(
|
||||
backend: &'a mut B,
|
||||
chip: ChipModel,
|
||||
chain: u8,
|
||||
sensor: u8,
|
||||
fan: u8,
|
||||
fan_percent: u8,
|
||||
max_temperature_mc: i32,
|
||||
) -> Option<Self> {
|
||||
if fan_percent == 0 || fan_percent > 100 || max_temperature_mc <= 0 {
|
||||
return None;
|
||||
}
|
||||
Some(Self {
|
||||
backend,
|
||||
chip,
|
||||
chain,
|
||||
sensor,
|
||||
fan,
|
||||
fan_percent,
|
||||
max_temperature_mc,
|
||||
running: false,
|
||||
faulted: false,
|
||||
work: [None; 32],
|
||||
used_work_ids: [false; 32],
|
||||
})
|
||||
}
|
||||
|
||||
fn power_off(&mut self) -> Result<(), B::Error> {
|
||||
self.work = [None; 32];
|
||||
match self.backend.set_psu_enabled(false) {
|
||||
Ok(()) => {
|
||||
self.running = false;
|
||||
self.faulted = false;
|
||||
self.used_work_ids = [false; 32];
|
||||
Ok(())
|
||||
}
|
||||
Err(error) => {
|
||||
// The backend may have left power on. Drop retries shutdown.
|
||||
self.running = true;
|
||||
self.faulted = true;
|
||||
Err(error)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn check_temperature(&mut self) -> Result<(), MinerError<B::Error>> {
|
||||
let value = match self.backend.read_temperature_mc(self.sensor) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
};
|
||||
if power_decision(Some(value), self.max_temperature_mc) == PowerDecision::Stop {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::UnsafeTemperature(value));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn start(&mut self) -> Result<(), MinerError<B::Error>> {
|
||||
if self.running {
|
||||
return Err(MinerError::AlreadyRunning);
|
||||
}
|
||||
self.power_off().map_err(MinerError::Backend)?;
|
||||
self.check_temperature()?;
|
||||
self.backend
|
||||
.set_fan_target(self.fan, self.fan_percent)
|
||||
.map_err(MinerError::Backend)?;
|
||||
if let Err(error) = self.backend.set_psu_enabled(true) {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
self.running = true;
|
||||
if let Err(error) = self.backend.set_chain_reset(self.chain, true) {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
if let Err(error) = self.backend.set_chain_reset(self.chain, false) {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn stop(&mut self) -> Result<(), B::Error> {
|
||||
self.power_off()
|
||||
}
|
||||
|
||||
/// Flush the ASIC's in-flight work before reusing any work IDs. A reset
|
||||
/// failure shuts the PSU down because old reports may still arrive.
|
||||
pub fn reset_chain(&mut self) -> Result<(), MinerError<B::Error>> {
|
||||
if !self.running {
|
||||
return Err(MinerError::NotRunning);
|
||||
}
|
||||
if self.faulted {
|
||||
return Err(MinerError::Faulted);
|
||||
}
|
||||
self.work = [None; 32];
|
||||
self.check_temperature()?;
|
||||
if let Err(error) = self.backend.set_chain_reset(self.chain, true) {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
if let Err(error) = self.backend.set_chain_reset(self.chain, false) {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
self.used_work_ids = [false; 32];
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn submit(
|
||||
&mut self,
|
||||
header: [u8; 80],
|
||||
target_le: [u8; 32],
|
||||
work_id: u8,
|
||||
) -> Result<(), MinerError<B::Error>> {
|
||||
if !self.running {
|
||||
return Err(MinerError::NotRunning);
|
||||
}
|
||||
if self.faulted {
|
||||
return Err(MinerError::Faulted);
|
||||
}
|
||||
self.check_temperature()?;
|
||||
let frame = match self.chip {
|
||||
ChipModel::Bm1362 => bm1362::encode_work(&header, work_id),
|
||||
ChipModel::Bm1366 => encode_work(&header, work_id),
|
||||
}
|
||||
.ok_or(MinerError::InvalidWork)?;
|
||||
let slot = usize::from(work_id >> 3);
|
||||
if self.used_work_ids[slot] {
|
||||
return Err(MinerError::WorkIdInUse(work_id));
|
||||
}
|
||||
// A failed send may still have reached the ASIC, so reserve first.
|
||||
self.used_work_ids[slot] = true;
|
||||
if let Err(error) = self.backend.send_frame(self.chain, &frame) {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
self.work[slot] = Some(Work {
|
||||
header,
|
||||
target_le,
|
||||
id: work_id,
|
||||
});
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Forget prior pool jobs after `clean_jobs`, while leaving the ASIC powered.
|
||||
/// Reports already in flight are then classified as stale. Their work IDs
|
||||
/// remain reserved until a confirmed chain reset or PSU shutdown.
|
||||
pub fn clear_work(&mut self) {
|
||||
self.work = [None; 32];
|
||||
}
|
||||
|
||||
pub fn poll(&mut self) -> Result<Option<ValidShare>, MinerError<B::Error>> {
|
||||
if !self.running {
|
||||
return Err(MinerError::NotRunning);
|
||||
}
|
||||
if self.faulted {
|
||||
return Err(MinerError::Faulted);
|
||||
}
|
||||
self.check_temperature()?;
|
||||
let mut frame = [0_u8; REPORT_BYTES];
|
||||
let length = match self.backend.receive_frame(self.chain, &mut frame) {
|
||||
Ok(length) => length,
|
||||
Err(error) => {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
};
|
||||
if length == 0 {
|
||||
return Ok(None);
|
||||
}
|
||||
let report = match decode_nonce_report(&frame[..length.min(REPORT_BYTES)]) {
|
||||
Ok(report) if length == REPORT_BYTES => report,
|
||||
Ok(_) => {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::InvalidReport(ReportError::Length));
|
||||
}
|
||||
Err(error) => {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::InvalidReport(error));
|
||||
}
|
||||
};
|
||||
let Some(work) = self.work[usize::from(report.work_id >> 3)] else {
|
||||
return Err(MinerError::StaleReport);
|
||||
};
|
||||
if report.work_id != work.id {
|
||||
return Err(MinerError::StaleReport);
|
||||
}
|
||||
let check = verify_sha256_report(
|
||||
&work.header,
|
||||
report.nonce,
|
||||
report.version_field,
|
||||
&work.target_le,
|
||||
);
|
||||
if !check.meets_target {
|
||||
return Err(MinerError::BelowTarget);
|
||||
}
|
||||
Ok(Some(ValidShare {
|
||||
nonce: report.nonce,
|
||||
work_id: report.work_id,
|
||||
rolled_version: check.rolled_version,
|
||||
hash_le: check.hash_le,
|
||||
}))
|
||||
}
|
||||
|
||||
/// Keep thermal supervision active while pool share replies are pending.
|
||||
pub fn supervise(&mut self) -> Result<(), MinerError<B::Error>> {
|
||||
if !self.running {
|
||||
return Err(MinerError::NotRunning);
|
||||
}
|
||||
if self.faulted {
|
||||
return Err(MinerError::Faulted);
|
||||
}
|
||||
self.check_temperature()
|
||||
}
|
||||
}
|
||||
|
||||
impl<B: HardwareBackend> Drop for Bm1366Miner<'_, B> {
|
||||
fn drop(&mut self) {
|
||||
if self.running {
|
||||
let _ = self.power_off();
|
||||
}
|
||||
}
|
||||
}
|
||||
+238
@@ -0,0 +1,238 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Verify reported SHA-256d shares. This module does not search for nonces.
|
||||
|
||||
const BM1366_VERSION_BITS: u32 = 0x1FFF_E000;
|
||||
|
||||
const ROUND: [u32; 64] = [
|
||||
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
|
||||
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
|
||||
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
|
||||
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
|
||||
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
|
||||
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
|
||||
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
|
||||
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
|
||||
];
|
||||
|
||||
const INITIAL: [u32; 8] = [
|
||||
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
|
||||
];
|
||||
|
||||
fn compress(state: &mut [u32; 8], block: &[u8]) {
|
||||
let mut words = [0_u32; 64];
|
||||
for (index, part) in block.chunks_exact(4).enumerate() {
|
||||
words[index] = u32::from_be_bytes(part.try_into().expect("four-byte word"));
|
||||
}
|
||||
for index in 16..64 {
|
||||
let a = words[index - 15];
|
||||
let b = words[index - 2];
|
||||
let small_zero = a.rotate_right(7) ^ a.rotate_right(18) ^ (a >> 3);
|
||||
let small_one = b.rotate_right(17) ^ b.rotate_right(19) ^ (b >> 10);
|
||||
words[index] = words[index - 16]
|
||||
.wrapping_add(small_zero)
|
||||
.wrapping_add(words[index - 7])
|
||||
.wrapping_add(small_one);
|
||||
}
|
||||
|
||||
let [mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut h] = *state;
|
||||
for index in 0..64 {
|
||||
let choose = (e & f) ^ (!e & g);
|
||||
let majority = (a & b) ^ (a & c) ^ (b & c);
|
||||
let big_one = e.rotate_right(6) ^ e.rotate_right(11) ^ e.rotate_right(25);
|
||||
let big_zero = a.rotate_right(2) ^ a.rotate_right(13) ^ a.rotate_right(22);
|
||||
let first = h
|
||||
.wrapping_add(big_one)
|
||||
.wrapping_add(choose)
|
||||
.wrapping_add(ROUND[index])
|
||||
.wrapping_add(words[index]);
|
||||
let second = big_zero.wrapping_add(majority);
|
||||
h = g;
|
||||
g = f;
|
||||
f = e;
|
||||
e = d.wrapping_add(first);
|
||||
d = c;
|
||||
c = b;
|
||||
b = a;
|
||||
a = first.wrapping_add(second);
|
||||
}
|
||||
for (current, result) in state.iter_mut().zip([a, b, c, d, e, f, g, h]) {
|
||||
*current = current.wrapping_add(result);
|
||||
}
|
||||
}
|
||||
|
||||
/// Compute SHA-256 for a message whose length fits the standard 64-bit field.
|
||||
pub fn sha256(message: &[u8]) -> [u8; 32] {
|
||||
let mut state = INITIAL;
|
||||
let chunks = message.chunks_exact(64);
|
||||
let remainder = chunks.remainder();
|
||||
for chunk in chunks {
|
||||
compress(&mut state, chunk);
|
||||
}
|
||||
let final_size = if remainder.len() >= 56 { 128 } else { 64 };
|
||||
let mut final_blocks = [0_u8; 128];
|
||||
final_blocks[..remainder.len()].copy_from_slice(remainder);
|
||||
final_blocks[remainder.len()] = 0x80;
|
||||
final_blocks[final_size - 8..final_size]
|
||||
.copy_from_slice(&((message.len() as u64).wrapping_mul(8)).to_be_bytes());
|
||||
for chunk in final_blocks[..final_size].chunks_exact(64) {
|
||||
compress(&mut state, chunk);
|
||||
}
|
||||
let mut digest = [0_u8; 32];
|
||||
for (word, bytes) in state.into_iter().zip(digest.chunks_exact_mut(4)) {
|
||||
bytes.copy_from_slice(&word.to_be_bytes());
|
||||
}
|
||||
digest
|
||||
}
|
||||
|
||||
/// Compute one double hash for verification, never for nonce search.
|
||||
pub fn sha256d(message: &[u8]) -> [u8; 32] {
|
||||
sha256(&sha256(message))
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ShareCheck {
|
||||
pub rolled_version: u32,
|
||||
pub hash_le: [u8; 32],
|
||||
pub meets_target: bool,
|
||||
}
|
||||
|
||||
/// Decode the raw BM1366 version extension against the version sent to the ASIC.
|
||||
/// The chip reports additional set bits; pool submission uses a separate mask.
|
||||
pub fn decode_bm1366_version(job_version: u32, version_field: u16) -> u32 {
|
||||
job_version | ((u32::from(version_field) << 13) & BM1366_VERSION_BITS)
|
||||
}
|
||||
|
||||
/// The BIP310 mask negotiated with a pool, limited to BM1366 rolling bits.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct VersionMask(u32);
|
||||
|
||||
impl VersionMask {
|
||||
pub fn new(mask: u32) -> Option<Self> {
|
||||
(mask & !BM1366_VERSION_BITS == 0).then_some(Self(mask))
|
||||
}
|
||||
|
||||
pub fn apply_submission_bits(self, base_version: u32, version_bits: u32) -> Option<u32> {
|
||||
(version_bits & !self.0 == 0).then_some((base_version & !self.0) | version_bits)
|
||||
}
|
||||
|
||||
pub fn bits(self) -> u32 {
|
||||
self.0
|
||||
}
|
||||
}
|
||||
|
||||
/// Check one ASIC-reported nonce against a little-endian 256-bit pool target.
|
||||
pub fn verify_sha256_report(
|
||||
nonce_zero_header: &[u8; 80],
|
||||
nonce: u32,
|
||||
version_field: u16,
|
||||
target_le: &[u8; 32],
|
||||
) -> ShareCheck {
|
||||
let mut header = *nonce_zero_header;
|
||||
let base_version = u32::from_le_bytes(header[..4].try_into().expect("version field"));
|
||||
let rolled_version = decode_bm1366_version(base_version, version_field);
|
||||
header[..4].copy_from_slice(&rolled_version.to_le_bytes());
|
||||
header[76..80].copy_from_slice(&nonce.to_le_bytes());
|
||||
let hash_le = sha256d(&header);
|
||||
let meets_target = hash_le.iter().rev().cmp(target_le.iter().rev()).is_le();
|
||||
ShareCheck {
|
||||
rolled_version,
|
||||
hash_le,
|
||||
meets_target,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn hex(bytes: &[u8]) -> String {
|
||||
bytes.iter().map(|byte| format!("{byte:02x}")).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sha256_matches_standard_padding_vectors() {
|
||||
let vectors: [(&[u8], &str); 6] = [
|
||||
(
|
||||
b"",
|
||||
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
|
||||
),
|
||||
(
|
||||
b"abc",
|
||||
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
|
||||
),
|
||||
(
|
||||
&(0_u8..55).collect::<Vec<_>>(),
|
||||
"463eb28e72f82e0a96c0a4cc53690c571281131f672aa229e0d45ae59b598b59",
|
||||
),
|
||||
(
|
||||
&(0_u8..56).collect::<Vec<_>>(),
|
||||
"da2ae4d6b36748f2a318f23e7ab1dfdf45acdc9d049bd80e59de82a60895f562",
|
||||
),
|
||||
(
|
||||
&(0_u8..64).collect::<Vec<_>>(),
|
||||
"fdeab9acf3710362bd2658cdc9a29e8f9c757fcf9811603a8c447cd1d9151108",
|
||||
),
|
||||
(
|
||||
&(0_u8..100).collect::<Vec<_>>(),
|
||||
"bce0aff19cf5aa6a7469a30d61d04e4376e4bbf6381052ee9e7f33925c954d52",
|
||||
),
|
||||
];
|
||||
for (message, expected) in vectors {
|
||||
assert_eq!(hex(&sha256(message)), expected);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn captured_bm1366_report_meets_diff_one_only_with_rolled_version() {
|
||||
let header = [
|
||||
0x00, 0x00, 0x00, 0x20, 0xfc, 0x3a, 0xb8, 0xd4, 0x30, 0x21, 0xf4, 0x5e, 0xb6, 0x62,
|
||||
0x38, 0x9d, 0x0f, 0x79, 0x1f, 0x65, 0x7d, 0xbf, 0x75, 0xa5, 0xcb, 0x93, 0x67, 0x0b,
|
||||
0x57, 0xb6, 0xc2, 0x25, 0x03, 0xb4, 0x21, 0x3a, 0x43, 0xae, 0x10, 0x52, 0xeb, 0xd4,
|
||||
0x44, 0x43, 0x06, 0x8f, 0xe1, 0x78, 0xe2, 0xc6, 0x1c, 0xa4, 0x99, 0x48, 0x46, 0xfd,
|
||||
0x13, 0x3a, 0xdd, 0xb0, 0x4a, 0xab, 0x2b, 0x38, 0x2c, 0x5b, 0x4c, 0x74, 0xc1, 0x01,
|
||||
0x2e, 0x6a, 0x8f, 0x06, 0x02, 0x17, 0x00, 0x00, 0x00, 0x00,
|
||||
];
|
||||
let mut diff_one = [0_u8; 32];
|
||||
diff_one[26..28].fill(0xff);
|
||||
let result = verify_sha256_report(&header, 0xEDAD_FF38, 0x04B3, &diff_one);
|
||||
assert_eq!(result.rolled_version, 0x2096_6000);
|
||||
assert_eq!(
|
||||
hex(&result.hash_le),
|
||||
"4b5e00850cf9de9809f822f8858eda39e49996d9d40f634f1043290000000000"
|
||||
);
|
||||
assert!(result.meets_target);
|
||||
assert!(!verify_sha256_report(&header, 0xEDAD_FF38, 0, &diff_one).meets_target);
|
||||
assert!(!verify_sha256_report(&header, 0xEDAD_FF39, 0x04B3, &diff_one).meets_target);
|
||||
assert!(verify_sha256_report(&header, 0xEDAD_FF38, 0x04B3, &[0xff; 32]).meets_target);
|
||||
assert!(!verify_sha256_report(&header, 0xEDAD_FF38, 0x04B3, &[0; 32]).meets_target);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raw_asic_version_preserves_bits_sent_to_chip() {
|
||||
assert_eq!(decode_bm1366_version(0x2100_0004, 1), 0x2100_2004);
|
||||
assert_eq!(decode_bm1366_version(0x2000_0000, 0), 0x2000_0000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pool_version_bits_replace_only_negotiated_mask() {
|
||||
let mask = VersionMask::new(0x0060_0000).expect("valid restricted mask");
|
||||
assert_eq!(
|
||||
mask.apply_submission_bits(0x2160_0004, 0x0020_0000),
|
||||
Some(0x2120_0004)
|
||||
);
|
||||
assert_eq!(mask.apply_submission_bits(0x2160_0004, 0x0080_0000), None);
|
||||
assert_eq!(
|
||||
VersionMask::new(0)
|
||||
.unwrap()
|
||||
.apply_submission_bits(0x2100_0004, 0),
|
||||
Some(0x2100_0004)
|
||||
);
|
||||
assert_eq!(
|
||||
VersionMask::new(BM1366_VERSION_BITS)
|
||||
.unwrap()
|
||||
.apply_submission_bits(0x2160_0004, 0),
|
||||
Some(0x2000_0004)
|
||||
);
|
||||
assert!(VersionMask::new(0x8000_0000).is_none());
|
||||
}
|
||||
}
|
||||
+236
@@ -0,0 +1,236 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Board profile database.
|
||||
//!
|
||||
//! Profiles carry the safe voltage/frequency envelope a chip/board combination may run inside.
|
||||
//! Detection may only use what this database provides: if a combination is absent, the answer is
|
||||
//! "refuse", never "assume a number". Entries are data, so they can be filled from captures
|
||||
//! without touching code.
|
||||
|
||||
use crate::detect::{BoardProfile, ChipModel, Envelope, SensorTopology};
|
||||
use serde_json::Value;
|
||||
|
||||
/// Why a profile database was rejected.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum ProfileError {
|
||||
InvalidJson,
|
||||
UnsupportedSchema,
|
||||
MissingProfiles,
|
||||
UnknownChip(String),
|
||||
UnknownSensor(String),
|
||||
InvalidEnvelope(String),
|
||||
DuplicateName(String),
|
||||
}
|
||||
|
||||
/// A validated set of profiles.
|
||||
#[derive(Clone, Debug, Default, Eq, PartialEq)]
|
||||
pub struct ProfileDb {
|
||||
profiles: Vec<BoardProfile>,
|
||||
}
|
||||
|
||||
impl ProfileDb {
|
||||
/// Validate and keep a set of profiles.
|
||||
pub fn new(profiles: Vec<BoardProfile>) -> Result<Self, ProfileError> {
|
||||
for (index, profile) in profiles.iter().enumerate() {
|
||||
if profiles[..index]
|
||||
.iter()
|
||||
.any(|other| other.name == profile.name)
|
||||
{
|
||||
return Err(ProfileError::DuplicateName(profile.name.clone()));
|
||||
}
|
||||
if profile.chains == 0 {
|
||||
return Err(ProfileError::InvalidEnvelope(profile.name.clone()));
|
||||
}
|
||||
let envelope = profile.envelope;
|
||||
if envelope.v_min_mv == 0
|
||||
|| envelope.v_min_mv > envelope.v_max_mv
|
||||
|| envelope.f_min_mhz > envelope.f_max_mhz
|
||||
{
|
||||
return Err(ProfileError::InvalidEnvelope(profile.name.clone()));
|
||||
}
|
||||
}
|
||||
Ok(Self { profiles })
|
||||
}
|
||||
|
||||
/// Parse the schema-1 profile document.
|
||||
pub fn from_json(text: &str) -> Result<Self, ProfileError> {
|
||||
let root: Value = serde_json::from_str(text).map_err(|_| ProfileError::InvalidJson)?;
|
||||
match root.get("schema").and_then(Value::as_u64) {
|
||||
Some(1) => {}
|
||||
Some(_) => return Err(ProfileError::UnsupportedSchema),
|
||||
None => return Err(ProfileError::UnsupportedSchema),
|
||||
}
|
||||
let entries = root
|
||||
.get("profiles")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or(ProfileError::MissingProfiles)?;
|
||||
let mut profiles = Vec::with_capacity(entries.len());
|
||||
for entry in entries {
|
||||
profiles.push(profile_from_value(entry)?);
|
||||
}
|
||||
if profiles.is_empty() {
|
||||
return Err(ProfileError::MissingProfiles);
|
||||
}
|
||||
Self::new(profiles)
|
||||
}
|
||||
|
||||
/// Exact lookup: a profile only applies to the chip, chain count and sensor wiring it declares.
|
||||
pub fn find(
|
||||
&self,
|
||||
chip: ChipModel,
|
||||
chains: u8,
|
||||
sensor: SensorTopology,
|
||||
) -> Option<&BoardProfile> {
|
||||
self.profiles.iter().find(|profile| {
|
||||
profile.chip == chip && profile.chains == chains && profile.sensor == sensor
|
||||
})
|
||||
}
|
||||
|
||||
pub fn len(&self) -> usize {
|
||||
self.profiles.len()
|
||||
}
|
||||
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.profiles.is_empty()
|
||||
}
|
||||
}
|
||||
|
||||
fn profile_from_value(entry: &Value) -> Result<BoardProfile, ProfileError> {
|
||||
let name = entry
|
||||
.get("name")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or(ProfileError::InvalidJson)?
|
||||
.to_owned();
|
||||
let chip_text = entry
|
||||
.get("chip")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or(ProfileError::UnknownChip(name.clone()))?;
|
||||
let chip = match chip_text {
|
||||
"bm1362" => ChipModel::Bm1362,
|
||||
"bm1366" => ChipModel::Bm1366,
|
||||
"bm1368" => ChipModel::Bm1368,
|
||||
"bm1370" => ChipModel::Bm1370,
|
||||
"bm1398" => ChipModel::Bm1398,
|
||||
other => return Err(ProfileError::UnknownChip(other.to_owned())),
|
||||
};
|
||||
let sensor_text = entry
|
||||
.get("sensor")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or(ProfileError::UnknownSensor(name.clone()))?;
|
||||
let sensor = match sensor_text {
|
||||
"pic" => SensorTopology::Pic,
|
||||
"nopic" => SensorTopology::NoPic,
|
||||
"unknown" => SensorTopology::Unknown,
|
||||
other => return Err(ProfileError::UnknownSensor(other.to_owned())),
|
||||
};
|
||||
let chains = entry
|
||||
.get("chains")
|
||||
.and_then(Value::as_u64)
|
||||
.and_then(|value| u8::try_from(value).ok())
|
||||
.ok_or(ProfileError::InvalidEnvelope(name.clone()))?;
|
||||
let envelope = entry
|
||||
.get("envelope")
|
||||
.and_then(Value::as_object)
|
||||
.ok_or(ProfileError::InvalidEnvelope(name.clone()))?;
|
||||
let field = |key: &str| -> Result<u16, ProfileError> {
|
||||
envelope
|
||||
.get(key)
|
||||
.and_then(Value::as_u64)
|
||||
.and_then(|value| u16::try_from(value).ok())
|
||||
.ok_or(ProfileError::InvalidEnvelope(name.clone()))
|
||||
};
|
||||
let envelope = Envelope {
|
||||
v_min_mv: field("v_min_mv")?,
|
||||
v_max_mv: field("v_max_mv")?,
|
||||
f_min_mhz: field("f_min_mhz")?,
|
||||
f_max_mhz: field("f_max_mhz")?,
|
||||
};
|
||||
Ok(BoardProfile {
|
||||
name,
|
||||
chip,
|
||||
sensor,
|
||||
chains,
|
||||
envelope,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
const VALID: &str = r#"{
|
||||
"schema": 1,
|
||||
"profiles": [
|
||||
{
|
||||
"name": "s19jpro-bm1362-pic",
|
||||
"chip": "bm1362",
|
||||
"sensor": "pic",
|
||||
"chains": 3,
|
||||
"envelope": {"v_min_mv": 1100, "v_max_mv": 1500, "f_min_mhz": 300, "f_max_mhz": 700}
|
||||
}
|
||||
]
|
||||
}"#;
|
||||
|
||||
#[test]
|
||||
fn valid_document_loads_and_resolves() {
|
||||
let db = ProfileDb::from_json(VALID).expect("db");
|
||||
assert_eq!(db.len(), 1);
|
||||
let profile = db
|
||||
.find(ChipModel::Bm1362, 3, SensorTopology::Pic)
|
||||
.expect("profile");
|
||||
assert_eq!(profile.name, "s19jpro-bm1362-pic");
|
||||
assert_eq!(profile.envelope.v_max_mv, 1500);
|
||||
assert!(db.find(ChipModel::Bm1362, 2, SensorTopology::Pic).is_none());
|
||||
assert!(db
|
||||
.find(ChipModel::Bm1362, 3, SensorTopology::NoPic)
|
||||
.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_chip_is_rejected() {
|
||||
let text = VALID.replace("bm1362", "bm9999");
|
||||
assert_eq!(
|
||||
ProfileDb::from_json(&text),
|
||||
Err(ProfileError::UnknownChip("bm9999".into()))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inverted_envelope_is_rejected() {
|
||||
let text = VALID.replace(
|
||||
"\"v_min_mv\": 1100, \"v_max_mv\": 1500",
|
||||
"\"v_min_mv\": 1500, \"v_max_mv\": 1100",
|
||||
);
|
||||
assert!(matches!(
|
||||
ProfileDb::from_json(&text),
|
||||
Err(ProfileError::InvalidEnvelope(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrong_schema_is_rejected() {
|
||||
let text = VALID.replace("\"schema\": 1", "\"schema\": 2");
|
||||
assert_eq!(
|
||||
ProfileDb::from_json(&text),
|
||||
Err(ProfileError::UnsupportedSchema)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_profiles_are_rejected() {
|
||||
assert_eq!(
|
||||
ProfileDb::from_json("{\"schema\": 1}"),
|
||||
Err(ProfileError::MissingProfiles)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn duplicate_names_are_rejected() {
|
||||
let one = VALID.split("\"profiles\": [").nth(1).unwrap();
|
||||
let entry = one.trim().trim_end_matches("]\n }").trim();
|
||||
let duplicated = format!("{{\"schema\": 1, \"profiles\": [{entry}, {entry}]}}");
|
||||
assert!(matches!(
|
||||
ProfileDb::from_json(&duplicated),
|
||||
Err(ProfileError::DuplicateName(_))
|
||||
));
|
||||
}
|
||||
}
|
||||
+287
@@ -0,0 +1,287 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Mining runtime: one state machine over the detection plan, the fault ladder and the tuner.
|
||||
//!
|
||||
//! Each tick takes a measurement, lets the tuner move the operating point, and lets the fault
|
||||
//! supervisor veto the machine. The pieces are tested in isolation elsewhere; this module is the
|
||||
//! place where their order is decided, and the order matters: a stopped machine must not be tuned,
|
||||
//! and a disabled chain must not be dispatched to.
|
||||
|
||||
use crate::detect::{HardwarePlan, OperatingPoint};
|
||||
use crate::fault::{FaultAction, FaultEvent, FaultPolicy, FaultSupervisor, StopReason};
|
||||
use crate::tuning::{Command, Observation, PidConfig, TuningError, TuningLoop, TuningTarget};
|
||||
|
||||
/// One control period's measurements.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct Tick {
|
||||
pub power_w: Option<f32>,
|
||||
pub hashrate_ths: Option<f32>,
|
||||
pub hottest_mc: Option<i32>,
|
||||
pub ambient_mc: Option<i32>,
|
||||
pub dt_s: f32,
|
||||
}
|
||||
|
||||
/// What the runtime decided for this period.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum TickOutcome {
|
||||
/// Apply this command to the hardware.
|
||||
Run(Command),
|
||||
/// Measurement missing; hold the previous operating point.
|
||||
Hold(Command),
|
||||
/// The machine is stopped and must not hash.
|
||||
Stopped(StopReason),
|
||||
}
|
||||
|
||||
/// Runtime state for one machine.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct MinerRuntime {
|
||||
plan: HardwarePlan,
|
||||
faults: FaultSupervisor,
|
||||
tuning: TuningLoop,
|
||||
last_command: Command,
|
||||
}
|
||||
|
||||
impl MinerRuntime {
|
||||
pub fn new(
|
||||
plan: HardwarePlan,
|
||||
policy: FaultPolicy,
|
||||
target: TuningTarget,
|
||||
pid: PidConfig,
|
||||
ceiling_mc: i32,
|
||||
) -> Self {
|
||||
let chains: Vec<u8> = plan.chains.iter().map(|chain| chain.index).collect();
|
||||
let last_command = Command {
|
||||
frequency_mhz: plan.operating_point.frequency_mhz,
|
||||
fan_pwm: None,
|
||||
};
|
||||
Self {
|
||||
faults: FaultSupervisor::new(&chains, policy),
|
||||
tuning: TuningLoop::new(target, plan.envelope, pid, ceiling_mc),
|
||||
plan,
|
||||
last_command,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn plan(&self) -> &HardwarePlan {
|
||||
&self.plan
|
||||
}
|
||||
|
||||
pub fn operating_point(&self) -> OperatingPoint {
|
||||
OperatingPoint {
|
||||
voltage_mv: self
|
||||
.plan
|
||||
.envelope
|
||||
.voltage_for(self.last_command.frequency_mhz),
|
||||
frequency_mhz: self.last_command.frequency_mhz,
|
||||
confirmed: self.plan.operating_point.confirmed,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn active_chains(&self) -> Vec<u8> {
|
||||
self.faults.active_chains()
|
||||
}
|
||||
|
||||
pub fn stop_reason(&self) -> Option<StopReason> {
|
||||
self.faults.stop_reason()
|
||||
}
|
||||
|
||||
/// Feed one health observation; returns what the supervisor decided.
|
||||
pub fn on_event(&mut self, event: FaultEvent) -> FaultAction {
|
||||
self.faults.observe(event)
|
||||
}
|
||||
|
||||
/// Advance one control period.
|
||||
pub fn tick(&mut self, tick: &Tick) -> TickOutcome {
|
||||
if let Some(reason) = self.faults.stop_reason() {
|
||||
return TickOutcome::Stopped(reason);
|
||||
}
|
||||
let observation = Observation {
|
||||
power_w: tick.power_w,
|
||||
hashrate_ths: tick.hashrate_ths,
|
||||
hottest_mc: tick.hottest_mc,
|
||||
ambient_mc: tick.ambient_mc,
|
||||
};
|
||||
match self.tuning.step(observation, tick.dt_s) {
|
||||
Ok(command) => {
|
||||
self.last_command = command;
|
||||
TickOutcome::Run(command)
|
||||
}
|
||||
Err(TuningError::NoMeasurement) => TickOutcome::Hold(self.last_command),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::detect::{ChainReport, ChipModel, EepromState, Envelope, FanZone};
|
||||
|
||||
fn plan() -> HardwarePlan {
|
||||
HardwarePlan {
|
||||
profile: "s19jpro-bm1362-pic".into(),
|
||||
chip: ChipModel::Bm1362,
|
||||
chains: (0..3)
|
||||
.map(|index| ChainReport {
|
||||
index,
|
||||
chip: ChipModel::Bm1362,
|
||||
chips_found: 126,
|
||||
eeprom: EepromState::Absent,
|
||||
response_per_mille: Some(950),
|
||||
})
|
||||
.collect(),
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
},
|
||||
operating_point: OperatingPoint {
|
||||
voltage_mv: 1200,
|
||||
frequency_mhz: 300,
|
||||
confirmed: false,
|
||||
},
|
||||
psu: "APW12".into(),
|
||||
fan_zones: vec![FanZone {
|
||||
fan: 0,
|
||||
zones: vec![0],
|
||||
}],
|
||||
}
|
||||
}
|
||||
|
||||
fn runtime() -> MinerRuntime {
|
||||
MinerRuntime::new(
|
||||
plan(),
|
||||
FaultPolicy::default(),
|
||||
TuningTarget::PowerW(2_400.0),
|
||||
PidConfig {
|
||||
kp: 0.2,
|
||||
ki: 0.05,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 0.0,
|
||||
max_step_per_s: 50.0,
|
||||
deadband: 0.0,
|
||||
},
|
||||
95_000,
|
||||
)
|
||||
}
|
||||
|
||||
fn tick(power: f32) -> Tick {
|
||||
Tick {
|
||||
power_w: Some(power),
|
||||
hashrate_ths: None,
|
||||
hottest_mc: Some(70_000),
|
||||
ambient_mc: None,
|
||||
dt_s: 1.0,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_fresh_runtime_exposes_every_chain() {
|
||||
assert_eq!(runtime().active_chains(), vec![0, 1, 2]);
|
||||
assert_eq!(runtime().stop_reason(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ticks_move_frequency_inside_the_envelope() {
|
||||
let mut runtime = runtime();
|
||||
let mut frequency = 300;
|
||||
for _ in 0..60 {
|
||||
let power = 4.0 * f32::from(frequency);
|
||||
if let TickOutcome::Run(command) = runtime.tick(&tick(power)) {
|
||||
frequency = command.frequency_mhz;
|
||||
assert!((300..=700).contains(&frequency));
|
||||
}
|
||||
}
|
||||
assert!(frequency > 300, "frequency never moved: {frequency}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_missing_measurement_holds_the_last_command() {
|
||||
let mut runtime = runtime();
|
||||
let empty = Tick {
|
||||
power_w: None,
|
||||
hashrate_ths: None,
|
||||
hottest_mc: None,
|
||||
ambient_mc: None,
|
||||
dt_s: 1.0,
|
||||
};
|
||||
match runtime.tick(&empty) {
|
||||
TickOutcome::Hold(command) => assert_eq!(command.frequency_mhz, 300),
|
||||
other => panic!("unexpected outcome: {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_dead_chain_is_removed_from_dispatch_without_stopping_the_machine() {
|
||||
let mut runtime = runtime();
|
||||
assert_eq!(
|
||||
runtime.on_event(FaultEvent::ChainError { chain: 1 }),
|
||||
FaultAction::Retry { chain: 1 }
|
||||
);
|
||||
assert_eq!(
|
||||
runtime.on_event(FaultEvent::ChainError { chain: 1 }),
|
||||
FaultAction::Retry { chain: 1 }
|
||||
);
|
||||
assert_eq!(
|
||||
runtime.on_event(FaultEvent::ChainError { chain: 1 }),
|
||||
FaultAction::DisableChain { chain: 1 }
|
||||
);
|
||||
assert_eq!(runtime.active_chains(), vec![0, 2]);
|
||||
assert!(matches!(runtime.tick(&tick(2_000.0)), TickOutcome::Run(_)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_temperature_fault_stops_the_machine_for_good() {
|
||||
let mut runtime = runtime();
|
||||
assert_eq!(
|
||||
runtime.on_event(FaultEvent::TemperatureFault { zone: 1 }),
|
||||
FaultAction::Stop {
|
||||
reason: StopReason::Temperature
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
runtime.tick(&tick(2_400.0)),
|
||||
TickOutcome::Stopped(StopReason::Temperature)
|
||||
);
|
||||
assert_eq!(
|
||||
runtime.tick(&tick(2_400.0)),
|
||||
TickOutcome::Stopped(StopReason::Temperature)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn losing_every_chain_stops_the_machine() {
|
||||
let mut runtime = MinerRuntime::new(
|
||||
plan(),
|
||||
FaultPolicy {
|
||||
retries: 0,
|
||||
..FaultPolicy::default()
|
||||
},
|
||||
TuningTarget::PowerW(2_400.0),
|
||||
PidConfig::default(),
|
||||
95_000,
|
||||
);
|
||||
for chain in 0..3 {
|
||||
runtime.on_event(FaultEvent::ChainError { chain });
|
||||
}
|
||||
assert_eq!(runtime.stop_reason(), Some(StopReason::NoChainsLeft));
|
||||
assert!(runtime.active_chains().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_operating_point_reflects_the_last_command() {
|
||||
let mut runtime = runtime();
|
||||
for _ in 0..10 {
|
||||
runtime.tick(&tick(1_500.0));
|
||||
}
|
||||
let point = runtime.operating_point();
|
||||
assert!(point.frequency_mhz > 300);
|
||||
assert!(!point.confirmed);
|
||||
// Voltage follows the frequency across the envelope instead of staying at the boot value.
|
||||
assert_eq!(
|
||||
point.voltage_mv,
|
||||
runtime.plan().envelope.voltage_for(point.frequency_mhz)
|
||||
);
|
||||
assert!(point.voltage_mv > 1100);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Litecoin's fixed scrypt proof-of-work hash for validating reported shares.
|
||||
//! This module hashes one supplied header and never searches for a nonce.
|
||||
|
||||
use crate::pow::sha256;
|
||||
|
||||
const N: usize = 1024;
|
||||
|
||||
fn hmac_sha256(key: &[u8], message: &[u8]) -> [u8; 32] {
|
||||
let mut block = [0_u8; 64];
|
||||
if key.len() > block.len() {
|
||||
block[..32].copy_from_slice(&sha256(key));
|
||||
} else {
|
||||
block[..key.len()].copy_from_slice(key);
|
||||
}
|
||||
let mut inner = Vec::with_capacity(64 + message.len());
|
||||
inner.extend(block.iter().map(|byte| byte ^ 0x36));
|
||||
inner.extend_from_slice(message);
|
||||
let inner_hash = sha256(&inner);
|
||||
let mut outer = [0_u8; 96];
|
||||
for (destination, byte) in outer[..64].iter_mut().zip(block) {
|
||||
*destination = byte ^ 0x5c;
|
||||
}
|
||||
outer[64..].copy_from_slice(&inner_hash);
|
||||
sha256(&outer)
|
||||
}
|
||||
|
||||
// PBKDF2-HMAC-SHA256 with the fixed single iteration specified for scrypt.
|
||||
fn pbkdf2_one(password: &[u8], salt: &[u8], output: &mut [u8]) {
|
||||
let mut message = Vec::with_capacity(salt.len() + 4);
|
||||
message.extend_from_slice(salt);
|
||||
message.extend_from_slice(&[0_u8; 4]);
|
||||
for (index, chunk) in output.chunks_mut(32).enumerate() {
|
||||
let block = u32::try_from(index + 1).expect("fixed scrypt output fits u32");
|
||||
message[salt.len()..].copy_from_slice(&block.to_be_bytes());
|
||||
chunk.copy_from_slice(&hmac_sha256(password, &message)[..chunk.len()]);
|
||||
}
|
||||
}
|
||||
|
||||
fn salsa20_8(input: &mut [u32; 16]) {
|
||||
let original = *input;
|
||||
let mut x = original;
|
||||
for _ in 0..4 {
|
||||
x[4] ^= x[0].wrapping_add(x[12]).rotate_left(7);
|
||||
x[8] ^= x[4].wrapping_add(x[0]).rotate_left(9);
|
||||
x[12] ^= x[8].wrapping_add(x[4]).rotate_left(13);
|
||||
x[0] ^= x[12].wrapping_add(x[8]).rotate_left(18);
|
||||
x[9] ^= x[5].wrapping_add(x[1]).rotate_left(7);
|
||||
x[13] ^= x[9].wrapping_add(x[5]).rotate_left(9);
|
||||
x[1] ^= x[13].wrapping_add(x[9]).rotate_left(13);
|
||||
x[5] ^= x[1].wrapping_add(x[13]).rotate_left(18);
|
||||
x[14] ^= x[10].wrapping_add(x[6]).rotate_left(7);
|
||||
x[2] ^= x[14].wrapping_add(x[10]).rotate_left(9);
|
||||
x[6] ^= x[2].wrapping_add(x[14]).rotate_left(13);
|
||||
x[10] ^= x[6].wrapping_add(x[2]).rotate_left(18);
|
||||
x[3] ^= x[15].wrapping_add(x[11]).rotate_left(7);
|
||||
x[7] ^= x[3].wrapping_add(x[15]).rotate_left(9);
|
||||
x[11] ^= x[7].wrapping_add(x[3]).rotate_left(13);
|
||||
x[15] ^= x[11].wrapping_add(x[7]).rotate_left(18);
|
||||
|
||||
x[1] ^= x[0].wrapping_add(x[3]).rotate_left(7);
|
||||
x[2] ^= x[1].wrapping_add(x[0]).rotate_left(9);
|
||||
x[3] ^= x[2].wrapping_add(x[1]).rotate_left(13);
|
||||
x[0] ^= x[3].wrapping_add(x[2]).rotate_left(18);
|
||||
x[6] ^= x[5].wrapping_add(x[4]).rotate_left(7);
|
||||
x[7] ^= x[6].wrapping_add(x[5]).rotate_left(9);
|
||||
x[4] ^= x[7].wrapping_add(x[6]).rotate_left(13);
|
||||
x[5] ^= x[4].wrapping_add(x[7]).rotate_left(18);
|
||||
x[11] ^= x[10].wrapping_add(x[9]).rotate_left(7);
|
||||
x[8] ^= x[11].wrapping_add(x[10]).rotate_left(9);
|
||||
x[9] ^= x[8].wrapping_add(x[11]).rotate_left(13);
|
||||
x[10] ^= x[9].wrapping_add(x[8]).rotate_left(18);
|
||||
x[12] ^= x[15].wrapping_add(x[14]).rotate_left(7);
|
||||
x[13] ^= x[12].wrapping_add(x[15]).rotate_left(9);
|
||||
x[14] ^= x[13].wrapping_add(x[12]).rotate_left(13);
|
||||
x[15] ^= x[14].wrapping_add(x[13]).rotate_left(18);
|
||||
}
|
||||
for ((word, initial), mixed) in input.iter_mut().zip(original).zip(x) {
|
||||
*word = initial.wrapping_add(mixed);
|
||||
}
|
||||
}
|
||||
|
||||
fn block_mix(input: &[u32; 32]) -> [u32; 32] {
|
||||
let mut x: [u32; 16] = input[16..].try_into().expect("fixed block size");
|
||||
let mut output = [0_u32; 32];
|
||||
for (index, chunk) in input.chunks_exact(16).enumerate() {
|
||||
for (word, source) in x.iter_mut().zip(chunk) {
|
||||
*word ^= source;
|
||||
}
|
||||
salsa20_8(&mut x);
|
||||
output[index * 16..(index + 1) * 16].copy_from_slice(&x);
|
||||
}
|
||||
output
|
||||
}
|
||||
|
||||
/// Hash one 80-byte Litecoin header with scrypt(N=1024, r=1, p=1, dkLen=32).
|
||||
/// The return value is the raw little-endian PoW digest.
|
||||
pub fn scrypt_1024_1_1_256(header: &[u8; 80]) -> [u8; 32] {
|
||||
let mut initial = [0_u8; 128];
|
||||
pbkdf2_one(header, header, &mut initial);
|
||||
let mut x = [0_u32; 32];
|
||||
for (word, bytes) in x.iter_mut().zip(initial.chunks_exact(4)) {
|
||||
*word = u32::from_le_bytes(bytes.try_into().expect("four-byte word"));
|
||||
}
|
||||
let mut memory = vec![[0_u32; 32]; N];
|
||||
for saved in &mut memory {
|
||||
*saved = x;
|
||||
x = block_mix(&x);
|
||||
}
|
||||
for _ in 0..N {
|
||||
let index = x[16] as usize & (N - 1);
|
||||
for (word, saved) in x.iter_mut().zip(memory[index]) {
|
||||
*word ^= saved;
|
||||
}
|
||||
x = block_mix(&x);
|
||||
}
|
||||
for (word, bytes) in x.iter().zip(initial.chunks_exact_mut(4)) {
|
||||
bytes.copy_from_slice(&word.to_le_bytes());
|
||||
}
|
||||
let mut digest = [0_u8; 32];
|
||||
pbkdf2_one(header, &initial, &mut digest);
|
||||
digest
|
||||
}
|
||||
|
||||
/// Validate one supplied header against an exact little-endian pool target.
|
||||
pub fn verify_scrypt_header(header: &[u8; 80], target_le: &[u8; 32]) -> ([u8; 32], bool) {
|
||||
let digest = scrypt_1024_1_1_256(header);
|
||||
let meets_target = digest.iter().rev().cmp(target_le.iter().rev()).is_le();
|
||||
(digest, meets_target)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn litecoin_block_29255_matches_published_scrypt_pow() {
|
||||
let header_hex = concat!(
|
||||
"01000000f615f7ce3b4fc6b8f61e8f89aedb1d0852507650533a9e3b10b9bbcc30639f27",
|
||||
"9fcaa86746e1ef52d3edb3c4ad8259920d509bd073605c9bf1d59983752a6b06b817bb4",
|
||||
"ea78e011d012d59d4"
|
||||
);
|
||||
let mut header = [0_u8; 80];
|
||||
for (byte, pair) in header.iter_mut().zip(header_hex.as_bytes().chunks_exact(2)) {
|
||||
*byte = u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap();
|
||||
}
|
||||
let expected_big = "0000000110c8357966576df46f3b802ca897deb7ad18b12f1c24ecff6386ebd9";
|
||||
let mut expected = [0_u8; 32];
|
||||
for (byte, pair) in expected
|
||||
.iter_mut()
|
||||
.rev()
|
||||
.zip(expected_big.as_bytes().chunks_exact(2))
|
||||
{
|
||||
*byte = u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap();
|
||||
}
|
||||
let (digest, accepted) = verify_scrypt_header(&header, &expected);
|
||||
assert_eq!(digest, expected);
|
||||
assert!(accepted);
|
||||
assert!(!verify_scrypt_header(&header, &[0_u8; 32]).1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fixed_header_matches_independent_openssl_scrypt() {
|
||||
let header = core::array::from_fn(|index| index as u8);
|
||||
let expected = "bc540a1a801df96e493005c71e010e2d387607fbf0fec416fd3c2645aa1ba9d2";
|
||||
let actual = scrypt_1024_1_1_256(&header);
|
||||
let actual_hex: String = actual.iter().map(|byte| format!("{byte:02x}")).collect();
|
||||
assert_eq!(actual_hex, expected);
|
||||
}
|
||||
}
|
||||
+172
@@ -0,0 +1,172 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Hashrate splitting across pools.
|
||||
//!
|
||||
//! Splitting is per work slot: each dispatched job comes from exactly one pool, and the router
|
||||
//! hands out slots in proportion to the configured weights. Smooth weighted round-robin is used
|
||||
//! because it keeps the mix correct at every prefix, not just over a long run, which matters when
|
||||
//! a miner only has a handful of chains.
|
||||
|
||||
/// Why a split configuration was rejected.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum SplitError {
|
||||
Empty,
|
||||
NoWeight,
|
||||
InvalidNumber,
|
||||
TooManyPools,
|
||||
}
|
||||
|
||||
/// Per-pool weights, `50,50` style.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct SplitWeights {
|
||||
weights: Vec<u32>,
|
||||
}
|
||||
|
||||
impl SplitWeights {
|
||||
/// Parse a comma-separated weight list such as `"60,40"`.
|
||||
pub fn parse(text: &str) -> Result<Self, SplitError> {
|
||||
let mut weights = Vec::new();
|
||||
for part in text.split(',') {
|
||||
let trimmed = part.trim();
|
||||
if trimmed.is_empty() {
|
||||
return Err(SplitError::InvalidNumber);
|
||||
}
|
||||
let weight: u32 = trimmed.parse().map_err(|_| SplitError::InvalidNumber)?;
|
||||
weights.push(weight);
|
||||
}
|
||||
Self::new(weights)
|
||||
}
|
||||
|
||||
pub fn new(weights: Vec<u32>) -> Result<Self, SplitError> {
|
||||
if weights.is_empty() {
|
||||
return Err(SplitError::Empty);
|
||||
}
|
||||
if weights.len() > 16 {
|
||||
return Err(SplitError::TooManyPools);
|
||||
}
|
||||
if weights.iter().all(|weight| *weight == 0) {
|
||||
return Err(SplitError::NoWeight);
|
||||
}
|
||||
Ok(Self { weights })
|
||||
}
|
||||
|
||||
pub fn pools(&self) -> usize {
|
||||
self.weights.len()
|
||||
}
|
||||
|
||||
pub fn weight(&self, pool: usize) -> u32 {
|
||||
self.weights.get(pool).copied().unwrap_or(0)
|
||||
}
|
||||
|
||||
/// Split `slots` work slots across the pools and return how many each receives.
|
||||
pub fn allocate(&self, slots: usize) -> Vec<usize> {
|
||||
let mut router = WorkRouter::new(self.clone());
|
||||
let mut counts = vec![0_usize; self.pools()];
|
||||
for _ in 0..slots {
|
||||
counts[router.next_pool()] += 1;
|
||||
}
|
||||
counts
|
||||
}
|
||||
}
|
||||
|
||||
/// Smooth weighted round-robin state.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct WorkRouter {
|
||||
weights: SplitWeights,
|
||||
current: Vec<i64>,
|
||||
total: i64,
|
||||
}
|
||||
|
||||
impl WorkRouter {
|
||||
pub fn new(weights: SplitWeights) -> Self {
|
||||
let current = vec![0_i64; weights.pools()];
|
||||
let total: i64 = weights
|
||||
.weights
|
||||
.iter()
|
||||
.map(|weight| i64::from(*weight))
|
||||
.sum();
|
||||
Self {
|
||||
weights,
|
||||
current,
|
||||
total,
|
||||
}
|
||||
}
|
||||
|
||||
/// Which pool supplies the next work slot.
|
||||
///
|
||||
/// A pool with weight 0 never receives a slot. The winner's running score is reduced by the
|
||||
/// total weight, which is what keeps the distribution proportional at every prefix.
|
||||
pub fn next_pool(&mut self) -> usize {
|
||||
let mut winner = 0;
|
||||
for pool in 0..self.weights.pools() {
|
||||
self.current[pool] += i64::from(self.weights.weight(pool));
|
||||
if self.current[pool] > self.current[winner] {
|
||||
winner = pool;
|
||||
}
|
||||
}
|
||||
self.current[winner] -= self.total;
|
||||
winner
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn equal_weights_split_evenly() {
|
||||
let weights = SplitWeights::parse("50,50").expect("weights");
|
||||
assert_eq!(weights.allocate(10), vec![5, 5]);
|
||||
assert_eq!(weights.allocate(4), vec![2, 2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unequal_weights_split_proportionally() {
|
||||
let weights = SplitWeights::parse("1,2").expect("weights");
|
||||
assert_eq!(weights.allocate(9), vec![3, 6]);
|
||||
assert_eq!(weights.allocate(3), vec![1, 2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rounding_is_exact_at_every_prefix() {
|
||||
let weights = SplitWeights::parse("1,1,1").expect("weights");
|
||||
assert_eq!(weights.allocate(10), vec![4, 3, 3]);
|
||||
assert_eq!(weights.allocate(3), vec![1, 1, 1]);
|
||||
assert_eq!(weights.allocate(1), vec![1, 0, 0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_weight_pools_never_receive_work() {
|
||||
let weights = SplitWeights::parse("100,0,100").expect("weights");
|
||||
assert_eq!(weights.allocate(6), vec![3, 0, 3]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_single_pool_takes_everything() {
|
||||
let weights = SplitWeights::parse("100").expect("weights");
|
||||
assert_eq!(weights.allocate(5), vec![5]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_configurations_are_rejected() {
|
||||
assert_eq!(SplitWeights::parse(""), Err(SplitError::InvalidNumber));
|
||||
assert_eq!(
|
||||
SplitWeights::parse("50,abc"),
|
||||
Err(SplitError::InvalidNumber)
|
||||
);
|
||||
assert_eq!(SplitWeights::parse("0,0"), Err(SplitError::NoWeight));
|
||||
assert_eq!(SplitWeights::new(Vec::new()), Err(SplitError::Empty));
|
||||
let many = vec![1_u32; 17];
|
||||
assert_eq!(SplitWeights::new(many), Err(SplitError::TooManyPools));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_router_is_deterministic_for_the_same_input() {
|
||||
let weights = SplitWeights::parse("60,40").expect("weights");
|
||||
let first = weights.allocate(50);
|
||||
let second = weights.allocate(50);
|
||||
assert_eq!(first, second);
|
||||
assert_eq!(first.iter().sum::<usize>(), 50);
|
||||
assert_eq!(first[0], 30);
|
||||
assert_eq!(first[1], 20);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,510 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! One bounded pool connection with ordered jobs and verified share replies.
|
||||
|
||||
use crate::miner::{Bm1366Miner, MinerError, ValidShare};
|
||||
use crate::stratum_session::{DispatchError, IssuedWork, PoolSession, SessionError};
|
||||
use crate::stratum_v1::{parse_boolean_response, PoolMessageError};
|
||||
use crate::stratum_wire::{HandshakeError, PoolHandshake, StratumWire, WireError};
|
||||
use crate::HardwareBackend;
|
||||
use serde_json::Value;
|
||||
use std::collections::VecDeque;
|
||||
use std::net::SocketAddr;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const MAX_PENDING_SHARES: usize = 32;
|
||||
const SHARE_REPLY_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
const MAX_REPORTS_PER_CYCLE: usize = 256;
|
||||
const POOL_WRITE_DEADLINE: Duration = Duration::from_millis(100);
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum ClientError<E> {
|
||||
Wire(WireError),
|
||||
Pool(PoolMessageError),
|
||||
Session(SessionError),
|
||||
Dispatch(DispatchError<E>),
|
||||
UnexpectedResponse,
|
||||
TooManyPending,
|
||||
RequestIdsExhausted,
|
||||
ShareReplyTimeout,
|
||||
EmergencyShutdown(E),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum PoolEvent {
|
||||
Idle,
|
||||
Control,
|
||||
Work(IssuedWork),
|
||||
ShareAccepted(u64),
|
||||
ShareRejected(u64),
|
||||
}
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub enum ReportEvent {
|
||||
Stale,
|
||||
BelowTarget,
|
||||
Submitted(u64),
|
||||
Backpressured,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum CycleError<E> {
|
||||
Pool(ClientError<E>),
|
||||
Miner(MinerError<E>),
|
||||
Submit(ClientError<()>),
|
||||
EmergencyShutdown(E),
|
||||
}
|
||||
|
||||
pub struct PoolConnection {
|
||||
wire: StratumWire,
|
||||
session: PoolSession,
|
||||
worker: String,
|
||||
early: VecDeque<Vec<u8>>,
|
||||
next_request_id: u64,
|
||||
pending: Vec<PendingShare>,
|
||||
accepted: u64,
|
||||
rejected: u64,
|
||||
}
|
||||
|
||||
struct PendingShare {
|
||||
id: u64,
|
||||
sent_at: Instant,
|
||||
}
|
||||
|
||||
impl PoolConnection {
|
||||
pub fn connect(
|
||||
address: SocketAddr,
|
||||
agent: &str,
|
||||
worker: &str,
|
||||
password: &str,
|
||||
io_timeout: Duration,
|
||||
handshake_timeout: Duration,
|
||||
) -> Result<Self, HandshakeError> {
|
||||
let mut wire = StratumWire::connect(address, io_timeout).map_err(HandshakeError::Wire)?;
|
||||
let handshake = wire.handshake(agent, worker, password, handshake_timeout)?;
|
||||
Self::from_handshake(wire, handshake, worker)
|
||||
.map_err(|_| HandshakeError::Pool(PoolMessageError::InvalidField))
|
||||
}
|
||||
|
||||
fn from_handshake(
|
||||
mut wire: StratumWire,
|
||||
handshake: PoolHandshake,
|
||||
worker: &str,
|
||||
) -> Result<Self, SessionError> {
|
||||
let session = PoolSession::new(
|
||||
handshake.subscription,
|
||||
handshake.configure.version_mask,
|
||||
handshake.configure.subscribe_extranonce,
|
||||
)?;
|
||||
wire.cap_write_timeout(POOL_WRITE_DEADLINE);
|
||||
Ok(Self {
|
||||
wire,
|
||||
session,
|
||||
worker: worker.to_owned(),
|
||||
early: handshake.early_notifications.into(),
|
||||
next_request_id: 4,
|
||||
pending: Vec::new(),
|
||||
accepted: 0,
|
||||
rejected: 0,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn step<B: HardwareBackend>(
|
||||
&mut self,
|
||||
miner: &mut Bm1366Miner<'_, B>,
|
||||
) -> Result<PoolEvent, ClientError<B::Error>> {
|
||||
let result = self.step_inner(miner);
|
||||
if result.is_err() {
|
||||
self.wire.close();
|
||||
if let Err(error) = miner.stop() {
|
||||
return Err(ClientError::EmergencyShutdown(error));
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn step_inner<B: HardwareBackend>(
|
||||
&mut self,
|
||||
miner: &mut Bm1366Miner<'_, B>,
|
||||
) -> Result<PoolEvent, ClientError<B::Error>> {
|
||||
if self
|
||||
.pending
|
||||
.first()
|
||||
.is_some_and(|share| share.sent_at.elapsed() >= SHARE_REPLY_TIMEOUT)
|
||||
{
|
||||
return Err(ClientError::ShareReplyTimeout);
|
||||
}
|
||||
let line = if let Some(line) = self.early.pop_front() {
|
||||
line
|
||||
} else {
|
||||
match self.wire.try_read_line() {
|
||||
Ok(Some(line)) => line,
|
||||
Ok(None) => return Ok(PoolEvent::Idle),
|
||||
Err(error) => return Err(ClientError::Wire(error)),
|
||||
}
|
||||
};
|
||||
let message: Value =
|
||||
serde_json::from_slice(&line).map_err(|_| ClientError::Pool(PoolMessageError::Json))?;
|
||||
if let Some(id) = message.get("id").and_then(Value::as_u64) {
|
||||
if !self.pending.iter().any(|share| share.id == id) {
|
||||
return Err(ClientError::UnexpectedResponse);
|
||||
}
|
||||
let accepted = parse_boolean_response(&line, id).map_err(ClientError::Pool)?;
|
||||
self.pending.retain(|pending| pending.id != id);
|
||||
if accepted {
|
||||
self.accepted = self.accepted.saturating_add(1);
|
||||
return Ok(PoolEvent::ShareAccepted(id));
|
||||
}
|
||||
self.rejected = self.rejected.saturating_add(1);
|
||||
return Ok(PoolEvent::ShareRejected(id));
|
||||
}
|
||||
if !message.get("id").is_none_or(Value::is_null) {
|
||||
return Err(ClientError::Pool(PoolMessageError::WrongMessage));
|
||||
}
|
||||
match message.get("method").and_then(Value::as_str) {
|
||||
Some("mining.notify") => {
|
||||
let issued = match self.session.issue_to_miner(miner, &line) {
|
||||
Err(DispatchError::Session(SessionError::WorkIdsExhausted)) => {
|
||||
miner
|
||||
.reset_chain()
|
||||
.map_err(|error| ClientError::Dispatch(DispatchError::Miner(error)))?;
|
||||
self.after_hardware_reset(miner);
|
||||
self.session.issue_to_miner(miner, &line)
|
||||
}
|
||||
result => result,
|
||||
};
|
||||
issued.map(PoolEvent::Work).map_err(ClientError::Dispatch)
|
||||
}
|
||||
Some("mining.set_difficulty" | "mining.set_version_mask" | "mining.set_extranonce") => {
|
||||
self.session
|
||||
.control_with_miner(miner, &line)
|
||||
.map_err(ClientError::Session)?;
|
||||
Ok(PoolEvent::Control)
|
||||
}
|
||||
_ => Err(ClientError::Pool(PoolMessageError::WrongMessage)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Send only a nonce already verified by the miner and session. A sent
|
||||
/// request remains pending until its matching boolean pool reply arrives.
|
||||
pub fn submit_share(&mut self, share: ValidShare) -> Result<u64, ClientError<()>> {
|
||||
if self.pending.len() >= MAX_PENDING_SHARES {
|
||||
return Err(ClientError::TooManyPending);
|
||||
}
|
||||
let id = self.next_request_id;
|
||||
let next = id.checked_add(1).ok_or(ClientError::RequestIdsExhausted)?;
|
||||
let line = self
|
||||
.session
|
||||
.submission(share, &self.worker, id)
|
||||
.map_err(ClientError::Session)?;
|
||||
self.wire
|
||||
.send_line(line.as_bytes())
|
||||
.map_err(ClientError::Wire)?;
|
||||
self.next_request_id = next;
|
||||
self.pending.push(PendingShare {
|
||||
id,
|
||||
sent_at: Instant::now(),
|
||||
});
|
||||
Ok(id)
|
||||
}
|
||||
|
||||
pub fn share_counts(&self) -> (u64, u64, usize) {
|
||||
(self.accepted, self.rejected, self.pending.len())
|
||||
}
|
||||
|
||||
/// Process one pool message, then drain a bounded burst of ASIC reports.
|
||||
/// A reported nonce is verified before sending. The caller must cycle
|
||||
/// continuously; hardware still requires an independent power watchdog.
|
||||
pub fn cycle<B: HardwareBackend>(
|
||||
&mut self,
|
||||
miner: &mut Bm1366Miner<'_, B>,
|
||||
) -> Result<(PoolEvent, Vec<ReportEvent>), CycleError<B::Error>> {
|
||||
let pool = self.step(miner).map_err(CycleError::Pool)?;
|
||||
let mut reports = Vec::new();
|
||||
for _ in 0..MAX_REPORTS_PER_CYCLE {
|
||||
if self.pending.len() >= MAX_PENDING_SHARES {
|
||||
miner.supervise().map_err(CycleError::Miner)?;
|
||||
reports.push(ReportEvent::Backpressured);
|
||||
break;
|
||||
}
|
||||
let event = match miner.poll() {
|
||||
Ok(None) => break,
|
||||
Ok(Some(share)) => {
|
||||
let id = match self.submit_share(share) {
|
||||
Ok(id) => id,
|
||||
Err(error) => {
|
||||
self.wire.close();
|
||||
miner.stop().map_err(CycleError::EmergencyShutdown)?;
|
||||
return Err(CycleError::Submit(error));
|
||||
}
|
||||
};
|
||||
ReportEvent::Submitted(id)
|
||||
}
|
||||
Err(MinerError::StaleReport) => ReportEvent::Stale,
|
||||
Err(MinerError::BelowTarget) => ReportEvent::BelowTarget,
|
||||
Err(error) => return Err(CycleError::Miner(error)),
|
||||
};
|
||||
reports.push(event);
|
||||
}
|
||||
Ok((pool, reports))
|
||||
}
|
||||
|
||||
/// Call only after an actual chain reset flushes old hardware reports.
|
||||
pub fn after_hardware_reset<B: HardwareBackend>(&mut self, miner: &mut Bm1366Miner<'_, B>) {
|
||||
miner.clear_work();
|
||||
self.session.after_hardware_reset();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::stratum_v1::Subscription;
|
||||
use std::cell::Cell;
|
||||
use std::io::Write;
|
||||
use std::net::{TcpListener, TcpStream};
|
||||
use std::rc::Rc;
|
||||
use std::sync::mpsc;
|
||||
use std::thread;
|
||||
|
||||
#[derive(Default)]
|
||||
struct Backend {
|
||||
sent: Vec<Vec<u8>>,
|
||||
powered: Rc<Cell<bool>>,
|
||||
reports_remaining: usize,
|
||||
reset_assertions: usize,
|
||||
}
|
||||
|
||||
impl HardwareBackend for Backend {
|
||||
type Error = ();
|
||||
|
||||
fn send_frame(&mut self, _chain: u8, frame: &[u8]) -> Result<(), Self::Error> {
|
||||
self.sent.push(frame.to_vec());
|
||||
Ok(())
|
||||
}
|
||||
fn receive_frame(&mut self, _chain: u8, frame: &mut [u8]) -> Result<usize, Self::Error> {
|
||||
if self.reports_remaining == 0 {
|
||||
return Ok(0);
|
||||
}
|
||||
self.reports_remaining -= 1;
|
||||
frame[..11].copy_from_slice(&[
|
||||
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
|
||||
]);
|
||||
Ok(11)
|
||||
}
|
||||
fn set_chain_reset(&mut self, _chain: u8, asserted: bool) -> Result<(), Self::Error> {
|
||||
if asserted {
|
||||
self.reset_assertions += 1;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn set_fan_target(&mut self, _fan: u8, _percent: u8) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
fn read_temperature_mc(&mut self, _sensor: u8) -> Result<i32, Self::Error> {
|
||||
Ok(50_000)
|
||||
}
|
||||
fn set_psu_enabled(&mut self, enabled: bool) -> Result<(), Self::Error> {
|
||||
self.powered.set(enabled);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn test_link(input: &'static [u8]) -> (PoolConnection, thread::JoinHandle<()>) {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let (ready, received) = mpsc::channel();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
stream.write_all(input).unwrap();
|
||||
ready.send(()).unwrap();
|
||||
});
|
||||
let stream = TcpStream::connect(address).unwrap();
|
||||
let wire = StratumWire::from_stream(stream, Duration::from_secs(2)).unwrap();
|
||||
received.recv_timeout(Duration::from_secs(2)).unwrap();
|
||||
let handshake = PoolHandshake {
|
||||
subscription: Subscription {
|
||||
extranonce1: vec![1, 2, 3, 4],
|
||||
extranonce2_size: 4,
|
||||
},
|
||||
configure: crate::stratum_v1::ConfigureResult {
|
||||
version_mask: None,
|
||||
subscribe_extranonce: false,
|
||||
},
|
||||
early_notifications: Vec::new(),
|
||||
};
|
||||
(
|
||||
PoolConnection::from_handshake(wire, handshake, "miner.worker").unwrap(),
|
||||
server,
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pool_controls_then_dispatches_one_synthetic_job() {
|
||||
let (mut link, server) = test_link(
|
||||
concat!(
|
||||
"{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[1]}\n",
|
||||
"{\"id\":null,\"method\":\"mining.notify\",\"params\":[\"job-1\",",
|
||||
"\"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f\",",
|
||||
"\"616263\",\"78797a\",[],\"20000000\",\"1d00ffff\",\"66554433\",true]}\n"
|
||||
)
|
||||
.as_bytes(),
|
||||
);
|
||||
let mut backend = Backend::default();
|
||||
{
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
assert!(matches!(
|
||||
link.cycle(&mut miner).unwrap(),
|
||||
(PoolEvent::Control, reports) if reports.is_empty()
|
||||
));
|
||||
match link.cycle(&mut miner).unwrap() {
|
||||
(PoolEvent::Work(work), reports) if reports.is_empty() => {
|
||||
assert_eq!(work.work_id, 0)
|
||||
}
|
||||
_ => panic!("expected job"),
|
||||
}
|
||||
}
|
||||
assert_eq!(backend.sent.len(), 1);
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn thirty_third_job_flushes_asic_before_reusing_work_id() {
|
||||
let (mut link, server) = test_link(b"");
|
||||
link.early.push_back(
|
||||
b"{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[1]}\n".to_vec(),
|
||||
);
|
||||
let notify = concat!(
|
||||
"{\"id\":null,\"method\":\"mining.notify\",\"params\":[\"job\",",
|
||||
"\"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f\",",
|
||||
"\"616263\",\"78797a\",[],\"20000000\",\"1d00ffff\",\"66554433\",true]}\n"
|
||||
);
|
||||
for _ in 0..33 {
|
||||
link.early.push_back(notify.as_bytes().to_vec());
|
||||
}
|
||||
let mut backend = Backend::default();
|
||||
let powered = Rc::clone(&backend.powered);
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
assert!(matches!(link.step(&mut miner), Ok(PoolEvent::Control)));
|
||||
let mut first_header = None;
|
||||
for index in 0..33 {
|
||||
let PoolEvent::Work(work) = link.step(&mut miner).unwrap() else {
|
||||
panic!("expected work");
|
||||
};
|
||||
if index == 0 {
|
||||
first_header = Some(work.header);
|
||||
}
|
||||
if index == 32 {
|
||||
assert_eq!(work.work_id, 0);
|
||||
assert_ne!(Some(work.header), first_header);
|
||||
}
|
||||
}
|
||||
assert!(powered.get());
|
||||
miner.stop().unwrap();
|
||||
drop(miner);
|
||||
assert_eq!(backend.reset_assertions, 2);
|
||||
assert_eq!(backend.sent.len(), 33);
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn share_replies_match_pending_ids_and_count_accepts_separately() {
|
||||
let (mut link, server) = test_link(
|
||||
concat!(
|
||||
"{\"id\":4,\"result\":true,\"error\":null}\n",
|
||||
"{\"id\":5,\"result\":false,\"error\":[23,\"stale\"]}\n",
|
||||
"{\"id\":6,\"result\":true,\"error\":null}\n"
|
||||
)
|
||||
.as_bytes(),
|
||||
);
|
||||
link.pending.extend([4, 5].map(|id| PendingShare {
|
||||
id,
|
||||
sent_at: Instant::now(),
|
||||
}));
|
||||
let mut backend = Backend::default();
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
assert!(matches!(
|
||||
link.step(&mut miner).unwrap(),
|
||||
PoolEvent::ShareAccepted(4)
|
||||
));
|
||||
assert!(matches!(
|
||||
link.step(&mut miner).unwrap(),
|
||||
PoolEvent::ShareRejected(5)
|
||||
));
|
||||
assert_eq!(link.share_counts(), (1, 1, 0));
|
||||
assert!(matches!(
|
||||
link.step(&mut miner),
|
||||
Err(ClientError::UnexpectedResponse)
|
||||
));
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn untracked_report_cannot_be_sent_to_pool() {
|
||||
let (mut link, server) = test_link(b"");
|
||||
let report = ValidShare {
|
||||
nonce: 1,
|
||||
work_id: 0,
|
||||
rolled_version: 0x2000_0000,
|
||||
hash_le: [0; 32],
|
||||
};
|
||||
assert!(matches!(
|
||||
link.submit_share(report),
|
||||
Err(ClientError::Session(SessionError::StaleShare))
|
||||
));
|
||||
assert_eq!(link.share_counts(), (0, 0, 0));
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unanswered_share_closes_pool_connection() {
|
||||
let (mut link, server) = test_link(b"");
|
||||
link.pending.push(PendingShare {
|
||||
id: 4,
|
||||
sent_at: Instant::now() - SHARE_REPLY_TIMEOUT - Duration::from_secs(1),
|
||||
});
|
||||
let mut backend = Backend::default();
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
assert!(matches!(
|
||||
link.step(&mut miner),
|
||||
Err(ClientError::ShareReplyTimeout)
|
||||
));
|
||||
assert!(link.wire.is_closed());
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_pool_message_stops_miner_before_returning() {
|
||||
let (mut link, server) = test_link(b"{}\n");
|
||||
let mut backend = Backend::default();
|
||||
let powered = Rc::clone(&backend.powered);
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
assert!(powered.get());
|
||||
assert!(matches!(link.cycle(&mut miner), Err(CycleError::Pool(_))));
|
||||
assert!(!powered.get());
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn idle_pool_does_not_limit_asic_report_burst_to_one() {
|
||||
let (mut link, server) =
|
||||
test_link(b"{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[1]}\n");
|
||||
let mut backend = Backend {
|
||||
reports_remaining: MAX_REPORTS_PER_CYCLE + 3,
|
||||
..Backend::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
let (pool, reports) = link.cycle(&mut miner).unwrap();
|
||||
assert!(matches!(pool, PoolEvent::Control));
|
||||
assert_eq!(reports.len(), MAX_REPORTS_PER_CYCLE);
|
||||
assert!(reports
|
||||
.iter()
|
||||
.all(|event| matches!(event, ReportEvent::Stale)));
|
||||
drop(miner);
|
||||
assert_eq!(backend.reports_remaining, 3);
|
||||
server.join().unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,385 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Stratum V2 transport and version selection.
|
||||
//!
|
||||
//! `TcpLink` turns a TCP stream into the framed messages the session expects: it buffers partial
|
||||
//! reads and hands out one frame at a time, so a frame split across packets is not a protocol
|
||||
//! error. The selection policy decides when a miner may fall back to Stratum V1.
|
||||
|
||||
use crate::stratum_v2::{Frame, V2Error};
|
||||
use crate::stratum_v2_session::V2Link;
|
||||
use std::io::{self, Read, Write};
|
||||
use std::net::{SocketAddr, TcpStream};
|
||||
use std::time::Duration;
|
||||
|
||||
const READ_CHUNK: usize = 4096;
|
||||
|
||||
/// A framed connection over TCP.
|
||||
pub struct TcpLink {
|
||||
stream: TcpStream,
|
||||
buffer: Vec<u8>,
|
||||
}
|
||||
|
||||
impl TcpLink {
|
||||
pub fn connect(address: SocketAddr, timeout: Duration) -> io::Result<Self> {
|
||||
let stream = TcpStream::connect_timeout(&address, timeout)?;
|
||||
stream.set_read_timeout(Some(timeout))?;
|
||||
stream.set_write_timeout(Some(timeout))?;
|
||||
stream.set_nodelay(true)?;
|
||||
Ok(Self {
|
||||
stream,
|
||||
buffer: Vec::new(),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn from_stream(stream: TcpStream) -> io::Result<Self> {
|
||||
stream.set_nodelay(true)?;
|
||||
Ok(Self {
|
||||
stream,
|
||||
buffer: Vec::new(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Bytes received but not yet consumed, for diagnostics.
|
||||
pub fn buffered(&self) -> usize {
|
||||
self.buffer.len()
|
||||
}
|
||||
}
|
||||
|
||||
impl V2Link for TcpLink {
|
||||
type Error = io::Error;
|
||||
|
||||
fn send(&mut self, frame: &Frame) -> io::Result<()> {
|
||||
let mut wire = Vec::with_capacity(frame.payload.len() + 6);
|
||||
frame.encode(&mut wire);
|
||||
self.stream.write_all(&wire)?;
|
||||
self.stream.flush()
|
||||
}
|
||||
|
||||
fn recv(&mut self) -> io::Result<Frame> {
|
||||
loop {
|
||||
if !self.buffer.is_empty() {
|
||||
match Frame::decode(&self.buffer) {
|
||||
Ok((frame, consumed)) => {
|
||||
self.buffer.drain(..consumed);
|
||||
return Ok(frame);
|
||||
}
|
||||
Err(V2Error::Truncated) => {}
|
||||
Err(error) => {
|
||||
self.buffer.clear();
|
||||
return Err(io::Error::new(io::ErrorKind::InvalidData, error));
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut chunk = [0_u8; READ_CHUNK];
|
||||
let count = self.stream.read(&mut chunk)?;
|
||||
if count == 0 {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::UnexpectedEof,
|
||||
"stratum v2 stream closed",
|
||||
));
|
||||
}
|
||||
self.buffer.extend_from_slice(&chunk[..count]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Which protocol the miner speaks.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum StratumVersion {
|
||||
V1,
|
||||
V2,
|
||||
}
|
||||
|
||||
/// Why an attempt failed.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum FailureKind {
|
||||
/// The server refused the connection or the setup message.
|
||||
Refused,
|
||||
/// No mutually supported version.
|
||||
Unsupported,
|
||||
/// The connection could not be established or dropped.
|
||||
Transport,
|
||||
/// The server did not answer in time.
|
||||
Timeout,
|
||||
}
|
||||
|
||||
/// Operator preference.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct Preference {
|
||||
pub primary: StratumVersion,
|
||||
pub allow_v1_fallback: bool,
|
||||
}
|
||||
|
||||
impl Default for Preference {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
primary: StratumVersion::V2,
|
||||
allow_v1_fallback: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The protocol to try next, or `None` when there is nothing left.
|
||||
///
|
||||
/// V1 is attempted only when the operator allowed it and the failure is not a transport-level
|
||||
/// problem: a dead route or a dropped stream will fail identically on V1, so falling back would
|
||||
/// only delay the operator-visible error.
|
||||
pub fn fallback(
|
||||
preference: Preference,
|
||||
failed: StratumVersion,
|
||||
kind: FailureKind,
|
||||
) -> Option<StratumVersion> {
|
||||
match (preference.primary, failed) {
|
||||
(StratumVersion::V2, StratumVersion::V2)
|
||||
if preference.allow_v1_fallback && kind != FailureKind::Transport =>
|
||||
{
|
||||
Some(StratumVersion::V1)
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::net::TcpListener;
|
||||
|
||||
#[test]
|
||||
fn a_frame_arrives_intact_over_tcp() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
|
||||
let address = listener.local_addr().expect("addr");
|
||||
let server = std::thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().expect("accept");
|
||||
let mut wire = Vec::new();
|
||||
Frame::new(0x00, vec![1, 2, 3, 4]).encode(&mut wire);
|
||||
stream.write_all(&wire).expect("write");
|
||||
});
|
||||
let mut link = TcpLink::connect(address, Duration::from_secs(2)).expect("connect");
|
||||
let frame = link.recv().expect("recv");
|
||||
assert_eq!(frame.msg_type, 0x00);
|
||||
assert_eq!(frame.payload, vec![1, 2, 3, 4]);
|
||||
server.join().expect("join");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_frame_split_across_reads_is_reassembled() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
|
||||
let address = listener.local_addr().expect("addr");
|
||||
let server = std::thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().expect("accept");
|
||||
let mut wire = Vec::new();
|
||||
Frame::new(0x10, vec![9; 40]).encode(&mut wire);
|
||||
stream.write_all(&wire[..5]).expect("first");
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
stream.write_all(&wire[5..]).expect("rest");
|
||||
});
|
||||
let mut link = TcpLink::connect(address, Duration::from_secs(2)).expect("connect");
|
||||
let frame = link.recv().expect("recv");
|
||||
assert_eq!(frame.msg_type, 0x10);
|
||||
assert_eq!(frame.payload.len(), 40);
|
||||
server.join().expect("join");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn two_frames_in_one_read_are_returned_one_at_a_time() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
|
||||
let address = listener.local_addr().expect("addr");
|
||||
let server = std::thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().expect("accept");
|
||||
let mut wire = Vec::new();
|
||||
Frame::new(0x01, vec![1]).encode(&mut wire);
|
||||
Frame::new(0x02, vec![2]).encode(&mut wire);
|
||||
stream.write_all(&wire).expect("write");
|
||||
});
|
||||
let mut link = TcpLink::connect(address, Duration::from_secs(2)).expect("connect");
|
||||
assert_eq!(link.recv().expect("first").msg_type, 0x01);
|
||||
assert_eq!(link.recv().expect("second").msg_type, 0x02);
|
||||
server.join().expect("join");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_closed_stream_is_an_error_not_an_empty_frame() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
|
||||
let address = listener.local_addr().expect("addr");
|
||||
let server = std::thread::spawn(move || {
|
||||
let (_stream, _) = listener.accept().expect("accept");
|
||||
});
|
||||
let mut link = TcpLink::connect(address, Duration::from_secs(2)).expect("connect");
|
||||
let error = link.recv().expect_err("closed stream");
|
||||
assert_eq!(error.kind(), io::ErrorKind::UnexpectedEof);
|
||||
server.join().expect("join");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn v1_fallback_requires_permission_and_a_non_transport_failure() {
|
||||
let allowed = Preference {
|
||||
primary: StratumVersion::V2,
|
||||
allow_v1_fallback: true,
|
||||
};
|
||||
assert_eq!(
|
||||
fallback(allowed, StratumVersion::V2, FailureKind::Refused),
|
||||
Some(StratumVersion::V1)
|
||||
);
|
||||
assert_eq!(
|
||||
fallback(allowed, StratumVersion::V2, FailureKind::Unsupported),
|
||||
Some(StratumVersion::V1)
|
||||
);
|
||||
assert_eq!(
|
||||
fallback(allowed, StratumVersion::V2, FailureKind::Timeout),
|
||||
Some(StratumVersion::V1)
|
||||
);
|
||||
assert_eq!(
|
||||
fallback(allowed, StratumVersion::V2, FailureKind::Transport),
|
||||
None
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn v1_fallback_can_be_disabled_and_v1_failures_do_not_loop() {
|
||||
let denied = Preference {
|
||||
primary: StratumVersion::V2,
|
||||
allow_v1_fallback: false,
|
||||
};
|
||||
assert_eq!(
|
||||
fallback(denied, StratumVersion::V2, FailureKind::Refused),
|
||||
None
|
||||
);
|
||||
let allowed = Preference::default();
|
||||
assert_eq!(
|
||||
fallback(allowed, StratumVersion::V1, FailureKind::Refused),
|
||||
None
|
||||
);
|
||||
}
|
||||
|
||||
fn mock_pool() -> std::net::SocketAddr {
|
||||
use crate::stratum_v2::{
|
||||
NewMiningJob, OpenStandardMiningChannelSuccess, SetNewPrevHash, SetupConnectionSuccess,
|
||||
OPEN_STANDARD_MINING_CHANNEL, OPEN_STANDARD_MINING_CHANNEL_SUCCESS, SETUP_CONNECTION,
|
||||
SETUP_CONNECTION_SUCCESS, SET_NEW_PREV_HASH, SUBMIT_SHARES_SUCCESS,
|
||||
};
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
|
||||
let address = listener.local_addr().expect("addr");
|
||||
// Publish the address through a channel so the test can connect after binding.
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
tx.send(address).expect("send address");
|
||||
std::thread::spawn(move || {
|
||||
let (stream, _) = listener.accept().expect("accept");
|
||||
let mut link = TcpLink::from_stream(stream).expect("link");
|
||||
let setup = link.recv().expect("setup");
|
||||
assert_eq!(setup.msg_type, SETUP_CONNECTION);
|
||||
link.send(&Frame::new(
|
||||
SETUP_CONNECTION_SUCCESS,
|
||||
SetupConnectionSuccess {
|
||||
used_version: 2,
|
||||
flags: 0,
|
||||
}
|
||||
.encode(),
|
||||
))
|
||||
.expect("setup success");
|
||||
let open = link.recv().expect("open");
|
||||
assert_eq!(open.msg_type, OPEN_STANDARD_MINING_CHANNEL);
|
||||
link.send(&Frame::new(
|
||||
OPEN_STANDARD_MINING_CHANNEL_SUCCESS,
|
||||
OpenStandardMiningChannelSuccess {
|
||||
request_id: 1,
|
||||
channel_id: 7,
|
||||
target: [0x7f; 32],
|
||||
extranonce_prefix: vec![9, 9],
|
||||
group_channel_id: 0,
|
||||
}
|
||||
.encode(),
|
||||
))
|
||||
.expect("channel success");
|
||||
link.send(&Frame::new(
|
||||
SET_NEW_PREV_HASH,
|
||||
SetNewPrevHash {
|
||||
channel_id: 7,
|
||||
job_id: 41,
|
||||
prev_hash: [0x11; 32],
|
||||
ntime_start: 1_700_000_000,
|
||||
nbits: 0x1707_0000,
|
||||
}
|
||||
.encode(),
|
||||
))
|
||||
.expect("prev hash");
|
||||
link.send(&Frame::new(
|
||||
NEW_MINING_JOB_TYPE,
|
||||
NewMiningJob {
|
||||
channel_id: 7,
|
||||
job_id: 42,
|
||||
ntime_start: Some(1_700_000_100),
|
||||
version: 0x2000_0000,
|
||||
merkle_root: [0x22; 32],
|
||||
}
|
||||
.encode(),
|
||||
))
|
||||
.expect("job");
|
||||
let share = link.recv().expect("share");
|
||||
assert_eq!(share.msg_type, SUBMIT_SHARES_STANDARD_TYPE);
|
||||
let mut body = Vec::new();
|
||||
body.extend_from_slice(&7_u32.to_le_bytes());
|
||||
body.extend_from_slice(&1_u32.to_le_bytes());
|
||||
body.extend_from_slice(&1_u32.to_le_bytes());
|
||||
body.extend_from_slice(&0_u64.to_le_bytes());
|
||||
link.send(&Frame::new(SUBMIT_SHARES_SUCCESS, body))
|
||||
.expect("share success");
|
||||
});
|
||||
rx.recv().expect("address")
|
||||
}
|
||||
|
||||
const NEW_MINING_JOB_TYPE: u8 = 0x15;
|
||||
const SUBMIT_SHARES_STANDARD_TYPE: u8 = 0x1a;
|
||||
|
||||
#[test]
|
||||
fn a_session_runs_against_a_socket_pool() {
|
||||
use crate::stratum_v2_session::{handshake, V2Config, V2Event, V2Session};
|
||||
let address = mock_pool();
|
||||
let mut link = TcpLink::connect(address, Duration::from_secs(3)).expect("connect");
|
||||
let config = V2Config {
|
||||
host: "pool.test".into(),
|
||||
port: 3333,
|
||||
flags: 0,
|
||||
user_identity: "worker".into(),
|
||||
nominal_hash_rate: 1.0e14,
|
||||
max_target: [0xff; 32],
|
||||
vendor: "alkane".into(),
|
||||
hardware: "bench".into(),
|
||||
firmware: "alkane-os".into(),
|
||||
device_id: "b1".into(),
|
||||
};
|
||||
let channel = handshake(&mut link, &config).expect("handshake");
|
||||
assert_eq!(channel.channel_id, 7);
|
||||
assert_eq!(channel.extranonce_prefix, vec![9, 9]);
|
||||
|
||||
let mut session = V2Session::new(channel);
|
||||
let prev = session
|
||||
.on_frame(&link.recv().expect("prev"))
|
||||
.expect("prev event");
|
||||
assert!(matches!(prev, V2Event::PrevHash { job_id: 41, .. }));
|
||||
let job = session
|
||||
.on_frame(&link.recv().expect("job"))
|
||||
.expect("job event");
|
||||
match job {
|
||||
V2Event::Job(parsed) => {
|
||||
assert_eq!(parsed.job_id, 42);
|
||||
assert_eq!(parsed.prev_hash, Some([0x11; 32]));
|
||||
assert_eq!(parsed.ntime_start, Some(1_700_000_100));
|
||||
}
|
||||
other => panic!("unexpected event: {other:?}"),
|
||||
}
|
||||
let sequence = session
|
||||
.submit(&mut link, 42, 0xdead_beef, 1_700_000_100, 0x2000_0000)
|
||||
.expect("submit");
|
||||
assert_eq!(sequence, 1);
|
||||
let ack = session
|
||||
.on_frame(&link.recv().expect("ack"))
|
||||
.expect("ack event");
|
||||
assert_eq!(
|
||||
ack,
|
||||
V2Event::ShareAccepted {
|
||||
last_sequence: 1,
|
||||
accepted: 1
|
||||
}
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,378 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Bounded pool-job bookkeeping for one BM1366 chain and one Stratum V1 session.
|
||||
|
||||
use crate::difficulty::PoolDifficulty;
|
||||
use crate::miner::{Bm1366Miner, MinerError, ValidShare};
|
||||
use crate::pow::{sha256d, VersionMask};
|
||||
use crate::stratum_submit::{format_submission, Submission, SubmitError};
|
||||
use crate::stratum_v1::{
|
||||
parse_control_notification, parse_notify, PoolMessageError, PoolNotification, Subscription,
|
||||
};
|
||||
use crate::stratum_work::JobError;
|
||||
use crate::HardwareBackend;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum SessionError {
|
||||
InvalidSubscription,
|
||||
Pool(PoolMessageError),
|
||||
Work(JobError),
|
||||
MissingDifficulty,
|
||||
ExtranonceExhausted,
|
||||
WorkIdsExhausted,
|
||||
StaleShare,
|
||||
UnverifiedShare,
|
||||
Submit(SubmitError),
|
||||
}
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub enum DispatchError<E> {
|
||||
Session(SessionError),
|
||||
Miner(MinerError<E>),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct IssuedWork {
|
||||
pub work_id: u8,
|
||||
pub header: [u8; 80],
|
||||
pub target_le: [u8; 32],
|
||||
/// The hardware miner must forget prior work before submitting this job.
|
||||
pub clean_jobs: bool,
|
||||
}
|
||||
|
||||
struct TrackedWork {
|
||||
job_id: String,
|
||||
header: [u8; 80],
|
||||
target_le: [u8; 32],
|
||||
extranonce2: Vec<u8>,
|
||||
ntime: u32,
|
||||
base_version: u32,
|
||||
}
|
||||
|
||||
struct NonceSpace {
|
||||
template: [u8; 80],
|
||||
next: [u8; 32],
|
||||
exhausted: bool,
|
||||
}
|
||||
|
||||
const MAX_NONCE_SPACES: usize = 4096;
|
||||
|
||||
pub struct PoolSession {
|
||||
subscription: Subscription,
|
||||
version_mask: Option<VersionMask>,
|
||||
subscribe_extranonce: bool,
|
||||
pending_difficulty: Option<PoolDifficulty>,
|
||||
active_difficulty: Option<PoolDifficulty>,
|
||||
nonce_spaces: Vec<NonceSpace>,
|
||||
zero_extranonce_headers: Vec<[u8; 80]>,
|
||||
tracked: [Option<TrackedWork>; 32],
|
||||
next_slot: usize,
|
||||
}
|
||||
|
||||
impl PoolSession {
|
||||
pub fn new(
|
||||
subscription: Subscription,
|
||||
version_mask: Option<VersionMask>,
|
||||
subscribe_extranonce: bool,
|
||||
) -> Result<Self, SessionError> {
|
||||
if subscription.extranonce1.len() > 32 || subscription.extranonce2_size > 32 {
|
||||
return Err(SessionError::InvalidSubscription);
|
||||
}
|
||||
Ok(Self {
|
||||
subscription,
|
||||
version_mask,
|
||||
subscribe_extranonce,
|
||||
pending_difficulty: None,
|
||||
active_difficulty: None,
|
||||
nonce_spaces: Vec::new(),
|
||||
zero_extranonce_headers: Vec::new(),
|
||||
tracked: std::array::from_fn(|_| None),
|
||||
next_slot: 0,
|
||||
})
|
||||
}
|
||||
|
||||
/// Apply a control message in wire order. A true result means the caller
|
||||
/// must call the hardware miner's `clear_work` before accepting reports.
|
||||
pub fn control(&mut self, line: &[u8]) -> Result<bool, SessionError> {
|
||||
let control = parse_control_notification(
|
||||
line,
|
||||
self.version_mask.is_some(),
|
||||
self.subscribe_extranonce,
|
||||
)
|
||||
.map_err(SessionError::Pool)?;
|
||||
match control {
|
||||
PoolNotification::SetDifficulty(difficulty) => {
|
||||
self.pending_difficulty = Some(difficulty);
|
||||
Ok(false)
|
||||
}
|
||||
PoolNotification::SetVersionMask(mask) => {
|
||||
if self.version_mask == Some(mask) {
|
||||
return Ok(false);
|
||||
}
|
||||
self.version_mask = Some(mask);
|
||||
self.tracked = std::array::from_fn(|_| None);
|
||||
Ok(true)
|
||||
}
|
||||
PoolNotification::SetExtranonce(subscription) => {
|
||||
self.subscription = subscription;
|
||||
self.nonce_spaces.clear();
|
||||
self.zero_extranonce_headers.clear();
|
||||
self.tracked = std::array::from_fn(|_| None);
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply a pool control message and invalidate the hardware miner's work
|
||||
/// when an extranonce or version-mask change makes earlier jobs stale.
|
||||
pub fn control_with_miner<B: HardwareBackend>(
|
||||
&mut self,
|
||||
miner: &mut Bm1366Miner<'_, B>,
|
||||
line: &[u8],
|
||||
) -> Result<(), SessionError> {
|
||||
if self.control(line)? {
|
||||
miner.clear_work();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Allocate one unique extranonce and ASIC work ID for a pool job. The
|
||||
/// caller must pass this header, target, and ID to `Bm1366Miner::submit`.
|
||||
/// On `clean_jobs`, clear the hardware miner's work first. Work IDs are
|
||||
/// never reused on the same chain without an explicit hardware reset.
|
||||
pub fn issue_notify(&mut self, line: &[u8]) -> Result<IssuedWork, SessionError> {
|
||||
let job = parse_notify(line, &self.subscription).map_err(SessionError::Pool)?;
|
||||
let difficulty = self
|
||||
.pending_difficulty
|
||||
.or(self.active_difficulty)
|
||||
.ok_or(SessionError::MissingDifficulty)?;
|
||||
if self.next_slot == self.tracked.len() {
|
||||
return Err(SessionError::WorkIdsExhausted);
|
||||
}
|
||||
let size = self.subscription.extranonce2_size;
|
||||
let template = if size == 0 {
|
||||
None
|
||||
} else {
|
||||
Some(
|
||||
job.work
|
||||
.nonce_zero_header(&vec![0; size], job.work.ntime)
|
||||
.map_err(SessionError::Work)?,
|
||||
)
|
||||
};
|
||||
let space_index = template.and_then(|header| {
|
||||
self.nonce_spaces
|
||||
.iter()
|
||||
.position(|space| space.template == header)
|
||||
});
|
||||
if size != 0 && space_index.is_none() && self.nonce_spaces.len() == MAX_NONCE_SPACES {
|
||||
return Err(SessionError::ExtranonceExhausted);
|
||||
}
|
||||
let extranonce2 = match space_index {
|
||||
Some(index) if self.nonce_spaces[index].exhausted => {
|
||||
return Err(SessionError::ExtranonceExhausted)
|
||||
}
|
||||
Some(index) => self.nonce_spaces[index].next[..size].to_vec(),
|
||||
None => vec![0; size],
|
||||
};
|
||||
let header = job
|
||||
.work
|
||||
.nonce_zero_header(&extranonce2, job.work.ntime)
|
||||
.map_err(SessionError::Work)?;
|
||||
if size == 0 && self.zero_extranonce_headers.contains(&header) {
|
||||
return Err(SessionError::ExtranonceExhausted);
|
||||
}
|
||||
let target_le = difficulty.target_le();
|
||||
if job.clean_jobs {
|
||||
self.tracked = std::array::from_fn(|_| None);
|
||||
}
|
||||
self.active_difficulty = Some(difficulty);
|
||||
self.pending_difficulty = None;
|
||||
let slot = self.next_slot;
|
||||
self.next_slot += 1;
|
||||
self.tracked[slot] = Some(TrackedWork {
|
||||
job_id: job.id,
|
||||
header,
|
||||
target_le,
|
||||
extranonce2,
|
||||
ntime: job.work.ntime,
|
||||
base_version: job.work.version,
|
||||
});
|
||||
if size == 0 {
|
||||
self.zero_extranonce_headers.push(header);
|
||||
} else {
|
||||
let space = match space_index {
|
||||
Some(index) => &mut self.nonce_spaces[index],
|
||||
None => {
|
||||
self.nonce_spaces.push(NonceSpace {
|
||||
template: template.expect("nonzero extranonce has a template"),
|
||||
next: [0; 32],
|
||||
exhausted: false,
|
||||
});
|
||||
self.nonce_spaces.last_mut().expect("just pushed")
|
||||
}
|
||||
};
|
||||
let mut carry = true;
|
||||
for byte in space.next[..size].iter_mut().rev() {
|
||||
let (new, overflow) = byte.overflowing_add(u8::from(carry));
|
||||
*byte = new;
|
||||
carry = overflow;
|
||||
if !carry {
|
||||
break;
|
||||
}
|
||||
}
|
||||
space.exhausted = carry;
|
||||
}
|
||||
Ok(IssuedWork {
|
||||
work_id: (slot as u8) << 3,
|
||||
header,
|
||||
target_le,
|
||||
clean_jobs: job.clean_jobs,
|
||||
})
|
||||
}
|
||||
|
||||
/// Preserve pool-message order while dispatching one job to the hardware
|
||||
/// miner. A failed dispatch consumes its ASIC work ID to avoid ambiguity
|
||||
/// with any frame that may have reached the device before the error.
|
||||
pub fn issue_to_miner<B: HardwareBackend>(
|
||||
&mut self,
|
||||
miner: &mut Bm1366Miner<'_, B>,
|
||||
line: &[u8],
|
||||
) -> Result<IssuedWork, DispatchError<B::Error>> {
|
||||
let issued = self.issue_notify(line).map_err(DispatchError::Session)?;
|
||||
if issued.clean_jobs {
|
||||
miner.clear_work();
|
||||
}
|
||||
if let Err(error) = miner.submit(issued.header, issued.target_le, issued.work_id) {
|
||||
self.tracked[usize::from(issued.work_id >> 3)] = None;
|
||||
return Err(DispatchError::Miner(error));
|
||||
}
|
||||
Ok(issued)
|
||||
}
|
||||
|
||||
/// Recheck the hardware-reported share and format its pool submission.
|
||||
/// This method verifies one reported nonce; it never searches for one.
|
||||
pub fn submission(
|
||||
&self,
|
||||
share: ValidShare,
|
||||
worker: &str,
|
||||
request_id: u64,
|
||||
) -> Result<String, SessionError> {
|
||||
let tracked = self
|
||||
.tracked
|
||||
.get(usize::from(share.work_id >> 3))
|
||||
.and_then(Option::as_ref)
|
||||
.ok_or(SessionError::StaleShare)?;
|
||||
if share.work_id & 7 != 0 {
|
||||
return Err(SessionError::StaleShare);
|
||||
}
|
||||
let mut header = tracked.header;
|
||||
header[..4].copy_from_slice(&share.rolled_version.to_le_bytes());
|
||||
header[76..80].copy_from_slice(&share.nonce.to_le_bytes());
|
||||
let hash_le = sha256d(&header);
|
||||
if hash_le != share.hash_le
|
||||
|| hash_le
|
||||
.iter()
|
||||
.rev()
|
||||
.cmp(tracked.target_le.iter().rev())
|
||||
.is_gt()
|
||||
{
|
||||
return Err(SessionError::UnverifiedShare);
|
||||
}
|
||||
format_submission(&Submission {
|
||||
request_id,
|
||||
worker,
|
||||
job_id: &tracked.job_id,
|
||||
extranonce2: &tracked.extranonce2,
|
||||
ntime: tracked.ntime,
|
||||
nonce: share.nonce,
|
||||
base_version: tracked.base_version,
|
||||
rolled_version: share.rolled_version,
|
||||
version_mask: self.version_mask,
|
||||
})
|
||||
.map_err(SessionError::Submit)
|
||||
}
|
||||
|
||||
/// Call only after the chain has actually reset and prior reports cannot
|
||||
/// arrive. A pool `clean_jobs` notification alone is insufficient.
|
||||
pub fn after_hardware_reset(&mut self) {
|
||||
self.tracked = std::array::from_fn(|_| None);
|
||||
self.next_slot = 0;
|
||||
self.zero_extranonce_headers.clear();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn bytes(text: &str) -> Vec<u8> {
|
||||
text.as_bytes()
|
||||
.chunks_exact(2)
|
||||
.map(|part| u8::from_str_radix(std::str::from_utf8(part).unwrap(), 16).unwrap())
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn captured_report_is_rechecked_and_formatted_for_pool() {
|
||||
let header: [u8; 80] = bytes(concat!(
|
||||
"00000020fc3ab8d43021f45eb662389d0f791f657dbf75a5cb93670b57b6c22503",
|
||||
"b4213a43ae1052ebd44443068fe178e2c61ca4994846fd133addb04aab2b382c5",
|
||||
"b4c74c1012e6a8f06021700000000"
|
||||
))
|
||||
.try_into()
|
||||
.unwrap();
|
||||
let hash_le: [u8; 32] =
|
||||
bytes("4b5e00850cf9de9809f822f8858eda39e49996d9d40f634f1043290000000000")
|
||||
.try_into()
|
||||
.unwrap();
|
||||
let mut target_le = [0_u8; 32];
|
||||
target_le[26..28].fill(0xff);
|
||||
let mut session = PoolSession::new(
|
||||
Subscription {
|
||||
extranonce1: vec![],
|
||||
extranonce2_size: 4,
|
||||
},
|
||||
VersionMask::new(0x1fff_e000),
|
||||
false,
|
||||
)
|
||||
.unwrap();
|
||||
session.tracked[3] = Some(TrackedWork {
|
||||
job_id: "captured-job".into(),
|
||||
header,
|
||||
target_le,
|
||||
extranonce2: vec![0, 0, 0, 1],
|
||||
ntime: u32::from_le_bytes(header[68..72].try_into().unwrap()),
|
||||
base_version: 0x2000_0000,
|
||||
});
|
||||
let share = ValidShare {
|
||||
nonce: 0xedad_ff38,
|
||||
work_id: 0x18,
|
||||
rolled_version: 0x2096_6000,
|
||||
hash_le,
|
||||
};
|
||||
let submit = session.submission(share, "miner.worker", 7).unwrap();
|
||||
assert!(submit.contains("\"mining.submit\""));
|
||||
assert!(submit.contains("\"captured-job\""));
|
||||
assert!(submit.contains("\"edadff38\",\"00966000\""));
|
||||
assert_eq!(
|
||||
session.submission(
|
||||
ValidShare {
|
||||
hash_le: [0; 32],
|
||||
..share
|
||||
},
|
||||
"miner.worker",
|
||||
8
|
||||
),
|
||||
Err(SessionError::UnverifiedShare)
|
||||
);
|
||||
assert_eq!(
|
||||
session.control(
|
||||
b"{\"id\":null,\"method\":\"mining.set_version_mask\",\"params\":[\"00002000\"]}"
|
||||
),
|
||||
Ok(true)
|
||||
);
|
||||
assert_eq!(
|
||||
session.submission(share, "miner.worker", 8),
|
||||
Err(SessionError::StaleShare)
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Format one verified share for Stratum V1 and negotiated BIP310 submission.
|
||||
//! Pool I/O and request tracking are owned by the caller.
|
||||
|
||||
use crate::pow::VersionMask;
|
||||
use std::fmt::Write;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum SubmitError {
|
||||
EmptyWorker,
|
||||
EmptyJobId,
|
||||
FieldTooLong,
|
||||
ExtranonceTooLong,
|
||||
UnrepresentableVersion,
|
||||
}
|
||||
|
||||
pub struct Submission<'a> {
|
||||
pub request_id: u64,
|
||||
pub worker: &'a str,
|
||||
pub job_id: &'a str,
|
||||
pub extranonce2: &'a [u8],
|
||||
pub ntime: u32,
|
||||
pub nonce: u32,
|
||||
pub base_version: u32,
|
||||
pub rolled_version: u32,
|
||||
/// The last pool mask, only after version rolling was accepted.
|
||||
pub version_mask: Option<VersionMask>,
|
||||
}
|
||||
|
||||
fn json_string(out: &mut String, value: &str) {
|
||||
out.push('"');
|
||||
for ch in value.chars() {
|
||||
match ch {
|
||||
'"' => out.push_str("\\\""),
|
||||
'\\' => out.push_str("\\\\"),
|
||||
'\n' => out.push_str("\\n"),
|
||||
'\r' => out.push_str("\\r"),
|
||||
'\t' => out.push_str("\\t"),
|
||||
c if c <= '\u{001f}' => {
|
||||
write!(out, "\\u{:04x}", c as u32).expect("write to String");
|
||||
}
|
||||
c => out.push(c),
|
||||
}
|
||||
}
|
||||
out.push('"');
|
||||
}
|
||||
|
||||
/// Emit one newline-terminated JSON request. The caller must have checked the
|
||||
/// ASIC report against the pool target and retained the original job metadata.
|
||||
pub fn format_submission(share: &Submission<'_>) -> Result<String, SubmitError> {
|
||||
if share.worker.is_empty() {
|
||||
return Err(SubmitError::EmptyWorker);
|
||||
}
|
||||
if share.job_id.is_empty() {
|
||||
return Err(SubmitError::EmptyJobId);
|
||||
}
|
||||
if share.worker.len() > 128 || share.job_id.len() > 128 {
|
||||
return Err(SubmitError::FieldTooLong);
|
||||
}
|
||||
if share.extranonce2.len() > 32 {
|
||||
return Err(SubmitError::ExtranonceTooLong);
|
||||
}
|
||||
let version_bits = match share.version_mask {
|
||||
Some(mask) => {
|
||||
let bits = share.rolled_version & mask.bits();
|
||||
if mask.apply_submission_bits(share.base_version, bits) != Some(share.rolled_version) {
|
||||
return Err(SubmitError::UnrepresentableVersion);
|
||||
}
|
||||
Some(bits)
|
||||
}
|
||||
None if share.rolled_version == share.base_version => None,
|
||||
None => return Err(SubmitError::UnrepresentableVersion),
|
||||
};
|
||||
|
||||
let mut out = format!(
|
||||
"{{\"id\":{},\"method\":\"mining.submit\",\"params\":[",
|
||||
share.request_id
|
||||
);
|
||||
json_string(&mut out, share.worker);
|
||||
out.push(',');
|
||||
json_string(&mut out, share.job_id);
|
||||
out.push_str(",\"");
|
||||
for byte in share.extranonce2 {
|
||||
write!(out, "{byte:02x}").expect("write to String");
|
||||
}
|
||||
write!(out, "\",\"{:08x}\",\"{:08x}\"", share.ntime, share.nonce).expect("write to String");
|
||||
if let Some(bits) = version_bits {
|
||||
write!(out, ",\"{bits:08x}\"").expect("write to String");
|
||||
}
|
||||
out.push_str("]}\n");
|
||||
Ok(out)
|
||||
}
|
||||
@@ -0,0 +1,308 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Bounded decoding of Bitcoin Stratum V1 subscription and job messages.
|
||||
//! The network client must enforce a line limit before passing data here.
|
||||
|
||||
use crate::difficulty::PoolDifficulty;
|
||||
use crate::pow::VersionMask;
|
||||
use crate::stratum_work::{JobError, Sha256Job};
|
||||
use serde_json::Value;
|
||||
|
||||
pub const MAX_POOL_LINE_BYTES: usize = 131_072;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum PoolMessageError {
|
||||
TooLarge,
|
||||
Json,
|
||||
WrongMessage,
|
||||
Unnegotiated,
|
||||
InvalidField,
|
||||
InvalidHex,
|
||||
InvalidWork(JobError),
|
||||
}
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub struct Subscription {
|
||||
pub extranonce1: Vec<u8>,
|
||||
pub extranonce2_size: usize,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ConfigureResult {
|
||||
pub version_mask: Option<VersionMask>,
|
||||
pub subscribe_extranonce: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub enum PoolNotification {
|
||||
SetDifficulty(PoolDifficulty),
|
||||
SetExtranonce(Subscription),
|
||||
SetVersionMask(VersionMask),
|
||||
}
|
||||
|
||||
pub struct PoolJob {
|
||||
pub id: String,
|
||||
pub clean_jobs: bool,
|
||||
pub work: Sha256Job,
|
||||
}
|
||||
|
||||
fn parse_json(line: &[u8]) -> Result<Value, PoolMessageError> {
|
||||
if line.len() > MAX_POOL_LINE_BYTES {
|
||||
return Err(PoolMessageError::TooLarge);
|
||||
}
|
||||
serde_json::from_slice(line).map_err(|_| PoolMessageError::Json)
|
||||
}
|
||||
|
||||
fn hex_bytes(text: &str) -> Result<Vec<u8>, PoolMessageError> {
|
||||
let bytes = text.as_bytes();
|
||||
if bytes.len() & 1 != 0 {
|
||||
return Err(PoolMessageError::InvalidHex);
|
||||
}
|
||||
let mut result = Vec::with_capacity(bytes.len() / 2);
|
||||
for pair in bytes.chunks_exact(2) {
|
||||
let high = (pair[0] as char)
|
||||
.to_digit(16)
|
||||
.ok_or(PoolMessageError::InvalidHex)?;
|
||||
let low = (pair[1] as char)
|
||||
.to_digit(16)
|
||||
.ok_or(PoolMessageError::InvalidHex)?;
|
||||
result.push(((high << 4) | low) as u8);
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
fn hex_fixed<const N: usize>(field: &Value) -> Result<[u8; N], PoolMessageError> {
|
||||
let text = field.as_str().ok_or(PoolMessageError::InvalidField)?;
|
||||
if text.len() != N * 2 {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
hex_bytes(text)?
|
||||
.try_into()
|
||||
.map_err(|_| PoolMessageError::InvalidField)
|
||||
}
|
||||
|
||||
fn hex_u32(field: &Value) -> Result<u32, PoolMessageError> {
|
||||
let text = field.as_str().ok_or(PoolMessageError::InvalidField)?;
|
||||
if text.len() != 8 {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
u32::from_str_radix(text, 16).map_err(|_| PoolMessageError::InvalidHex)
|
||||
}
|
||||
|
||||
fn valid_subscription(
|
||||
extranonce1: Vec<u8>,
|
||||
extranonce2_size: u64,
|
||||
) -> Result<Subscription, PoolMessageError> {
|
||||
if extranonce1.len() > 32 || extranonce2_size > 32 {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
Ok(Subscription {
|
||||
extranonce1,
|
||||
extranonce2_size: extranonce2_size as usize,
|
||||
})
|
||||
}
|
||||
|
||||
/// Parse the response to a matching `mining.subscribe` request.
|
||||
pub fn parse_subscription(line: &[u8], request_id: u64) -> Result<Subscription, PoolMessageError> {
|
||||
let message = parse_json(line)?;
|
||||
if message.get("id").and_then(Value::as_u64) != Some(request_id)
|
||||
|| !message.get("error").is_none_or(Value::is_null)
|
||||
{
|
||||
return Err(PoolMessageError::WrongMessage);
|
||||
}
|
||||
let result = message
|
||||
.get("result")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or(PoolMessageError::InvalidField)?;
|
||||
if result.len() != 3 || !result[0].is_array() {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
let extranonce1 = hex_bytes(result[1].as_str().ok_or(PoolMessageError::InvalidField)?)?;
|
||||
let extranonce2_size = result[2].as_u64().ok_or(PoolMessageError::InvalidField)?;
|
||||
valid_subscription(extranonce1, extranonce2_size)
|
||||
}
|
||||
|
||||
/// Decode the response to a BIP310 configure request that offered version
|
||||
/// rolling. A pool mask outside this ASIC's changeable bits is unusable: the
|
||||
/// pool would reconstruct a different block version for submitted shares.
|
||||
pub fn parse_configure_response(
|
||||
line: &[u8],
|
||||
request_id: u64,
|
||||
) -> Result<Option<VersionMask>, PoolMessageError> {
|
||||
let message = parse_json(line)?;
|
||||
if message.get("id").and_then(Value::as_u64) != Some(request_id)
|
||||
|| !message.get("error").is_none_or(Value::is_null)
|
||||
{
|
||||
return Err(PoolMessageError::WrongMessage);
|
||||
}
|
||||
let result = message
|
||||
.get("result")
|
||||
.and_then(Value::as_object)
|
||||
.ok_or(PoolMessageError::InvalidField)?;
|
||||
match result.get("version-rolling") {
|
||||
Some(Value::Bool(false) | Value::String(_)) => Ok(None),
|
||||
Some(Value::Bool(true)) => {
|
||||
let mask = hex_u32(
|
||||
result
|
||||
.get("version-rolling.mask")
|
||||
.ok_or(PoolMessageError::InvalidField)?,
|
||||
)?;
|
||||
VersionMask::new(mask)
|
||||
.map(Some)
|
||||
.ok_or(PoolMessageError::InvalidField)
|
||||
}
|
||||
_ => Err(PoolMessageError::InvalidField),
|
||||
}
|
||||
}
|
||||
|
||||
/// Decode both offered BIP310 extensions. An omitted extranonce extension is
|
||||
/// unsupported; its notifications cannot be used without an explicit grant.
|
||||
pub fn parse_configure_result(
|
||||
line: &[u8],
|
||||
request_id: u64,
|
||||
) -> Result<ConfigureResult, PoolMessageError> {
|
||||
let version_mask = parse_configure_response(line, request_id)?;
|
||||
let message = parse_json(line)?;
|
||||
let result = message
|
||||
.get("result")
|
||||
.and_then(Value::as_object)
|
||||
.ok_or(PoolMessageError::InvalidField)?;
|
||||
let subscribe_extranonce = match result.get("subscribe-extranonce") {
|
||||
Some(Value::Bool(value)) => *value,
|
||||
Some(Value::String(_)) | None => false,
|
||||
_ => return Err(PoolMessageError::InvalidField),
|
||||
};
|
||||
Ok(ConfigureResult {
|
||||
version_mask,
|
||||
subscribe_extranonce,
|
||||
})
|
||||
}
|
||||
|
||||
/// Decode a matching authorization or share-submission result. A false
|
||||
/// result is an ordinary pool rejection and must not count as an accept.
|
||||
pub fn parse_boolean_response(line: &[u8], request_id: u64) -> Result<bool, PoolMessageError> {
|
||||
let message = parse_json(line)?;
|
||||
if message.get("id").and_then(Value::as_u64) != Some(request_id) {
|
||||
return Err(PoolMessageError::WrongMessage);
|
||||
}
|
||||
match message.get("result") {
|
||||
Some(Value::Bool(true)) if message.get("error").is_none_or(Value::is_null) => Ok(true),
|
||||
Some(Value::Bool(false)) => Ok(false),
|
||||
Some(Value::Null) if !message.get("error").is_none_or(Value::is_null) => Ok(false),
|
||||
_ => Err(PoolMessageError::InvalidField),
|
||||
}
|
||||
}
|
||||
|
||||
/// Decode pool control notifications. The caller applies them in stream order:
|
||||
/// difficulty to the next job, extranonce to subsequent work, and the version
|
||||
/// mask immediately to all pending submissions.
|
||||
pub fn parse_control_notification(
|
||||
line: &[u8],
|
||||
version_rolling: bool,
|
||||
subscribe_extranonce: bool,
|
||||
) -> Result<PoolNotification, PoolMessageError> {
|
||||
let message = parse_json(line)?;
|
||||
if !message.get("id").is_none_or(Value::is_null) {
|
||||
return Err(PoolMessageError::WrongMessage);
|
||||
}
|
||||
let method = message
|
||||
.get("method")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or(PoolMessageError::WrongMessage)?;
|
||||
let params = message
|
||||
.get("params")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or(PoolMessageError::InvalidField)?;
|
||||
match method {
|
||||
"mining.set_difficulty" if params.len() == 1 => {
|
||||
let number = params[0]
|
||||
.as_number()
|
||||
.ok_or(PoolMessageError::InvalidField)?;
|
||||
let difficulty = PoolDifficulty::from_json_number(number)
|
||||
.map_err(|_| PoolMessageError::InvalidField)?;
|
||||
Ok(PoolNotification::SetDifficulty(difficulty))
|
||||
}
|
||||
"mining.set_version_mask" if params.len() == 1 => {
|
||||
if !version_rolling {
|
||||
return Err(PoolMessageError::Unnegotiated);
|
||||
}
|
||||
let mask = hex_u32(¶ms[0])?;
|
||||
let mask = VersionMask::new(mask).ok_or(PoolMessageError::InvalidField)?;
|
||||
Ok(PoolNotification::SetVersionMask(mask))
|
||||
}
|
||||
"mining.set_extranonce" if params.len() == 2 => {
|
||||
if !subscribe_extranonce {
|
||||
return Err(PoolMessageError::Unnegotiated);
|
||||
}
|
||||
let extranonce1 = hex_bytes(params[0].as_str().ok_or(PoolMessageError::InvalidField)?)?;
|
||||
let size = params[1].as_u64().ok_or(PoolMessageError::InvalidField)?;
|
||||
Ok(PoolNotification::SetExtranonce(valid_subscription(
|
||||
extranonce1,
|
||||
size,
|
||||
)?))
|
||||
}
|
||||
"mining.set_difficulty" | "mining.set_version_mask" | "mining.set_extranonce" => {
|
||||
Err(PoolMessageError::InvalidField)
|
||||
}
|
||||
_ => Err(PoolMessageError::WrongMessage),
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse exactly the nine Bitcoin `mining.notify` parameters into work.
|
||||
pub fn parse_notify(line: &[u8], subscription: &Subscription) -> Result<PoolJob, PoolMessageError> {
|
||||
let message = parse_json(line)?;
|
||||
if message.get("method").and_then(Value::as_str) != Some("mining.notify")
|
||||
|| !message.get("id").is_none_or(Value::is_null)
|
||||
{
|
||||
return Err(PoolMessageError::WrongMessage);
|
||||
}
|
||||
let params = message
|
||||
.get("params")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or(PoolMessageError::InvalidField)?;
|
||||
if params.len() != 9 {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
let id = params[0].as_str().ok_or(PoolMessageError::InvalidField)?;
|
||||
if id.is_empty() || id.len() > 128 {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
let branches = params[4].as_array().ok_or(PoolMessageError::InvalidField)?;
|
||||
if branches.len() > 64 {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
let mut merkle_branches = Vec::with_capacity(branches.len());
|
||||
for branch in branches {
|
||||
merkle_branches.push(hex_fixed::<32>(branch)?);
|
||||
}
|
||||
let work = Sha256Job {
|
||||
prevhash_stratum: hex_fixed::<32>(¶ms[1])?,
|
||||
coinb1: hex_bytes(params[2].as_str().ok_or(PoolMessageError::InvalidField)?)?,
|
||||
coinb2: hex_bytes(params[3].as_str().ok_or(PoolMessageError::InvalidField)?)?,
|
||||
merkle_branches,
|
||||
version: hex_u32(¶ms[5])?,
|
||||
nbits: hex_u32(¶ms[6])?,
|
||||
ntime: hex_u32(¶ms[7])?,
|
||||
extranonce1: subscription.extranonce1.clone(),
|
||||
extranonce2_size: subscription.extranonce2_size,
|
||||
};
|
||||
work.validate().map_err(PoolMessageError::InvalidWork)?;
|
||||
let clean_jobs = params[8].as_bool().ok_or(PoolMessageError::InvalidField)?;
|
||||
Ok(PoolJob {
|
||||
id: id.to_owned(),
|
||||
clean_jobs,
|
||||
work,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod configure_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn omitted_extranonce_extension_is_unsupported() {
|
||||
let line = br#"{"id":1,"result":{"version-rolling":true,"version-rolling.mask":"1fffe000"},"error":null}"#;
|
||||
let result = parse_configure_result(line, 1).unwrap();
|
||||
assert!(result.version_mask.is_some());
|
||||
assert!(!result.subscribe_extranonce);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,631 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Stratum V2 mining-protocol codec.
|
||||
//!
|
||||
//! Covers the client half of the mining sub-protocol: connection setup, opening a standard
|
||||
//! channel, and the job/share messages that follow. Layouts follow the published specification
|
||||
//! (framing in 03-Protocol-Overview 3.2, message types in 08-Message-Types, payloads in
|
||||
//! 05-Mining-Protocol 5.3).
|
||||
//!
|
||||
//! Everything is little-endian. `U256` is carried as the raw 32 bytes of the little-endian
|
||||
//! integer, which for a SHA-256 digest is the digest's own byte order.
|
||||
|
||||
use std::fmt;
|
||||
|
||||
pub const EXTENSION_TYPE_CORE: u16 = 0;
|
||||
|
||||
pub const SETUP_CONNECTION: u8 = 0x00;
|
||||
pub const SETUP_CONNECTION_SUCCESS: u8 = 0x01;
|
||||
pub const SETUP_CONNECTION_ERROR: u8 = 0x02;
|
||||
pub const OPEN_STANDARD_MINING_CHANNEL: u8 = 0x10;
|
||||
pub const OPEN_STANDARD_MINING_CHANNEL_SUCCESS: u8 = 0x11;
|
||||
pub const OPEN_MINING_CHANNEL_ERROR: u8 = 0x12;
|
||||
pub const NEW_MINING_JOB: u8 = 0x15;
|
||||
pub const SUBMIT_SHARES_STANDARD: u8 = 0x1a;
|
||||
pub const SUBMIT_SHARES_SUCCESS: u8 = 0x1c;
|
||||
pub const SUBMIT_SHARES_ERROR: u8 = 0x1d;
|
||||
pub const SET_NEW_PREV_HASH: u8 = 0x20;
|
||||
pub const SET_TARGET: u8 = 0x21;
|
||||
|
||||
const HEADER_LEN: usize = 6;
|
||||
const MAX_FRAME: usize = 1 << 20;
|
||||
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum V2Error {
|
||||
Truncated,
|
||||
Length,
|
||||
String,
|
||||
NonFiniteRate,
|
||||
UnknownMessage(u8),
|
||||
}
|
||||
|
||||
impl fmt::Display for V2Error {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Truncated => f.write_str("stratum v2 message is truncated"),
|
||||
Self::Length => f.write_str("stratum v2 length field is invalid"),
|
||||
Self::String => f.write_str("stratum v2 string field is invalid"),
|
||||
Self::NonFiniteRate => {
|
||||
f.write_str("stratum v2 hashrate is not a finite positive number")
|
||||
}
|
||||
Self::UnknownMessage(kind) => {
|
||||
write!(f, "unsupported stratum v2 message type {kind:#x}")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for V2Error {}
|
||||
|
||||
/// One framed message: 6-byte header plus payload.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct Frame {
|
||||
pub extension_type: u16,
|
||||
pub msg_type: u8,
|
||||
pub payload: Vec<u8>,
|
||||
}
|
||||
|
||||
impl Frame {
|
||||
pub fn new(msg_type: u8, payload: Vec<u8>) -> Self {
|
||||
Self {
|
||||
extension_type: EXTENSION_TYPE_CORE,
|
||||
msg_type,
|
||||
payload,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn encode(&self, out: &mut Vec<u8>) {
|
||||
out.extend_from_slice(&self.extension_type.to_le_bytes());
|
||||
out.push(self.msg_type);
|
||||
let length = self.payload.len() as u32;
|
||||
out.extend_from_slice(&length.to_le_bytes()[..3]);
|
||||
out.extend_from_slice(&self.payload);
|
||||
}
|
||||
|
||||
/// Decode one frame from `buf`, returning it and how many bytes it consumed.
|
||||
pub fn decode(buf: &[u8]) -> Result<(Self, usize), V2Error> {
|
||||
if buf.len() < HEADER_LEN {
|
||||
return Err(V2Error::Truncated);
|
||||
}
|
||||
let extension_type = u16::from_le_bytes([buf[0], buf[1]]);
|
||||
let msg_type = buf[2];
|
||||
let length = u32::from_le_bytes([buf[3], buf[4], buf[5], 0]) as usize;
|
||||
if length > MAX_FRAME {
|
||||
return Err(V2Error::Length);
|
||||
}
|
||||
let end = HEADER_LEN + length;
|
||||
if buf.len() < end {
|
||||
return Err(V2Error::Truncated);
|
||||
}
|
||||
Ok((
|
||||
Self {
|
||||
extension_type,
|
||||
msg_type,
|
||||
payload: buf[HEADER_LEN..end].to_vec(),
|
||||
},
|
||||
end,
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
/// `SetupConnection` for the mining sub-protocol.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct SetupConnection {
|
||||
pub protocol: u8,
|
||||
pub min_version: u16,
|
||||
pub max_version: u16,
|
||||
pub flags: u32,
|
||||
pub endpoint_host: String,
|
||||
pub endpoint_port: u16,
|
||||
pub vendor: String,
|
||||
pub hardware_version: String,
|
||||
pub firmware: String,
|
||||
pub device_id: String,
|
||||
}
|
||||
|
||||
impl SetupConnection {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
out.push(self.protocol);
|
||||
put_u16(&mut out, self.min_version);
|
||||
put_u16(&mut out, self.max_version);
|
||||
put_u32(&mut out, self.flags);
|
||||
put_str(&mut out, &self.endpoint_host);
|
||||
put_u16(&mut out, self.endpoint_port);
|
||||
put_str(&mut out, &self.vendor);
|
||||
put_str(&mut out, &self.hardware_version);
|
||||
put_str(&mut out, &self.firmware);
|
||||
put_str(&mut out, &self.device_id);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
Ok(Self {
|
||||
protocol: reader.u8()?,
|
||||
min_version: reader.u16()?,
|
||||
max_version: reader.u16()?,
|
||||
flags: reader.u32()?,
|
||||
endpoint_host: reader.string()?,
|
||||
endpoint_port: reader.u16()?,
|
||||
vendor: reader.string()?,
|
||||
hardware_version: reader.string()?,
|
||||
firmware: reader.string()?,
|
||||
device_id: reader.string()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `SetupConnection.Success`.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct SetupConnectionSuccess {
|
||||
pub used_version: u16,
|
||||
pub flags: u32,
|
||||
}
|
||||
|
||||
impl SetupConnectionSuccess {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_u16(&mut out, self.used_version);
|
||||
put_u32(&mut out, self.flags);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
Ok(Self {
|
||||
used_version: reader.u16()?,
|
||||
flags: reader.u32()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `OpenStandardMiningChannel`.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct OpenStandardMiningChannel {
|
||||
pub request_id: u32,
|
||||
pub user_identity: String,
|
||||
pub nominal_hash_rate: f32,
|
||||
pub max_target: [u8; 32],
|
||||
}
|
||||
|
||||
impl OpenStandardMiningChannel {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_u32(&mut out, self.request_id);
|
||||
put_str(&mut out, &self.user_identity);
|
||||
out.extend_from_slice(&self.nominal_hash_rate.to_le_bytes());
|
||||
out.extend_from_slice(&self.max_target);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
let request_id = reader.u32()?;
|
||||
let user_identity = reader.string()?;
|
||||
let nominal_hash_rate = reader.f32()?;
|
||||
if !nominal_hash_rate.is_finite() || nominal_hash_rate < 0.0 {
|
||||
return Err(V2Error::NonFiniteRate);
|
||||
}
|
||||
Ok(Self {
|
||||
request_id,
|
||||
user_identity,
|
||||
nominal_hash_rate,
|
||||
max_target: reader.u256()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `OpenStandardMiningChannel.Success`.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct OpenStandardMiningChannelSuccess {
|
||||
pub request_id: u32,
|
||||
pub channel_id: u32,
|
||||
pub target: [u8; 32],
|
||||
pub extranonce_prefix: Vec<u8>,
|
||||
pub group_channel_id: u32,
|
||||
}
|
||||
|
||||
impl OpenStandardMiningChannelSuccess {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_u32(&mut out, self.request_id);
|
||||
put_u32(&mut out, self.channel_id);
|
||||
out.extend_from_slice(&self.target);
|
||||
put_bytes(&mut out, &self.extranonce_prefix);
|
||||
put_u32(&mut out, self.group_channel_id);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
Ok(Self {
|
||||
request_id: reader.u32()?,
|
||||
channel_id: reader.u32()?,
|
||||
target: reader.u256()?,
|
||||
extranonce_prefix: reader.bytes(32)?,
|
||||
group_channel_id: reader.u32()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `NewMiningJob` on a standard channel.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct NewMiningJob {
|
||||
pub channel_id: u32,
|
||||
pub job_id: u32,
|
||||
/// `None` means a future job, activated by the matching `SetNewPrevHash`.
|
||||
pub ntime_start: Option<u32>,
|
||||
pub version: u32,
|
||||
pub merkle_root: [u8; 32],
|
||||
}
|
||||
|
||||
impl NewMiningJob {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_u32(&mut out, self.channel_id);
|
||||
put_u32(&mut out, self.job_id);
|
||||
match self.ntime_start {
|
||||
Some(ntime) => {
|
||||
out.push(1);
|
||||
put_u32(&mut out, ntime);
|
||||
}
|
||||
None => out.push(0),
|
||||
}
|
||||
put_u32(&mut out, self.version);
|
||||
out.extend_from_slice(&self.merkle_root);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
let channel_id = reader.u32()?;
|
||||
let job_id = reader.u32()?;
|
||||
let ntime_start = reader.option_u32()?;
|
||||
Ok(Self {
|
||||
channel_id,
|
||||
job_id,
|
||||
ntime_start,
|
||||
version: reader.u32()?,
|
||||
merkle_root: reader.u256()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `SetNewPrevHash`.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct SetNewPrevHash {
|
||||
pub channel_id: u32,
|
||||
pub job_id: u32,
|
||||
pub prev_hash: [u8; 32],
|
||||
pub ntime_start: u32,
|
||||
pub nbits: u32,
|
||||
}
|
||||
|
||||
impl SetNewPrevHash {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_u32(&mut out, self.channel_id);
|
||||
put_u32(&mut out, self.job_id);
|
||||
out.extend_from_slice(&self.prev_hash);
|
||||
put_u32(&mut out, self.ntime_start);
|
||||
put_u32(&mut out, self.nbits);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
Ok(Self {
|
||||
channel_id: reader.u32()?,
|
||||
job_id: reader.u32()?,
|
||||
prev_hash: reader.u256()?,
|
||||
ntime_start: reader.u32()?,
|
||||
nbits: reader.u32()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `SubmitSharesStandard`.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct SubmitSharesStandard {
|
||||
pub channel_id: u32,
|
||||
pub sequence_number: u32,
|
||||
pub job_id: u32,
|
||||
pub nonce: u32,
|
||||
pub ntime: u32,
|
||||
pub version: u32,
|
||||
}
|
||||
|
||||
impl SubmitSharesStandard {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_u32(&mut out, self.channel_id);
|
||||
put_u32(&mut out, self.sequence_number);
|
||||
put_u32(&mut out, self.job_id);
|
||||
put_u32(&mut out, self.nonce);
|
||||
put_u32(&mut out, self.ntime);
|
||||
put_u32(&mut out, self.version);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
Ok(Self {
|
||||
channel_id: reader.u32()?,
|
||||
sequence_number: reader.u32()?,
|
||||
job_id: reader.u32()?,
|
||||
nonce: reader.u32()?,
|
||||
ntime: reader.u32()?,
|
||||
version: reader.u32()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn put_u16(out: &mut Vec<u8>, value: u16) {
|
||||
out.extend_from_slice(&value.to_le_bytes());
|
||||
}
|
||||
|
||||
fn put_u32(out: &mut Vec<u8>, value: u32) {
|
||||
out.extend_from_slice(&value.to_le_bytes());
|
||||
}
|
||||
|
||||
fn put_str(out: &mut Vec<u8>, text: &str) {
|
||||
let bytes = text.as_bytes();
|
||||
let length = bytes.len().min(255);
|
||||
out.push(length as u8);
|
||||
out.extend_from_slice(&bytes[..length]);
|
||||
}
|
||||
|
||||
fn put_bytes(out: &mut Vec<u8>, bytes: &[u8]) {
|
||||
let length = bytes.len().min(255);
|
||||
out.push(length as u8);
|
||||
out.extend_from_slice(&bytes[..length]);
|
||||
}
|
||||
|
||||
struct Reader<'a> {
|
||||
buf: &'a [u8],
|
||||
at: usize,
|
||||
}
|
||||
|
||||
impl<'a> Reader<'a> {
|
||||
fn new(buf: &'a [u8]) -> Self {
|
||||
Self { buf, at: 0 }
|
||||
}
|
||||
|
||||
fn take(&mut self, count: usize) -> Result<&'a [u8], V2Error> {
|
||||
let end = self.at.checked_add(count).ok_or(V2Error::Length)?;
|
||||
if end > self.buf.len() {
|
||||
return Err(V2Error::Truncated);
|
||||
}
|
||||
let slice = &self.buf[self.at..end];
|
||||
self.at = end;
|
||||
Ok(slice)
|
||||
}
|
||||
|
||||
fn u8(&mut self) -> Result<u8, V2Error> {
|
||||
Ok(self.take(1)?[0])
|
||||
}
|
||||
|
||||
fn u16(&mut self) -> Result<u16, V2Error> {
|
||||
let bytes = self.take(2)?;
|
||||
Ok(u16::from_le_bytes([bytes[0], bytes[1]]))
|
||||
}
|
||||
|
||||
fn u32(&mut self) -> Result<u32, V2Error> {
|
||||
let bytes = self.take(4)?;
|
||||
Ok(u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]))
|
||||
}
|
||||
|
||||
fn f32(&mut self) -> Result<f32, V2Error> {
|
||||
Ok(f32::from_bits(self.u32()?))
|
||||
}
|
||||
|
||||
fn u256(&mut self) -> Result<[u8; 32], V2Error> {
|
||||
let bytes = self.take(32)?;
|
||||
let mut out = [0_u8; 32];
|
||||
out.copy_from_slice(bytes);
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn string(&mut self) -> Result<String, V2Error> {
|
||||
let length = self.u8()? as usize;
|
||||
let bytes = self.take(length)?;
|
||||
String::from_utf8(bytes.to_vec()).map_err(|_| V2Error::String)
|
||||
}
|
||||
|
||||
fn bytes(&mut self, max: usize) -> Result<Vec<u8>, V2Error> {
|
||||
let length = self.u8()? as usize;
|
||||
if length > max {
|
||||
return Err(V2Error::Length);
|
||||
}
|
||||
Ok(self.take(length)?.to_vec())
|
||||
}
|
||||
|
||||
fn option_u32(&mut self) -> Result<Option<u32>, V2Error> {
|
||||
match self.u8()? {
|
||||
0 => Ok(None),
|
||||
1 => Ok(Some(self.u32()?)),
|
||||
_ => Err(V2Error::Length),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn hash(byte: u8) -> [u8; 32] {
|
||||
[byte; 32]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn frame_header_matches_the_specification() {
|
||||
let mut wire = Vec::new();
|
||||
Frame::new(SETUP_CONNECTION, vec![1, 2, 3]).encode(&mut wire);
|
||||
assert_eq!(&wire[..3], &[0x00, 0x00, 0x00]);
|
||||
assert_eq!(&wire[3..6], &[0x03, 0x00, 0x00]);
|
||||
let (frame, consumed) = Frame::decode(&wire).expect("frame");
|
||||
assert_eq!(consumed, wire.len());
|
||||
assert_eq!(frame.msg_type, SETUP_CONNECTION);
|
||||
assert_eq!(frame.payload, vec![1, 2, 3]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_truncated_frame_is_rejected() {
|
||||
assert_eq!(Frame::decode(&[0, 0, 0x00]), Err(V2Error::Truncated));
|
||||
let mut wire = Vec::new();
|
||||
Frame::new(SETUP_CONNECTION, vec![9; 10]).encode(&mut wire);
|
||||
assert_eq!(Frame::decode(&wire[..8]), Err(V2Error::Truncated));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn setup_connection_round_trips() {
|
||||
let message = SetupConnection {
|
||||
protocol: 0,
|
||||
min_version: 2,
|
||||
max_version: 2,
|
||||
flags: 0b1011,
|
||||
endpoint_host: "pool.example".into(),
|
||||
endpoint_port: 3333,
|
||||
vendor: "alkane".into(),
|
||||
hardware_version: "s19jpro-bm1362".into(),
|
||||
firmware: "alkane-os/0.1.0".into(),
|
||||
device_id: "bench-169".into(),
|
||||
};
|
||||
let wire = message.encode();
|
||||
assert_eq!(SetupConnection::decode(&wire).expect("decode"), message);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn setup_connection_success_round_trips() {
|
||||
let message = SetupConnectionSuccess {
|
||||
used_version: 2,
|
||||
flags: 0,
|
||||
};
|
||||
assert_eq!(
|
||||
SetupConnectionSuccess::decode(&message.encode()).expect("decode"),
|
||||
message
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn open_standard_channel_round_trips() {
|
||||
let message = OpenStandardMiningChannel {
|
||||
request_id: 7,
|
||||
user_identity: "bc1q.example".into(),
|
||||
nominal_hash_rate: 95_000_000_000_000.0,
|
||||
max_target: hash(0xff),
|
||||
};
|
||||
assert_eq!(
|
||||
OpenStandardMiningChannel::decode(&message.encode()).expect("decode"),
|
||||
message
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_non_finite_hashrate_is_a_protocol_error() {
|
||||
let message = OpenStandardMiningChannel {
|
||||
request_id: 1,
|
||||
user_identity: "x".into(),
|
||||
nominal_hash_rate: f32::NAN,
|
||||
max_target: hash(0),
|
||||
};
|
||||
assert_eq!(
|
||||
OpenStandardMiningChannel::decode(&message.encode()),
|
||||
Err(V2Error::NonFiniteRate)
|
||||
);
|
||||
let negative = OpenStandardMiningChannel {
|
||||
nominal_hash_rate: -1.0,
|
||||
..message
|
||||
};
|
||||
assert_eq!(
|
||||
OpenStandardMiningChannel::decode(&negative.encode()),
|
||||
Err(V2Error::NonFiniteRate)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn channel_success_carries_the_extranonce_prefix() {
|
||||
let message = OpenStandardMiningChannelSuccess {
|
||||
request_id: 7,
|
||||
channel_id: 11,
|
||||
target: hash(0x7f),
|
||||
extranonce_prefix: vec![0xde, 0xad, 0xbe, 0xef],
|
||||
group_channel_id: 0,
|
||||
};
|
||||
assert_eq!(
|
||||
OpenStandardMiningChannelSuccess::decode(&message.encode()).expect("decode"),
|
||||
message
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn new_job_round_trips_both_ntime_forms() {
|
||||
let active = NewMiningJob {
|
||||
channel_id: 1,
|
||||
job_id: 2,
|
||||
ntime_start: Some(1_700_000_000),
|
||||
version: 0x2000_0000,
|
||||
merkle_root: hash(0x11),
|
||||
};
|
||||
assert_eq!(
|
||||
NewMiningJob::decode(&active.encode()).expect("decode"),
|
||||
active
|
||||
);
|
||||
let future = NewMiningJob {
|
||||
ntime_start: None,
|
||||
..active
|
||||
};
|
||||
assert_eq!(
|
||||
NewMiningJob::decode(&future.encode()).expect("decode"),
|
||||
future
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_new_prev_hash_round_trips() {
|
||||
let message = SetNewPrevHash {
|
||||
channel_id: 1,
|
||||
job_id: 2,
|
||||
prev_hash: hash(0x22),
|
||||
ntime_start: 1_700_000_100,
|
||||
nbits: 0x1707_0000,
|
||||
};
|
||||
assert_eq!(
|
||||
SetNewPrevHash::decode(&message.encode()).expect("decode"),
|
||||
message
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn submit_shares_round_trips() {
|
||||
let message = SubmitSharesStandard {
|
||||
channel_id: 3,
|
||||
sequence_number: 99,
|
||||
job_id: 4,
|
||||
nonce: 0xdead_beef,
|
||||
ntime: 1_700_000_200,
|
||||
version: 0x2000_0000,
|
||||
};
|
||||
assert_eq!(
|
||||
SubmitSharesStandard::decode(&message.encode()).expect("decode"),
|
||||
message
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_short_payload_is_rejected_rather_than_padded() {
|
||||
let wire = SubmitSharesStandard {
|
||||
channel_id: 3,
|
||||
sequence_number: 99,
|
||||
job_id: 4,
|
||||
nonce: 0,
|
||||
ntime: 0,
|
||||
version: 0,
|
||||
}
|
||||
.encode();
|
||||
assert_eq!(
|
||||
SubmitSharesStandard::decode(&wire[..8]),
|
||||
Err(V2Error::Truncated)
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,553 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Stratum V2 session: handshake, channel, jobs and share submission.
|
||||
//!
|
||||
//! The codec in `stratum_v2` owns bytes; this module owns order. It drives the client half of a
|
||||
//! mining connection and refuses to invent state: a job received before any `SetNewPrevHash` is
|
||||
//! reported with no previous hash rather than with a zero one, and a rejected setup surfaces the
|
||||
//! server's code.
|
||||
|
||||
use crate::stratum_v2::{
|
||||
Frame, NewMiningJob, OpenStandardMiningChannel, SetNewPrevHash, SetupConnection,
|
||||
SetupConnectionSuccess, SubmitSharesStandard, NEW_MINING_JOB, OPEN_MINING_CHANNEL_ERROR,
|
||||
OPEN_STANDARD_MINING_CHANNEL, OPEN_STANDARD_MINING_CHANNEL_SUCCESS, SETUP_CONNECTION,
|
||||
SETUP_CONNECTION_ERROR, SETUP_CONNECTION_SUCCESS, SET_NEW_PREV_HASH, SET_TARGET,
|
||||
SUBMIT_SHARES_ERROR, SUBMIT_SHARES_STANDARD, SUBMIT_SHARES_SUCCESS,
|
||||
};
|
||||
|
||||
/// A connection that carries whole frames.
|
||||
pub trait V2Link {
|
||||
type Error;
|
||||
|
||||
fn send(&mut self, frame: &Frame) -> Result<(), Self::Error>;
|
||||
fn recv(&mut self) -> Result<Frame, Self::Error>;
|
||||
}
|
||||
|
||||
/// What the client declares when it connects.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct V2Config {
|
||||
pub host: String,
|
||||
pub port: u16,
|
||||
pub flags: u32,
|
||||
pub user_identity: String,
|
||||
pub nominal_hash_rate: f32,
|
||||
pub max_target: [u8; 32],
|
||||
pub vendor: String,
|
||||
pub hardware: String,
|
||||
pub firmware: String,
|
||||
pub device_id: String,
|
||||
}
|
||||
|
||||
/// An opened standard channel.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct V2Channel {
|
||||
pub channel_id: u32,
|
||||
pub target: [u8; 32],
|
||||
pub extranonce_prefix: Vec<u8>,
|
||||
pub group_channel_id: u32,
|
||||
}
|
||||
|
||||
/// A job the miner may work on.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct V2Job {
|
||||
pub job_id: u32,
|
||||
pub version: u32,
|
||||
pub merkle_root: [u8; 32],
|
||||
pub ntime_start: Option<u32>,
|
||||
pub prev_hash: Option<[u8; 32]>,
|
||||
pub nbits: Option<u32>,
|
||||
}
|
||||
|
||||
/// Something the server told us.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum V2Event {
|
||||
Job(V2Job),
|
||||
PrevHash {
|
||||
job_id: u32,
|
||||
prev_hash: [u8; 32],
|
||||
ntime_start: u32,
|
||||
nbits: u32,
|
||||
},
|
||||
Target {
|
||||
channel_id: u32,
|
||||
target: [u8; 32],
|
||||
},
|
||||
ShareAccepted {
|
||||
last_sequence: u32,
|
||||
accepted: u32,
|
||||
},
|
||||
ShareRejected {
|
||||
last_sequence: u32,
|
||||
},
|
||||
Ignored,
|
||||
}
|
||||
|
||||
/// A protocol-level failure, without a link error inside it.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum SessionError {
|
||||
Protocol(&'static str),
|
||||
Rejected(String),
|
||||
}
|
||||
|
||||
/// A failure that may have come from the transport.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum ConnectError<E> {
|
||||
Link(E),
|
||||
Session(SessionError),
|
||||
}
|
||||
|
||||
/// Run the client handshake and return the opened channel.
|
||||
pub fn handshake<L: V2Link>(
|
||||
link: &mut L,
|
||||
config: &V2Config,
|
||||
) -> Result<V2Channel, ConnectError<L::Error>> {
|
||||
let setup = SetupConnection {
|
||||
protocol: 0,
|
||||
min_version: 2,
|
||||
max_version: 2,
|
||||
flags: config.flags,
|
||||
endpoint_host: config.host.clone(),
|
||||
endpoint_port: config.port,
|
||||
vendor: config.vendor.clone(),
|
||||
hardware_version: config.hardware.clone(),
|
||||
firmware: config.firmware.clone(),
|
||||
device_id: config.device_id.clone(),
|
||||
};
|
||||
link.send(&Frame::new(SETUP_CONNECTION, setup.encode()))
|
||||
.map_err(ConnectError::Link)?;
|
||||
let reply = link.recv().map_err(ConnectError::Link)?;
|
||||
match reply.msg_type {
|
||||
SETUP_CONNECTION_SUCCESS => {
|
||||
let _ = SetupConnectionSuccess::decode(&reply.payload)
|
||||
.map_err(|_| ConnectError::Session(SessionError::Protocol("bad setup success")))?;
|
||||
}
|
||||
SETUP_CONNECTION_ERROR => {
|
||||
return Err(ConnectError::Session(SessionError::Rejected(
|
||||
setup_error_text(&reply.payload),
|
||||
)))
|
||||
}
|
||||
_ => {
|
||||
return Err(ConnectError::Session(SessionError::Protocol(
|
||||
"unexpected message before setup success",
|
||||
)))
|
||||
}
|
||||
}
|
||||
|
||||
let open = OpenStandardMiningChannel {
|
||||
request_id: 1,
|
||||
user_identity: config.user_identity.clone(),
|
||||
nominal_hash_rate: config.nominal_hash_rate,
|
||||
max_target: config.max_target,
|
||||
};
|
||||
link.send(&Frame::new(OPEN_STANDARD_MINING_CHANNEL, open.encode()))
|
||||
.map_err(ConnectError::Link)?;
|
||||
let reply = link.recv().map_err(ConnectError::Link)?;
|
||||
match reply.msg_type {
|
||||
OPEN_STANDARD_MINING_CHANNEL_SUCCESS => {
|
||||
let success =
|
||||
crate::stratum_v2::OpenStandardMiningChannelSuccess::decode(&reply.payload)
|
||||
.map_err(|_| {
|
||||
ConnectError::Session(SessionError::Protocol("bad channel success"))
|
||||
})?;
|
||||
if success.request_id != 1 {
|
||||
return Err(ConnectError::Session(SessionError::Protocol(
|
||||
"channel response does not match the request",
|
||||
)));
|
||||
}
|
||||
Ok(V2Channel {
|
||||
channel_id: success.channel_id,
|
||||
target: success.target,
|
||||
extranonce_prefix: success.extranonce_prefix,
|
||||
group_channel_id: success.group_channel_id,
|
||||
})
|
||||
}
|
||||
OPEN_MINING_CHANNEL_ERROR => Err(ConnectError::Session(SessionError::Rejected(
|
||||
setup_error_text(&reply.payload),
|
||||
))),
|
||||
_ => Err(ConnectError::Session(SessionError::Protocol(
|
||||
"unexpected message while opening a channel",
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
fn setup_error_text(payload: &[u8]) -> String {
|
||||
// Error messages are a U32 flag mask followed by a STR0_255 code.
|
||||
if payload.len() < 5 {
|
||||
return String::from("unspecified");
|
||||
}
|
||||
let length = payload[4] as usize;
|
||||
payload
|
||||
.get(5..5 + length)
|
||||
.and_then(|bytes| std::str::from_utf8(bytes).ok())
|
||||
.unwrap_or("unspecified")
|
||||
.to_owned()
|
||||
}
|
||||
|
||||
/// Session state after the handshake.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct V2Session {
|
||||
channel: V2Channel,
|
||||
prev_hash: Option<[u8; 32]>,
|
||||
nbits: Option<u32>,
|
||||
sequence: u32,
|
||||
}
|
||||
|
||||
impl V2Session {
|
||||
pub fn new(channel: V2Channel) -> Self {
|
||||
Self {
|
||||
channel,
|
||||
prev_hash: None,
|
||||
nbits: None,
|
||||
sequence: 0,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn channel(&self) -> &V2Channel {
|
||||
&self.channel
|
||||
}
|
||||
|
||||
/// Interpret one server frame.
|
||||
pub fn on_frame(&mut self, frame: &Frame) -> Result<V2Event, SessionError> {
|
||||
match frame.msg_type {
|
||||
NEW_MINING_JOB => {
|
||||
let job = NewMiningJob::decode(&frame.payload)
|
||||
.map_err(|_| SessionError::Protocol("bad NewMiningJob"))?;
|
||||
Ok(V2Event::Job(V2Job {
|
||||
job_id: job.job_id,
|
||||
version: job.version,
|
||||
merkle_root: job.merkle_root,
|
||||
ntime_start: job.ntime_start,
|
||||
prev_hash: self.prev_hash,
|
||||
nbits: self.nbits,
|
||||
}))
|
||||
}
|
||||
SET_NEW_PREV_HASH => {
|
||||
let message = SetNewPrevHash::decode(&frame.payload)
|
||||
.map_err(|_| SessionError::Protocol("bad SetNewPrevHash"))?;
|
||||
self.prev_hash = Some(message.prev_hash);
|
||||
self.nbits = Some(message.nbits);
|
||||
Ok(V2Event::PrevHash {
|
||||
job_id: message.job_id,
|
||||
prev_hash: message.prev_hash,
|
||||
ntime_start: message.ntime_start,
|
||||
nbits: message.nbits,
|
||||
})
|
||||
}
|
||||
SET_TARGET => {
|
||||
if frame.payload.len() != 4 + 32 {
|
||||
return Err(SessionError::Protocol("bad SetTarget"));
|
||||
}
|
||||
let channel_id = u32::from_le_bytes([
|
||||
frame.payload[0],
|
||||
frame.payload[1],
|
||||
frame.payload[2],
|
||||
frame.payload[3],
|
||||
]);
|
||||
let mut target = [0_u8; 32];
|
||||
target.copy_from_slice(&frame.payload[4..36]);
|
||||
Ok(V2Event::Target { channel_id, target })
|
||||
}
|
||||
SUBMIT_SHARES_SUCCESS => {
|
||||
if frame.payload.len() < 20 {
|
||||
return Err(SessionError::Protocol("bad SubmitShares.Success"));
|
||||
}
|
||||
let last_sequence = u32::from_le_bytes([
|
||||
frame.payload[4],
|
||||
frame.payload[5],
|
||||
frame.payload[6],
|
||||
frame.payload[7],
|
||||
]);
|
||||
let accepted = u32::from_le_bytes([
|
||||
frame.payload[8],
|
||||
frame.payload[9],
|
||||
frame.payload[10],
|
||||
frame.payload[11],
|
||||
]);
|
||||
Ok(V2Event::ShareAccepted {
|
||||
last_sequence,
|
||||
accepted,
|
||||
})
|
||||
}
|
||||
SUBMIT_SHARES_ERROR => {
|
||||
let last_sequence = if frame.payload.len() >= 8 {
|
||||
u32::from_le_bytes([
|
||||
frame.payload[0],
|
||||
frame.payload[1],
|
||||
frame.payload[2],
|
||||
frame.payload[3],
|
||||
])
|
||||
} else {
|
||||
0
|
||||
};
|
||||
Ok(V2Event::ShareRejected { last_sequence })
|
||||
}
|
||||
_ => Ok(V2Event::Ignored),
|
||||
}
|
||||
}
|
||||
|
||||
/// Submit one standard share; returns the sequence number used.
|
||||
pub fn submit<L: V2Link>(
|
||||
&mut self,
|
||||
link: &mut L,
|
||||
job_id: u32,
|
||||
nonce: u32,
|
||||
ntime: u32,
|
||||
version: u32,
|
||||
) -> Result<u32, ConnectError<L::Error>> {
|
||||
self.sequence = self.sequence.wrapping_add(1);
|
||||
let share = SubmitSharesStandard {
|
||||
channel_id: self.channel.channel_id,
|
||||
sequence_number: self.sequence,
|
||||
job_id,
|
||||
nonce,
|
||||
ntime,
|
||||
version,
|
||||
};
|
||||
link.send(&Frame::new(SUBMIT_SHARES_STANDARD, share.encode()))
|
||||
.map_err(ConnectError::Link)?;
|
||||
Ok(self.sequence)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::collections::VecDeque;
|
||||
|
||||
struct Scripted {
|
||||
incoming: VecDeque<Frame>,
|
||||
sent: Vec<Frame>,
|
||||
}
|
||||
|
||||
impl Scripted {
|
||||
fn new(incoming: Vec<Frame>) -> Self {
|
||||
Self {
|
||||
incoming: incoming.into(),
|
||||
sent: Vec::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl V2Link for Scripted {
|
||||
type Error = ();
|
||||
|
||||
fn send(&mut self, frame: &Frame) -> Result<(), ()> {
|
||||
self.sent.push(frame.clone());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn recv(&mut self) -> Result<Frame, ()> {
|
||||
self.incoming.pop_front().ok_or(())
|
||||
}
|
||||
}
|
||||
|
||||
fn config() -> V2Config {
|
||||
V2Config {
|
||||
host: "pool.example".into(),
|
||||
port: 3333,
|
||||
flags: 0,
|
||||
user_identity: "worker".into(),
|
||||
nominal_hash_rate: 1.0e14,
|
||||
max_target: [0xff; 32],
|
||||
vendor: "alkane".into(),
|
||||
hardware: "bench".into(),
|
||||
firmware: "alkane-os".into(),
|
||||
device_id: "bench-1".into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn setup_success() -> Frame {
|
||||
Frame::new(
|
||||
SETUP_CONNECTION_SUCCESS,
|
||||
SetupConnectionSuccess {
|
||||
used_version: 2,
|
||||
flags: 0,
|
||||
}
|
||||
.encode(),
|
||||
)
|
||||
}
|
||||
|
||||
fn channel_success() -> Frame {
|
||||
Frame::new(
|
||||
OPEN_STANDARD_MINING_CHANNEL_SUCCESS,
|
||||
crate::stratum_v2::OpenStandardMiningChannelSuccess {
|
||||
request_id: 1,
|
||||
channel_id: 9,
|
||||
target: [0x7f; 32],
|
||||
extranonce_prefix: vec![1, 2],
|
||||
group_channel_id: 0,
|
||||
}
|
||||
.encode(),
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn handshake_sends_setup_then_open_and_returns_the_channel() {
|
||||
let mut link = Scripted::new(vec![setup_success(), channel_success()]);
|
||||
let channel = handshake(&mut link, &config()).expect("handshake");
|
||||
assert_eq!(channel.channel_id, 9);
|
||||
assert_eq!(channel.extranonce_prefix, vec![1, 2]);
|
||||
assert_eq!(link.sent.len(), 2);
|
||||
assert_eq!(link.sent[0].msg_type, SETUP_CONNECTION);
|
||||
assert_eq!(link.sent[1].msg_type, OPEN_STANDARD_MINING_CHANNEL);
|
||||
let open = OpenStandardMiningChannel::decode(&link.sent[1].payload).expect("open");
|
||||
assert_eq!(open.user_identity, "worker");
|
||||
assert_eq!(open.request_id, 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_setup_error_surfaces_the_server_code() {
|
||||
let mut payload = 0_u32.to_le_bytes().to_vec();
|
||||
payload.push(3);
|
||||
payload.extend_from_slice(b"bad");
|
||||
let mut link = Scripted::new(vec![Frame::new(SETUP_CONNECTION_ERROR, payload)]);
|
||||
assert_eq!(
|
||||
handshake(&mut link, &config()),
|
||||
Err(ConnectError::Session(SessionError::Rejected("bad".into())))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unexpected_message_during_setup_is_a_protocol_error() {
|
||||
let mut link = Scripted::new(vec![Frame::new(NEW_MINING_JOB, vec![0; 44])]);
|
||||
assert_eq!(
|
||||
handshake(&mut link, &config()),
|
||||
Err(ConnectError::Session(SessionError::Protocol(
|
||||
"unexpected message before setup success"
|
||||
)))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_job_before_any_prev_hash_has_no_prev_hash() {
|
||||
let mut session = V2Session::new(V2Channel {
|
||||
channel_id: 9,
|
||||
target: [0xff; 32],
|
||||
extranonce_prefix: Vec::new(),
|
||||
group_channel_id: 0,
|
||||
});
|
||||
let job = NewMiningJob {
|
||||
channel_id: 9,
|
||||
job_id: 1,
|
||||
ntime_start: Some(1_700_000_000),
|
||||
version: 0x2000_0000,
|
||||
merkle_root: [0x11; 32],
|
||||
};
|
||||
let event = session
|
||||
.on_frame(&Frame::new(NEW_MINING_JOB, job.encode()))
|
||||
.expect("job");
|
||||
match event {
|
||||
V2Event::Job(parsed) => {
|
||||
assert_eq!(parsed.job_id, 1);
|
||||
assert_eq!(parsed.prev_hash, None);
|
||||
assert_eq!(parsed.nbits, None);
|
||||
}
|
||||
other => panic!("unexpected event: {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prev_hash_is_remembered_for_later_jobs() {
|
||||
let mut session = V2Session::new(V2Channel {
|
||||
channel_id: 9,
|
||||
target: [0xff; 32],
|
||||
extranonce_prefix: Vec::new(),
|
||||
group_channel_id: 0,
|
||||
});
|
||||
let prev = SetNewPrevHash {
|
||||
channel_id: 9,
|
||||
job_id: 1,
|
||||
prev_hash: [0x22; 32],
|
||||
ntime_start: 1_700_000_100,
|
||||
nbits: 0x1707_0000,
|
||||
};
|
||||
session
|
||||
.on_frame(&Frame::new(SET_NEW_PREV_HASH, prev.encode()))
|
||||
.expect("prev hash");
|
||||
let job = NewMiningJob {
|
||||
channel_id: 9,
|
||||
job_id: 2,
|
||||
ntime_start: None,
|
||||
version: 0x2000_0000,
|
||||
merkle_root: [0x33; 32],
|
||||
};
|
||||
match session
|
||||
.on_frame(&Frame::new(NEW_MINING_JOB, job.encode()))
|
||||
.expect("job")
|
||||
{
|
||||
V2Event::Job(parsed) => {
|
||||
assert_eq!(parsed.prev_hash, Some([0x22; 32]));
|
||||
assert_eq!(parsed.nbits, Some(0x1707_0000));
|
||||
assert_eq!(parsed.ntime_start, None);
|
||||
}
|
||||
other => panic!("unexpected event: {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn submissions_use_the_channel_and_increasing_sequence_numbers() {
|
||||
let mut session = V2Session::new(V2Channel {
|
||||
channel_id: 9,
|
||||
target: [0xff; 32],
|
||||
extranonce_prefix: Vec::new(),
|
||||
group_channel_id: 0,
|
||||
});
|
||||
let mut link = Scripted::new(Vec::new());
|
||||
assert_eq!(
|
||||
session
|
||||
.submit(&mut link, 1, 0xabcd, 1_700_000_000, 0x2000_0000)
|
||||
.expect("submit"),
|
||||
1
|
||||
);
|
||||
assert_eq!(
|
||||
session
|
||||
.submit(&mut link, 1, 0xabce, 1_700_000_000, 0x2000_0000)
|
||||
.expect("submit"),
|
||||
2
|
||||
);
|
||||
assert_eq!(link.sent.len(), 2);
|
||||
let first = SubmitSharesStandard::decode(&link.sent[0].payload).expect("share");
|
||||
assert_eq!(first.channel_id, 9);
|
||||
assert_eq!(first.sequence_number, 1);
|
||||
assert_eq!(first.nonce, 0xabcd);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn share_success_reports_the_last_sequence() {
|
||||
let mut session = V2Session::new(V2Channel {
|
||||
channel_id: 9,
|
||||
target: [0xff; 32],
|
||||
extranonce_prefix: Vec::new(),
|
||||
group_channel_id: 0,
|
||||
});
|
||||
let mut payload = Vec::new();
|
||||
payload.extend_from_slice(&9_u32.to_le_bytes());
|
||||
payload.extend_from_slice(&7_u32.to_le_bytes());
|
||||
payload.extend_from_slice(&3_u32.to_le_bytes());
|
||||
payload.extend_from_slice(&0_u64.to_le_bytes());
|
||||
assert_eq!(
|
||||
session
|
||||
.on_frame(&Frame::new(SUBMIT_SHARES_SUCCESS, payload))
|
||||
.expect("event"),
|
||||
V2Event::ShareAccepted {
|
||||
last_sequence: 7,
|
||||
accepted: 3
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unknown_message_is_ignored_not_fatal() {
|
||||
let mut session = V2Session::new(V2Channel {
|
||||
channel_id: 9,
|
||||
target: [0xff; 32],
|
||||
extranonce_prefix: Vec::new(),
|
||||
group_channel_id: 0,
|
||||
});
|
||||
assert_eq!(
|
||||
session
|
||||
.on_frame(&Frame::new(0x7e, vec![0; 4]))
|
||||
.expect("event"),
|
||||
V2Event::Ignored
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,408 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Bounded newline-framed TCP transport for Bitcoin Stratum V1 pools.
|
||||
|
||||
use crate::stratum_v1::MAX_POOL_LINE_BYTES;
|
||||
use crate::stratum_v1::{
|
||||
parse_boolean_response, parse_configure_result, parse_subscription, ConfigureResult,
|
||||
PoolMessageError, Subscription,
|
||||
};
|
||||
use serde_json::json;
|
||||
use std::io::{self, Read, Write};
|
||||
use std::net::{Shutdown, SocketAddr, TcpStream};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const MAX_EARLY_NOTIFICATIONS: usize = 32;
|
||||
const MAX_EARLY_NOTIFICATION_BYTES: usize = 262_144;
|
||||
const READ_SLICE: Duration = Duration::from_millis(1);
|
||||
const MAX_PARTIAL_AGE: Duration = Duration::from_secs(2);
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum WireError {
|
||||
InvalidRequest,
|
||||
LineTooLong,
|
||||
Timeout,
|
||||
Eof,
|
||||
Closed,
|
||||
Io(io::Error),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum HandshakeError {
|
||||
Wire(WireError),
|
||||
Pool(PoolMessageError),
|
||||
Rejected,
|
||||
TooManyNotifications,
|
||||
}
|
||||
|
||||
pub struct PoolHandshake {
|
||||
pub subscription: Subscription,
|
||||
pub configure: ConfigureResult,
|
||||
/// Notifications received during negotiation, in original wire order.
|
||||
pub early_notifications: Vec<Vec<u8>>,
|
||||
}
|
||||
|
||||
pub struct StratumWire {
|
||||
stream: TcpStream,
|
||||
buffered: Vec<u8>,
|
||||
partial_started: Option<Instant>,
|
||||
timeout: Duration,
|
||||
write_timeout: Duration,
|
||||
closed: bool,
|
||||
}
|
||||
|
||||
impl StratumWire {
|
||||
pub fn connect(address: SocketAddr, timeout: Duration) -> Result<Self, WireError> {
|
||||
if timeout.is_zero() || Instant::now().checked_add(timeout).is_none() {
|
||||
return Err(WireError::InvalidRequest);
|
||||
}
|
||||
let stream = TcpStream::connect_timeout(&address, timeout).map_err(WireError::Io)?;
|
||||
stream.set_nodelay(true).map_err(WireError::Io)?;
|
||||
Ok(Self {
|
||||
stream,
|
||||
buffered: Vec::new(),
|
||||
partial_started: None,
|
||||
timeout,
|
||||
write_timeout: timeout,
|
||||
closed: false,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn from_stream(stream: TcpStream, timeout: Duration) -> Result<Self, WireError> {
|
||||
if timeout.is_zero() || Instant::now().checked_add(timeout).is_none() {
|
||||
return Err(WireError::InvalidRequest);
|
||||
}
|
||||
stream.set_nodelay(true).map_err(WireError::Io)?;
|
||||
Ok(Self {
|
||||
stream,
|
||||
buffered: Vec::new(),
|
||||
partial_started: None,
|
||||
timeout,
|
||||
write_timeout: timeout,
|
||||
closed: false,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn close(&mut self) {
|
||||
self.closed = true;
|
||||
let _ = self.stream.shutdown(Shutdown::Both);
|
||||
}
|
||||
|
||||
pub fn is_closed(&self) -> bool {
|
||||
self.closed
|
||||
}
|
||||
|
||||
pub(crate) fn cap_write_timeout(&mut self, limit: Duration) {
|
||||
self.write_timeout = self.write_timeout.min(limit);
|
||||
}
|
||||
|
||||
fn remaining(deadline: Instant) -> Result<Duration, WireError> {
|
||||
deadline
|
||||
.checked_duration_since(Instant::now())
|
||||
.filter(|remaining| !remaining.is_zero())
|
||||
.ok_or(WireError::Timeout)
|
||||
}
|
||||
|
||||
fn transport_error(error: io::Error) -> WireError {
|
||||
match error.kind() {
|
||||
io::ErrorKind::TimedOut | io::ErrorKind::WouldBlock => WireError::Timeout,
|
||||
_ => WireError::Io(error),
|
||||
}
|
||||
}
|
||||
|
||||
fn read_line_before(&mut self, deadline: Instant) -> Result<Vec<u8>, WireError> {
|
||||
if self.closed {
|
||||
return Err(WireError::Closed);
|
||||
}
|
||||
loop {
|
||||
if let Some(end) = self.buffered.iter().position(|byte| *byte == b'\n') {
|
||||
if end + 1 > MAX_POOL_LINE_BYTES {
|
||||
self.close();
|
||||
return Err(WireError::LineTooLong);
|
||||
}
|
||||
let line = self.buffered.drain(..=end).collect();
|
||||
self.partial_started = if self.buffered.is_empty() {
|
||||
None
|
||||
} else {
|
||||
self.partial_started.or_else(|| Some(Instant::now()))
|
||||
};
|
||||
return Ok(line);
|
||||
}
|
||||
if self.buffered.len() >= MAX_POOL_LINE_BYTES {
|
||||
self.close();
|
||||
return Err(WireError::LineTooLong);
|
||||
}
|
||||
let remaining = match Self::remaining(deadline) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
if !self.buffered.is_empty() {
|
||||
self.close();
|
||||
}
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
if let Err(error) = self.stream.set_read_timeout(Some(remaining)) {
|
||||
self.close();
|
||||
return Err(WireError::Io(error));
|
||||
}
|
||||
let mut chunk = [0_u8; 4096];
|
||||
match self.stream.read(&mut chunk) {
|
||||
Ok(0) => {
|
||||
self.close();
|
||||
return Err(WireError::Eof);
|
||||
}
|
||||
Ok(length) => {
|
||||
if self.buffered.is_empty() {
|
||||
self.partial_started = Some(Instant::now());
|
||||
}
|
||||
self.buffered.extend_from_slice(&chunk[..length]);
|
||||
}
|
||||
Err(error) => {
|
||||
let error = Self::transport_error(error);
|
||||
if !matches!(error, WireError::Timeout) || !self.buffered.is_empty() {
|
||||
self.close();
|
||||
}
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read_line(&mut self) -> Result<Vec<u8>, WireError> {
|
||||
self.read_line_before(Instant::now() + self.timeout)
|
||||
}
|
||||
|
||||
/// Check one socket slice without coupling ASIC polling to pool silence.
|
||||
/// An unfinished line has its own absolute deadline across calls.
|
||||
pub fn try_read_line(&mut self) -> Result<Option<Vec<u8>>, WireError> {
|
||||
if self.closed {
|
||||
return Err(WireError::Closed);
|
||||
}
|
||||
if let Some(line) = self.try_read_line_buffered()? {
|
||||
return Ok(Some(line));
|
||||
}
|
||||
if self
|
||||
.partial_started
|
||||
.is_some_and(|start| start.elapsed() >= MAX_PARTIAL_AGE)
|
||||
{
|
||||
self.close();
|
||||
return Err(WireError::Timeout);
|
||||
}
|
||||
self.stream
|
||||
.set_read_timeout(Some(READ_SLICE))
|
||||
.map_err(WireError::Io)?;
|
||||
let mut chunk = [0_u8; 4096];
|
||||
match self.stream.read(&mut chunk) {
|
||||
Ok(0) => {
|
||||
self.close();
|
||||
Err(WireError::Eof)
|
||||
}
|
||||
Ok(length) => {
|
||||
if self.buffered.is_empty() {
|
||||
self.partial_started = Some(Instant::now());
|
||||
}
|
||||
self.buffered.extend_from_slice(&chunk[..length]);
|
||||
self.try_read_line_buffered()
|
||||
}
|
||||
Err(error)
|
||||
if matches!(
|
||||
error.kind(),
|
||||
io::ErrorKind::TimedOut | io::ErrorKind::WouldBlock
|
||||
) =>
|
||||
{
|
||||
Ok(None)
|
||||
}
|
||||
Err(error) => {
|
||||
self.close();
|
||||
Err(WireError::Io(error))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn try_read_line_buffered(&mut self) -> Result<Option<Vec<u8>>, WireError> {
|
||||
if let Some(end) = self.buffered.iter().position(|byte| *byte == b'\n') {
|
||||
if end + 1 > MAX_POOL_LINE_BYTES {
|
||||
self.close();
|
||||
return Err(WireError::LineTooLong);
|
||||
}
|
||||
let line = self.buffered.drain(..=end).collect();
|
||||
self.partial_started = if self.buffered.is_empty() {
|
||||
None
|
||||
} else {
|
||||
self.partial_started.or_else(|| Some(Instant::now()))
|
||||
};
|
||||
return Ok(Some(line));
|
||||
}
|
||||
if self.buffered.len() >= MAX_POOL_LINE_BYTES {
|
||||
self.close();
|
||||
return Err(WireError::LineTooLong);
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
fn send_line_before(&mut self, line: &[u8], deadline: Instant) -> Result<(), WireError> {
|
||||
if self.closed {
|
||||
return Err(WireError::Closed);
|
||||
}
|
||||
if line.is_empty()
|
||||
|| line.len() > MAX_POOL_LINE_BYTES
|
||||
|| line.last() != Some(&b'\n')
|
||||
|| line[..line.len() - 1].contains(&b'\n')
|
||||
{
|
||||
return Err(WireError::InvalidRequest);
|
||||
}
|
||||
let mut sent = 0;
|
||||
while sent < line.len() {
|
||||
let remaining = match Self::remaining(deadline) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
self.close();
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
if let Err(error) = self.stream.set_write_timeout(Some(remaining)) {
|
||||
self.close();
|
||||
return Err(WireError::Io(error));
|
||||
}
|
||||
match self.stream.write(&line[sent..]) {
|
||||
Ok(0) => {
|
||||
self.close();
|
||||
return Err(WireError::Eof);
|
||||
}
|
||||
Ok(length) => sent += length,
|
||||
Err(error) => {
|
||||
self.close();
|
||||
return Err(Self::transport_error(error));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn send_line(&mut self, line: &[u8]) -> Result<(), WireError> {
|
||||
self.send_line_before(line, Instant::now() + self.write_timeout)
|
||||
}
|
||||
|
||||
fn read_reply(
|
||||
&mut self,
|
||||
request_id: u64,
|
||||
deadline: Instant,
|
||||
early: &mut Vec<Vec<u8>>,
|
||||
early_bytes: &mut usize,
|
||||
) -> Result<Vec<u8>, HandshakeError> {
|
||||
loop {
|
||||
let line = self
|
||||
.read_line_before(deadline)
|
||||
.map_err(HandshakeError::Wire)?;
|
||||
let message: serde_json::Value = serde_json::from_slice(&line)
|
||||
.map_err(|_| HandshakeError::Pool(PoolMessageError::Json))?;
|
||||
if message.get("id").and_then(serde_json::Value::as_u64) == Some(request_id) {
|
||||
return Ok(line);
|
||||
}
|
||||
if !message.get("id").is_none_or(serde_json::Value::is_null)
|
||||
|| !matches!(
|
||||
message.get("method").and_then(serde_json::Value::as_str),
|
||||
Some(
|
||||
"mining.set_difficulty"
|
||||
| "mining.set_version_mask"
|
||||
| "mining.set_extranonce"
|
||||
| "mining.notify"
|
||||
)
|
||||
)
|
||||
{
|
||||
return Err(HandshakeError::Pool(PoolMessageError::WrongMessage));
|
||||
}
|
||||
*early_bytes += line.len();
|
||||
if early.len() >= MAX_EARLY_NOTIFICATIONS || *early_bytes > MAX_EARLY_NOTIFICATION_BYTES
|
||||
{
|
||||
return Err(HandshakeError::TooManyNotifications);
|
||||
}
|
||||
early.push(line);
|
||||
}
|
||||
}
|
||||
|
||||
/// Negotiate BIP310, subscribe, and authorize in that order. The entire
|
||||
/// handshake shares one absolute deadline; early notifications are kept
|
||||
/// for the caller to apply before reading new pool lines.
|
||||
pub fn handshake(
|
||||
&mut self,
|
||||
agent: &str,
|
||||
worker: &str,
|
||||
password: &str,
|
||||
timeout: Duration,
|
||||
) -> Result<PoolHandshake, HandshakeError> {
|
||||
let result = self.handshake_inner(agent, worker, password, timeout);
|
||||
if result.is_err() {
|
||||
self.close();
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn handshake_inner(
|
||||
&mut self,
|
||||
agent: &str,
|
||||
worker: &str,
|
||||
password: &str,
|
||||
timeout: Duration,
|
||||
) -> Result<PoolHandshake, HandshakeError> {
|
||||
let deadline = Instant::now()
|
||||
.checked_add(timeout)
|
||||
.filter(|_| !timeout.is_zero())
|
||||
.ok_or(HandshakeError::Wire(WireError::InvalidRequest))?;
|
||||
let subscribe = subscribe_request(2, agent).map_err(HandshakeError::Wire)?;
|
||||
let authorize = authorize_request(3, worker, password).map_err(HandshakeError::Wire)?;
|
||||
let mut early_notifications = Vec::new();
|
||||
let mut early_bytes = 0;
|
||||
self.send_line_before(configure_request(1).as_bytes(), deadline)
|
||||
.map_err(HandshakeError::Wire)?;
|
||||
let configure = self.read_reply(1, deadline, &mut early_notifications, &mut early_bytes)?;
|
||||
let configure = parse_configure_result(&configure, 1).map_err(HandshakeError::Pool)?;
|
||||
self.send_line_before(subscribe.as_bytes(), deadline)
|
||||
.map_err(HandshakeError::Wire)?;
|
||||
let subscription =
|
||||
self.read_reply(2, deadline, &mut early_notifications, &mut early_bytes)?;
|
||||
let subscription = parse_subscription(&subscription, 2).map_err(HandshakeError::Pool)?;
|
||||
self.send_line_before(authorize.as_bytes(), deadline)
|
||||
.map_err(HandshakeError::Wire)?;
|
||||
let authorized =
|
||||
self.read_reply(3, deadline, &mut early_notifications, &mut early_bytes)?;
|
||||
if !parse_boolean_response(&authorized, 3).map_err(HandshakeError::Pool)? {
|
||||
return Err(HandshakeError::Rejected);
|
||||
}
|
||||
Ok(PoolHandshake {
|
||||
subscription,
|
||||
configure,
|
||||
early_notifications,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Offer BIP310 version rolling and extranonce updates before subscribing.
|
||||
pub fn configure_request(id: u64) -> String {
|
||||
json!({
|
||||
"id": id,
|
||||
"method": "mining.configure",
|
||||
"params": [
|
||||
["version-rolling", "subscribe-extranonce"],
|
||||
{"version-rolling.mask": "1fffe000", "version-rolling.min-bit-count": 0}
|
||||
]
|
||||
})
|
||||
.to_string()
|
||||
+ "\n"
|
||||
}
|
||||
|
||||
pub fn subscribe_request(id: u64, agent: &str) -> Result<String, WireError> {
|
||||
if agent.is_empty() || agent.len() > 128 {
|
||||
return Err(WireError::InvalidRequest);
|
||||
}
|
||||
Ok(json!({"id": id, "method": "mining.subscribe", "params": [agent]}).to_string() + "\n")
|
||||
}
|
||||
|
||||
pub fn authorize_request(id: u64, worker: &str, password: &str) -> Result<String, WireError> {
|
||||
if worker.is_empty() || worker.len() > 128 || password.len() > 256 {
|
||||
return Err(WireError::InvalidRequest);
|
||||
}
|
||||
Ok(
|
||||
json!({"id": id, "method": "mining.authorize", "params": [worker, password]}).to_string()
|
||||
+ "\n",
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Construct SHA-256 Stratum V1 work after a protocol client decodes notify.
|
||||
//! This module assembles headers; it never searches for nonces.
|
||||
|
||||
use crate::pow::sha256d;
|
||||
|
||||
const MAX_COINBASE_BYTES: usize = 65_536;
|
||||
const MAX_MERKLE_BRANCHES: usize = 64;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum JobError {
|
||||
InvalidExtranonceSize,
|
||||
CoinbaseTooLarge,
|
||||
TooManyMerkleBranches,
|
||||
ExtranonceLength,
|
||||
}
|
||||
|
||||
/// Binary fields from `mining.notify`, plus `mining.subscribe` extranonce data.
|
||||
/// `prevhash_stratum` is the eight word-swapped 32-bit words sent on the wire.
|
||||
pub struct Sha256Job {
|
||||
pub prevhash_stratum: [u8; 32],
|
||||
pub coinb1: Vec<u8>,
|
||||
pub coinb2: Vec<u8>,
|
||||
pub merkle_branches: Vec<[u8; 32]>,
|
||||
pub version: u32,
|
||||
pub nbits: u32,
|
||||
pub ntime: u32,
|
||||
pub extranonce1: Vec<u8>,
|
||||
pub extranonce2_size: usize,
|
||||
}
|
||||
|
||||
impl Sha256Job {
|
||||
pub fn validate(&self) -> Result<(), JobError> {
|
||||
if self.extranonce1.len() > 32 || self.extranonce2_size > 32 {
|
||||
return Err(JobError::InvalidExtranonceSize);
|
||||
}
|
||||
let total = self
|
||||
.coinb1
|
||||
.len()
|
||||
.checked_add(self.extranonce1.len())
|
||||
.and_then(|sum| sum.checked_add(self.extranonce2_size))
|
||||
.and_then(|sum| sum.checked_add(self.coinb2.len()));
|
||||
if total.is_none_or(|sum| sum > MAX_COINBASE_BYTES) {
|
||||
return Err(JobError::CoinbaseTooLarge);
|
||||
}
|
||||
if self.merkle_branches.len() > MAX_MERKLE_BRANCHES {
|
||||
return Err(JobError::TooManyMerkleBranches);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn nonce_zero_header(&self, extranonce2: &[u8], ntime: u32) -> Result<[u8; 80], JobError> {
|
||||
self.validate()?;
|
||||
if extranonce2.len() != self.extranonce2_size {
|
||||
return Err(JobError::ExtranonceLength);
|
||||
}
|
||||
let mut coinbase = Vec::with_capacity(
|
||||
self.coinb1.len() + self.extranonce1.len() + extranonce2.len() + self.coinb2.len(),
|
||||
);
|
||||
coinbase.extend_from_slice(&self.coinb1);
|
||||
coinbase.extend_from_slice(&self.extranonce1);
|
||||
coinbase.extend_from_slice(extranonce2);
|
||||
coinbase.extend_from_slice(&self.coinb2);
|
||||
let mut root = sha256d(&coinbase);
|
||||
for branch in &self.merkle_branches {
|
||||
let mut pair = [0_u8; 64];
|
||||
pair[..32].copy_from_slice(&root);
|
||||
pair[32..].copy_from_slice(branch);
|
||||
root = sha256d(&pair);
|
||||
}
|
||||
let mut header = [0_u8; 80];
|
||||
header[..4].copy_from_slice(&self.version.to_le_bytes());
|
||||
for (index, word) in self.prevhash_stratum.chunks_exact(4).enumerate() {
|
||||
for (offset, byte) in word.iter().rev().enumerate() {
|
||||
header[4 + index * 4 + offset] = *byte;
|
||||
}
|
||||
}
|
||||
header[36..68].copy_from_slice(&root);
|
||||
header[68..72].copy_from_slice(&ntime.to_le_bytes());
|
||||
header[72..76].copy_from_slice(&self.nbits.to_le_bytes());
|
||||
Ok(header)
|
||||
}
|
||||
}
|
||||
+506
@@ -0,0 +1,506 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Adaptive tuning.
|
||||
//!
|
||||
//! The miner targets a power draw, a hashrate, or an operating point chosen for the ambient
|
||||
//! temperature. Rather than picking a preset, a bounded PID moves the chain frequency inside the
|
||||
//! profile envelope each control period, and a thermal guard can always override it downward.
|
||||
//!
|
||||
//! The controller is deliberately conservative: bounded output, rate limit, deadband, derivative
|
||||
//! on the measurement (no setpoint kick) and conditional integration (no windup while saturated).
|
||||
|
||||
use crate::detect::Envelope;
|
||||
|
||||
/// What the operator asked for.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TuningTarget {
|
||||
/// Hold this DC power draw; efficiency follows from the power point.
|
||||
PowerW(f32),
|
||||
/// Maximise hashrate up to this value.
|
||||
HashrateThs(f32),
|
||||
/// Hold the hottest sensor this far above the measured ambient: efficiency at that ambient.
|
||||
AmbientC { margin_mc: i32 },
|
||||
/// Pin the fan at this duty and maximise hashrate under it.
|
||||
MaxFan { max_pwm: u8 },
|
||||
}
|
||||
|
||||
/// Controller tuning.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct PidConfig {
|
||||
pub kp: f32,
|
||||
pub ki: f32,
|
||||
pub kd: f32,
|
||||
pub out_min: f32,
|
||||
pub out_max: f32,
|
||||
/// Maximum output change per second.
|
||||
pub max_step_per_s: f32,
|
||||
/// Errors inside this band are ignored.
|
||||
pub deadband: f32,
|
||||
}
|
||||
|
||||
impl Default for PidConfig {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
kp: 0.5,
|
||||
ki: 0.1,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 1_000.0,
|
||||
max_step_per_s: 50.0,
|
||||
deadband: 1.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A bounded PID with anti-windup and rate limiting.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Pid {
|
||||
config: PidConfig,
|
||||
integral: f32,
|
||||
last_measurement: Option<f32>,
|
||||
output: f32,
|
||||
}
|
||||
|
||||
impl Pid {
|
||||
pub fn new(config: PidConfig, initial_output: f32) -> Self {
|
||||
Self {
|
||||
config,
|
||||
integral: 0.0,
|
||||
last_measurement: None,
|
||||
output: initial_output.clamp(config.out_min, config.out_max),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn output(&self) -> f32 {
|
||||
self.output
|
||||
}
|
||||
|
||||
/// Force the output (used by ramp modes and the thermal guard).
|
||||
pub fn set_output(&mut self, value: f32) {
|
||||
self.output = value.clamp(self.config.out_min, self.config.out_max);
|
||||
}
|
||||
|
||||
/// Advance one control period and return the new output.
|
||||
pub fn update(&mut self, setpoint: f32, measurement: f32, dt_s: f32) -> f32 {
|
||||
if !dt_s.is_finite() || dt_s <= 0.0 {
|
||||
return self.output;
|
||||
}
|
||||
let error = setpoint - measurement;
|
||||
if error.abs() <= self.config.deadband {
|
||||
self.last_measurement = Some(measurement);
|
||||
return self.output;
|
||||
}
|
||||
let derivative = match self.last_measurement {
|
||||
Some(previous) => -(measurement - previous) / dt_s,
|
||||
None => 0.0,
|
||||
};
|
||||
let candidate = self.config.kp * error + self.integral + self.config.kd * derivative;
|
||||
let saturated = candidate > self.config.out_max || candidate < self.config.out_min;
|
||||
// Conditional integration: never accumulate while the actuator is pinned in the direction
|
||||
// of the error, or the loop unwinds slowly after a saturation episode.
|
||||
let pinning = (candidate > self.config.out_max && error > 0.0)
|
||||
|| (candidate < self.config.out_min && error < 0.0);
|
||||
if !saturated || !pinning {
|
||||
self.integral += self.config.ki * error * dt_s;
|
||||
}
|
||||
let mut desired = self.config.kp * error + self.integral + self.config.kd * derivative;
|
||||
desired = desired.clamp(self.config.out_min, self.config.out_max);
|
||||
let max_step = self.config.max_step_per_s * dt_s;
|
||||
let step = (desired - self.output).clamp(-max_step, max_step);
|
||||
self.output = (self.output + step).clamp(self.config.out_min, self.config.out_max);
|
||||
self.last_measurement = Some(measurement);
|
||||
self.output
|
||||
}
|
||||
}
|
||||
|
||||
/// What the loop needs to know each period.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct Observation {
|
||||
pub power_w: Option<f32>,
|
||||
pub hashrate_ths: Option<f32>,
|
||||
/// Hottest sensor in millidegrees, when telemetry is available.
|
||||
pub hottest_mc: Option<i32>,
|
||||
/// Intake/enclosure temperature in millidegrees, for the ambient target.
|
||||
pub ambient_mc: Option<i32>,
|
||||
}
|
||||
|
||||
/// What the loop wants applied this period.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct Command {
|
||||
pub frequency_mhz: u16,
|
||||
/// `Some` only when the target owns the fan (max-fan mode).
|
||||
pub fan_pwm: Option<u8>,
|
||||
}
|
||||
|
||||
/// Why the loop could not produce a command.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum TuningError {
|
||||
/// The measurement the target needs is missing this period.
|
||||
NoMeasurement,
|
||||
}
|
||||
|
||||
/// The tuning loop: one PID over chain frequency, bounded by the profile envelope.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct TuningLoop {
|
||||
pid: Pid,
|
||||
envelope: Envelope,
|
||||
target: TuningTarget,
|
||||
ceiling_mc: i32,
|
||||
}
|
||||
|
||||
impl TuningLoop {
|
||||
/// Start from the conservative floor of the envelope.
|
||||
pub fn new(target: TuningTarget, envelope: Envelope, pid: PidConfig, ceiling_mc: i32) -> Self {
|
||||
let config = PidConfig {
|
||||
out_min: f32::from(envelope.f_min_mhz),
|
||||
out_max: f32::from(envelope.f_max_mhz),
|
||||
..pid
|
||||
};
|
||||
let start = f32::from(envelope.f_min_mhz);
|
||||
Self {
|
||||
pid: Pid::new(config, start),
|
||||
envelope,
|
||||
target,
|
||||
ceiling_mc,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn frequency_mhz(&self) -> u16 {
|
||||
self.pid.output().round() as u16
|
||||
}
|
||||
|
||||
/// Fan duty implied by the target, if the target owns the fan.
|
||||
fn target_fan(&self) -> Option<u8> {
|
||||
match self.target {
|
||||
TuningTarget::MaxFan { max_pwm } => Some(max_pwm),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn command(&self) -> Command {
|
||||
Command {
|
||||
frequency_mhz: self.frequency_mhz(),
|
||||
fan_pwm: self.target_fan(),
|
||||
}
|
||||
}
|
||||
|
||||
/// One control period. Returns the command to apply, inside the envelope.
|
||||
pub fn step(&mut self, observation: Observation, dt_s: f32) -> Result<Command, TuningError> {
|
||||
// Thermal guard: a hot sensor always derates, whatever the target says.
|
||||
if let Some(hottest) = observation.hottest_mc {
|
||||
if hottest >= self.ceiling_mc {
|
||||
let derated = (self.pid.output() - 25.0).max(f32::from(self.envelope.f_min_mhz));
|
||||
self.pid = Pid::new(
|
||||
PidConfig {
|
||||
out_min: f32::from(self.envelope.f_min_mhz),
|
||||
out_max: f32::from(self.envelope.f_max_mhz),
|
||||
..self.pid.config
|
||||
},
|
||||
derated,
|
||||
);
|
||||
return Ok(self.command());
|
||||
}
|
||||
}
|
||||
match self.target {
|
||||
TuningTarget::PowerW(setpoint) => {
|
||||
let measurement = observation.power_w.ok_or(TuningError::NoMeasurement)?;
|
||||
self.pid.update(setpoint, measurement, dt_s);
|
||||
}
|
||||
TuningTarget::HashrateThs(setpoint) => {
|
||||
let measurement = observation.hashrate_ths.ok_or(TuningError::NoMeasurement)?;
|
||||
self.pid.update(setpoint, measurement, dt_s);
|
||||
}
|
||||
TuningTarget::AmbientC { margin_mc } => {
|
||||
let ambient = observation.ambient_mc.ok_or(TuningError::NoMeasurement)?;
|
||||
let hottest = observation.hottest_mc.ok_or(TuningError::NoMeasurement)?;
|
||||
let setpoint = ambient as f32 + margin_mc as f32;
|
||||
self.pid.update(setpoint, hottest as f32, dt_s);
|
||||
}
|
||||
TuningTarget::MaxFan { .. } => {
|
||||
// No setpoint loop here: ramp toward the envelope ceiling and let the thermal
|
||||
// guard be the only thing that stops it.
|
||||
let step = self.pid.config.max_step_per_s * dt_s;
|
||||
let next = (self.pid.output() + step).min(f32::from(self.envelope.f_max_mhz));
|
||||
self.pid.set_output(next);
|
||||
}
|
||||
}
|
||||
Ok(self.command())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn envelope() -> Envelope {
|
||||
Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
}
|
||||
}
|
||||
|
||||
fn observation(hottest: i32) -> Observation {
|
||||
Observation {
|
||||
power_w: None,
|
||||
hashrate_ths: None,
|
||||
hottest_mc: Some(hottest),
|
||||
ambient_mc: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pid_drives_the_plant_to_the_setpoint() {
|
||||
let mut pid = Pid::new(
|
||||
PidConfig {
|
||||
kp: 0.02,
|
||||
ki: 0.01,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 700.0,
|
||||
max_step_per_s: 1_000.0,
|
||||
deadband: 0.0,
|
||||
},
|
||||
0.0,
|
||||
);
|
||||
// Plant: 5 W per MHz, so 3 kW needs 600 MHz, inside the controller ceiling.
|
||||
let mut power = 0.0_f32;
|
||||
for _ in 0..400 {
|
||||
let freq = pid.update(3_000.0, power, 1.0);
|
||||
power = 5.0 * freq;
|
||||
}
|
||||
assert!((power - 3_000.0).abs() < 50.0, "power settled at {power}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn output_is_rate_limited() {
|
||||
let mut pid = Pid::new(
|
||||
PidConfig {
|
||||
kp: 1.0,
|
||||
ki: 0.0,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 1_000.0,
|
||||
max_step_per_s: 10.0,
|
||||
deadband: 0.0,
|
||||
},
|
||||
0.0,
|
||||
);
|
||||
assert!((pid.update(1_000.0, 0.0, 1.0) - 10.0).abs() < f32::EPSILON);
|
||||
assert!((pid.update(1_000.0, 0.0, 1.0) - 20.0).abs() < f32::EPSILON);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deadband_holds_the_output() {
|
||||
let mut pid = Pid::new(
|
||||
PidConfig {
|
||||
kp: 1.0,
|
||||
ki: 0.1,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 1_000.0,
|
||||
max_step_per_s: 100.0,
|
||||
deadband: 5.0,
|
||||
},
|
||||
100.0,
|
||||
);
|
||||
let before = pid.output();
|
||||
assert!((pid.update(102.0, 100.0, 1.0) - before).abs() < f32::EPSILON);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn saturation_does_not_wind_up_the_integral() {
|
||||
let mut pid = Pid::new(
|
||||
PidConfig {
|
||||
kp: 1.0,
|
||||
ki: 1.0,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 100.0,
|
||||
max_step_per_s: 1_000.0,
|
||||
deadband: 0.0,
|
||||
},
|
||||
0.0,
|
||||
);
|
||||
for _ in 0..100 {
|
||||
pid.update(1_000.0, 0.0, 1.0);
|
||||
}
|
||||
assert!((pid.output() - 100.0).abs() < 0.01);
|
||||
for _ in 0..5 {
|
||||
pid.update(0.0, 200.0, 1.0);
|
||||
}
|
||||
assert!(
|
||||
pid.output() < 99.0,
|
||||
"output stuck at the rail: {}",
|
||||
pid.output()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn power_target_moves_frequency_inside_the_envelope() {
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::PowerW(2_400.0),
|
||||
envelope(),
|
||||
PidConfig {
|
||||
kp: 0.2,
|
||||
ki: 0.05,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 0.0,
|
||||
max_step_per_s: 50.0,
|
||||
deadband: 0.0,
|
||||
},
|
||||
95_000,
|
||||
);
|
||||
let mut freq = loop_.frequency_mhz();
|
||||
for _ in 0..100 {
|
||||
let power = 4.0 * f32::from(freq);
|
||||
let mut obs = observation(70_000);
|
||||
obs.power_w = Some(power);
|
||||
freq = loop_.step(obs, 1.0).expect("step").frequency_mhz;
|
||||
assert!((300..=700).contains(&freq), "out of envelope: {freq}");
|
||||
}
|
||||
let power = 4.0 * f32::from(freq);
|
||||
assert!((power - 2_400.0).abs() < 200.0, "power settled at {power}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn thermal_guard_derates_regardless_of_target() {
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::HashrateThs(200.0),
|
||||
envelope(),
|
||||
PidConfig::default(),
|
||||
90_000,
|
||||
);
|
||||
for _ in 0..50 {
|
||||
let mut obs = observation(60_000);
|
||||
obs.hashrate_ths = Some(10.0);
|
||||
loop_.step(obs, 1.0).expect("step");
|
||||
}
|
||||
let hot = loop_.frequency_mhz();
|
||||
let mut obs = observation(91_000);
|
||||
obs.hashrate_ths = Some(10.0);
|
||||
let derated = loop_.step(obs, 1.0).expect("step").frequency_mhz;
|
||||
assert!(
|
||||
derated < hot,
|
||||
"thermal guard did not derate: {derated} vs {hot}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_measurement_is_an_error() {
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::PowerW(3_000.0),
|
||||
envelope(),
|
||||
PidConfig::default(),
|
||||
95_000,
|
||||
);
|
||||
let mut obs = observation(50_000);
|
||||
obs.hashrate_ths = Some(1.0);
|
||||
assert_eq!(loop_.step(obs, 1.0), Err(TuningError::NoMeasurement));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_dt_holds_the_output() {
|
||||
let mut pid = Pid::new(PidConfig::default(), 42.0);
|
||||
assert!((pid.update(100.0, 0.0, 0.0) - 42.0).abs() < f32::EPSILON);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ambient_target_holds_the_hottest_sensor_near_ambient_plus_margin() {
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::AmbientC { margin_mc: 20_000 },
|
||||
envelope(),
|
||||
PidConfig {
|
||||
kp: 0.5,
|
||||
ki: 0.05,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 0.0,
|
||||
max_step_per_s: 50.0,
|
||||
deadband: 0.0,
|
||||
},
|
||||
200_000,
|
||||
);
|
||||
// Plant: hottest = ambient + 50 mC per MHz.
|
||||
let ambient = 40_000;
|
||||
let mut freq = loop_.frequency_mhz();
|
||||
for _ in 0..300 {
|
||||
let hottest = ambient + 50 * i32::from(freq);
|
||||
let obs = Observation {
|
||||
power_w: None,
|
||||
hashrate_ths: None,
|
||||
hottest_mc: Some(hottest),
|
||||
ambient_mc: Some(ambient),
|
||||
};
|
||||
freq = loop_.step(obs, 1.0).expect("step").frequency_mhz;
|
||||
}
|
||||
let hottest = ambient + 50 * i32::from(freq);
|
||||
assert!(
|
||||
(hottest - (ambient + 20_000)).abs() < 2_000,
|
||||
"hottest settled at {hottest}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ambient_target_needs_an_ambient_sensor() {
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::AmbientC { margin_mc: 20_000 },
|
||||
envelope(),
|
||||
PidConfig::default(),
|
||||
95_000,
|
||||
);
|
||||
assert_eq!(
|
||||
loop_.step(observation(50_000), 1.0),
|
||||
Err(TuningError::NoMeasurement)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn max_fan_mode_pins_the_fan_and_ramps_frequency() {
|
||||
let ramp = PidConfig {
|
||||
kp: 1.0,
|
||||
ki: 0.0,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 0.0,
|
||||
max_step_per_s: 50.0,
|
||||
deadband: 0.0,
|
||||
};
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::MaxFan { max_pwm: 100 },
|
||||
envelope(),
|
||||
ramp,
|
||||
120_000,
|
||||
);
|
||||
let start = loop_.frequency_mhz();
|
||||
let mut last = start;
|
||||
for _ in 0..20 {
|
||||
let command = loop_.step(observation(70_000), 1.0).expect("step");
|
||||
assert_eq!(command.fan_pwm, Some(100));
|
||||
last = command.frequency_mhz;
|
||||
}
|
||||
assert!(last > start, "frequency did not ramp: {last} vs {start}");
|
||||
assert!(
|
||||
last == 700,
|
||||
"ramp did not reach the envelope ceiling: {last}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn max_fan_mode_still_respects_the_temperature_ceiling() {
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::MaxFan { max_pwm: 100 },
|
||||
envelope(),
|
||||
PidConfig::default(),
|
||||
80_000,
|
||||
);
|
||||
for _ in 0..50 {
|
||||
loop_.step(observation(70_000), 1.0).expect("step");
|
||||
}
|
||||
let hot = loop_.frequency_mhz();
|
||||
let command = loop_.step(observation(85_000), 1.0).expect("step");
|
||||
assert!(command.frequency_mhz < hot);
|
||||
assert_eq!(command.fan_pwm, Some(100));
|
||||
}
|
||||
}
|
||||
+248
@@ -0,0 +1,248 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! On-box web UI.
|
||||
//!
|
||||
//! A small HTTP surface served by the miner itself: a single page that polls the JSON API, plus
|
||||
//! the API routes it uses. The API stays the interface of record; the page is a convenience, so a
|
||||
//! client that only speaks JSON loses nothing.
|
||||
//!
|
||||
//! No framework and no dependency: the request parser is bounded, only `GET` is accepted, and every
|
||||
//! response closes the connection.
|
||||
|
||||
use crate::management::MiningStatus;
|
||||
use std::io::{self, Read, Write};
|
||||
use std::net::{SocketAddr, TcpListener, TcpStream};
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
const MAX_REQUEST_BYTES: usize = 2048;
|
||||
const CLIENT_TIMEOUT: Duration = Duration::from_millis(500);
|
||||
|
||||
const PAGE: &str = r#"<!doctype html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<title>Alkane miner</title>
|
||||
<style>
|
||||
body{font:14px/1.4 system-ui,sans-serif;margin:2rem;color:#1b1b1b}
|
||||
h1{font-size:1.2rem;margin:0 0 1rem}
|
||||
table{border-collapse:collapse;min-width:28rem}
|
||||
th,td{text-align:left;padding:.35rem .6rem;border-bottom:1px solid #ddd}
|
||||
th{width:11rem;color:#555;font-weight:600}
|
||||
.bad{color:#a11}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<h1>Alkane miner</h1>
|
||||
<table id="t"><tbody><tr><td>loading</td><td></td></tr></tbody></table>
|
||||
<script>
|
||||
async function refresh(){
|
||||
const t=document.getElementById('t').tBodies[0];
|
||||
try{
|
||||
const h=await (await fetch('/api/hardware')).json();
|
||||
const d=h.HARDWARE[0];
|
||||
if(!d.available){t.innerHTML='<tr><td>hardware</td><td class="bad">not detected yet</td></tr>';return}
|
||||
const rows=[
|
||||
['profile',d.profile],['chip',d.chip],['PSU',d.psu],
|
||||
['frequency',d.frequency_mhz+' MHz'],
|
||||
['voltage',d.operating_point.voltage_mv+' mV'],
|
||||
['confirmed',d.operating_point.confirmed?'yes':'no (conservative)'],
|
||||
['chains',d.chains.length],['active chains',d.active_chains.length],
|
||||
['target',d.target],
|
||||
['stopped',d.stopped||'no']
|
||||
];
|
||||
t.innerHTML=rows.map(r=>'<tr><th>'+r[0]+'</th><td>'+r[1]+'</td></tr>').join('')
|
||||
+d.chains.map(c=>'<tr><th>chain '+c.index+'</th><td>'+c.chip+', '+c.chips_found+
|
||||
' chips, EEPROM '+c.eeprom.state+'</td></tr>').join('');
|
||||
}catch(e){t.innerHTML='<tr><td>error</td><td class="bad">'+e+'</td></tr>'}
|
||||
}
|
||||
refresh();setInterval(refresh,5000);
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
"#;
|
||||
|
||||
/// Bind and serve until the listener fails.
|
||||
pub fn serve(bind: SocketAddr, status: Arc<MiningStatus>) -> io::Result<()> {
|
||||
let listener = TcpListener::bind(bind)?;
|
||||
serve_listener(listener, status)
|
||||
}
|
||||
|
||||
/// Serve on an already-bound listener.
|
||||
pub fn serve_listener(listener: TcpListener, status: Arc<MiningStatus>) -> io::Result<()> {
|
||||
for stream in listener.incoming() {
|
||||
let Ok(stream) = stream else { continue };
|
||||
let status = Arc::clone(&status);
|
||||
// Each connection is short, bounded and closes itself.
|
||||
std::thread::spawn(move || {
|
||||
let _ = handle(stream, &status);
|
||||
});
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Handle one HTTP request.
|
||||
pub fn handle(mut stream: TcpStream, status: &MiningStatus) -> io::Result<()> {
|
||||
stream.set_read_timeout(Some(CLIENT_TIMEOUT))?;
|
||||
stream.set_write_timeout(Some(CLIENT_TIMEOUT))?;
|
||||
let mut request = Vec::new();
|
||||
let mut chunk = [0_u8; 512];
|
||||
loop {
|
||||
let count = stream.read(&mut chunk)?;
|
||||
if count == 0 {
|
||||
break;
|
||||
}
|
||||
request.extend_from_slice(&chunk[..count]);
|
||||
if request.len() > MAX_REQUEST_BYTES {
|
||||
return respond(&mut stream, 431, "text/plain", b"request too large");
|
||||
}
|
||||
if request.windows(4).any(|window| window == b"\r\n\r\n") {
|
||||
break;
|
||||
}
|
||||
}
|
||||
let head = String::from_utf8_lossy(&request);
|
||||
let mut parts = head.lines().next().unwrap_or("").split_whitespace();
|
||||
let method = parts.next().unwrap_or("");
|
||||
let path = parts.next().unwrap_or("");
|
||||
if method != "GET" {
|
||||
return respond(&mut stream, 405, "text/plain", b"method not allowed");
|
||||
}
|
||||
match path {
|
||||
"/" | "/index.html" => respond(
|
||||
&mut stream,
|
||||
200,
|
||||
"text/html; charset=utf-8",
|
||||
PAGE.as_bytes(),
|
||||
),
|
||||
"/api/hardware" => {
|
||||
let body = status.hardware_document().to_string();
|
||||
respond(&mut stream, 200, "application/json", body.as_bytes())
|
||||
}
|
||||
"/api/summary" => {
|
||||
let body = status.summary_document().to_string();
|
||||
respond(&mut stream, 200, "application/json", body.as_bytes())
|
||||
}
|
||||
_ => respond(&mut stream, 404, "text/plain", b"not found"),
|
||||
}
|
||||
}
|
||||
|
||||
fn respond(stream: &mut TcpStream, code: u16, content_type: &str, body: &[u8]) -> io::Result<()> {
|
||||
let reason = match code {
|
||||
200 => "OK",
|
||||
404 => "Not Found",
|
||||
405 => "Method Not Allowed",
|
||||
431 => "Request Header Fields Too Large",
|
||||
_ => "Error",
|
||||
};
|
||||
let header = format!(
|
||||
"HTTP/1.1 {code} {reason}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\nCache-Control: no-store\r\n\r\n",
|
||||
body.len()
|
||||
);
|
||||
stream.write_all(header.as_bytes())?;
|
||||
stream.write_all(body)?;
|
||||
stream.flush()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::detect::{
|
||||
ChainReport, ChipModel, EepromState, Envelope, HardwarePlan, OperatingPoint,
|
||||
};
|
||||
use crate::management::HardwareSnapshot;
|
||||
use std::net::TcpStream as Client;
|
||||
|
||||
fn status() -> Arc<MiningStatus> {
|
||||
let status = MiningStatus::new();
|
||||
status.set_hardware(HardwareSnapshot {
|
||||
plan: HardwarePlan {
|
||||
profile: "s19jpro-bm1362-pic".into(),
|
||||
chip: ChipModel::Bm1362,
|
||||
chains: vec![ChainReport {
|
||||
index: 0,
|
||||
chip: ChipModel::Bm1362,
|
||||
chips_found: 126,
|
||||
eeprom: EepromState::Absent,
|
||||
response_per_mille: Some(950),
|
||||
}],
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
},
|
||||
operating_point: OperatingPoint {
|
||||
voltage_mv: 1200,
|
||||
frequency_mhz: 500,
|
||||
confirmed: false,
|
||||
},
|
||||
psu: "APW12".into(),
|
||||
fan_zones: Vec::new(),
|
||||
},
|
||||
active_chains: vec![0],
|
||||
stopped: None,
|
||||
frequency_mhz: 512,
|
||||
target: "power:3000".into(),
|
||||
});
|
||||
Arc::new(status)
|
||||
}
|
||||
|
||||
fn request(path: &str) -> String {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
|
||||
let address = listener.local_addr().expect("addr");
|
||||
let status = status();
|
||||
let worker = std::thread::spawn(move || {
|
||||
let (stream, _) = listener.accept().expect("accept");
|
||||
handle(stream, &status).expect("handle");
|
||||
});
|
||||
let mut client = Client::connect(address).expect("connect");
|
||||
client
|
||||
.write_all(format!("GET {path} HTTP/1.1\r\nHost: miner\r\n\r\n").as_bytes())
|
||||
.expect("write");
|
||||
let mut reply = String::new();
|
||||
client.read_to_string(&mut reply).expect("read");
|
||||
worker.join().expect("join");
|
||||
reply
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_page_is_served_at_root() {
|
||||
let reply = request("/");
|
||||
assert!(reply.starts_with("HTTP/1.1 200 OK"));
|
||||
assert!(reply.contains("text/html"));
|
||||
assert!(reply.contains("Alkane miner"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_api_returns_the_hardware_document() {
|
||||
let reply = request("/api/hardware");
|
||||
assert!(reply.starts_with("HTTP/1.1 200 OK"));
|
||||
assert!(reply.contains("application/json"));
|
||||
assert!(reply.contains("s19jpro-bm1362-pic"));
|
||||
assert!(reply.contains("bm1362"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_paths_are_404() {
|
||||
let reply = request("/nope");
|
||||
assert!(reply.starts_with("HTTP/1.1 404 Not Found"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_get_is_accepted() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
|
||||
let address = listener.local_addr().expect("addr");
|
||||
let status = status();
|
||||
let worker = std::thread::spawn(move || {
|
||||
let (stream, _) = listener.accept().expect("accept");
|
||||
handle(stream, &status).expect("handle");
|
||||
});
|
||||
let mut client = Client::connect(address).expect("connect");
|
||||
client
|
||||
.write_all(b"POST / HTTP/1.1\r\nHost: miner\r\nContent-Length: 0\r\n\r\n")
|
||||
.expect("write");
|
||||
let mut reply = String::new();
|
||||
client.read_to_string(&mut reply).expect("read");
|
||||
worker.join().expect("join");
|
||||
assert!(reply.starts_with("HTTP/1.1 405 Method Not Allowed"));
|
||||
}
|
||||
}
|
||||
+441
-4
@@ -1,13 +1,55 @@
|
||||
use alkane_os::{power_decision, target_matrix};
|
||||
use alkane_os::bm1362::{
|
||||
bt8d_for_baud, chain_inactive, encode_job, encode_work as encode_bm1362_work, read_register,
|
||||
read_register_all, set_chip_address, write_register, write_register_all, Job, S19J_PRO,
|
||||
};
|
||||
use alkane_os::bm1366::{decode_nonce_report, encode_work};
|
||||
use alkane_os::bm13xx::{crc16, crc5};
|
||||
use alkane_os::difficulty::PoolDifficulty;
|
||||
use alkane_os::hal_wire::HalClient;
|
||||
use alkane_os::miner::Bm1366Miner;
|
||||
use alkane_os::pow::verify_sha256_report;
|
||||
use alkane_os::pow::VersionMask;
|
||||
use alkane_os::scrypt_pow::verify_scrypt_header;
|
||||
use alkane_os::stratum_session::PoolSession;
|
||||
use alkane_os::stratum_submit::{format_submission, Submission};
|
||||
use alkane_os::stratum_v1::{
|
||||
parse_boolean_response, parse_configure_result, parse_control_notification, parse_notify,
|
||||
parse_subscription, Subscription,
|
||||
};
|
||||
use alkane_os::stratum_wire::{
|
||||
authorize_request, configure_request, subscribe_request, StratumWire,
|
||||
};
|
||||
use alkane_os::stratum_work::Sha256Job;
|
||||
use alkane_os::{power_decision, target_matrix, HardwareBackend};
|
||||
use std::hint::black_box;
|
||||
use std::time::Instant;
|
||||
use std::io::{Read, Write};
|
||||
use std::net::TcpListener;
|
||||
use std::os::unix::net::UnixStream;
|
||||
use std::thread;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
fn measure(name: &str, iterations: u64, mut f: impl FnMut()) {
|
||||
fn sample(iterations: u64, f: &mut impl FnMut()) -> Duration {
|
||||
let started = Instant::now();
|
||||
for _ in 0..iterations {
|
||||
f();
|
||||
}
|
||||
let ns = started.elapsed().as_nanos() as f64 / iterations as f64;
|
||||
started.elapsed()
|
||||
}
|
||||
|
||||
fn measure(name: &str, minimum_iterations: u64, mut f: impl FnMut()) {
|
||||
for _ in 0..minimum_iterations.min(1000) {
|
||||
f();
|
||||
}
|
||||
let mut iterations = minimum_iterations.max(1);
|
||||
while sample(iterations, &mut f) < Duration::from_millis(20) && iterations < 100_000_000 {
|
||||
iterations = (iterations * 2).min(100_000_000);
|
||||
}
|
||||
let mut measurements = [0_f64; 7];
|
||||
for value in &mut measurements {
|
||||
*value = sample(iterations, &mut f).as_nanos() as f64 / iterations as f64;
|
||||
}
|
||||
measurements.sort_by(f64::total_cmp);
|
||||
let ns = measurements[measurements.len() / 2];
|
||||
println!("BENCH {name} {ns:.3} ns/op");
|
||||
}
|
||||
|
||||
@@ -30,3 +72,398 @@ fn bench_power_policy() {
|
||||
black_box(power_decision(black_box(Some(64_000)), 80_000));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm13xx_crc5() {
|
||||
let command = [0x53, 0x05, 0, 0];
|
||||
measure("bm13xx_crc5", 100_000, || {
|
||||
black_box(crc5(black_box(&command)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm13xx_crc16() {
|
||||
let job = [0x21_u8; 84];
|
||||
measure("bm13xx_crc16", 20_000, || {
|
||||
black_box(crc16(black_box(&job)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_share_verification() {
|
||||
let header = [0_u8; 80];
|
||||
let target = [0xff_u8; 32];
|
||||
measure("share_verification", 20_000, || {
|
||||
black_box(verify_sha256_report(
|
||||
black_box(&header),
|
||||
black_box(0xEDAD_FF38),
|
||||
black_box(0x04B3),
|
||||
black_box(&target),
|
||||
));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_scrypt_share_verification() {
|
||||
let header = [0_u8; 80];
|
||||
let target = [0xff_u8; 32];
|
||||
measure("scrypt_share_verification", 4, || {
|
||||
black_box(verify_scrypt_header(black_box(&header), black_box(&target)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1366_work_encoding() {
|
||||
let header = [0_u8; 80];
|
||||
measure("bm1366_work_encoding", 20_000, || {
|
||||
black_box(encode_work(black_box(&header), black_box(0x18)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1362_commands() {
|
||||
measure("bm1362_commands", 20_000, || {
|
||||
black_box(chain_inactive());
|
||||
black_box(set_chip_address(black_box(8)));
|
||||
black_box(read_register(black_box(0x40), 0x1c));
|
||||
black_box(read_register_all(0));
|
||||
black_box(write_register(black_box(0x40), 0x18, 0x7a31));
|
||||
black_box(write_register_all(0x80, 0));
|
||||
black_box(bt8d_for_baud(black_box(115_200)));
|
||||
black_box(S19J_PRO.chip_addresses().last());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1362_job_encoding() {
|
||||
let job = Job {
|
||||
work_id: 8,
|
||||
num_midstates: 1,
|
||||
start_nonce: 0,
|
||||
nbits: 0x1a1f_2c34,
|
||||
ntime: 0x5e9b_3cd4,
|
||||
merkle_root: [0xa5; 32],
|
||||
previous_hash: [0x5a; 32],
|
||||
version: 0x2000_0000,
|
||||
};
|
||||
measure("bm1362_job_encoding", 20_000, || {
|
||||
black_box(encode_job(black_box(&job)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1362_work_encoding() {
|
||||
let header = [0_u8; 80];
|
||||
measure("bm1362_work_encoding", 20_000, || {
|
||||
black_box(encode_bm1362_work(black_box(&header), black_box(8)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1366_report_decode() {
|
||||
let report = [
|
||||
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
|
||||
];
|
||||
measure("bm1366_report_decode", 100_000, || {
|
||||
let _ = black_box(decode_nonce_report(black_box(&report)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_header() {
|
||||
let job = Sha256Job {
|
||||
prevhash_stratum: [0; 32],
|
||||
coinb1: vec![0; 48],
|
||||
coinb2: vec![0; 64],
|
||||
merkle_branches: vec![[0; 32]; 4],
|
||||
version: 0x2000_0000,
|
||||
nbits: 0x1d00_ffff,
|
||||
ntime: 0x6655_4433,
|
||||
extranonce1: vec![0; 4],
|
||||
extranonce2_size: 8,
|
||||
};
|
||||
measure("stratum_header", 5_000, || {
|
||||
black_box(
|
||||
job.nonce_zero_header(black_box(&[0; 8]), job.ntime)
|
||||
.unwrap(),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_submission() {
|
||||
let share = Submission {
|
||||
request_id: 1,
|
||||
worker: "miner.worker",
|
||||
job_id: "job-123",
|
||||
extranonce2: &[0; 8],
|
||||
ntime: 0x680f_6a2e,
|
||||
nonce: 0xedad_ff38,
|
||||
base_version: 0x2000_0000,
|
||||
rolled_version: 0x2096_6000,
|
||||
version_mask: Some(VersionMask::new(0x1fff_e000).unwrap()),
|
||||
};
|
||||
measure("stratum_submission", 20_000, || {
|
||||
black_box(format_submission(black_box(&share)).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_authorize_format() {
|
||||
measure("stratum_authorize_format", 20_000, || {
|
||||
black_box(authorize_request(black_box(3), "miner.worker", "password").unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_configure_format() {
|
||||
measure("stratum_configure_format", 20_000, || {
|
||||
black_box(configure_request(black_box(1)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_subscribe_format() {
|
||||
measure("stratum_subscribe_format", 20_000, || {
|
||||
black_box(subscribe_request(black_box(2), "alkane-os/0.1").unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_subscription_parse() {
|
||||
let line = br#"{"id":1,"result":[[["mining.notify","session"]],"01020304",4],"error":null}"#;
|
||||
measure("stratum_subscription_parse", 20_000, || {
|
||||
black_box(parse_subscription(black_box(line), black_box(1)).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_accept_parse() {
|
||||
let line = br#"{"id":5,"result":true,"error":null}"#;
|
||||
measure("stratum_accept_parse", 20_000, || {
|
||||
black_box(parse_boolean_response(black_box(line), black_box(5)).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_notify_parse() {
|
||||
let line = serde_json::json!({
|
||||
"id": null,
|
||||
"method": "mining.notify",
|
||||
"params": [
|
||||
"job-1",
|
||||
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
|
||||
"616263", "78797a", [], "20000000", "1d00ffff", "66554433", true
|
||||
]
|
||||
})
|
||||
.to_string();
|
||||
let subscription = Subscription {
|
||||
extranonce1: vec![1, 2, 3, 4],
|
||||
extranonce2_size: 4,
|
||||
};
|
||||
measure("stratum_notify_parse", 20_000, || {
|
||||
black_box(parse_notify(black_box(line.as_bytes()), &subscription).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_control_parse() {
|
||||
let line = br#"{"id":null,"method":"mining.set_difficulty","params":[2048.5]}"#;
|
||||
measure("stratum_control_parse", 20_000, || {
|
||||
black_box(parse_control_notification(black_box(line), false, false).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_configure_parse() {
|
||||
let line = br#"{"id":1,"result":{"version-rolling":true,"version-rolling.mask":"1fffe000","subscribe-extranonce":true},"error":null}"#;
|
||||
measure("stratum_configure_parse", 20_000, || {
|
||||
black_box(parse_configure_result(black_box(line), 1).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_difficulty_target() {
|
||||
let number = serde_json::from_str("2048.5").unwrap();
|
||||
let difficulty = PoolDifficulty::from_json_number(&number).unwrap();
|
||||
measure("difficulty_target", 20_000, || {
|
||||
black_box(black_box(difficulty).target_le());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_job_issue() {
|
||||
let line = serde_json::json!({
|
||||
"id": null,
|
||||
"method": "mining.notify",
|
||||
"params": [
|
||||
"job-1", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
|
||||
"616263", "78797a", [], "20000000", "1d00ffff", "66554433", true
|
||||
]
|
||||
})
|
||||
.to_string();
|
||||
let mut session = PoolSession::new(
|
||||
Subscription {
|
||||
extranonce1: vec![1, 2, 3, 4],
|
||||
extranonce2_size: 4,
|
||||
},
|
||||
None,
|
||||
false,
|
||||
)
|
||||
.unwrap();
|
||||
session
|
||||
.control(br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#)
|
||||
.unwrap();
|
||||
measure("stratum_job_issue", 5_000, || {
|
||||
session.after_hardware_reset();
|
||||
black_box(session.issue_notify(black_box(line.as_bytes())).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
struct BenchBackend {
|
||||
report: Option<[u8; 11]>,
|
||||
}
|
||||
|
||||
impl HardwareBackend for BenchBackend {
|
||||
type Error = ();
|
||||
|
||||
fn send_frame(&mut self, _chain: u8, frame: &[u8]) -> Result<(), Self::Error> {
|
||||
black_box(frame);
|
||||
Ok(())
|
||||
}
|
||||
fn receive_frame(&mut self, _chain: u8, frame: &mut [u8]) -> Result<usize, Self::Error> {
|
||||
if let Some(report) = self.report {
|
||||
frame[..report.len()].copy_from_slice(&report);
|
||||
Ok(report.len())
|
||||
} else {
|
||||
Ok(0)
|
||||
}
|
||||
}
|
||||
fn set_chain_reset(&mut self, _chain: u8, _asserted: bool) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
fn set_fan_target(&mut self, _fan: u8, _percent: u8) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
fn read_temperature_mc(&mut self, _sensor: u8) -> Result<i32, Self::Error> {
|
||||
Ok(50_000)
|
||||
}
|
||||
fn set_psu_enabled(&mut self, _enabled: bool) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1366_session_cycle() {
|
||||
let header = [0_u8; 80];
|
||||
let target = [0xff_u8; 32];
|
||||
measure("bm1366_session_cycle", 20_000, || {
|
||||
let mut backend = BenchBackend { report: None };
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner
|
||||
.submit(black_box(header), black_box(target), 0x18)
|
||||
.unwrap();
|
||||
black_box(miner.poll().unwrap());
|
||||
miner.stop().unwrap();
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1366_captured_report_poll() {
|
||||
let header = [
|
||||
0x00, 0x00, 0x00, 0x20, 0xfc, 0x3a, 0xb8, 0xd4, 0x30, 0x21, 0xf4, 0x5e, 0xb6, 0x62, 0x38,
|
||||
0x9d, 0x0f, 0x79, 0x1f, 0x65, 0x7d, 0xbf, 0x75, 0xa5, 0xcb, 0x93, 0x67, 0x0b, 0x57, 0xb6,
|
||||
0xc2, 0x25, 0x03, 0xb4, 0x21, 0x3a, 0x43, 0xae, 0x10, 0x52, 0xeb, 0xd4, 0x44, 0x43, 0x06,
|
||||
0x8f, 0xe1, 0x78, 0xe2, 0xc6, 0x1c, 0xa4, 0x99, 0x48, 0x46, 0xfd, 0x13, 0x3a, 0xdd, 0xb0,
|
||||
0x4a, 0xab, 0x2b, 0x38, 0x2c, 0x5b, 0x4c, 0x74, 0xc1, 0x01, 0x2e, 0x6a, 0x8f, 0x06, 0x02,
|
||||
0x17, 0x00, 0x00, 0x00, 0x00,
|
||||
];
|
||||
let report = [
|
||||
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
|
||||
];
|
||||
let mut target = [0_u8; 32];
|
||||
target[26..28].fill(0xff);
|
||||
let mut backend = BenchBackend {
|
||||
report: Some(report),
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(header, target, 0x18).unwrap();
|
||||
measure("bm1366_captured_report_poll", 20_000, || {
|
||||
let share = miner.poll().unwrap().unwrap();
|
||||
assert_eq!(black_box(share).nonce, 0xedad_ff38);
|
||||
});
|
||||
miner.stop().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_hal_socket_exchange() {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let mut header = [0_u8; 16];
|
||||
let mut payload = [0_u8; 2];
|
||||
while server.read_exact(&mut header).is_ok() {
|
||||
assert_eq!(&header[..6], b"ALKH\x01\x04");
|
||||
assert_eq!(u32::from_le_bytes(header[12..16].try_into().unwrap()), 2);
|
||||
server.read_exact(&mut payload).unwrap();
|
||||
assert_eq!(payload, [0, 80]);
|
||||
header[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
||||
header[12..16].copy_from_slice(&1_u32.to_le_bytes());
|
||||
server.write_all(&header).unwrap();
|
||||
server.write_all(&[0]).unwrap();
|
||||
}
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
measure("hal_socket_exchange", 100, || {
|
||||
backend.set_fan_target(black_box(0), black_box(80)).unwrap();
|
||||
});
|
||||
drop(backend);
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_socket_round_trip() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let (mut server, _) = listener.accept().unwrap();
|
||||
let mut request = [0_u8; 3];
|
||||
while server.read_exact(&mut request).is_ok() {
|
||||
assert_eq!(&request, b"{}\n");
|
||||
server.write_all(b"{}\n").unwrap();
|
||||
}
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
measure("stratum_socket_round_trip", 100, || {
|
||||
wire.send_line(black_box(b"{}\n")).unwrap();
|
||||
black_box(wire.read_line().unwrap());
|
||||
});
|
||||
drop(wire);
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,73 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::difficulty::{DifficultyError, PoolDifficulty};
|
||||
|
||||
fn target(decimal: &str) -> String {
|
||||
let number = serde_json::from_str(decimal).unwrap();
|
||||
PoolDifficulty::from_json_number(&number)
|
||||
.unwrap()
|
||||
.target_le()
|
||||
.iter()
|
||||
.rev()
|
||||
.map(|byte| format!("{byte:02x}"))
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exact_share_targets_match_integer_reference() {
|
||||
for (difficulty, expected) in [
|
||||
(
|
||||
"1",
|
||||
"00000000ffff0000000000000000000000000000000000000000000000000000",
|
||||
),
|
||||
(
|
||||
"2",
|
||||
"000000007fff8000000000000000000000000000000000000000000000000000",
|
||||
),
|
||||
(
|
||||
"0.5",
|
||||
"00000001fffe0000000000000000000000000000000000000000000000000000",
|
||||
),
|
||||
(
|
||||
"1.25",
|
||||
"00000000cccc0000000000000000000000000000000000000000000000000000",
|
||||
),
|
||||
(
|
||||
"2048.5",
|
||||
"00000000001ffde021fde021fde021fde021fde021fde021fde021fde021fde0",
|
||||
),
|
||||
(
|
||||
"0.000001",
|
||||
"000f4230bdc00000000000000000000000000000000000000000000000000000",
|
||||
),
|
||||
(
|
||||
"1000000000000000000",
|
||||
"000000000000000000000012724b5f7471d95d3bbefee5e602a7b17261180d8e",
|
||||
),
|
||||
] {
|
||||
assert_eq!(target(difficulty), expected, "difficulty {difficulty}");
|
||||
}
|
||||
assert_eq!(target("1.2e3"), target("1200"));
|
||||
assert_eq!(target("1e-19"), "ff".repeat(32));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_or_unrepresentable_difficulty_is_rejected() {
|
||||
let zero = serde_json::from_str("0").unwrap();
|
||||
assert_eq!(
|
||||
PoolDifficulty::from_json_number(&zero),
|
||||
Err(DifficultyError::Invalid)
|
||||
);
|
||||
let negative = serde_json::from_str("-1").unwrap();
|
||||
assert_eq!(
|
||||
PoolDifficulty::from_json_number(&negative),
|
||||
Err(DifficultyError::OutOfRange)
|
||||
);
|
||||
for value in ["1e20", "1e-20", "1.00000000000000000001"] {
|
||||
let number = serde_json::from_str(value).unwrap();
|
||||
assert_eq!(
|
||||
PoolDifficulty::from_json_number(&number),
|
||||
Err(DifficultyError::OutOfRange),
|
||||
"difficulty {value}"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,214 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::hal_wire::{HalClient, HalError};
|
||||
use alkane_os::HardwareBackend;
|
||||
use std::io::{Read, Write};
|
||||
use std::os::unix::net::{UnixListener, UnixStream};
|
||||
use std::thread;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
fn reply(socket: &mut UnixStream, request: &[u8; 16], body: &[u8]) {
|
||||
let mut header = *request;
|
||||
header[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
||||
header[12..16].copy_from_slice(&(body.len() as u32).to_le_bytes());
|
||||
socket.write_all(&header).unwrap();
|
||||
socket.write_all(body).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sdk_backend_round_trip_and_safety_limits() {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let expected = [
|
||||
(1, vec![2, 3, 0, 0x55, 0xaa, 0x21], vec![0]),
|
||||
(2, vec![2, 8, 0], vec![0, 3, 0, 0xaa, 0x55, 0x01]),
|
||||
(3, vec![2, 1], vec![0]),
|
||||
(4, vec![0, 90], vec![0]),
|
||||
(
|
||||
5,
|
||||
vec![1],
|
||||
[vec![0], 72_500_i32.to_le_bytes().to_vec()].concat(),
|
||||
),
|
||||
(6, vec![1], vec![0]),
|
||||
];
|
||||
for (index, (opcode, request_body, response_body)) in expected.iter().enumerate() {
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
assert_eq!(&header[..4], b"ALKH");
|
||||
assert_eq!(header[4], 1);
|
||||
assert_eq!(header[5], *opcode);
|
||||
assert_eq!(
|
||||
u32::from_le_bytes(header[8..12].try_into().unwrap()),
|
||||
index as u32 + 1
|
||||
);
|
||||
let length = u32::from_le_bytes(header[12..16].try_into().unwrap()) as usize;
|
||||
let mut body = vec![0_u8; length];
|
||||
server.read_exact(&mut body).unwrap();
|
||||
assert_eq!(&body, request_body);
|
||||
reply(&mut server, &header, response_body);
|
||||
}
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
backend.send_frame(2, &[0x55, 0xaa, 0x21]).unwrap();
|
||||
let mut buffer = [0_u8; 8];
|
||||
assert_eq!(backend.receive_frame(2, &mut buffer).unwrap(), 3);
|
||||
assert_eq!(&buffer[..3], &[0xaa, 0x55, 0x01]);
|
||||
backend.set_chain_reset(2, true).unwrap();
|
||||
backend.set_fan_target(0, 90).unwrap();
|
||||
assert_eq!(backend.read_temperature_mc(1).unwrap(), 72_500);
|
||||
backend.set_psu_enabled(true).unwrap();
|
||||
assert!(matches!(
|
||||
backend.set_fan_target(0, 101),
|
||||
Err(HalError::InvalidFanPercent)
|
||||
));
|
||||
assert!(matches!(
|
||||
backend.send_frame(0, &[0_u8; 4094]),
|
||||
Err(HalError::FrameTooLong)
|
||||
));
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_wrong_response_sequence() {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
let mut body = [0_u8; 1];
|
||||
server.read_exact(&mut body).unwrap();
|
||||
header[8..12].copy_from_slice(&2_u32.to_le_bytes());
|
||||
header[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
||||
header[12..16].copy_from_slice(&1_u32.to_le_bytes());
|
||||
server.write_all(&header).unwrap();
|
||||
let mut one = [0_u8; 1];
|
||||
assert_eq!(server.read(&mut one).unwrap(), 0);
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
assert!(matches!(
|
||||
backend.set_psu_enabled(true),
|
||||
Err(HalError::Protocol("response sequence mismatch"))
|
||||
));
|
||||
assert!(matches!(
|
||||
backend.set_psu_enabled(true),
|
||||
Err(HalError::Protocol("connection is unusable"))
|
||||
));
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_power_off_ends_backend_power_lease() {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
let mut body = [0_u8; 1];
|
||||
server.read_exact(&mut body).unwrap();
|
||||
assert_eq!(header[5], 6);
|
||||
assert_eq!(body, [0]);
|
||||
reply(&mut server, &header, &[3]);
|
||||
assert_eq!(server.read(&mut body).unwrap(), 0);
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
assert!(matches!(
|
||||
backend.set_psu_enabled(false),
|
||||
Err(HalError::Device(3))
|
||||
));
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_temperature_response_disconnects_power_lease() {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
let mut request = [0_u8; 1];
|
||||
server.read_exact(&mut request).unwrap();
|
||||
assert_eq!(header[5], 5);
|
||||
reply(&mut server, &header, &[0, 1]);
|
||||
assert_eq!(server.read(&mut request).unwrap(), 0);
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
assert!(matches!(
|
||||
backend.read_temperature_mc(1),
|
||||
Err(HalError::Protocol("invalid temperature response"))
|
||||
));
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_malformed_error_response_and_poisoned_connection() {
|
||||
for body in [&[4_u8][..], &[3_u8, 99][..]] {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let response = body.to_vec();
|
||||
let worker = thread::spawn(move || {
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
let mut request = [0_u8; 1];
|
||||
server.read_exact(&mut request).unwrap();
|
||||
reply(&mut server, &header, &response);
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
assert!(matches!(
|
||||
backend.set_psu_enabled(true),
|
||||
Err(HalError::Protocol("invalid error response"))
|
||||
));
|
||||
assert!(matches!(
|
||||
backend.set_psu_enabled(true),
|
||||
Err(HalError::Protocol("connection is unusable"))
|
||||
));
|
||||
worker.join().unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn slow_partial_response_hits_absolute_exchange_deadline() {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
let mut request = [0_u8; 1];
|
||||
server.read_exact(&mut request).unwrap();
|
||||
header[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
||||
header[12..16].copy_from_slice(&1_u32.to_le_bytes());
|
||||
for byte in header.into_iter().chain([0]) {
|
||||
if server.write_all(&[byte]).is_err() {
|
||||
break;
|
||||
}
|
||||
thread::sleep(Duration::from_millis(250));
|
||||
}
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
let start = Instant::now();
|
||||
assert!(matches!(
|
||||
backend.set_psu_enabled(true),
|
||||
Err(HalError::Io(_))
|
||||
));
|
||||
assert!(start.elapsed() < Duration::from_secs(4));
|
||||
drop(backend);
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn connects_to_a_local_backend_socket() {
|
||||
let path = std::env::temp_dir().join(format!(
|
||||
"alkane-hal-{}-{}.sock",
|
||||
std::process::id(),
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.unwrap()
|
||||
.as_nanos()
|
||||
));
|
||||
let listener = UnixListener::bind(&path).unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let (mut server, _) = listener.accept().unwrap();
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
let mut request = [0_u8; 1];
|
||||
server.read_exact(&mut request).unwrap();
|
||||
reply(&mut server, &header, &[0]);
|
||||
});
|
||||
let mut backend = HalClient::connect(&path).unwrap();
|
||||
backend.set_psu_enabled(true).unwrap();
|
||||
worker.join().unwrap();
|
||||
std::fs::remove_file(path).unwrap();
|
||||
}
|
||||
+360
@@ -0,0 +1,360 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::bm1366::REPORT_BYTES;
|
||||
use alkane_os::miner::{Bm1366Miner, ChipModel, MinerError};
|
||||
use alkane_os::HardwareBackend;
|
||||
|
||||
const HEADER: [u8; 80] = [
|
||||
0x00, 0x00, 0x00, 0x20, 0xfc, 0x3a, 0xb8, 0xd4, 0x30, 0x21, 0xf4, 0x5e, 0xb6, 0x62, 0x38, 0x9d,
|
||||
0x0f, 0x79, 0x1f, 0x65, 0x7d, 0xbf, 0x75, 0xa5, 0xcb, 0x93, 0x67, 0x0b, 0x57, 0xb6, 0xc2, 0x25,
|
||||
0x03, 0xb4, 0x21, 0x3a, 0x43, 0xae, 0x10, 0x52, 0xeb, 0xd4, 0x44, 0x43, 0x06, 0x8f, 0xe1, 0x78,
|
||||
0xe2, 0xc6, 0x1c, 0xa4, 0x99, 0x48, 0x46, 0xfd, 0x13, 0x3a, 0xdd, 0xb0, 0x4a, 0xab, 0x2b, 0x38,
|
||||
0x2c, 0x5b, 0x4c, 0x74, 0xc1, 0x01, 0x2e, 0x6a, 0x8f, 0x06, 0x02, 0x17, 0x00, 0x00, 0x00, 0x00,
|
||||
];
|
||||
const REPORT: [u8; REPORT_BYTES] = [
|
||||
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
|
||||
];
|
||||
|
||||
fn diff_one() -> [u8; 32] {
|
||||
let mut target = [0_u8; 32];
|
||||
target[26..28].fill(0xff);
|
||||
target
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct FakeBackend {
|
||||
events: Vec<&'static str>,
|
||||
temperatures: Vec<i32>,
|
||||
powered: bool,
|
||||
fail_off_call: usize,
|
||||
off_calls: usize,
|
||||
fail_reset_call: usize,
|
||||
reset_calls: usize,
|
||||
report: Option<[u8; REPORT_BYTES]>,
|
||||
additional_reports: Vec<[u8; REPORT_BYTES]>,
|
||||
sent: Vec<u8>,
|
||||
}
|
||||
|
||||
impl HardwareBackend for FakeBackend {
|
||||
type Error = &'static str;
|
||||
|
||||
fn send_frame(&mut self, _chain: u8, frame: &[u8]) -> Result<(), Self::Error> {
|
||||
assert!(self.powered);
|
||||
self.events.push("send");
|
||||
self.sent = frame.to_vec();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn receive_frame(&mut self, _chain: u8, frame: &mut [u8]) -> Result<usize, Self::Error> {
|
||||
self.events.push("receive");
|
||||
if let Some(report) = self.report.take().or_else(|| self.additional_reports.pop()) {
|
||||
frame[..REPORT_BYTES].copy_from_slice(&report);
|
||||
Ok(REPORT_BYTES)
|
||||
} else {
|
||||
Ok(0)
|
||||
}
|
||||
}
|
||||
|
||||
fn set_chain_reset(&mut self, _chain: u8, asserted: bool) -> Result<(), Self::Error> {
|
||||
assert!(self.powered);
|
||||
self.reset_calls += 1;
|
||||
if self.reset_calls == self.fail_reset_call {
|
||||
return Err("reset failed");
|
||||
}
|
||||
self.events
|
||||
.push(if asserted { "reset-on" } else { "reset-off" });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set_fan_target(&mut self, _fan: u8, percent: u8) -> Result<(), Self::Error> {
|
||||
assert!(percent > 0);
|
||||
self.events.push("fan");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_temperature_mc(&mut self, _sensor: u8) -> Result<i32, Self::Error> {
|
||||
self.events.push("temperature");
|
||||
if self.temperatures.is_empty() {
|
||||
return Err("sensor unavailable");
|
||||
}
|
||||
Ok(self.temperatures.remove(0))
|
||||
}
|
||||
|
||||
fn set_psu_enabled(&mut self, enabled: bool) -> Result<(), Self::Error> {
|
||||
self.events.push(if enabled { "psu-on" } else { "psu-off" });
|
||||
if !enabled {
|
||||
self.off_calls += 1;
|
||||
if self.off_calls == self.fail_off_call {
|
||||
return Err("power-off did not complete");
|
||||
}
|
||||
}
|
||||
self.powered = enabled;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn captured_nonce_passes_a_started_miner() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000, 50_000, 50_000],
|
||||
report: Some(REPORT),
|
||||
..Default::default()
|
||||
};
|
||||
{
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
let share = miner.poll().unwrap().unwrap();
|
||||
assert_eq!(share.nonce, 0xedad_ff38);
|
||||
assert_eq!(share.work_id, 0x18);
|
||||
assert_eq!(share.rolled_version, 0x2096_6000);
|
||||
miner.stop().unwrap();
|
||||
}
|
||||
assert!(!backend.powered);
|
||||
assert_eq!(&backend.sent[..5], &[0x55, 0xaa, 0x21, 0x54, 0x18]);
|
||||
assert_eq!(
|
||||
&backend.events[..6],
|
||||
&[
|
||||
"psu-off",
|
||||
"temperature",
|
||||
"fan",
|
||||
"psu-on",
|
||||
"reset-on",
|
||||
"reset-off"
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn real_bm1362_capture_uses_its_job_format_and_shared_report() {
|
||||
// SDK capture bm1362-real-nonces.txt: one real-silicon pool-accepted share.
|
||||
// This checks host framing and proof only; board initialization is separate.
|
||||
let header_hex = concat!(
|
||||
"00000020fc3ab8d43021f45eb662389d0f791f657dbf75a5cb93670b57b6c22503b4213a",
|
||||
"0503969b7384e1215aace8cfc65dae22d8493ad48fec0b7ac3b0ad7b4e7fb0c5",
|
||||
"c0012e6a8f06021700000000"
|
||||
);
|
||||
let mut header = [0_u8; 80];
|
||||
for (byte, pair) in header.iter_mut().zip(header_hex.as_bytes().chunks_exact(2)) {
|
||||
*byte = u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap();
|
||||
}
|
||||
let report = [
|
||||
0xaa, 0x55, 0x33, 0x25, 0x0b, 0x63, 0x00, 0x18, 0x67, 0x6b, 0x95,
|
||||
];
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000; 3],
|
||||
report: Some(report),
|
||||
..Default::default()
|
||||
};
|
||||
{
|
||||
let mut miner =
|
||||
Bm1366Miner::new_for_chip(&mut backend, ChipModel::Bm1362, 0, 0, 0, 100, 80_000)
|
||||
.unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(header, diff_one(), 0x18).unwrap();
|
||||
let share = miner.poll().unwrap().unwrap();
|
||||
assert_eq!(share.nonce, 0x630b_2533);
|
||||
assert_eq!(share.work_id, 0x18);
|
||||
assert_eq!(share.rolled_version, 0x2ced_6000);
|
||||
miner.stop().unwrap();
|
||||
}
|
||||
assert!(!backend.powered);
|
||||
assert_eq!(&backend.sent[..6], &[0x55, 0xaa, 0x21, 0x56, 0x18, 1]);
|
||||
assert_eq!(&backend.sent[10..14], &header[72..76]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hot_or_missing_sensor_stops_power() {
|
||||
let mut hot = FakeBackend {
|
||||
temperatures: vec![80_000],
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut hot, 0, 0, 0, 100, 80_000).unwrap();
|
||||
assert_eq!(miner.start(), Err(MinerError::UnsafeTemperature(80_000)));
|
||||
drop(miner);
|
||||
assert!(!hot.powered);
|
||||
assert!(!hot.events.contains(&"psu-on"));
|
||||
|
||||
let mut missing = FakeBackend::default();
|
||||
let mut miner = Bm1366Miner::new(&mut missing, 0, 0, 0, 100, 80_000).unwrap();
|
||||
assert_eq!(
|
||||
miner.start(),
|
||||
Err(MinerError::Backend("sensor unavailable"))
|
||||
);
|
||||
drop(miner);
|
||||
assert!(!missing.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn temperature_rise_stops_power_and_stale_reports_preserve_mining() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000, 50_000, 90_000],
|
||||
report: Some(REPORT),
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
assert_eq!(miner.poll(), Err(MinerError::UnsafeTemperature(90_000)));
|
||||
assert_eq!(miner.poll(), Err(MinerError::NotRunning));
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000; 5],
|
||||
report: Some(REPORT),
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x20).unwrap();
|
||||
assert_eq!(miner.poll(), Err(MinerError::StaleReport));
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
assert_eq!(miner.poll(), Ok(None));
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn earlier_in_flight_job_is_checked_against_its_own_target() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000; 5],
|
||||
report: Some(REPORT),
|
||||
additional_reports: vec![REPORT],
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
miner.submit(HEADER, [0; 32], 0x20).unwrap();
|
||||
assert_eq!(miner.poll().unwrap().unwrap().work_id, 0x18);
|
||||
miner.clear_work();
|
||||
assert_eq!(miner.poll(), Err(MinerError::StaleReport));
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn below_target_is_rejected_without_misreporting_a_share() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000, 50_000, 50_000],
|
||||
report: Some(REPORT),
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, [0; 32], 0x18).unwrap();
|
||||
assert_eq!(miner.poll(), Err(MinerError::BelowTarget));
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_power_off_is_retried_on_drop() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000],
|
||||
fail_off_call: 2,
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
assert_eq!(miner.stop(), Err("power-off did not complete"));
|
||||
drop(miner);
|
||||
assert_eq!(backend.off_calls, 3);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_chain_flush_powers_off_before_work_id_reuse() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000, 50_000],
|
||||
fail_reset_call: 3,
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
assert_eq!(
|
||||
miner.reset_chain(),
|
||||
Err(MinerError::Backend("reset failed"))
|
||||
);
|
||||
assert_eq!(
|
||||
miner.submit(HEADER, diff_one(), 0),
|
||||
Err(MinerError::NotRunning)
|
||||
);
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn work_id_stays_reserved_until_confirmed_chain_reset() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000; 6],
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
assert_eq!(
|
||||
miner.submit(HEADER, diff_one(), 0x18),
|
||||
Err(MinerError::WorkIdInUse(0x18))
|
||||
);
|
||||
miner.clear_work();
|
||||
assert_eq!(
|
||||
miner.submit(HEADER, diff_one(), 0x18),
|
||||
Err(MinerError::WorkIdInUse(0x18))
|
||||
);
|
||||
miner.reset_chain().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
miner.stop().unwrap();
|
||||
drop(miner);
|
||||
assert_eq!(
|
||||
backend
|
||||
.events
|
||||
.iter()
|
||||
.filter(|event| **event == "send")
|
||||
.count(),
|
||||
2
|
||||
);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn duplicate_work_request_still_checks_temperature() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000, 50_000, 90_000],
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
assert_eq!(
|
||||
miner.submit(HEADER, diff_one(), 0x18),
|
||||
Err(MinerError::UnsafeTemperature(90_000))
|
||||
);
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unconfirmed_power_off_blocks_mining_until_shutdown_retries() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000],
|
||||
fail_off_call: 2,
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
assert_eq!(miner.stop(), Err("power-off did not complete"));
|
||||
assert_eq!(
|
||||
miner.submit(HEADER, diff_one(), 0),
|
||||
Err(MinerError::Faulted)
|
||||
);
|
||||
assert_eq!(miner.poll(), Err(MinerError::Faulted));
|
||||
assert_eq!(miner.reset_chain(), Err(MinerError::Faulted));
|
||||
miner.stop().unwrap();
|
||||
assert_eq!(
|
||||
miner.submit(HEADER, diff_one(), 0),
|
||||
Err(MinerError::NotRunning)
|
||||
);
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
@@ -0,0 +1,260 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::miner::{Bm1366Miner, MinerError, ValidShare};
|
||||
use alkane_os::pow::VersionMask;
|
||||
use alkane_os::stratum_session::{DispatchError, PoolSession, SessionError};
|
||||
use alkane_os::stratum_v1::Subscription;
|
||||
use alkane_os::HardwareBackend;
|
||||
|
||||
fn session() -> PoolSession {
|
||||
PoolSession::new(
|
||||
Subscription {
|
||||
extranonce1: vec![1, 2, 3, 4],
|
||||
extranonce2_size: 4,
|
||||
},
|
||||
Some(VersionMask::new(0x1fff_e000).unwrap()),
|
||||
true,
|
||||
)
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn notify(id: &str, clean: bool) -> String {
|
||||
serde_json::json!({
|
||||
"id": null,
|
||||
"method": "mining.notify",
|
||||
"params": [
|
||||
id,
|
||||
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
|
||||
"616263", "78797a", [], "20000000", "1d00ffff", "66554433", clean
|
||||
]
|
||||
})
|
||||
.to_string()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn difficulty_changes_on_next_job_and_old_work_keeps_its_target() {
|
||||
let mut pool = session();
|
||||
assert_eq!(
|
||||
pool.issue_notify(notify("early", true).as_bytes()).err(),
|
||||
Some(SessionError::MissingDifficulty)
|
||||
);
|
||||
pool.control(br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#)
|
||||
.unwrap();
|
||||
let first = pool.issue_notify(notify("first", true).as_bytes()).unwrap();
|
||||
assert!(first.clean_jobs);
|
||||
assert_eq!(first.work_id, 0);
|
||||
assert_eq!(&first.target_le[26..28], &[0xff, 0xff]);
|
||||
pool.control(br#"{"id":null,"method":"mining.set_difficulty","params":[2]}"#)
|
||||
.unwrap();
|
||||
let second = pool
|
||||
.issue_notify(notify("second", false).as_bytes())
|
||||
.unwrap();
|
||||
assert!(!second.clean_jobs);
|
||||
assert_eq!(second.work_id, 8);
|
||||
assert_eq!(&second.target_le[26..28], &[0xff, 0x7f]);
|
||||
assert_ne!(first.header, second.header);
|
||||
assert_eq!(
|
||||
pool.control(br#"{"id":null,"method":"mining.set_version_mask","params":["00006000"]}"#),
|
||||
Ok(true)
|
||||
);
|
||||
assert_eq!(
|
||||
pool.submission(
|
||||
ValidShare {
|
||||
nonce: 0xedad_ff38,
|
||||
work_id: first.work_id,
|
||||
rolled_version: 0x2000_0000,
|
||||
hash_le: [0; 32],
|
||||
},
|
||||
"worker",
|
||||
10,
|
||||
),
|
||||
Err(SessionError::StaleShare)
|
||||
);
|
||||
assert_eq!(
|
||||
pool.control(br#"{"id":null,"method":"mining.set_version_mask","params":["00006000"]}"#),
|
||||
Ok(false)
|
||||
);
|
||||
let clean = pool.issue_notify(notify("third", true).as_bytes()).unwrap();
|
||||
assert!(clean.clean_jobs);
|
||||
assert_eq!(clean.work_id, 16);
|
||||
let old = ValidShare {
|
||||
nonce: 0xedad_ff38,
|
||||
work_id: first.work_id,
|
||||
rolled_version: 0x2000_0000,
|
||||
hash_le: [0; 32],
|
||||
};
|
||||
assert_eq!(
|
||||
pool.submission(old, "worker", 10),
|
||||
Err(SessionError::StaleShare)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extranonce_change_invalidates_jobs_without_reusing_asic_ids() {
|
||||
let mut pool = session();
|
||||
pool.control(br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#)
|
||||
.unwrap();
|
||||
let old = pool.issue_notify(notify("old", true).as_bytes()).unwrap();
|
||||
assert!(pool
|
||||
.control(br#"{"id":null,"method":"mining.set_extranonce","params":["aabbccdd",4]}"#)
|
||||
.unwrap());
|
||||
let new = pool.issue_notify(notify("new", false).as_bytes()).unwrap();
|
||||
assert_eq!(new.work_id, 8);
|
||||
assert_ne!(old.header, new.header);
|
||||
for index in 2..32 {
|
||||
let work = pool.issue_notify(notify("more", false).as_bytes()).unwrap();
|
||||
assert_eq!(work.work_id, (index as u8) << 3);
|
||||
}
|
||||
assert_eq!(
|
||||
pool.issue_notify(notify("exhausted", false).as_bytes())
|
||||
.err(),
|
||||
Some(SessionError::WorkIdsExhausted)
|
||||
);
|
||||
pool.after_hardware_reset();
|
||||
assert_eq!(
|
||||
pool.issue_notify(notify("after-reset", false).as_bytes())
|
||||
.unwrap()
|
||||
.work_id,
|
||||
0
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_length_extranonce_requires_distinct_header_until_hardware_reset() {
|
||||
let mut pool = PoolSession::new(
|
||||
Subscription {
|
||||
extranonce1: vec![1],
|
||||
extranonce2_size: 0,
|
||||
},
|
||||
None,
|
||||
false,
|
||||
)
|
||||
.unwrap();
|
||||
pool.control(br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#)
|
||||
.unwrap();
|
||||
pool.issue_notify(notify("one", true).as_bytes()).unwrap();
|
||||
assert_eq!(
|
||||
pool.issue_notify(notify("two", false).as_bytes()).err(),
|
||||
Some(SessionError::ExtranonceExhausted)
|
||||
);
|
||||
let distinct = notify("two", true).replace("66554433", "66554434");
|
||||
pool.issue_notify(distinct.as_bytes()).unwrap();
|
||||
pool.after_hardware_reset();
|
||||
pool.issue_notify(notify("three", true).as_bytes()).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_byte_extranonce_restarts_only_for_a_distinct_header_template() {
|
||||
let mut pool = PoolSession::new(
|
||||
Subscription {
|
||||
extranonce1: vec![1],
|
||||
extranonce2_size: 1,
|
||||
},
|
||||
None,
|
||||
false,
|
||||
)
|
||||
.unwrap();
|
||||
pool.control(br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#)
|
||||
.unwrap();
|
||||
for index in 0..256 {
|
||||
if index != 0 && index % 32 == 0 {
|
||||
pool.after_hardware_reset();
|
||||
}
|
||||
pool.issue_notify(notify("same", false).as_bytes()).unwrap();
|
||||
}
|
||||
pool.after_hardware_reset();
|
||||
assert_eq!(
|
||||
pool.issue_notify(notify("same", false).as_bytes()).err(),
|
||||
Some(SessionError::ExtranonceExhausted)
|
||||
);
|
||||
let distinct = notify("new", false).replace("66554433", "66554434");
|
||||
pool.issue_notify(distinct.as_bytes()).unwrap();
|
||||
pool.after_hardware_reset();
|
||||
for index in 0..256_u32 {
|
||||
if index != 0 && index % 32 == 0 {
|
||||
pool.after_hardware_reset();
|
||||
}
|
||||
let ntime = format!("{index:08x}");
|
||||
let next = notify("fresh", false).replace("66554433", &ntime);
|
||||
pool.issue_notify(next.as_bytes()).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
struct FakeBackend {
|
||||
powered: bool,
|
||||
sent: usize,
|
||||
report: Option<[u8; 11]>,
|
||||
}
|
||||
|
||||
impl HardwareBackend for FakeBackend {
|
||||
type Error = &'static str;
|
||||
|
||||
fn send_frame(&mut self, _chain: u8, frame: &[u8]) -> Result<(), Self::Error> {
|
||||
assert!(self.powered);
|
||||
assert_eq!(&frame[..4], &[0x55, 0xaa, 0x21, 0x54]);
|
||||
self.sent += 1;
|
||||
Ok(())
|
||||
}
|
||||
fn receive_frame(&mut self, _chain: u8, frame: &mut [u8]) -> Result<usize, Self::Error> {
|
||||
match self.report.take() {
|
||||
Some(report) => {
|
||||
frame[..11].copy_from_slice(&report);
|
||||
Ok(11)
|
||||
}
|
||||
None => Ok(0),
|
||||
}
|
||||
}
|
||||
fn set_chain_reset(&mut self, _chain: u8, _asserted: bool) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
fn set_fan_target(&mut self, _fan: u8, _percent: u8) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
fn read_temperature_mc(&mut self, _sensor: u8) -> Result<i32, Self::Error> {
|
||||
Ok(50_000)
|
||||
}
|
||||
fn set_psu_enabled(&mut self, enabled: bool) -> Result<(), Self::Error> {
|
||||
self.powered = enabled;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pool_job_dispatch_and_version_mask_invalidation_reach_the_miner() {
|
||||
let mut backend = FakeBackend {
|
||||
powered: false,
|
||||
sent: 0,
|
||||
report: Some([
|
||||
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
|
||||
]),
|
||||
};
|
||||
{
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
let mut pool = session();
|
||||
pool.control_with_miner(
|
||||
&mut miner,
|
||||
br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#,
|
||||
)
|
||||
.unwrap();
|
||||
for index in 0..4 {
|
||||
let work = pool
|
||||
.issue_to_miner(&mut miner, notify("job", index == 0).as_bytes())
|
||||
.unwrap();
|
||||
assert_eq!(work.work_id, (index as u8) << 3);
|
||||
}
|
||||
pool.control_with_miner(
|
||||
&mut miner,
|
||||
br#"{"id":null,"method":"mining.set_version_mask","params":["00006000"]}"#,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(miner.poll(), Err(MinerError::StaleReport));
|
||||
miner.stop().unwrap();
|
||||
assert_eq!(
|
||||
pool.issue_to_miner(&mut miner, notify("stopped", false).as_bytes())
|
||||
.err(),
|
||||
Some(DispatchError::Miner(MinerError::NotRunning))
|
||||
);
|
||||
}
|
||||
assert!(!backend.powered);
|
||||
assert_eq!(backend.sent, 4);
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::pow::VersionMask;
|
||||
use alkane_os::stratum_submit::{format_submission, Submission, SubmitError};
|
||||
|
||||
fn share() -> Submission<'static> {
|
||||
Submission {
|
||||
request_id: 7,
|
||||
worker: "miner.worker",
|
||||
job_id: "pool-job",
|
||||
extranonce2: &[0, 1, 0xfe, 0xff],
|
||||
ntime: 0x680f6a2e,
|
||||
nonce: 0xedadff38,
|
||||
base_version: 0x20000000,
|
||||
rolled_version: 0x20966000,
|
||||
version_mask: Some(VersionMask::new(0x1fffe000).unwrap()),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn captured_bm1366_version_is_represented_under_negotiated_mask() {
|
||||
assert_eq!(
|
||||
format_submission(&share()).unwrap(),
|
||||
"{\"id\":7,\"method\":\"mining.submit\",\"params\":[\"miner.worker\",\"pool-job\",\"0001feff\",\"680f6a2e\",\"edadff38\",\"00966000\"]}\n"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unnegotiated_or_narrow_mask_rejects_rolled_share() {
|
||||
let mut value = share();
|
||||
value.version_mask = None;
|
||||
assert_eq!(
|
||||
format_submission(&value),
|
||||
Err(SubmitError::UnrepresentableVersion)
|
||||
);
|
||||
value.version_mask = Some(VersionMask::new(0x0060_0000).unwrap());
|
||||
assert_eq!(
|
||||
format_submission(&value),
|
||||
Err(SubmitError::UnrepresentableVersion)
|
||||
);
|
||||
value.rolled_version = value.base_version;
|
||||
value.version_mask = None;
|
||||
assert_eq!(
|
||||
format_submission(&value).unwrap(),
|
||||
"{\"id\":7,\"method\":\"mining.submit\",\"params\":[\"miner.worker\",\"pool-job\",\"0001feff\",\"680f6a2e\",\"edadff38\"]}\n"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pool_fields_are_escaped_and_bounded() {
|
||||
let mut value = share();
|
||||
value.worker = "worker\"\\\n";
|
||||
value.job_id = "job\t\u{0001}";
|
||||
let wire = format_submission(&value).unwrap();
|
||||
assert!(wire.contains("\"worker\\\"\\\\\\n\""));
|
||||
assert!(wire.contains("\"job\\t\\u0001\""));
|
||||
value.worker = "";
|
||||
assert_eq!(format_submission(&value), Err(SubmitError::EmptyWorker));
|
||||
value.worker = "worker";
|
||||
value.job_id = "";
|
||||
assert_eq!(format_submission(&value), Err(SubmitError::EmptyJobId));
|
||||
value.job_id = "job";
|
||||
value.extranonce2 = &[0; 33];
|
||||
assert_eq!(
|
||||
format_submission(&value),
|
||||
Err(SubmitError::ExtranonceTooLong)
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,208 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::difficulty::PoolDifficulty;
|
||||
use alkane_os::stratum_v1::{
|
||||
parse_boolean_response, parse_configure_response, parse_configure_result,
|
||||
parse_control_notification, parse_notify, parse_subscription, PoolMessageError,
|
||||
PoolNotification, Subscription,
|
||||
};
|
||||
|
||||
const SUBSCRIBE: &str =
|
||||
r#"{"id":1,"result":[[["mining.notify","session"]],"01020304",4],"error":null}"#;
|
||||
fn notify() -> String {
|
||||
serde_json::json!({
|
||||
"id": null,
|
||||
"method": "mining.notify",
|
||||
"params": [
|
||||
"job-1",
|
||||
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
|
||||
"616263", "78797a",
|
||||
["202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"],
|
||||
"20000000", "1d00ffff", "66554433", true
|
||||
]
|
||||
})
|
||||
.to_string()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn subscribe_and_notify_construct_expected_asic_header() {
|
||||
let subscription = parse_subscription(SUBSCRIBE.as_bytes(), 1).unwrap();
|
||||
let line = notify();
|
||||
let job = parse_notify(line.as_bytes(), &subscription).unwrap();
|
||||
assert_eq!(job.id, "job-1");
|
||||
assert!(job.clean_jobs);
|
||||
let header = job
|
||||
.work
|
||||
.nonce_zero_header(&[5, 6, 7, 8], job.work.ntime)
|
||||
.unwrap();
|
||||
let hex: String = header.iter().map(|byte| format!("{byte:02x}")).collect();
|
||||
assert_eq!(
|
||||
hex,
|
||||
concat!(
|
||||
"0000002003020100070605040b0a09080f0e0d0c13121110171615141b1a19181f1e1d1c",
|
||||
"9b9bc91f078af83ff63d00c6da09b5bc4dd26e2d8c0df8ab16b933a259a05881",
|
||||
"33445566ffff001d00000000"
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_pool_messages_fail_before_work_issuance() {
|
||||
assert!(matches!(
|
||||
parse_subscription(SUBSCRIBE.as_bytes(), 2),
|
||||
Err(PoolMessageError::WrongMessage)
|
||||
));
|
||||
let subscription = parse_subscription(SUBSCRIBE.as_bytes(), 1).unwrap();
|
||||
let malformed = notify().replace("66554433", "6655443g");
|
||||
assert!(matches!(
|
||||
parse_notify(malformed.as_bytes(), &subscription),
|
||||
Err(PoolMessageError::InvalidHex)
|
||||
));
|
||||
let wrong_method = notify().replace("mining.notify", "mining.submit");
|
||||
assert!(matches!(
|
||||
parse_notify(wrong_method.as_bytes(), &subscription),
|
||||
Err(PoolMessageError::WrongMessage)
|
||||
));
|
||||
let too_large = vec![b' '; 131_073];
|
||||
assert!(matches!(
|
||||
parse_notify(&too_large, &subscription),
|
||||
Err(PoolMessageError::TooLarge)
|
||||
));
|
||||
let too_large_coinbase = notify().replace("616263", &"aa".repeat(65_537));
|
||||
assert!(matches!(
|
||||
parse_notify(too_large_coinbase.as_bytes(), &subscription),
|
||||
Err(PoolMessageError::TooLarge)
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn version_rolling_negotiation_and_immediate_mask_change() {
|
||||
let response = br#"{"id":3,"result":{"version-rolling":true,"version-rolling.mask":"1fffe000"},"error":null}"#;
|
||||
let mask = parse_configure_response(response, 3).unwrap().unwrap();
|
||||
assert_eq!(mask.bits(), 0x1fff_e000);
|
||||
let update = br#"{"id":null,"method":"mining.set_version_mask","params":["00006000"]}"#;
|
||||
assert_eq!(
|
||||
parse_control_notification(update, true, false).unwrap(),
|
||||
PoolNotification::SetVersionMask(alkane_os::pow::VersionMask::new(0x6000).unwrap())
|
||||
);
|
||||
assert_eq!(
|
||||
parse_control_notification(update, false, false),
|
||||
Err(PoolMessageError::Unnegotiated)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_configure_response(response, 4),
|
||||
Err(PoolMessageError::WrongMessage)
|
||||
);
|
||||
let declined = br#"{"id":3,"result":{"version-rolling":false},"error":null}"#;
|
||||
assert_eq!(parse_configure_response(declined, 3), Ok(None));
|
||||
let unsafe_mask = br#"{"id":3,"result":{"version-rolling":true,"version-rolling.mask":"ffffffff"},"error":null}"#;
|
||||
assert_eq!(
|
||||
parse_configure_response(unsafe_mask, 3),
|
||||
Err(PoolMessageError::InvalidField)
|
||||
);
|
||||
let absent_mask = br#"{"id":3,"result":{"version-rolling":true},"error":null}"#;
|
||||
assert_eq!(
|
||||
parse_configure_response(absent_mask, 3),
|
||||
Err(PoolMessageError::InvalidField)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn both_bip310_extensions_and_boolean_responses_are_checked() {
|
||||
let accepted = br#"{"id":3,"result":{"version-rolling":true,"version-rolling.mask":"1fffe000","subscribe-extranonce":true},"error":null}"#;
|
||||
let result = parse_configure_result(accepted, 3).unwrap();
|
||||
assert_eq!(result.version_mask.unwrap().bits(), 0x1fff_e000);
|
||||
assert!(result.subscribe_extranonce);
|
||||
let declined =
|
||||
br#"{"id":3,"result":{"version-rolling":false,"subscribe-extranonce":false},"error":null}"#;
|
||||
let result = parse_configure_result(declined, 3).unwrap();
|
||||
assert_eq!(result.version_mask, None);
|
||||
assert!(!result.subscribe_extranonce);
|
||||
let unavailable = br#"{"id":3,"result":{"version-rolling":"unavailable","subscribe-extranonce":"unsupported"},"error":null}"#;
|
||||
let result = parse_configure_result(unavailable, 3).unwrap();
|
||||
assert_eq!(result.version_mask, None);
|
||||
assert!(!result.subscribe_extranonce);
|
||||
assert_eq!(
|
||||
parse_configure_result(
|
||||
br#"{"id":3,"result":{"version-rolling":false},"error":null}"#,
|
||||
3
|
||||
),
|
||||
Ok(alkane_os::stratum_v1::ConfigureResult {
|
||||
version_mask: None,
|
||||
subscribe_extranonce: false,
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
parse_configure_result(
|
||||
br#"{"id":3,"result":{"version-rolling":false,"subscribe-extranonce":null},"error":null}"#,
|
||||
3
|
||||
),
|
||||
Err(PoolMessageError::InvalidField)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_boolean_response(br#"{"id":5,"result":true,"error":null}"#, 5),
|
||||
Ok(true)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_boolean_response(br#"{"id":5,"result":false,"error":[23,"stale"]}"#, 5),
|
||||
Ok(false)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_boolean_response(
|
||||
br#"{"id":5,"result":null,"error":[21,"Job not found",null]}"#,
|
||||
5
|
||||
),
|
||||
Ok(false)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_boolean_response(br#"{"id":5,"result":true,"error":[23,"stale"]}"#, 5),
|
||||
Err(PoolMessageError::InvalidField)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_boolean_response(br#"{"id":6,"result":true,"error":null}"#, 5),
|
||||
Err(PoolMessageError::WrongMessage)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn difficulty_and_extranonce_notifications_validate_shape_and_negotiation() {
|
||||
let difficulty = br#"{"id":null,"method":"mining.set_difficulty","params":[2048.5]}"#;
|
||||
assert_eq!(
|
||||
parse_control_notification(difficulty, false, false),
|
||||
Ok(PoolNotification::SetDifficulty(
|
||||
PoolDifficulty::from_json_number(&serde_json::from_str("2048.5").unwrap()).unwrap()
|
||||
))
|
||||
);
|
||||
let extranonce = br#"{"id":null,"method":"mining.set_extranonce","params":["aabbccdd",4]}"#;
|
||||
assert_eq!(
|
||||
parse_control_notification(extranonce, false, true),
|
||||
Ok(PoolNotification::SetExtranonce(Subscription {
|
||||
extranonce1: vec![0xaa, 0xbb, 0xcc, 0xdd],
|
||||
extranonce2_size: 4,
|
||||
}))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_control_notification(extranonce, false, false),
|
||||
Err(PoolMessageError::Unnegotiated)
|
||||
);
|
||||
for value in ["0", "-1", "\"2\"", "null"] {
|
||||
let line =
|
||||
format!("{{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[{value}]}}");
|
||||
assert_eq!(
|
||||
parse_control_notification(line.as_bytes(), false, false),
|
||||
Err(PoolMessageError::InvalidField)
|
||||
);
|
||||
}
|
||||
let oversize = format!(
|
||||
"{{\"id\":null,\"method\":\"mining.set_extranonce\",\"params\":[\"{}\",1]}}",
|
||||
"ab".repeat(33)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_control_notification(oversize.as_bytes(), false, true),
|
||||
Err(PoolMessageError::InvalidField)
|
||||
);
|
||||
let response_id = br#"{"id":5,"method":"mining.set_difficulty","params":[2]}"#;
|
||||
assert_eq!(
|
||||
parse_control_notification(response_id, false, false),
|
||||
Err(PoolMessageError::WrongMessage)
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,249 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::stratum_v1::MAX_POOL_LINE_BYTES;
|
||||
use alkane_os::stratum_wire::{
|
||||
authorize_request, configure_request, subscribe_request, HandshakeError, StratumWire, WireError,
|
||||
};
|
||||
use serde_json::Value;
|
||||
use std::io::{BufRead, BufReader, Read, Write};
|
||||
use std::net::TcpListener;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
|
||||
#[test]
|
||||
fn request_frames_escape_pool_credentials_and_advertise_supported_bits() {
|
||||
let configure: Value = serde_json::from_str(&configure_request(1)).unwrap();
|
||||
assert_eq!(configure["method"], "mining.configure");
|
||||
assert_eq!(configure["params"][1]["version-rolling.mask"], "1fffe000");
|
||||
assert_eq!(configure["params"][0][1], "subscribe-extranonce");
|
||||
let subscribe: Value =
|
||||
serde_json::from_str(&subscribe_request(2, "alkane-os/0.1").unwrap()).unwrap();
|
||||
assert_eq!(subscribe["params"][0], "alkane-os/0.1");
|
||||
let authorized = authorize_request(3, "worker\"name", "secret\nvalue").unwrap();
|
||||
assert_eq!(authorized.as_bytes().last(), Some(&b'\n'));
|
||||
let authorize: Value = serde_json::from_str(&authorized).unwrap();
|
||||
assert_eq!(authorize["params"][0], "worker\"name");
|
||||
assert_eq!(authorize["params"][1], "secret\nvalue");
|
||||
assert!(matches!(
|
||||
subscribe_request(2, ""),
|
||||
Err(WireError::InvalidRequest)
|
||||
));
|
||||
assert!(matches!(
|
||||
authorize_request(3, "", "pass"),
|
||||
Err(WireError::InvalidRequest)
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loopback_frames_preserve_pipelined_lines_and_reject_invalid_sends() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
stream.write_all(b"{\"id\":1}\n{\"id\":2}\n").unwrap();
|
||||
let mut request = [0_u8; 3];
|
||||
stream.read_exact(&mut request).unwrap();
|
||||
assert_eq!(&request, b"{}\n");
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
assert_eq!(wire.read_line().unwrap(), b"{\"id\":1}\n");
|
||||
assert_eq!(wire.read_line().unwrap(), b"{\"id\":2}\n");
|
||||
assert!(matches!(
|
||||
wire.send_line(b"bad\nline\n"),
|
||||
Err(WireError::InvalidRequest)
|
||||
));
|
||||
wire.send_line(b"{}\n").unwrap();
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn oversized_pool_line_poison_closes_the_connection() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
let mut line = vec![b'a'; MAX_POOL_LINE_BYTES];
|
||||
line.push(b'\n');
|
||||
let _ = stream.write_all(&line);
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
assert!(matches!(wire.read_line(), Err(WireError::LineTooLong)));
|
||||
assert!(matches!(wire.read_line(), Err(WireError::Closed)));
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trickled_pool_line_hits_the_absolute_deadline() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
for byte in b"{123}\n" {
|
||||
if stream.write_all(&[*byte]).is_err() {
|
||||
break;
|
||||
}
|
||||
thread::sleep(Duration::from_millis(60));
|
||||
}
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_millis(130)).unwrap();
|
||||
assert!(matches!(wire.read_line(), Err(WireError::Timeout)));
|
||||
assert!(matches!(wire.send_line(b"{}\n"), Err(WireError::Closed)));
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn buffered_complete_lines_do_not_extend_a_partial_line_deadline() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
stream.write_all(b"first\nsecond\nunfinished").unwrap();
|
||||
thread::sleep(Duration::from_secs(3));
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
let first = loop {
|
||||
if let Some(line) = wire.try_read_line().unwrap() {
|
||||
break line;
|
||||
}
|
||||
};
|
||||
assert_eq!(first, b"first\n");
|
||||
thread::sleep(Duration::from_millis(1300));
|
||||
assert_eq!(wire.try_read_line().unwrap(), Some(b"second\n".to_vec()));
|
||||
thread::sleep(Duration::from_millis(800));
|
||||
assert!(matches!(wire.try_read_line(), Err(WireError::Timeout)));
|
||||
assert!(wire.is_closed());
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn idle_timeout_keeps_connection_available_for_later_messages() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let (release, wait) = std::sync::mpsc::channel();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
wait.recv().unwrap();
|
||||
stream
|
||||
.write_all(b"{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[1]}\n")
|
||||
.unwrap();
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_millis(130)).unwrap();
|
||||
assert!(matches!(wire.read_line(), Err(WireError::Timeout)));
|
||||
release.send(()).unwrap();
|
||||
assert_eq!(
|
||||
serde_json::from_slice::<Value>(&wire.read_line().unwrap()).unwrap()["method"],
|
||||
"mining.set_difficulty"
|
||||
);
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn handshake_preserves_early_notifications_and_authorizes_worker() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
let mut input = BufReader::new(stream.try_clone().unwrap());
|
||||
let mut line = String::new();
|
||||
input.read_line(&mut line).unwrap();
|
||||
assert_eq!(
|
||||
serde_json::from_str::<Value>(&line).unwrap()["method"],
|
||||
"mining.configure"
|
||||
);
|
||||
stream.write_all(b"{\"id\":1,\"result\":{\"version-rolling\":true,\"version-rolling.mask\":\"1fffe000\",\"subscribe-extranonce\":true},\"error\":null}\n").unwrap();
|
||||
line.clear();
|
||||
input.read_line(&mut line).unwrap();
|
||||
assert_eq!(
|
||||
serde_json::from_str::<Value>(&line).unwrap()["method"],
|
||||
"mining.subscribe"
|
||||
);
|
||||
stream.write_all(b"{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[1]}\n{\"id\":2,\"result\":[[],\"01020304\",4],\"error\":null}\n").unwrap();
|
||||
line.clear();
|
||||
input.read_line(&mut line).unwrap();
|
||||
assert_eq!(
|
||||
serde_json::from_str::<Value>(&line).unwrap()["method"],
|
||||
"mining.authorize"
|
||||
);
|
||||
stream
|
||||
.write_all(b"{\"id\":3,\"result\":true,\"error\":null}\n")
|
||||
.unwrap();
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
let result = wire
|
||||
.handshake(
|
||||
"alkane-os/0.1",
|
||||
"miner.worker",
|
||||
"password",
|
||||
Duration::from_secs(2),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(result.subscription.extranonce1, [1, 2, 3, 4]);
|
||||
assert_eq!(result.subscription.extranonce2_size, 4);
|
||||
assert!(result.configure.subscribe_extranonce);
|
||||
assert_eq!(result.configure.version_mask.unwrap().bits(), 0x1fff_e000);
|
||||
assert_eq!(result.early_notifications.len(), 1);
|
||||
assert_eq!(
|
||||
serde_json::from_slice::<Value>(&result.early_notifications[0]).unwrap()["method"],
|
||||
"mining.set_difficulty"
|
||||
);
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejected_worker_closes_the_handshake_connection() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
let mut input = BufReader::new(stream.try_clone().unwrap());
|
||||
let mut line = String::new();
|
||||
input.read_line(&mut line).unwrap();
|
||||
stream.write_all(b"{\"id\":1,\"result\":{\"version-rolling\":false,\"subscribe-extranonce\":false},\"error\":null}\n").unwrap();
|
||||
line.clear();
|
||||
input.read_line(&mut line).unwrap();
|
||||
stream
|
||||
.write_all(b"{\"id\":2,\"result\":[[],\"01020304\",4],\"error\":null}\n")
|
||||
.unwrap();
|
||||
line.clear();
|
||||
input.read_line(&mut line).unwrap();
|
||||
stream
|
||||
.write_all(b"{\"id\":3,\"result\":false,\"error\":[24,\"unauthorized\"]}\n")
|
||||
.unwrap();
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
assert!(matches!(
|
||||
wire.handshake("alkane-os/0.1", "bad", "password", Duration::from_secs(2)),
|
||||
Err(HandshakeError::Rejected)
|
||||
));
|
||||
assert!(matches!(wire.read_line(), Err(WireError::Closed)));
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrong_handshake_reply_id_is_rejected_and_connection_closed() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
let mut line = String::new();
|
||||
BufReader::new(stream.try_clone().unwrap())
|
||||
.read_line(&mut line)
|
||||
.unwrap();
|
||||
stream
|
||||
.write_all(b"{\"id\":9,\"result\":true,\"error\":null}\n")
|
||||
.unwrap();
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
assert!(matches!(
|
||||
wire.handshake(
|
||||
"alkane-os/0.1",
|
||||
"miner.worker",
|
||||
"password",
|
||||
Duration::from_secs(2)
|
||||
),
|
||||
Err(HandshakeError::Pool(
|
||||
alkane_os::stratum_v1::PoolMessageError::WrongMessage
|
||||
))
|
||||
));
|
||||
assert!(matches!(wire.read_line(), Err(WireError::Closed)));
|
||||
server.join().unwrap();
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::bm1366::encode_work;
|
||||
use alkane_os::stratum_work::{JobError, Sha256Job};
|
||||
|
||||
fn fixture() -> Sha256Job {
|
||||
let mut prevhash_stratum = [0_u8; 32];
|
||||
let mut branch = [0_u8; 32];
|
||||
for (index, byte) in prevhash_stratum.iter_mut().enumerate() {
|
||||
*byte = index as u8;
|
||||
}
|
||||
for (index, byte) in branch.iter_mut().enumerate() {
|
||||
*byte = (index + 32) as u8;
|
||||
}
|
||||
Sha256Job {
|
||||
prevhash_stratum,
|
||||
coinb1: b"abc".to_vec(),
|
||||
coinb2: b"xyz".to_vec(),
|
||||
merkle_branches: vec![branch],
|
||||
version: 0x2000_0000,
|
||||
nbits: 0x1d00_ffff,
|
||||
ntime: 0x6655_4433,
|
||||
extranonce1: vec![1, 2, 3, 4],
|
||||
extranonce2_size: 4,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn builds_cross_checked_header_and_asic_work() {
|
||||
let job = fixture();
|
||||
let header = job.nonce_zero_header(&[5, 6, 7, 8], job.ntime).unwrap();
|
||||
let expected = concat!(
|
||||
"0000002003020100070605040b0a09080f0e0d0c13121110171615141b1a19181f1e1d1c",
|
||||
"9b9bc91f078af83ff63d00c6da09b5bc4dd26e2d8c0df8ab16b933a259a05881",
|
||||
"33445566ffff001d00000000"
|
||||
);
|
||||
let actual: String = header.iter().map(|byte| format!("{byte:02x}")).collect();
|
||||
assert_eq!(actual, expected);
|
||||
let frame = encode_work(&header, 0x18).unwrap();
|
||||
assert_eq!(&frame[10..14], &header[72..76]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_invalid_pool_work_before_hashing() {
|
||||
let mut job = fixture();
|
||||
assert_eq!(
|
||||
job.nonce_zero_header(&[5, 6], job.ntime),
|
||||
Err(JobError::ExtranonceLength)
|
||||
);
|
||||
job.extranonce2_size = 33;
|
||||
assert_eq!(job.validate(), Err(JobError::InvalidExtranonceSize));
|
||||
job.extranonce2_size = 4;
|
||||
job.coinb1.resize(65_536, 0);
|
||||
assert_eq!(job.validate(), Err(JobError::CoinbaseTooLarge));
|
||||
job.coinb1 = b"abc".to_vec();
|
||||
job.merkle_branches.resize(65, [0; 32]);
|
||||
assert_eq!(job.validate(), Err(JobError::TooManyMerkleBranches));
|
||||
}
|
||||
+1
@@ -0,0 +1 @@
|
||||
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"e0165305f3b22a9ab4217a121f85379aa56c2675caa7afedc0a7468fc187600b",".github/FUNDING.yml":"b017158736b3c9751a2d21edfce7fe61c8954e2fced8da8dd3013c2f3e295bd9",".github/workflows/ci.yml":"89c4f60223daf03217ea7c1e8879135b11d2554bd1e57dd9eff5c02f1adc7909","Cargo.lock":"1cd64090b8e883963bb08d91e6968cc1e83ffdba4f4b2f47651ce9d351a8a947","Cargo.toml":"894c215e4e7e973b556b0e9627bf9b6a719a043fac9b5af9838660816392a09f","Cargo.toml.orig":"44ca1ae5d9b48743305b57f3367051289512037e7836b8b3693b68d48dec0483","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"1305bd79675db0194915d9bc91bd0b3cf9487bc1126e05bf46b48ab43edce44b","benches/bench.rs":"29a0bdb973848007d681e571c57487e21e1bfb7aed5980c2190dba354498b154","src/lib.rs":"e962338e1886873aa7c3399ec89aa5378ccbfed712b9690f043628079390a34f","src/u128_ext.rs":"498cc94f13805e551248fd82f47cc318f51d953a5002a9f8698858cd12fbae3c","tests/test.rs":"b22f8a8ed89edcbb4140b74f5edd7f2adf3cb0e363990dd6010cd6ebe0dc36b7"},"package":"8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"}
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"git": {
|
||||
"sha1": "af77385d0daf4d0e949e81f2588be2e44f69f086"
|
||||
},
|
||||
"path_in_vcs": ""
|
||||
}
|
||||
+1
@@ -0,0 +1 @@
|
||||
github: dtolnay
|
||||
+126
@@ -0,0 +1,126 @@
|
||||
name: CI
|
||||
|
||||
on:
|
||||
push:
|
||||
pull_request:
|
||||
workflow_dispatch:
|
||||
schedule: [cron: "40 1 * * *"]
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
env:
|
||||
RUSTFLAGS: -Dwarnings
|
||||
|
||||
jobs:
|
||||
pre_ci:
|
||||
uses: dtolnay/.github/.github/workflows/pre_ci.yml@master
|
||||
|
||||
test:
|
||||
name: Rust ${{matrix.rust}}
|
||||
needs: pre_ci
|
||||
if: needs.pre_ci.outputs.continue
|
||||
runs-on: ubuntu-latest
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
rust: [nightly, beta, stable, 1.86.0]
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@master
|
||||
with:
|
||||
toolchain: ${{matrix.rust}}
|
||||
- name: Enable type layout randomization
|
||||
run: echo RUSTFLAGS=${RUSTFLAGS}\ -Zrandomize-layout >> $GITHUB_ENV
|
||||
if: matrix.rust == 'nightly'
|
||||
- run: cargo build
|
||||
- run: cargo test
|
||||
- run: cargo test --release
|
||||
- run: cargo build --no-default-features
|
||||
- run: cargo test --tests --no-default-features
|
||||
- run: cargo test --tests --no-default-features --release
|
||||
- run: cargo build --tests --features no-panic --release
|
||||
if: matrix.rust == 'nightly'
|
||||
- run: cargo bench --no-run
|
||||
if: matrix.rust == 'nightly'
|
||||
- uses: actions/upload-artifact@v6
|
||||
if: matrix.rust == 'nightly' && always()
|
||||
with:
|
||||
name: Cargo.lock
|
||||
path: Cargo.lock
|
||||
continue-on-error: true
|
||||
|
||||
msrv:
|
||||
name: Rust 1.68.0
|
||||
needs: pre_ci
|
||||
if: needs.pre_ci.outputs.continue
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@1.68
|
||||
- run: cargo build
|
||||
- run: cargo build --no-default-features
|
||||
|
||||
doc:
|
||||
name: Documentation
|
||||
needs: pre_ci
|
||||
if: needs.pre_ci.outputs.continue
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 45
|
||||
env:
|
||||
RUSTDOCFLAGS: -Dwarnings
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@nightly
|
||||
- uses: dtolnay/install@cargo-docs-rs
|
||||
- run: cargo docs-rs
|
||||
|
||||
miri:
|
||||
name: Miri
|
||||
needs: pre_ci
|
||||
if: needs.pre_ci.outputs.continue
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@miri
|
||||
- run: cargo miri setup
|
||||
- run: cargo miri test
|
||||
env:
|
||||
MIRIFLAGS: -Zmiri-strict-provenance
|
||||
|
||||
clippy:
|
||||
name: Clippy
|
||||
runs-on: ubuntu-latest
|
||||
if: github.event_name != 'pull_request'
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@clippy
|
||||
- run: cargo clippy --tests --benches -- -Dclippy::all -Dclippy::pedantic
|
||||
|
||||
fuzz:
|
||||
name: Fuzz
|
||||
needs: pre_ci
|
||||
if: needs.pre_ci.outputs.continue
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@nightly
|
||||
- uses: dtolnay/install@cargo-fuzz
|
||||
- run: cargo fuzz check
|
||||
|
||||
outdated:
|
||||
name: Outdated
|
||||
runs-on: ubuntu-latest
|
||||
if: github.event_name != 'pull_request'
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@stable
|
||||
- uses: dtolnay/install@cargo-outdated
|
||||
- run: cargo outdated --workspace --exit-code 1
|
||||
- run: cargo outdated --manifest-path fuzz/Cargo.toml --exit-code 1
|
||||
+460
@@ -0,0 +1,460 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 3
|
||||
|
||||
[[package]]
|
||||
name = "aho-corasick"
|
||||
version = "1.1.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "alloca"
|
||||
version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4"
|
||||
dependencies = [
|
||||
"cc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "anes"
|
||||
version = "0.1.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
|
||||
|
||||
[[package]]
|
||||
name = "anstyle"
|
||||
version = "1.0.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
|
||||
|
||||
[[package]]
|
||||
name = "autocfg"
|
||||
version = "1.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
|
||||
|
||||
[[package]]
|
||||
name = "cast"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
|
||||
|
||||
[[package]]
|
||||
name = "cc"
|
||||
version = "1.2.57"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423"
|
||||
dependencies = [
|
||||
"find-msvc-tools",
|
||||
"shlex",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cfg-if"
|
||||
version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
|
||||
|
||||
[[package]]
|
||||
name = "ciborium"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
|
||||
dependencies = [
|
||||
"ciborium-io",
|
||||
"ciborium-ll",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ciborium-io"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
|
||||
|
||||
[[package]]
|
||||
name = "ciborium-ll"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
|
||||
dependencies = [
|
||||
"ciborium-io",
|
||||
"half",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap"
|
||||
version = "4.6.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b193af5b67834b676abd72466a96c1024e6a6ad978a1f484bd90b85c94041351"
|
||||
dependencies = [
|
||||
"clap_builder",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_builder"
|
||||
version = "4.6.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
|
||||
dependencies = [
|
||||
"anstyle",
|
||||
"clap_lex",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_lex"
|
||||
version = "1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
|
||||
|
||||
[[package]]
|
||||
name = "criterion"
|
||||
version = "0.8.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3"
|
||||
dependencies = [
|
||||
"alloca",
|
||||
"anes",
|
||||
"cast",
|
||||
"ciborium",
|
||||
"clap",
|
||||
"criterion-plot",
|
||||
"itertools",
|
||||
"num-traits",
|
||||
"oorandom",
|
||||
"page_size",
|
||||
"regex",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"tinytemplate",
|
||||
"walkdir",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "criterion-plot"
|
||||
version = "0.8.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea"
|
||||
dependencies = [
|
||||
"cast",
|
||||
"itertools",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crunchy"
|
||||
version = "0.2.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
|
||||
|
||||
[[package]]
|
||||
name = "either"
|
||||
version = "1.15.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
|
||||
|
||||
[[package]]
|
||||
name = "find-msvc-tools"
|
||||
version = "0.1.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
|
||||
|
||||
[[package]]
|
||||
name = "half"
|
||||
version = "2.7.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"crunchy",
|
||||
"zerocopy",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.13.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
|
||||
dependencies = [
|
||||
"either",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.18"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"no-panic",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.183"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.8.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
|
||||
|
||||
[[package]]
|
||||
name = "no-panic"
|
||||
version = "0.1.36"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f967505aabc8af5752d098c34146544a43684817cdba8f9725b292530cabbf53"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-traits"
|
||||
version = "0.2.19"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
|
||||
dependencies = [
|
||||
"autocfg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "oorandom"
|
||||
version = "11.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
|
||||
|
||||
[[package]]
|
||||
name = "page_size"
|
||||
version = "0.6.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.106"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.45"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex"
|
||||
version = "1.12.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
|
||||
dependencies = [
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-automata",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-automata"
|
||||
version = "0.4.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
|
||||
dependencies = [
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-syntax"
|
||||
version = "0.8.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
|
||||
|
||||
[[package]]
|
||||
name = "same-file"
|
||||
version = "1.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
|
||||
dependencies = [
|
||||
"winapi-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde"
|
||||
version = "1.0.228"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
|
||||
dependencies = [
|
||||
"serde_core",
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_core"
|
||||
version = "1.0.228"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
|
||||
dependencies = [
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_derive"
|
||||
version = "1.0.228"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_json"
|
||||
version = "1.0.149"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
|
||||
dependencies = [
|
||||
"itoa 1.0.17",
|
||||
"memchr",
|
||||
"serde",
|
||||
"serde_core",
|
||||
"zmij",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "shlex"
|
||||
version = "1.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "2.0.117"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tinytemplate"
|
||||
version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.24"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
|
||||
|
||||
[[package]]
|
||||
name = "walkdir"
|
||||
version = "2.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
|
||||
dependencies = [
|
||||
"same-file",
|
||||
"winapi-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi"
|
||||
version = "0.3.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
|
||||
dependencies = [
|
||||
"winapi-i686-pc-windows-gnu",
|
||||
"winapi-x86_64-pc-windows-gnu",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi-i686-pc-windows-gnu"
|
||||
version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
|
||||
|
||||
[[package]]
|
||||
name = "winapi-util"
|
||||
version = "0.1.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
|
||||
dependencies = [
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi-x86_64-pc-windows-gnu"
|
||||
version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
|
||||
|
||||
[[package]]
|
||||
name = "windows-link"
|
||||
version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
|
||||
|
||||
[[package]]
|
||||
name = "windows-sys"
|
||||
version = "0.61.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
|
||||
dependencies = [
|
||||
"windows-link",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy"
|
||||
version = "0.8.47"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "efbb2a062be311f2ba113ce66f697a4dc589f85e78a4aea276200804cea0ed87"
|
||||
dependencies = [
|
||||
"zerocopy-derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy-derive"
|
||||
version = "0.8.47"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0e8bc7269b54418e7aeeef514aa68f8690b8c0489a06b0136e5f57c4c5ccab89"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zmij"
|
||||
version = "1.0.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
|
||||
Vendored
+66
@@ -0,0 +1,66 @@
|
||||
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
|
||||
#
|
||||
# When uploading crates to the registry Cargo will automatically
|
||||
# "normalize" Cargo.toml files for maximal compatibility
|
||||
# with all versions of Cargo and also rewrite `path` dependencies
|
||||
# to registry (e.g., crates.io) dependencies.
|
||||
#
|
||||
# If you are reading this file be aware that the original Cargo.toml
|
||||
# will likely look very different (and much more reasonable).
|
||||
# See Cargo.toml.orig for the original contents.
|
||||
|
||||
[package]
|
||||
edition = "2021"
|
||||
rust-version = "1.68"
|
||||
name = "itoa"
|
||||
version = "1.0.18"
|
||||
authors = ["David Tolnay <dtolnay@gmail.com>"]
|
||||
build = false
|
||||
exclude = ["*.png"]
|
||||
autolib = false
|
||||
autobins = false
|
||||
autoexamples = false
|
||||
autotests = false
|
||||
autobenches = false
|
||||
description = "Fast integer primitive to string conversion"
|
||||
documentation = "https://docs.rs/itoa"
|
||||
readme = "README.md"
|
||||
keywords = ["integer"]
|
||||
categories = [
|
||||
"value-formatting",
|
||||
"no-std",
|
||||
"no-std::no-alloc",
|
||||
]
|
||||
license = "MIT OR Apache-2.0"
|
||||
repository = "https://github.com/dtolnay/itoa"
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
targets = ["x86_64-unknown-linux-gnu"]
|
||||
rustdoc-args = [
|
||||
"--generate-link-to-definition",
|
||||
"--generate-macro-expansion",
|
||||
"--extern-html-root-url=core=https://doc.rust-lang.org",
|
||||
"--extern-html-root-url=alloc=https://doc.rust-lang.org",
|
||||
"--extern-html-root-url=std=https://doc.rust-lang.org",
|
||||
]
|
||||
|
||||
[lib]
|
||||
name = "itoa"
|
||||
path = "src/lib.rs"
|
||||
|
||||
[[test]]
|
||||
name = "test"
|
||||
path = "tests/test.rs"
|
||||
|
||||
[[bench]]
|
||||
name = "bench"
|
||||
path = "benches/bench.rs"
|
||||
harness = false
|
||||
|
||||
[dependencies.no-panic]
|
||||
version = "0.1"
|
||||
optional = true
|
||||
|
||||
[target."cfg(not(miri))".dev-dependencies.criterion]
|
||||
version = "0.8"
|
||||
default-features = false
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
[package]
|
||||
name = "itoa"
|
||||
version = "1.0.18"
|
||||
authors = ["David Tolnay <dtolnay@gmail.com>"]
|
||||
categories = ["value-formatting", "no-std", "no-std::no-alloc"]
|
||||
description = "Fast integer primitive to string conversion"
|
||||
documentation = "https://docs.rs/itoa"
|
||||
edition = "2021"
|
||||
exclude = ["*.png"]
|
||||
keywords = ["integer"]
|
||||
license = "MIT OR Apache-2.0"
|
||||
repository = "https://github.com/dtolnay/itoa"
|
||||
rust-version = "1.68"
|
||||
|
||||
[dependencies]
|
||||
no-panic = { version = "0.1", optional = true }
|
||||
|
||||
[target.'cfg(not(miri))'.dev-dependencies]
|
||||
criterion = { version = "0.8", default-features = false }
|
||||
|
||||
[[bench]]
|
||||
name = "bench"
|
||||
harness = false
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
targets = ["x86_64-unknown-linux-gnu"]
|
||||
rustdoc-args = [
|
||||
"--generate-link-to-definition",
|
||||
"--generate-macro-expansion",
|
||||
"--extern-html-root-url=core=https://doc.rust-lang.org",
|
||||
"--extern-html-root-url=alloc=https://doc.rust-lang.org",
|
||||
"--extern-html-root-url=std=https://doc.rust-lang.org",
|
||||
]
|
||||
Vendored
+176
@@ -0,0 +1,176 @@
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
Vendored
+23
@@ -0,0 +1,23 @@
|
||||
Permission is hereby granted, free of charge, to any
|
||||
person obtaining a copy of this software and associated
|
||||
documentation files (the "Software"), to deal in the
|
||||
Software without restriction, including without
|
||||
limitation the rights to use, copy, modify, merge,
|
||||
publish, distribute, sublicense, and/or sell copies of
|
||||
the Software, and to permit persons to whom the Software
|
||||
is furnished to do so, subject to the following
|
||||
conditions:
|
||||
|
||||
The above copyright notice and this permission notice
|
||||
shall be included in all copies or substantial portions
|
||||
of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
DEALINGS IN THE SOFTWARE.
|
||||
Vendored
+65
@@ -0,0 +1,65 @@
|
||||
itoa
|
||||
====
|
||||
|
||||
[<img alt="github" src="https://img.shields.io/badge/github-dtolnay/itoa-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/dtolnay/itoa)
|
||||
[<img alt="crates.io" src="https://img.shields.io/crates/v/itoa.svg?style=for-the-badge&color=fc8d62&logo=rust" height="20">](https://crates.io/crates/itoa)
|
||||
[<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-itoa-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs" height="20">](https://docs.rs/itoa)
|
||||
[<img alt="build status" src="https://img.shields.io/github/actions/workflow/status/dtolnay/itoa/ci.yml?branch=master&style=for-the-badge" height="20">](https://github.com/dtolnay/itoa/actions?query=branch%3Amaster)
|
||||
|
||||
This crate provides a fast conversion of integer primitives to decimal strings.
|
||||
The implementation comes straight from [libcore] but avoids the performance
|
||||
penalty of going through [`core::fmt::Formatter`].
|
||||
|
||||
See also [`zmij`] for printing floating point primitives.
|
||||
|
||||
[libcore]: https://github.com/rust-lang/rust/blob/1.92.0/library/core/src/fmt/num.rs#L190-L253
|
||||
[`core::fmt::Formatter`]: https://doc.rust-lang.org/std/fmt/struct.Formatter.html
|
||||
[`zmij`]: https://github.com/dtolnay/zmij
|
||||
|
||||
```toml
|
||||
[dependencies]
|
||||
itoa = "1.0"
|
||||
```
|
||||
|
||||
<br>
|
||||
|
||||
## Example
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let mut buffer = itoa::Buffer::new();
|
||||
let printed = buffer.format(128u64);
|
||||
assert_eq!(printed, "128");
|
||||
}
|
||||
```
|
||||
|
||||
<br>
|
||||
|
||||
## Performance
|
||||
|
||||
The [itoa-benchmark] compares this library and other Rust integer formatting
|
||||
implementations across a range of integer sizes. The vertical axis in this chart
|
||||
shows nanoseconds taken by a single execution of
|
||||
`itoa::Buffer::new().format(value)` so a lower result indicates a faster
|
||||
library.
|
||||
|
||||
[itoa-benchmark]: https://github.com/dtolnay/itoa-benchmark
|
||||
|
||||

|
||||
|
||||
<br>
|
||||
|
||||
#### License
|
||||
|
||||
<sup>
|
||||
Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
|
||||
2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
|
||||
</sup>
|
||||
|
||||
<br>
|
||||
|
||||
<sub>
|
||||
Unless you explicitly state otherwise, any contribution intentionally submitted
|
||||
for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
|
||||
be dual licensed as above, without any additional terms or conditions.
|
||||
</sub>
|
||||
Vendored
+41
@@ -0,0 +1,41 @@
|
||||
use criterion::{criterion_group, criterion_main, Criterion};
|
||||
use std::fmt::Display;
|
||||
use std::hint;
|
||||
use std::io::Write;
|
||||
|
||||
fn do_bench(c: &mut Criterion, group_name: &str, int: impl itoa::Integer + Display) {
|
||||
let mut group = c.benchmark_group(group_name);
|
||||
group.bench_function("itoa", |b| {
|
||||
let mut buf = itoa::Buffer::new();
|
||||
b.iter(move || {
|
||||
let int = hint::black_box(int);
|
||||
let formatted = buf.format(int);
|
||||
hint::black_box(formatted);
|
||||
});
|
||||
});
|
||||
group.bench_function("std::fmt", |b| {
|
||||
let mut buf = Vec::with_capacity(20);
|
||||
b.iter(|| {
|
||||
buf.clear();
|
||||
let int = hint::black_box(int);
|
||||
write!(&mut buf, "{int}").unwrap();
|
||||
hint::black_box(buf.as_slice());
|
||||
});
|
||||
});
|
||||
group.finish();
|
||||
}
|
||||
|
||||
fn bench(c: &mut Criterion) {
|
||||
do_bench(c, "u64[0]", 0u64);
|
||||
do_bench(c, "u64[half]", u64::from(u32::MAX));
|
||||
do_bench(c, "u64[max]", u64::MAX);
|
||||
|
||||
do_bench(c, "i16[0]", 0i16);
|
||||
do_bench(c, "i16[min]", i16::MIN);
|
||||
|
||||
do_bench(c, "u128[0]", 0u128);
|
||||
do_bench(c, "u128[max]", u128::MAX);
|
||||
}
|
||||
|
||||
criterion_group!(benches, bench);
|
||||
criterion_main!(benches);
|
||||
Vendored
+466
@@ -0,0 +1,466 @@
|
||||
//! [![github]](https://github.com/dtolnay/itoa) [![crates-io]](https://crates.io/crates/itoa) [![docs-rs]](https://docs.rs/itoa)
|
||||
//!
|
||||
//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
|
||||
//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
|
||||
//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs
|
||||
//!
|
||||
//! <br>
|
||||
//!
|
||||
//! This crate provides a fast conversion of integer primitives to decimal
|
||||
//! strings. The implementation comes straight from [libcore] but avoids the
|
||||
//! performance penalty of going through [`core::fmt::Formatter`].
|
||||
//!
|
||||
//! See also [`zmij`] for printing floating point primitives.
|
||||
//!
|
||||
//! [libcore]: https://github.com/rust-lang/rust/blob/1.92.0/library/core/src/fmt/num.rs#L190-L253
|
||||
//! [`zmij`]: https://github.com/dtolnay/zmij
|
||||
//!
|
||||
//! # Example
|
||||
//!
|
||||
//! ```
|
||||
//! fn main() {
|
||||
//! let mut buffer = itoa::Buffer::new();
|
||||
//! let printed = buffer.format(128u64);
|
||||
//! assert_eq!(printed, "128");
|
||||
//! }
|
||||
//! ```
|
||||
//!
|
||||
//! # Performance
|
||||
//!
|
||||
//! The [itoa-benchmark] compares this library and other Rust integer formatting
|
||||
//! implementations across a range of integer sizes. The vertical axis in this
|
||||
//! chart shows nanoseconds taken by a single execution of
|
||||
//! `itoa::Buffer::new().format(value)` so a lower result indicates a faster
|
||||
//! library.
|
||||
//!
|
||||
//! [itoa-benchmark]: https://github.com/dtolnay/itoa-benchmark
|
||||
//!
|
||||
//! 
|
||||
|
||||
#![doc(html_root_url = "https://docs.rs/itoa/1.0.18")]
|
||||
#![no_std]
|
||||
#![allow(
|
||||
clippy::cast_lossless,
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::cast_sign_loss,
|
||||
clippy::expl_impl_clone_on_copy,
|
||||
clippy::identity_op,
|
||||
clippy::items_after_statements,
|
||||
clippy::must_use_candidate,
|
||||
clippy::needless_doctest_main,
|
||||
clippy::unreadable_literal
|
||||
)]
|
||||
|
||||
mod u128_ext;
|
||||
|
||||
use core::hint;
|
||||
use core::mem::{self, MaybeUninit};
|
||||
use core::str;
|
||||
#[cfg(feature = "no-panic")]
|
||||
use no_panic::no_panic;
|
||||
|
||||
/// A correctly sized stack allocation for the formatted integer to be written
|
||||
/// into.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// let mut buffer = itoa::Buffer::new();
|
||||
/// let printed = buffer.format(1234);
|
||||
/// assert_eq!(printed, "1234");
|
||||
/// ```
|
||||
pub struct Buffer {
|
||||
bytes: [MaybeUninit<u8>; i128::MAX_STR_LEN],
|
||||
}
|
||||
|
||||
impl Default for Buffer {
|
||||
#[inline]
|
||||
fn default() -> Buffer {
|
||||
Buffer::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl Copy for Buffer {}
|
||||
|
||||
#[allow(clippy::non_canonical_clone_impl)]
|
||||
impl Clone for Buffer {
|
||||
#[inline]
|
||||
fn clone(&self) -> Self {
|
||||
Buffer::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl Buffer {
|
||||
/// This is a cheap operation; you don't need to worry about reusing buffers
|
||||
/// for efficiency.
|
||||
#[inline]
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
pub fn new() -> Buffer {
|
||||
let bytes = [MaybeUninit::<u8>::uninit(); i128::MAX_STR_LEN];
|
||||
Buffer { bytes }
|
||||
}
|
||||
|
||||
/// Print an integer into this buffer and return a reference to its string
|
||||
/// representation within the buffer.
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
pub fn format<I: Integer>(&mut self, i: I) -> &str {
|
||||
let buf_ptr = self.bytes.as_mut_ptr().cast::<I::Buffer>();
|
||||
let string = i.write(unsafe { &mut *buf_ptr });
|
||||
if string.len() > I::MAX_STR_LEN {
|
||||
unsafe { hint::unreachable_unchecked() };
|
||||
}
|
||||
string
|
||||
}
|
||||
}
|
||||
|
||||
/// An integer that can be written into an [`itoa::Buffer`][Buffer].
|
||||
///
|
||||
/// This trait is sealed and cannot be implemented for types outside of itoa.
|
||||
pub trait Integer: private::Sealed {
|
||||
/// The maximum length of string that formatting an integer of this type can
|
||||
/// produce on the current target platform.
|
||||
const MAX_STR_LEN: usize;
|
||||
}
|
||||
|
||||
// Seal to prevent downstream implementations of the Integer trait.
|
||||
mod private {
|
||||
#[doc(hidden)]
|
||||
pub trait Sealed: Copy {
|
||||
#[doc(hidden)]
|
||||
type Buffer: 'static;
|
||||
fn write(self, buf: &mut Self::Buffer) -> &str;
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! impl_Integer {
|
||||
($Signed:ident, $Unsigned:ident) => {
|
||||
const _: () = {
|
||||
assert!($Signed::MIN < 0, "need signed");
|
||||
assert!($Unsigned::MIN == 0, "need unsigned");
|
||||
assert!($Signed::BITS == $Unsigned::BITS, "need counterparts");
|
||||
};
|
||||
|
||||
impl Integer for $Unsigned {
|
||||
const MAX_STR_LEN: usize = $Unsigned::MAX.ilog10() as usize + 1;
|
||||
}
|
||||
|
||||
impl private::Sealed for $Unsigned {
|
||||
type Buffer = [MaybeUninit<u8>; Self::MAX_STR_LEN];
|
||||
|
||||
#[inline]
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
fn write(self, buf: &mut Self::Buffer) -> &str {
|
||||
let offset = Unsigned::fmt(self, buf);
|
||||
// SAFETY: Starting from `offset`, all elements of the slice have been set.
|
||||
unsafe { slice_buffer_to_str(buf, offset) }
|
||||
}
|
||||
}
|
||||
|
||||
impl Integer for $Signed {
|
||||
const MAX_STR_LEN: usize = $Signed::MAX.ilog10() as usize + 2;
|
||||
}
|
||||
|
||||
impl private::Sealed for $Signed {
|
||||
type Buffer = [MaybeUninit<u8>; Self::MAX_STR_LEN];
|
||||
|
||||
#[inline]
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
fn write(self, buf: &mut Self::Buffer) -> &str {
|
||||
let mut offset = Self::MAX_STR_LEN - $Unsigned::MAX_STR_LEN;
|
||||
offset += Unsigned::fmt(
|
||||
self.unsigned_abs(),
|
||||
(&mut buf[offset..]).try_into().unwrap(),
|
||||
);
|
||||
if self < 0 {
|
||||
offset -= 1;
|
||||
buf[offset].write(b'-');
|
||||
}
|
||||
// SAFETY: Starting from `offset`, all elements of the slice have been set.
|
||||
unsafe { slice_buffer_to_str(buf, offset) }
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
impl_Integer!(i8, u8);
|
||||
impl_Integer!(i16, u16);
|
||||
impl_Integer!(i32, u32);
|
||||
impl_Integer!(i64, u64);
|
||||
impl_Integer!(i128, u128);
|
||||
|
||||
macro_rules! impl_Integer_size {
|
||||
($t:ty as $primitive:ident #[cfg(target_pointer_width = $width:literal)]) => {
|
||||
#[cfg(target_pointer_width = $width)]
|
||||
impl Integer for $t {
|
||||
const MAX_STR_LEN: usize = <$primitive as Integer>::MAX_STR_LEN;
|
||||
}
|
||||
|
||||
#[cfg(target_pointer_width = $width)]
|
||||
impl private::Sealed for $t {
|
||||
type Buffer = <$primitive as private::Sealed>::Buffer;
|
||||
|
||||
#[inline]
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
fn write(self, buf: &mut Self::Buffer) -> &str {
|
||||
(self as $primitive).write(buf)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
impl_Integer_size!(isize as i16 #[cfg(target_pointer_width = "16")]);
|
||||
impl_Integer_size!(usize as u16 #[cfg(target_pointer_width = "16")]);
|
||||
impl_Integer_size!(isize as i32 #[cfg(target_pointer_width = "32")]);
|
||||
impl_Integer_size!(usize as u32 #[cfg(target_pointer_width = "32")]);
|
||||
impl_Integer_size!(isize as i64 #[cfg(target_pointer_width = "64")]);
|
||||
impl_Integer_size!(usize as u64 #[cfg(target_pointer_width = "64")]);
|
||||
|
||||
#[repr(C, align(2))]
|
||||
struct DecimalPairs([u8; 200]);
|
||||
|
||||
// The string of all two-digit numbers in range 00..99 is used as a lookup table.
|
||||
static DECIMAL_PAIRS: DecimalPairs = DecimalPairs(
|
||||
*b"0001020304050607080910111213141516171819\
|
||||
2021222324252627282930313233343536373839\
|
||||
4041424344454647484950515253545556575859\
|
||||
6061626364656667686970717273747576777879\
|
||||
8081828384858687888990919293949596979899",
|
||||
);
|
||||
|
||||
// Returns {value / 100, value % 100} correct for values of up to 4 digits.
|
||||
fn divmod100(value: u32) -> (u32, u32) {
|
||||
debug_assert!(value < 10_000);
|
||||
const EXP: u32 = 19; // 19 is faster or equal to 12 even for 3 digits.
|
||||
const SIG: u32 = (1 << EXP) / 100 + 1;
|
||||
let div = (value * SIG) >> EXP; // value / 100
|
||||
(div, value - div * 100)
|
||||
}
|
||||
|
||||
/// This function converts a slice of ascii characters into a `&str` starting
|
||||
/// from `offset`.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// `buf` content starting from `offset` index MUST BE initialized and MUST BE
|
||||
/// ascii characters.
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
unsafe fn slice_buffer_to_str(buf: &[MaybeUninit<u8>], offset: usize) -> &str {
|
||||
// SAFETY: `offset` is always included between 0 and `buf`'s length.
|
||||
let written = unsafe { buf.get_unchecked(offset..) };
|
||||
// SAFETY: (`assume_init_ref`) All buf content since offset is set.
|
||||
// SAFETY: (`from_utf8_unchecked`) Writes use ASCII from the lookup table exclusively.
|
||||
unsafe { str::from_utf8_unchecked(&*(written as *const [MaybeUninit<u8>] as *const [u8])) }
|
||||
}
|
||||
|
||||
trait Unsigned: Integer {
|
||||
fn fmt(self, buf: &mut Self::Buffer) -> usize;
|
||||
}
|
||||
|
||||
macro_rules! impl_Unsigned {
|
||||
($Unsigned:ident) => {
|
||||
impl Unsigned for $Unsigned {
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
fn fmt(self, buf: &mut Self::Buffer) -> usize {
|
||||
// Count the number of bytes in buf that are not initialized.
|
||||
let mut offset = buf.len();
|
||||
// Consume the least-significant decimals from a working copy.
|
||||
let mut remain = self;
|
||||
|
||||
// Format per four digits from the lookup table.
|
||||
// Four digits need a 16-bit $Unsigned or wider.
|
||||
while mem::size_of::<Self>() > 1
|
||||
&& remain
|
||||
> 999
|
||||
.try_into()
|
||||
.expect("branch is not hit for types that cannot fit 999 (u8)")
|
||||
{
|
||||
offset -= 4;
|
||||
|
||||
// pull two pairs
|
||||
let scale: Self = 1_00_00
|
||||
.try_into()
|
||||
.expect("branch is not hit for types that cannot fit 1E4 (u8)");
|
||||
let quad = remain % scale;
|
||||
remain /= scale;
|
||||
let (pair1, pair2) = divmod100(quad as u32);
|
||||
unsafe {
|
||||
buf[offset + 0]
|
||||
.write(*DECIMAL_PAIRS.0.get_unchecked(pair1 as usize * 2 + 0));
|
||||
buf[offset + 1]
|
||||
.write(*DECIMAL_PAIRS.0.get_unchecked(pair1 as usize * 2 + 1));
|
||||
buf[offset + 2]
|
||||
.write(*DECIMAL_PAIRS.0.get_unchecked(pair2 as usize * 2 + 0));
|
||||
buf[offset + 3]
|
||||
.write(*DECIMAL_PAIRS.0.get_unchecked(pair2 as usize * 2 + 1));
|
||||
}
|
||||
}
|
||||
|
||||
// Format per two digits from the lookup table.
|
||||
if remain > 9 {
|
||||
offset -= 2;
|
||||
|
||||
let (last, pair) = divmod100(remain as u32);
|
||||
remain = last as Self;
|
||||
unsafe {
|
||||
buf[offset + 0]
|
||||
.write(*DECIMAL_PAIRS.0.get_unchecked(pair as usize * 2 + 0));
|
||||
buf[offset + 1]
|
||||
.write(*DECIMAL_PAIRS.0.get_unchecked(pair as usize * 2 + 1));
|
||||
}
|
||||
}
|
||||
|
||||
// Format the last remaining digit, if any.
|
||||
if remain != 0 || self == 0 {
|
||||
offset -= 1;
|
||||
|
||||
// Either the compiler sees that remain < 10, or it prevents
|
||||
// a boundary check up next.
|
||||
let last = remain as u8 & 15;
|
||||
buf[offset].write(b'0' + last);
|
||||
// not used: remain = 0;
|
||||
}
|
||||
|
||||
offset
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
impl_Unsigned!(u8);
|
||||
impl_Unsigned!(u16);
|
||||
impl_Unsigned!(u32);
|
||||
impl_Unsigned!(u64);
|
||||
|
||||
impl Unsigned for u128 {
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
fn fmt(self, buf: &mut Self::Buffer) -> usize {
|
||||
// Optimize common-case zero, which would also need special treatment due to
|
||||
// its "leading" zero.
|
||||
if self == 0 {
|
||||
let offset = buf.len() - 1;
|
||||
buf[offset].write(b'0');
|
||||
return offset;
|
||||
}
|
||||
// Take the 16 least-significant decimals.
|
||||
let (quot_1e16, mod_1e16) = div_rem_1e16(self);
|
||||
let (mut remain, mut offset) = if quot_1e16 == 0 {
|
||||
(mod_1e16, u128::MAX_STR_LEN)
|
||||
} else {
|
||||
// Write digits at buf[23..39].
|
||||
enc_16lsd::<{ u128::MAX_STR_LEN - 16 }>(buf, mod_1e16);
|
||||
|
||||
// Take another 16 decimals.
|
||||
let (quot2, mod2) = div_rem_1e16(quot_1e16);
|
||||
if quot2 == 0 {
|
||||
(mod2, u128::MAX_STR_LEN - 16)
|
||||
} else {
|
||||
// Write digits at buf[7..23].
|
||||
enc_16lsd::<{ u128::MAX_STR_LEN - 32 }>(buf, mod2);
|
||||
// Quot2 has at most 7 decimals remaining after two 1e16 divisions.
|
||||
(quot2 as u64, u128::MAX_STR_LEN - 32)
|
||||
}
|
||||
};
|
||||
|
||||
// Format per four digits from the lookup table.
|
||||
while remain > 999 {
|
||||
offset -= 4;
|
||||
|
||||
// pull two pairs
|
||||
let quad = remain % 1_00_00;
|
||||
remain /= 1_00_00;
|
||||
let (pair1, pair2) = divmod100(quad as u32);
|
||||
unsafe {
|
||||
buf[offset + 0].write(*DECIMAL_PAIRS.0.get_unchecked(pair1 as usize * 2 + 0));
|
||||
buf[offset + 1].write(*DECIMAL_PAIRS.0.get_unchecked(pair1 as usize * 2 + 1));
|
||||
buf[offset + 2].write(*DECIMAL_PAIRS.0.get_unchecked(pair2 as usize * 2 + 0));
|
||||
buf[offset + 3].write(*DECIMAL_PAIRS.0.get_unchecked(pair2 as usize * 2 + 1));
|
||||
}
|
||||
}
|
||||
|
||||
// Format per two digits from the lookup table.
|
||||
if remain > 9 {
|
||||
offset -= 2;
|
||||
|
||||
let (last, pair) = divmod100(remain as u32);
|
||||
remain = last as u64;
|
||||
unsafe {
|
||||
buf[offset + 0].write(*DECIMAL_PAIRS.0.get_unchecked(pair as usize * 2 + 0));
|
||||
buf[offset + 1].write(*DECIMAL_PAIRS.0.get_unchecked(pair as usize * 2 + 1));
|
||||
}
|
||||
}
|
||||
|
||||
// Format the last remaining digit, if any.
|
||||
if remain != 0 {
|
||||
offset -= 1;
|
||||
|
||||
// Either the compiler sees that remain < 10, or it prevents
|
||||
// a boundary check up next.
|
||||
let last = remain as u8 & 15;
|
||||
buf[offset].write(b'0' + last);
|
||||
// not used: remain = 0;
|
||||
}
|
||||
offset
|
||||
}
|
||||
}
|
||||
|
||||
// Encodes the 16 least-significant decimals of n into `buf[OFFSET..OFFSET + 16]`.
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
fn enc_16lsd<const OFFSET: usize>(buf: &mut [MaybeUninit<u8>], n: u64) {
|
||||
// Consume the least-significant decimals from a working copy.
|
||||
let mut remain = n;
|
||||
|
||||
// Format per four digits from the lookup table.
|
||||
for quad_index in (1..4).rev() {
|
||||
// pull two pairs
|
||||
let quad = remain % 1_00_00;
|
||||
remain /= 1_00_00;
|
||||
let (pair1, pair2) = divmod100(quad as u32);
|
||||
unsafe {
|
||||
buf[quad_index * 4 + OFFSET + 0]
|
||||
.write(*DECIMAL_PAIRS.0.get_unchecked(pair1 as usize * 2 + 0));
|
||||
buf[quad_index * 4 + OFFSET + 1]
|
||||
.write(*DECIMAL_PAIRS.0.get_unchecked(pair1 as usize * 2 + 1));
|
||||
buf[quad_index * 4 + OFFSET + 2]
|
||||
.write(*DECIMAL_PAIRS.0.get_unchecked(pair2 as usize * 2 + 0));
|
||||
buf[quad_index * 4 + OFFSET + 3]
|
||||
.write(*DECIMAL_PAIRS.0.get_unchecked(pair2 as usize * 2 + 1));
|
||||
}
|
||||
}
|
||||
|
||||
// final two pairs
|
||||
let (pair1, pair2) = divmod100(remain as u32);
|
||||
unsafe {
|
||||
buf[OFFSET + 0].write(*DECIMAL_PAIRS.0.get_unchecked(pair1 as usize * 2 + 0));
|
||||
buf[OFFSET + 1].write(*DECIMAL_PAIRS.0.get_unchecked(pair1 as usize * 2 + 1));
|
||||
buf[OFFSET + 2].write(*DECIMAL_PAIRS.0.get_unchecked(pair2 as usize * 2 + 0));
|
||||
buf[OFFSET + 3].write(*DECIMAL_PAIRS.0.get_unchecked(pair2 as usize * 2 + 1));
|
||||
}
|
||||
}
|
||||
|
||||
// Euclidean division plus remainder with constant 1E16 basically consumes 16
|
||||
// decimals from n.
|
||||
//
|
||||
// The integer division algorithm is based on the following paper:
|
||||
//
|
||||
// T. Granlund and P. Montgomery, “Division by Invariant Integers Using Multiplication”
|
||||
// in Proc. of the SIGPLAN94 Conference on Programming Language Design and
|
||||
// Implementation, 1994, pp. 61–72
|
||||
//
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
fn div_rem_1e16(n: u128) -> (u128, u64) {
|
||||
const D: u128 = 1_0000_0000_0000_0000;
|
||||
// The check inlines well with the caller flow.
|
||||
if n < D {
|
||||
return (0, n as u64);
|
||||
}
|
||||
|
||||
// These constant values are computed with the CHOOSE_MULTIPLIER procedure
|
||||
// from the Granlund & Montgomery paper, using N=128, prec=128 and d=1E16.
|
||||
const M_HIGH: u128 = 76624777043294442917917351357515459181;
|
||||
const SH_POST: u8 = 51;
|
||||
|
||||
// n.widening_mul(M_HIGH).1 >> SH_POST
|
||||
let quot = u128_ext::mulhi(n, M_HIGH) >> SH_POST;
|
||||
let rem = n - quot * D;
|
||||
(quot, rem as u64)
|
||||
}
|
||||
Vendored
+22
@@ -0,0 +1,22 @@
|
||||
#[cfg(feature = "no-panic")]
|
||||
use no_panic::no_panic;
|
||||
|
||||
/// Multiply unsigned 128 bit integers, return upper 128 bits of the result
|
||||
#[inline]
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
pub(crate) fn mulhi(x: u128, y: u128) -> u128 {
|
||||
let x_lo = x as u64;
|
||||
let x_hi = (x >> 64) as u64;
|
||||
let y_lo = y as u64;
|
||||
let y_hi = (y >> 64) as u64;
|
||||
|
||||
// handle possibility of overflow
|
||||
let carry = (u128::from(x_lo) * u128::from(y_lo)) >> 64;
|
||||
let m = u128::from(x_lo) * u128::from(y_hi) + carry;
|
||||
let high1 = m >> 64;
|
||||
|
||||
let m_lo = m as u64;
|
||||
let high2 = (u128::from(x_hi) * u128::from(y_lo) + u128::from(m_lo)) >> 64;
|
||||
|
||||
u128::from(x_hi) * u128::from(y_hi) + high1 + high2
|
||||
}
|
||||
Vendored
+45
@@ -0,0 +1,45 @@
|
||||
#![allow(non_snake_case)]
|
||||
|
||||
macro_rules! test {
|
||||
($($name:ident($value:expr, $expected:expr))*) => {
|
||||
$(
|
||||
#[test]
|
||||
fn $name() {
|
||||
let mut buffer = itoa::Buffer::new();
|
||||
let s = buffer.format($value);
|
||||
assert_eq!(s, $expected);
|
||||
}
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
test! {
|
||||
test_u64_0(0u64, "0")
|
||||
test_u64_half(u64::from(u32::MAX), "4294967295")
|
||||
test_u64_max(u64::MAX, "18446744073709551615")
|
||||
test_i64_min(i64::MIN, "-9223372036854775808")
|
||||
|
||||
test_i16_0(0i16, "0")
|
||||
test_i16_min(i16::MIN, "-32768")
|
||||
|
||||
test_u128_0(0u128, "0")
|
||||
test_u128_max(u128::MAX, "340282366920938463463374607431768211455")
|
||||
test_i128_min(i128::MIN, "-170141183460469231731687303715884105728")
|
||||
test_i128_max(i128::MAX, "170141183460469231731687303715884105727")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_max_str_len() {
|
||||
use itoa::Integer as _;
|
||||
|
||||
assert_eq!(i8::MAX_STR_LEN, 4);
|
||||
assert_eq!(u8::MAX_STR_LEN, 3);
|
||||
assert_eq!(i16::MAX_STR_LEN, 6);
|
||||
assert_eq!(u16::MAX_STR_LEN, 5);
|
||||
assert_eq!(i32::MAX_STR_LEN, 11);
|
||||
assert_eq!(u32::MAX_STR_LEN, 10);
|
||||
assert_eq!(i64::MAX_STR_LEN, 20);
|
||||
assert_eq!(u64::MAX_STR_LEN, 20);
|
||||
assert_eq!(i128::MAX_STR_LEN, 40);
|
||||
assert_eq!(u128::MAX_STR_LEN, 39);
|
||||
}
|
||||
+1
File diff suppressed because one or more lines are too long
+6
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"git": {
|
||||
"sha1": "5fdb40c054e1fff359a2f7bdf7f87a13b34b465d"
|
||||
},
|
||||
"path_in_vcs": ""
|
||||
}
|
||||
Vendored
+1
@@ -0,0 +1 @@
|
||||
!.github
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
{
|
||||
"rust-analyzer.cargo.allFeatures": false,
|
||||
"rust-analyzer.linkedProjects": [
|
||||
"benchmarks/engines/libc/Cargo.toml",
|
||||
"benchmarks/engines/rust-bytecount/Cargo.toml",
|
||||
"benchmarks/engines/rust-jetscii/Cargo.toml",
|
||||
"benchmarks/engines/rust-memchr/Cargo.toml",
|
||||
"benchmarks/engines/rust-memchrold/Cargo.toml",
|
||||
"benchmarks/engines/rust-sliceslice/Cargo.toml",
|
||||
"benchmarks/engines/rust-std/Cargo.toml",
|
||||
"benchmarks/engines/stringzilla/Cargo.toml",
|
||||
"benchmarks/shared/Cargo.toml",
|
||||
"fuzz/Cargo.toml",
|
||||
"Cargo.toml"
|
||||
]
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user