perf(vdf): optimize hot loop with direct compress256 and copy elimination (#1214)

* perf(vdf): replace Sha256 API with direct compress256 in hot loop

* perf(vdf): eliminate per-iteration 32-byte copy in hot loop

* refactor(vdf): review comments

* refactor(vdf): review comments

* refactor(vdf): review comments

* chore(ci): restrict benchmark workflow to PR creation, approval, and merge

* fix(bench): update vdf_bench to match rebased vdf_sha signature

* fix(vdf): add debug_assert for checkpoint length in vdf_sha

* fix(ci): handle workflow_dispatch branch detection in bench workflow

* refactor(vdf): address review findings for vdf optimisation PR

* refactor(chain-tests): remove unused vdf imports

* refactor(vdf): extract compress_n_rounds and remove redundant comments

* fix(vdf): qualify size_of/align_of for Rust 2024 edition

* feat(ci): seed branch benchmarks with master baseline

Author: glottologist

.github/workflows/bench.yml

@@ -9,7 +9,7 @@ concurrency:
 
 on:
   pull_request:
-    types: [opened, synchronize, closed]
+    types: [opened, closed]
   pull_request_review:
     types: [submitted]
   push:
@@ -29,106 +29,36 @@ jobs:
     outputs:
       should-run: ${{ steps.set-output.outputs.should-run }}
     steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Check if CI should run
+      - name: Check if benchmarks should run
         id: set-output
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_DISABLE_CI: ${{ contains(github.event.pull_request.body, '#disable-ci') }}
+          COMMIT_DISABLE_CI: ${{ contains(github.event.head_commit.message, '#disable-ci') }}
         run: |
-          # default to running
-          SHOULD_RUN=true
-
-          # this string disables CI if a commit/branch description includes it
-          DISABLE_CI_STRING="#disable-ci"
-
-          # check if CI is disabled in the commit message (for any event type)
-          if [[ "${{ contains(github.event.head_commit.message, '#disable-ci') }}" == "true" ]]; then
-            echo "commit message contains '$DISABLE_CI_STRING', skipping CI..."
-            SHOULD_RUN=false
-          fi
+          SHOULD_RUN=false
 
-          # Function to check if PR description contains disable string
-          check_pr_description() {
-            local pr_number=$1
-            if [[ -n "$pr_number" ]]; then
-              PR_DESCRIPTION=$(curl -s -H "Authorization: token $GITHUB_TOKEN" \
-                "https://api.github.com/repos/${{ github.repository }}/pulls/$pr_number" | \
-                jq --raw-output .body)
-
-              if [[ "$PR_DESCRIPTION" == *"$DISABLE_CI_STRING"* ]]; then
-                echo "PR #$pr_number description contains '$DISABLE_CI_STRING'"
-                return 1
-              fi
-            fi
-            return 0
-          }
-
-          # For push events, check if this commit is part of an open PR
-          if [[ "${{ github.event_name }}" == "push" && "$SHOULD_RUN" == "true" ]]; then
-            COMMIT_SHA="${{ github.event.after }}"
-            ASSOCIATED_PRS=$(curl -s -H "Authorization: token $GITHUB_TOKEN" \
-              "https://api.github.com/repos/${{ github.repository }}/commits/$COMMIT_SHA/pulls" | \
-              jq --raw-output '.[].number')
-
-            if [[ -n "$ASSOCIATED_PRS" ]]; then
-              echo "Found PRs associated with this commit: $ASSOCIATED_PRS"
-
-              ALL_PRS_DISABLED=true
-              PR_COUNT=0
-
-              for PR_NUMBER in $ASSOCIATED_PRS; do
-                PR_COUNT=$((PR_COUNT+1))
-                if check_pr_description "$PR_NUMBER"; then
-                  echo "PR #$PR_NUMBER doesn't have the disable string, will run CI"
-                  ALL_PRS_DISABLED=false
-                fi
-              done
-
-              if [[ "$ALL_PRS_DISABLED" == "true" && "$PR_COUNT" -gt 0 ]]; then
-                echo "All $PR_COUNT associated PRs have the disable string, skipping CI"
-                SHOULD_RUN=false
-              fi
-            else
-              echo "No open PRs found associated with this commit"
-            fi
-          fi
-
-          # For pull_request events, check PR description
-          if [[ "${{ github.event_name }}" == "pull_request" && "$SHOULD_RUN" == "true" ]]; then
-            PR_NUMBER="${{ github.event.pull_request.number }}"
-            if ! check_pr_description "$PR_NUMBER"; then
-              SHOULD_RUN=false
-            fi
+          if [[ "${{ github.event_name }}" == "pull_request" && "${{ github.event.action }}" == "opened" ]]; then
+            SHOULD_RUN=true
           fi
 
-          # For pull_request_review events, only run on approvals; check PR description
-          if [[ "${{ github.event_name }}" == "pull_request_review" && "$SHOULD_RUN" == "true" ]]; then
-            if [[ "${{ github.event.review.state }}" != "approved" ]]; then
-              echo "Review is not an approval, skipping..."
-              SHOULD_RUN=false
-            fi
-
-            if [[ "$SHOULD_RUN" == "true" ]]; then
-              PR_NUMBER="${{ github.event.pull_request.number }}"
-              if ! check_pr_description "$PR_NUMBER"; then
-                SHOULD_RUN=false
-              fi
-            fi
+          if [[ "${{ github.event_name }}" == "pull_request_review" && "${{ github.event.review.state }}" == "approved" ]]; then
+            SHOULD_RUN=true
           fi
 
-          # always run on the default branch
-          if [[ "${{ github.ref }}" == "refs/heads/${{ github.event.repository.default_branch }}" ]]; then
+          if [[ "${{ github.event_name }}" == "push" ]]; then
             SHOULD_RUN=true
           fi
 
-          # always run on workflow_dispatch
           if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
             SHOULD_RUN=true
           fi
 
-          echo "Should run? ${SHOULD_RUN}"
+          if [[ "$PR_DISABLE_CI" == "true" || "$COMMIT_DISABLE_CI" == "true" ]]; then
+            echo "#disable-ci found, skipping benchmarks"
+            SHOULD_RUN=false
+          fi
+
+          echo "Should run benchmarks? ${SHOULD_RUN}"
           echo "should-run=${SHOULD_RUN}" >> $GITHUB_OUTPUT
 
   cleanup-branch-data:
@@ -200,28 +130,64 @@ jobs:
           print(f'Converted {len(results)} benchmarks from ns to ms')
           "
 
+      - name: Seed branch with master baseline
+        if: (github.head_ref || github.ref_name) != github.event.repository.default_branch
+        env:
+          BRANCH_NAME: ${{ github.head_ref || github.ref_name }}
+        run: |
+          git fetch origin gh-pages:gh-pages
+          git worktree add /tmp/gh-pages gh-pages
+
+          BRANCH_DIR="/tmp/gh-pages/dev/bench/$BRANCH_NAME"
+          MASTER_DATA="/tmp/gh-pages/data.js"
+
+          if [ ! -f "$BRANCH_DIR/data.js" ] && [ -f "$MASTER_DATA" ]; then
+            mkdir -p "$BRANCH_DIR"
+            cp "$MASTER_DATA" "$BRANCH_DIR/data.js"
+            cd /tmp/gh-pages
+            git config user.name "github-actions[bot]"
+            git config user.email "github-actions[bot]@users.noreply.github.com"
+            git add "dev/bench/$BRANCH_NAME/data.js"
+            git commit -m "seed: copy master baseline to branch $BRANCH_NAME"
+            git push origin gh-pages
+          else
+            echo "Branch data already exists or no master baseline found, skipping seed"
+          fi
+
+          git worktree remove /tmp/gh-pages
+
       - name: Store benchmark result
         uses: benchmark-action/github-action-benchmark@v1
         with:
           tool: 'customSmallerIsBetter'
           output-file-path: bench-output.json
           github-token: ${{ secrets.GITHUB_TOKEN }}
           auto-push: true
-          benchmark-data-dir-path: ${{ github.head_ref && format('dev/bench/{0}', github.head_ref) || '.' }}
+          benchmark-data-dir-path: ${{ (github.head_ref || github.ref_name) != github.event.repository.default_branch && format('dev/bench/{0}', github.head_ref || github.ref_name) || '.' }}
           alert-threshold: '120%'
           comment-on-alert: true
           fail-on-alert: false
 
       - name: Comment benchmark results URL on PR
-        if: github.head_ref != ''
+        if: (github.head_ref || github.ref_name) != github.event.repository.default_branch
         uses: actions/github-script@v7
         with:
           script: |
-            const prNumber = context.payload.pull_request?.number
+            let prNumber = context.payload.pull_request?.number
               ?? context.payload.review?.pull_request?.number;
+
+            if (!prNumber) {
+              const branch = '${{ github.head_ref || github.ref_name }}';
+              const { data: prs } = await github.rest.pulls.list({
+                ...context.repo,
+                head: `${context.repo.owner}:${branch}`,
+                state: 'open',
+              });
+              prNumber = prs[0]?.number;
+            }
             if (!prNumber) return;
 
-            const branch = '${{ github.head_ref }}';
+            const branch = '${{ github.head_ref || github.ref_name }}';
             const url = `https://irys-xyz.github.io/irys/dev/bench/${encodeURIComponent(branch)}/index.html`;
             const marker = '<!-- benchmark-results-url -->';
             const body = `${marker}\n**Benchmark results:** ${url}`;

Cargo.lock

@@ -80,7 +80,7 @@ assert_matches = "1"
 bytes = "1.5"
 derive_more = { version = "2", features = ["full"] }
 eyre = "0.6"
-sha2 = "0.10"
+sha2 = { version = "0.10", features = ["compress"] }
 rayon = "1.8.0"
 reqwest = "0.12.15"
 color-eyre = "0.6"

Cargo.toml

@@ -62,8 +62,8 @@ use irys_types::{
 use irys_types::{
     HandshakeRequest, HandshakeRequestV2, Interval, PartitionChunkOffset, ProtocolVersion,
 };
+use irys_vdf::compute_step_checkpoints;
 use irys_vdf::state::VdfStateReadonly;
-use irys_vdf::{step_number_to_salt_number, vdf_sha};
 use itertools::Itertools as _;
 use reth::{
     network::{PeerInfo, Peers as _},
@@ -89,6 +89,7 @@ pub async fn capacity_chunk_solution(
     vdf_steps_guard: VdfStateReadonly,
     config: &Config,
     difficulty: U256,
+    reset_seed: H256,
 ) -> SolutionContext {
     // Wait until we have at least 2 new VDF steps so we can compute checkpoints for (step-1, step)
     let max_wait_retries = 20;
@@ -122,25 +123,8 @@ pub async fn capacity_chunk_solution(
             }
         };
 
-        // Calculate last step checkpoints for current_step - 1
-        let mut hasher = Sha256::new();
-        let mut salt = irys_types::U256::from(step_number_to_salt_number(
-            &config.vdf,
-            current_step.saturating_sub(1),
-        ));
-        let mut seed = steps[0];
-
-        let mut checkpoints: Vec<H256> =
-            vec![H256::default(); config.vdf.num_checkpoints_in_vdf_step];
-
-        vdf_sha(
-            &mut hasher,
-            &mut salt,
-            &mut seed,
-            config.vdf.num_checkpoints_in_vdf_step,
-            config.vdf.num_iterations_per_checkpoint(),
-            &mut checkpoints,
-        );
+        let (_seed, checkpoints) =
+            compute_step_checkpoints(&config.vdf, current_step, steps[0], reset_seed);
 
         // Determine recall range for this step
         let recall_range_idx = block_validation::get_recall_range(
@@ -242,27 +226,7 @@ pub async fn capacity_chunk_solution(
         chunk: entropy_chunk,
         vdf_step: current_step,
         checkpoints: H256List(
-            // recompute checkpoints for fallback
-            {
-                let mut h = Sha256::new();
-                let mut s = irys_types::U256::from(step_number_to_salt_number(
-                    &config.vdf,
-                    current_step.saturating_sub(1),
-                ));
-                let mut sd = steps[0];
-                let mut cps: Vec<H256> =
-                    vec![H256::default(); config.vdf.num_checkpoints_in_vdf_step];
-                vdf_sha(
-                    &mut h,
-                    &mut s,
-                    &mut sd,
-                    config.vdf.num_checkpoints_in_vdf_step,
-                    config.vdf.num_iterations_per_checkpoint(),
-                    &mut cps,
-                );
-                H256List(cps)
-            }
-            .0,
+            compute_step_checkpoints(&config.vdf, current_step, steps[0], reset_seed).1,
         ),
         seed: Seed(steps[1]),
         solution_hash,
@@ -3657,21 +3621,15 @@ pub async fn solution_context_with_poa_chunk(
             tokio::time::sleep(std::time::Duration::from_millis(50)).await;
         };
 
-        // Compute checkpoints for (step-1)
-        let mut hasher = Sha256::new();
-        let mut salt =
-            irys_types::U256::from(step_number_to_salt_number(&node_ctx.config.vdf, step - 1));
-        let mut seed = steps[0];
-        let mut checkpoints: Vec<H256> =
-            vec![H256::default(); node_ctx.config.vdf.num_checkpoints_in_vdf_step];
-        vdf_sha(
-            &mut hasher,
-            &mut salt,
-            &mut seed,
-            node_ctx.config.vdf.num_checkpoints_in_vdf_step,
-            node_ctx.config.vdf.num_iterations_per_checkpoint(),
-            &mut checkpoints,
-        );
+        let reset_seed = {
+            let read = node_ctx.block_tree_guard.read();
+            let parent_hash = read.get_max_cumulative_difficulty_block().1;
+            read.get_block(&parent_hash)
+                .map(|b| b.vdf_limiter_info.next_seed)
+                .unwrap_or_default()
+        };
+        let (_seed, checkpoints) =
+            compute_step_checkpoints(&node_ctx.config.vdf, step, steps[0], reset_seed);
 
         // For deterministic linkage without recall-range dependency, use offset 0
         let partition_hash = H256::zero();
@@ -3729,6 +3687,7 @@ pub async fn solution_context(node_ctx: &IrysNodeCtx) -> Result<SolutionContext,
         vdf_steps_guard.clone(),
         &node_ctx.config,
         prev_block.diff,
+        prev_block.vdf_limiter_info.next_seed,
     )
     .await;
     if !was_vdf_enabled {

crates/chain-tests/src/utils.rs

@@ -26,6 +26,7 @@ irys-types = { workspace = true, features = ["test-utils"] }
 irys-database = { workspace = true, features = ["test-utils"] }
 tracing-subscriber.workspace = true
 criterion.workspace = true
+proptest.workspace = true
 
 [[bench]]
 name = "vdf_bench"