diff --git a/proving/prover-floor/sp1-gpu-6.8.1-floor.patch b/proving/prover-floor/sp1-gpu-6.8.1-floor.patch index c66939337..9d257aaa3 100644 --- a/proving/prover-floor/sp1-gpu-6.8.1-floor.patch +++ b/proving/prover-floor/sp1-gpu-6.8.1-floor.patch @@ -1,5 +1,5 @@ diff --git a/sp1-gpu/crates/jagged_tracegen/src/lib.rs b/sp1-gpu/crates/jagged_tracegen/src/lib.rs -index 579f70a..09e73e8 100644 +index 579f70a..2264044 100644 --- a/sp1-gpu/crates/jagged_tracegen/src/lib.rs +++ b/sp1-gpu/crates/jagged_tracegen/src/lib.rs @@ -481,6 +481,33 @@ async fn device_preprocessed_tracegen>( @@ -64,7 +64,81 @@ index 579f70a..09e73e8 100644 log_stacking_height, max_log_row_count, backend, -@@ -984,9 +1021,15 @@ pub async fn full_tracegen>( +@@ -906,6 +943,11 @@ pub async fn main_tracegen, A: CudaTracegenAir>( + + log_chip_stats(machine, &chip_set, &traces); + ++ // Igneum prover-floor patch: the key's buffer is sized to its preprocessed traces at setup (upstream sized it ++ // for a whole shard), so grow it here to what this shard needs before the main traces are appended: a bigger ++ // dense buffer and column index, the preprocessed region copied device to device, swapped into the key. ++ grow_for_main(&mut jagged_traces.preprocessed_traces, &traces, log_stacking_height, backend); ++ + copy_main_jagged_traces( + traces, + &mut jagged_traces.preprocessed_traces, +@@ -918,6 +960,61 @@ pub async fn main_tracegen, A: CudaTracegenAir>( + (public_values, chip_set, permit) + } + ++/// Igneum prover-floor patch: see `main_tracegen`. The need is the preprocessed phase as laid out (its padded ++/// end, `preprocessed_offset`) plus the main traces padded to the stacking height plus one stacking height of ++/// slack; a buffer at least that big is left alone. The process aborts, loudly, if the copy cannot be made, ++/// because a panic inside a prover task is what left sweep 2 hanging on the client's socket. ++fn grow_for_main( ++ jagged: &mut JaggedTraceMle, ++ main_traces: &BTreeMap>, ++ log_stacking_height: u32, ++ backend: &TaskScope, ++) { ++ let pre_end = jagged.dense().preprocessed_offset; ++ let needed = pre_end ++ + padded_trace_elements(main_traces, log_stacking_height) ++ + (1 << log_stacking_height); ++ let have = jagged.dense().dense.capacity(); ++ if have >= needed { ++ return; ++ } ++ let mut new_dense: Buffer = Buffer::with_capacity_in(needed, backend.clone()); ++ let mut new_col_index: Buffer = ++ Buffer::with_capacity_in(needed >> 1, backend.clone()); ++ unsafe { ++ new_dense.assume_init(); ++ new_col_index.assume_init(); ++ } ++ { ++ let JaggedMle { dense_data, col_index, .. } = &mut **jagged; ++ let src_dense: &Slice<_, _> = &dense_data.dense[..pre_end]; ++ let dst_dense: &mut Slice<_, _> = &mut new_dense[..pre_end]; ++ let src_col: &Slice<_, _> = &col_index[..pre_end >> 1]; ++ let dst_col: &mut Slice<_, _> = &mut new_col_index[..pre_end >> 1]; ++ unsafe { ++ if dst_dense.copy_from_slice(src_dense, backend).is_err() ++ || dst_col.copy_from_slice(src_col, backend).is_err() ++ { ++ eprintln!("FLOOR grow FAILED: could not copy the preprocessed region ({pre_end} elements) into the grown buffer ({needed} elements); aborting instead of hanging"); ++ std::process::abort(); ++ } ++ } ++ } ++ if std::env::var("SP1_GPU_FLOOR_LOG").is_ok() { ++ eprintln!( ++ "FLOOR grow key buffer {have} -> {needed} elements (preprocessed {pre_end}, {} bytes)", ++ needed * 6 ++ ); ++ } ++ let JaggedMle { dense_data, col_index, .. } = &mut **jagged; ++ dense_data.dense = new_dense; ++ *col_index = new_col_index; ++ unsafe { ++ dense_data.dense.set_len(pre_end); ++ col_index.set_len(pre_end >> 1); ++ } ++} ++ + #[allow(clippy::too_many_arguments)] + pub async fn main_tracegen_permit, A: CudaTracegenAir>( + machine: &Machine, +@@ -984,9 +1081,15 @@ pub async fn full_tracegen>( log_chip_stats(machine, &chip_set, &main_traces); @@ -81,7 +155,7 @@ index 579f70a..09e73e8 100644 log_stacking_height, max_log_row_count, backend, -@@ -1002,6 +1045,18 @@ pub async fn full_tracegen>( +@@ -1002,6 +1105,18 @@ pub async fn full_tracegen>( ) .await; diff --git a/tools/prover-floor/pc2-build-server.ps1 b/tools/prover-floor/pc2-build-server.ps1 index dd94da4a2..d4ca0dfb1 100644 --- a/tools/prover-floor/pc2-build-server.ps1 +++ b/tools/prover-floor/pc2-build-server.ps1 @@ -1,13 +1,13 @@ # Prover floor (5 October 2026): builds sp1-gpu-server 6.8.1 from source with the Igneum floor patch on PC 2 inside # WSL2 Ubuntu-24.04 as root, into /opt/igneum-floor (the live /root/.sp1/bin/sp1-gpu-server and /opt/igneum are # never touched). CPU only: the miners keep mining, the card is not used. Generated by make-build-playbook.sh; -# patch sha256 08ce05557ee756ff5c302912a0b36910603e67eb786ed58b6529455e0c3b2d52. CUDA_ARCHS=86,89,120 (the 12 GB tier is sm_86 (3060) and sm_89 (4070), the 16 GB tier sm_89 and sm_120; PC 2 runs sm_120; a shipped build lists every target the stock server does: 80, 86, 89, 90, 100, 120). +# patch sha256 3f9d3ab0845b08c01683038765db07a9293aeb03360c45dc5cba5a8c607bed8a. CUDA_ARCHS=86,89,120 (the 12 GB tier is sm_86 (3060) and sm_89 (4070), the 16 GB tier sm_89 and sm_120; PC 2 runs sm_120; a shipped build lists every target the stock server does: 80, 86, 89, 90, 100, 120). $ErrorActionPreference = 'Continue' function Stamp { (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ') } "RESULT start $(Stamp)" $job = $env:IGNEUM_JOB_DIR; if (-not $job) { $job = Join-Path $env:TEMP 'igneum-floor' }; New-Item -ItemType Directory -Force -Path $job | Out-Null function WslPath($p) { $w = (& wsl.exe -d Ubuntu-24.04 -u root -- wslpath -a ($p -replace '\\', '/') 2>$null); if ($w) { ($w -replace "`0", '').Trim() } else { '/mnt/c' + ($p.Substring(2) -replace '\\', '/') } } -$patchB64 = 'diff --git a/sp1-gpu/crates/jagged_tracegen/src/lib.rs b/sp1-gpu/crates/jagged_tracegen/src/lib.rs
index 579f70a..09e73e8 100644
--- a/sp1-gpu/crates/jagged_tracegen/src/lib.rs
+++ b/sp1-gpu/crates/jagged_tracegen/src/lib.rs
@@ -481,6 +481,33 @@ async fn device_preprocessed_tracegen<A: CudaTracegenAir<Felt>>(
     named_traces
 }
 
+/// Igneum prover-floor patch: the dense elements a set of traces will occupy once `generate_jagged_traces`
+/// has laid them out, that is the sum of their buffers padded to the next multiple of 2^log_stacking_height
+/// (the "final padding" step below). Each phase (preprocessed, then main) is padded on its own.
+pub fn padded_trace_elements(
+    traces: &BTreeMap<String, Trace<TaskScope>>,
+    log_stacking_height: u32,
+) -> usize {
+    let total: usize = traces
+        .values()
+        .map(|t| match t {
+            Trace::Real(trace) => trace.guts().as_buffer().len(),
+            Trace::Padding(_) => 0,
+        })
+        .sum();
+    total.next_multiple_of(1 << log_stacking_height)
+}
+
+/// Igneum prover-floor patch: the capacity to allocate for a trace set: the exact padded size plus one
+/// stacking height of slack, never more than the prover's `max_trace_size`. `SP1_GPU_FLOOR_EXACT=0` restores
+/// upstream's full-capacity allocation.
+fn floor_capacity(max_trace_size: usize, needed: usize, log_stacking_height: u32) -> usize {
+    if std::env::var("SP1_GPU_FLOOR_EXACT").map(|v| v == "0").unwrap_or(false) {
+        return max_trace_size;
+    }
+    max_trace_size.min(needed + (1 << log_stacking_height))
+}
+
 async fn allocate_and_initialize_traces(
     preprocessed_traces: BTreeMap<String, Trace<TaskScope>>,
     max_trace_size: usize,
@@ -494,6 +521,11 @@ async fn allocate_and_initialize_traces(
 
     let total_gb = total_bytes as f64 / (1 << 30) as f64;
     tracing::debug!("Allocating {:?} GB of traces", total_gb);
+    if std::env::var("SP1_GPU_FLOOR_LOG").is_ok() {
+        eprintln!(
+            "FLOOR tracegen alloc capacity_elements={max_trace_size} bytes={total_bytes} ({total_gb:.3} GB)"
+        );
+    }
     let mut dense_data: Buffer<Felt, TaskScope> =
         Buffer::with_capacity_in(max_trace_size, backend.clone());
     let mut col_index: Buffer<u32, TaskScope> =
@@ -677,9 +709,14 @@ pub async fn setup_tracegen<A: CudaTracegenAir<Felt>>(
     let preprocessed_traces =
         device_preprocessed_tracegen(program, host_phase_tracegen, backend).await;
 
+    let capacity = floor_capacity(
+        max_trace_size,
+        padded_trace_elements(&preprocessed_traces, log_stacking_height),
+        log_stacking_height,
+    );
     let jagged_traces = allocate_and_initialize_traces(
         preprocessed_traces,
-        max_trace_size,
+        capacity,
         log_stacking_height,
         max_log_row_count,
         backend,
@@ -984,9 +1021,15 @@ pub async fn full_tracegen<A: CudaTracegenAir<Felt>>(
 
     log_chip_stats(machine, &chip_set, &main_traces);
 
+    let capacity = floor_capacity(
+        max_trace_size,
+        padded_trace_elements(&preprocessed_traces, log_stacking_height)
+            + padded_trace_elements(&main_traces, log_stacking_height),
+        log_stacking_height,
+    );
     let mut jagged_mle = allocate_and_initialize_traces(
         preprocessed_traces,
-        max_trace_size,
+        capacity,
         log_stacking_height,
         max_log_row_count,
         backend,
@@ -1002,6 +1045,18 @@ pub async fn full_tracegen<A: CudaTracegenAir<Felt>>(
     )
     .await;
 
+    if std::env::var("SP1_GPU_FLOOR_LOG").is_ok() {
+        let dense = jagged_mle.dense();
+        let (free, total) = sp1_gpu_cudart::cuda_memory_info().unwrap_or((0, 0));
+        eprintln!(
+            "FLOOR tracegen used preprocessed_elements={} main_elements={} dense_len={} capacity_elements={capacity} max_trace_size={max_trace_size} device_used_mib={}",
+            dense.preprocessed_offset,
+            dense.main_size(),
+            dense.dense.len(),
+            (total - free) >> 20
+        );
+    }
+
     (public_values, jagged_mle, chip_set, permit)
 }
 
diff --git a/sp1-gpu/crates/prover_components/src/builder.rs b/sp1-gpu/crates/prover_components/src/builder.rs
index 5dccd9d..574d4fa 100644
--- a/sp1-gpu/crates/prover_components/src/builder.rs
+++ b/sp1-gpu/crates/prover_components/src/builder.rs
@@ -23,28 +23,75 @@ use crate::{
     SP1CudaProverComponents,
 };
 
+/// Igneum prover-floor patch (5 October 2026). Upstream sizes every device buffer for a 24 GB card or larger
+/// and panics below that, whatever the shard. Here the card's memory (or `SP1_GPU_MEMORY_BUDGET_GB`) picks a
+/// tier, and `SP1_GPU_ELEMENT_THRESHOLD` / `SP1_GPU_RECURSION_TRACE_ALLOCATION` set the two buffers directly.
+/// The proof format, the verifier and the program ids do not change: the element threshold only decides where
+/// the executor splits shards, as upstream's own 24 GB tier already does.
+fn env_usize(name: &str) -> Option<usize> {
+    std::env::var(name).ok().and_then(|s| s.parse::<usize>().ok())
+}
+
+fn env_f64(name: &str) -> Option<f64> {
+    std::env::var(name).ok().and_then(|s| s.parse::<f64>().ok())
+}
+
+/// The core element threshold for a memory budget in GB (upstream's own figure for the budget, +4, as it
+/// computed it: a 32 GB card is 36, a 24 GB card 28, a 16 GB card 20, a 12 GB card 16).
+pub fn element_threshold_for_budget(gpu_memory_gb: usize, full_size_shards: bool) -> u64 {
+    if gpu_memory_gb > 30 || (full_size_shards && gpu_memory_gb >= 24) {
+        ELEMENT_THRESHOLD
+    } else if gpu_memory_gb >= 24 {
+        ELEMENT_THRESHOLD - (1 << 26) - (1 << 25) - (1 << 24)
+    } else if gpu_memory_gb >= 18 {
+        (1 << 27) + (1 << 26)
+    } else {
+        1 << 27
+    }
+}
+
+/// The recursion trace allocation (elements) for a memory budget.
+pub fn recursion_trace_allocation_for_budget(gpu_memory_gb: usize) -> usize {
+    if gpu_memory_gb >= 24 {
+        RECURSION_TRACE_ALLOCATION
+    } else {
+        RECURSION_TRACE_ALLOCATION
+    }
+}
+
+pub fn gpu_memory_gb() -> usize {
+    let gb = 1024.0 * 1024.0 * 1024.0;
+    match env_f64("SP1_GPU_MEMORY_BUDGET_GB") {
+        Some(b) => (b.ceil() as usize) + 4,
+        None => (((cuda_memory_info().unwrap().1 as f64) / gb).ceil() as usize) + 4,
+    }
+}
+
+pub fn recursion_trace_allocation() -> usize {
+    env_usize("SP1_GPU_RECURSION_TRACE_ALLOCATION")
+        .unwrap_or_else(|| recursion_trace_allocation_for_budget(gpu_memory_gb()))
+}
+
 pub fn local_gpu_opts() -> SP1CoreOpts {
     let mut opts = SP1CoreOpts::default();
 
     let log2_shard_size = 24;
     opts.shard_size = 1 << log2_shard_size;
 
-    let gb = 1024.0 * 1024.0 * 1024.0;
-
-    // Get the amount of memory on the GPU.
-    let gpu_memory_gb: usize = (((cuda_memory_info().unwrap().1 as f64) / gb).ceil() as usize) + 4;
-
-    if gpu_memory_gb < 24 {
-        panic!("Unsupported GPU memory: {gpu_memory_gb}, must be at least 24GB");
-    }
+    // The card's memory plus 4, as upstream computed it (a 32 GB card reads 36), or the budget given.
+    let gpu_memory_gb = gpu_memory_gb();
 
-    let shard_threshold = if !opts.full_size_shards && gpu_memory_gb <= 30 {
-        ELEMENT_THRESHOLD - (1 << 26) - (1 << 25) - (1 << 24)
-    } else {
-        ELEMENT_THRESHOLD
+    let shard_threshold = match env_usize("SP1_GPU_ELEMENT_THRESHOLD") {
+        Some(t) => t as u64,
+        None => element_threshold_for_budget(gpu_memory_gb, opts.full_size_shards),
     };
+    let height_threshold = opts.sharding_threshold.height_threshold;
 
-    tracing::debug!("Shard threshold: {shard_threshold}");
+    eprintln!(
+        "FLOOR opts gpu_memory_gb={gpu_memory_gb} element_threshold={shard_threshold} height_threshold={height_threshold} recursion_trace_allocation={} full_size_shards={}",
+        recursion_trace_allocation(),
+        opts.full_size_shards
+    );
     opts.sharding_threshold.element_threshold = shard_threshold;
 
     opts.global_dependencies_opt = true;
@@ -92,7 +139,7 @@ pub async fn recursion_prover_and_verifier(
 ) {
     let recursion_verifier = SP1CudaProverComponents::compress_verifier();
     (
-        new_cuda_prover(&recursion_verifier, RECURSION_TRACE_ALLOCATION, 4, false, false, scope)
+        new_cuda_prover(&recursion_verifier, recursion_trace_allocation(), 4, false, false, scope)
             .await,
         recursion_verifier,
     )
diff --git a/sp1-gpu/crates/server/src/server.rs b/sp1-gpu/crates/server/src/server.rs
index 4035f1f..0d0d907 100644
--- a/sp1-gpu/crates/server/src/server.rs
+++ b/sp1-gpu/crates/server/src/server.rs
@@ -157,6 +157,7 @@ impl Server {
                 };
                 let pk = CachedProgram { elf: Arc::new(Elf::Dynamic(elf.into())), vk: vk.clone() };
                 ctx.pk_cache.insert(elf_hash, pk);
+                floor_memory_line("after setup");
                 Response::Setup { id: elf_hash, vk }
             }
             Request::Destroy { key } => {
@@ -177,15 +178,31 @@ impl Server {
                     );
                 };
                 let context = SP1Context::builder().proof_nonce(proof_nonce).build();
-                match prover.prove_with_mode(&cached.elf, stdin, context, mode).await {
+                let started = std::time::Instant::now();
+                let response = match prover.prove_with_mode(&cached.elf, stdin, context, mode).await {
                     Ok(proof) => Response::Proof { proof },
                     Err(e) => Response::ProverError(e.to_string()),
-                }
+                };
+                floor_memory_line(&format!("after prove {:?} in {:.1} s", mode, started.elapsed().as_secs_f64()));
+                response
             }
         }
     }
 }
 
+/// Igneum prover-floor patch: the device memory in use (total minus free, as the driver reports it) at the
+/// points that bound a proof, so a run's log carries the terms of the peak without a sampler.
+fn floor_memory_line(what: &str) {
+    if let Ok((free, total)) = sp1_gpu_cudart::cuda_memory_info() {
+        eprintln!(
+            "FLOOR memory {what}: device_used_mib={} free_mib={} total_mib={}",
+            (total - free) >> 20,
+            free >> 20,
+            total >> 20
+        );
+    }
+}
+
 fn sha256(data: &[u8]) -> [u8; 32] {
     use sha2::{Digest, Sha256};
     let mut hasher = Sha256::new();
' +$patchB64 = 'diff --git a/sp1-gpu/crates/jagged_tracegen/src/lib.rs b/sp1-gpu/crates/jagged_tracegen/src/lib.rs
index 579f70a..2264044 100644
--- a/sp1-gpu/crates/jagged_tracegen/src/lib.rs
+++ b/sp1-gpu/crates/jagged_tracegen/src/lib.rs
@@ -481,6 +481,33 @@ async fn device_preprocessed_tracegen<A: CudaTracegenAir<Felt>>(
     named_traces
 }
 
+/// Igneum prover-floor patch: the dense elements a set of traces will occupy once `generate_jagged_traces`
+/// has laid them out, that is the sum of their buffers padded to the next multiple of 2^log_stacking_height
+/// (the "final padding" step below). Each phase (preprocessed, then main) is padded on its own.
+pub fn padded_trace_elements(
+    traces: &BTreeMap<String, Trace<TaskScope>>,
+    log_stacking_height: u32,
+) -> usize {
+    let total: usize = traces
+        .values()
+        .map(|t| match t {
+            Trace::Real(trace) => trace.guts().as_buffer().len(),
+            Trace::Padding(_) => 0,
+        })
+        .sum();
+    total.next_multiple_of(1 << log_stacking_height)
+}
+
+/// Igneum prover-floor patch: the capacity to allocate for a trace set: the exact padded size plus one
+/// stacking height of slack, never more than the prover's `max_trace_size`. `SP1_GPU_FLOOR_EXACT=0` restores
+/// upstream's full-capacity allocation.
+fn floor_capacity(max_trace_size: usize, needed: usize, log_stacking_height: u32) -> usize {
+    if std::env::var("SP1_GPU_FLOOR_EXACT").map(|v| v == "0").unwrap_or(false) {
+        return max_trace_size;
+    }
+    max_trace_size.min(needed + (1 << log_stacking_height))
+}
+
 async fn allocate_and_initialize_traces(
     preprocessed_traces: BTreeMap<String, Trace<TaskScope>>,
     max_trace_size: usize,
@@ -494,6 +521,11 @@ async fn allocate_and_initialize_traces(
 
     let total_gb = total_bytes as f64 / (1 << 30) as f64;
     tracing::debug!("Allocating {:?} GB of traces", total_gb);
+    if std::env::var("SP1_GPU_FLOOR_LOG").is_ok() {
+        eprintln!(
+            "FLOOR tracegen alloc capacity_elements={max_trace_size} bytes={total_bytes} ({total_gb:.3} GB)"
+        );
+    }
     let mut dense_data: Buffer<Felt, TaskScope> =
         Buffer::with_capacity_in(max_trace_size, backend.clone());
     let mut col_index: Buffer<u32, TaskScope> =
@@ -677,9 +709,14 @@ pub async fn setup_tracegen<A: CudaTracegenAir<Felt>>(
     let preprocessed_traces =
         device_preprocessed_tracegen(program, host_phase_tracegen, backend).await;
 
+    let capacity = floor_capacity(
+        max_trace_size,
+        padded_trace_elements(&preprocessed_traces, log_stacking_height),
+        log_stacking_height,
+    );
     let jagged_traces = allocate_and_initialize_traces(
         preprocessed_traces,
-        max_trace_size,
+        capacity,
         log_stacking_height,
         max_log_row_count,
         backend,
@@ -906,6 +943,11 @@ pub async fn main_tracegen<GC: IopCtx<F = Felt>, A: CudaTracegenAir<Felt>>(
 
     log_chip_stats(machine, &chip_set, &traces);
 
+    // Igneum prover-floor patch: the key's buffer is sized to its preprocessed traces at setup (upstream sized it
+    // for a whole shard), so grow it here to what this shard needs before the main traces are appended: a bigger
+    // dense buffer and column index, the preprocessed region copied device to device, swapped into the key.
+    grow_for_main(&mut jagged_traces.preprocessed_traces, &traces, log_stacking_height, backend);
+
     copy_main_jagged_traces(
         traces,
         &mut jagged_traces.preprocessed_traces,
@@ -918,6 +960,61 @@ pub async fn main_tracegen<GC: IopCtx<F = Felt>, A: CudaTracegenAir<Felt>>(
     (public_values, chip_set, permit)
 }
 
+/// Igneum prover-floor patch: see `main_tracegen`. The need is the preprocessed phase as laid out (its padded
+/// end, `preprocessed_offset`) plus the main traces padded to the stacking height plus one stacking height of
+/// slack; a buffer at least that big is left alone. The process aborts, loudly, if the copy cannot be made,
+/// because a panic inside a prover task is what left sweep 2 hanging on the client's socket.
+fn grow_for_main(
+    jagged: &mut JaggedTraceMle<Felt, TaskScope>,
+    main_traces: &BTreeMap<String, Trace<TaskScope>>,
+    log_stacking_height: u32,
+    backend: &TaskScope,
+) {
+    let pre_end = jagged.dense().preprocessed_offset;
+    let needed = pre_end
+        + padded_trace_elements(main_traces, log_stacking_height)
+        + (1 << log_stacking_height);
+    let have = jagged.dense().dense.capacity();
+    if have >= needed {
+        return;
+    }
+    let mut new_dense: Buffer<Felt, TaskScope> = Buffer::with_capacity_in(needed, backend.clone());
+    let mut new_col_index: Buffer<u32, TaskScope> =
+        Buffer::with_capacity_in(needed >> 1, backend.clone());
+    unsafe {
+        new_dense.assume_init();
+        new_col_index.assume_init();
+    }
+    {
+        let JaggedMle { dense_data, col_index, .. } = &mut **jagged;
+        let src_dense: &Slice<_, _> = &dense_data.dense[..pre_end];
+        let dst_dense: &mut Slice<_, _> = &mut new_dense[..pre_end];
+        let src_col: &Slice<_, _> = &col_index[..pre_end >> 1];
+        let dst_col: &mut Slice<_, _> = &mut new_col_index[..pre_end >> 1];
+        unsafe {
+            if dst_dense.copy_from_slice(src_dense, backend).is_err()
+                || dst_col.copy_from_slice(src_col, backend).is_err()
+            {
+                eprintln!("FLOOR grow FAILED: could not copy the preprocessed region ({pre_end} elements) into the grown buffer ({needed} elements); aborting instead of hanging");
+                std::process::abort();
+            }
+        }
+    }
+    if std::env::var("SP1_GPU_FLOOR_LOG").is_ok() {
+        eprintln!(
+            "FLOOR grow key buffer {have} -> {needed} elements (preprocessed {pre_end}, {} bytes)",
+            needed * 6
+        );
+    }
+    let JaggedMle { dense_data, col_index, .. } = &mut **jagged;
+    dense_data.dense = new_dense;
+    *col_index = new_col_index;
+    unsafe {
+        dense_data.dense.set_len(pre_end);
+        col_index.set_len(pre_end >> 1);
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 pub async fn main_tracegen_permit<GC: IopCtx<F = Felt>, A: CudaTracegenAir<Felt>>(
     machine: &Machine<Felt, A>,
@@ -984,9 +1081,15 @@ pub async fn full_tracegen<A: CudaTracegenAir<Felt>>(
 
     log_chip_stats(machine, &chip_set, &main_traces);
 
+    let capacity = floor_capacity(
+        max_trace_size,
+        padded_trace_elements(&preprocessed_traces, log_stacking_height)
+            + padded_trace_elements(&main_traces, log_stacking_height),
+        log_stacking_height,
+    );
     let mut jagged_mle = allocate_and_initialize_traces(
         preprocessed_traces,
-        max_trace_size,
+        capacity,
         log_stacking_height,
         max_log_row_count,
         backend,
@@ -1002,6 +1105,18 @@ pub async fn full_tracegen<A: CudaTracegenAir<Felt>>(
     )
     .await;
 
+    if std::env::var("SP1_GPU_FLOOR_LOG").is_ok() {
+        let dense = jagged_mle.dense();
+        let (free, total) = sp1_gpu_cudart::cuda_memory_info().unwrap_or((0, 0));
+        eprintln!(
+            "FLOOR tracegen used preprocessed_elements={} main_elements={} dense_len={} capacity_elements={capacity} max_trace_size={max_trace_size} device_used_mib={}",
+            dense.preprocessed_offset,
+            dense.main_size(),
+            dense.dense.len(),
+            (total - free) >> 20
+        );
+    }
+
     (public_values, jagged_mle, chip_set, permit)
 }
 
diff --git a/sp1-gpu/crates/prover_components/src/builder.rs b/sp1-gpu/crates/prover_components/src/builder.rs
index 5dccd9d..574d4fa 100644
--- a/sp1-gpu/crates/prover_components/src/builder.rs
+++ b/sp1-gpu/crates/prover_components/src/builder.rs
@@ -23,28 +23,75 @@ use crate::{
     SP1CudaProverComponents,
 };
 
+/// Igneum prover-floor patch (5 October 2026). Upstream sizes every device buffer for a 24 GB card or larger
+/// and panics below that, whatever the shard. Here the card's memory (or `SP1_GPU_MEMORY_BUDGET_GB`) picks a
+/// tier, and `SP1_GPU_ELEMENT_THRESHOLD` / `SP1_GPU_RECURSION_TRACE_ALLOCATION` set the two buffers directly.
+/// The proof format, the verifier and the program ids do not change: the element threshold only decides where
+/// the executor splits shards, as upstream's own 24 GB tier already does.
+fn env_usize(name: &str) -> Option<usize> {
+    std::env::var(name).ok().and_then(|s| s.parse::<usize>().ok())
+}
+
+fn env_f64(name: &str) -> Option<f64> {
+    std::env::var(name).ok().and_then(|s| s.parse::<f64>().ok())
+}
+
+/// The core element threshold for a memory budget in GB (upstream's own figure for the budget, +4, as it
+/// computed it: a 32 GB card is 36, a 24 GB card 28, a 16 GB card 20, a 12 GB card 16).
+pub fn element_threshold_for_budget(gpu_memory_gb: usize, full_size_shards: bool) -> u64 {
+    if gpu_memory_gb > 30 || (full_size_shards && gpu_memory_gb >= 24) {
+        ELEMENT_THRESHOLD
+    } else if gpu_memory_gb >= 24 {
+        ELEMENT_THRESHOLD - (1 << 26) - (1 << 25) - (1 << 24)
+    } else if gpu_memory_gb >= 18 {
+        (1 << 27) + (1 << 26)
+    } else {
+        1 << 27
+    }
+}
+
+/// The recursion trace allocation (elements) for a memory budget.
+pub fn recursion_trace_allocation_for_budget(gpu_memory_gb: usize) -> usize {
+    if gpu_memory_gb >= 24 {
+        RECURSION_TRACE_ALLOCATION
+    } else {
+        RECURSION_TRACE_ALLOCATION
+    }
+}
+
+pub fn gpu_memory_gb() -> usize {
+    let gb = 1024.0 * 1024.0 * 1024.0;
+    match env_f64("SP1_GPU_MEMORY_BUDGET_GB") {
+        Some(b) => (b.ceil() as usize) + 4,
+        None => (((cuda_memory_info().unwrap().1 as f64) / gb).ceil() as usize) + 4,
+    }
+}
+
+pub fn recursion_trace_allocation() -> usize {
+    env_usize("SP1_GPU_RECURSION_TRACE_ALLOCATION")
+        .unwrap_or_else(|| recursion_trace_allocation_for_budget(gpu_memory_gb()))
+}
+
 pub fn local_gpu_opts() -> SP1CoreOpts {
     let mut opts = SP1CoreOpts::default();
 
     let log2_shard_size = 24;
     opts.shard_size = 1 << log2_shard_size;
 
-    let gb = 1024.0 * 1024.0 * 1024.0;
-
-    // Get the amount of memory on the GPU.
-    let gpu_memory_gb: usize = (((cuda_memory_info().unwrap().1 as f64) / gb).ceil() as usize) + 4;
-
-    if gpu_memory_gb < 24 {
-        panic!("Unsupported GPU memory: {gpu_memory_gb}, must be at least 24GB");
-    }
+    // The card's memory plus 4, as upstream computed it (a 32 GB card reads 36), or the budget given.
+    let gpu_memory_gb = gpu_memory_gb();
 
-    let shard_threshold = if !opts.full_size_shards && gpu_memory_gb <= 30 {
-        ELEMENT_THRESHOLD - (1 << 26) - (1 << 25) - (1 << 24)
-    } else {
-        ELEMENT_THRESHOLD
+    let shard_threshold = match env_usize("SP1_GPU_ELEMENT_THRESHOLD") {
+        Some(t) => t as u64,
+        None => element_threshold_for_budget(gpu_memory_gb, opts.full_size_shards),
     };
+    let height_threshold = opts.sharding_threshold.height_threshold;
 
-    tracing::debug!("Shard threshold: {shard_threshold}");
+    eprintln!(
+        "FLOOR opts gpu_memory_gb={gpu_memory_gb} element_threshold={shard_threshold} height_threshold={height_threshold} recursion_trace_allocation={} full_size_shards={}",
+        recursion_trace_allocation(),
+        opts.full_size_shards
+    );
     opts.sharding_threshold.element_threshold = shard_threshold;
 
     opts.global_dependencies_opt = true;
@@ -92,7 +139,7 @@ pub async fn recursion_prover_and_verifier(
 ) {
     let recursion_verifier = SP1CudaProverComponents::compress_verifier();
     (
-        new_cuda_prover(&recursion_verifier, RECURSION_TRACE_ALLOCATION, 4, false, false, scope)
+        new_cuda_prover(&recursion_verifier, recursion_trace_allocation(), 4, false, false, scope)
             .await,
         recursion_verifier,
     )
diff --git a/sp1-gpu/crates/server/src/server.rs b/sp1-gpu/crates/server/src/server.rs
index 4035f1f..0d0d907 100644
--- a/sp1-gpu/crates/server/src/server.rs
+++ b/sp1-gpu/crates/server/src/server.rs
@@ -157,6 +157,7 @@ impl Server {
                 };
                 let pk = CachedProgram { elf: Arc::new(Elf::Dynamic(elf.into())), vk: vk.clone() };
                 ctx.pk_cache.insert(elf_hash, pk);
+                floor_memory_line("after setup");
                 Response::Setup { id: elf_hash, vk }
             }
             Request::Destroy { key } => {
@@ -177,15 +178,31 @@ impl Server {
                     );
                 };
                 let context = SP1Context::builder().proof_nonce(proof_nonce).build();
-                match prover.prove_with_mode(&cached.elf, stdin, context, mode).await {
+                let started = std::time::Instant::now();
+                let response = match prover.prove_with_mode(&cached.elf, stdin, context, mode).await {
                     Ok(proof) => Response::Proof { proof },
                     Err(e) => Response::ProverError(e.to_string()),
-                }
+                };
+                floor_memory_line(&format!("after prove {:?} in {:.1} s", mode, started.elapsed().as_secs_f64()));
+                response
             }
         }
     }
 }
 
+/// Igneum prover-floor patch: the device memory in use (total minus free, as the driver reports it) at the
+/// points that bound a proof, so a run's log carries the terms of the peak without a sampler.
+fn floor_memory_line(what: &str) {
+    if let Ok((free, total)) = sp1_gpu_cudart::cuda_memory_info() {
+        eprintln!(
+            "FLOOR memory {what}: device_used_mib={} free_mib={} total_mib={}",
+            (total - free) >> 20,
+            free >> 20,
+            total >> 20
+        );
+    }
+}
+
 fn sha256(data: &[u8]) -> [u8; 32] {
     use sha2::{Digest, Sha256};
     let mut hasher = Sha256::new();
' [IO.File]::WriteAllBytes((Join-Path $job 'floor.patch'), [Convert]::FromBase64String($patchB64)) $patchW = WslPath (Join-Path $job 'floor.patch') $bash = @' @@ -19,7 +19,7 @@ export CUDA_PATH="$CUDA_DIR" CUDACXX="$CUDA_DIR/bin/nvcc" PATH="$CUDA_DIR/bin:$P stamp() { date -u +%Y-%m-%dT%H:%M:%SZ; } FLOOR=/opt/igneum-floor; SRC=$FLOOR/sp1; mkdir -p $FLOOR/bin $FLOOR/home/.sp1/bin $FLOOR/logs PATCH="PATCH_PATH_PLACEHOLDER" -echo "RESULT patch_sha256 $(sha256sum "$PATCH" | cut -c1-64) expected 08ce05557ee756ff5c302912a0b36910603e67eb786ed58b6529455e0c3b2d52" +echo "RESULT patch_sha256 $(sha256sum "$PATCH" | cut -c1-64) expected 3f9d3ab0845b08c01683038765db07a9293aeb03360c45dc5cba5a8c607bed8a" echo "RESULT toolchain nvcc=$(nvcc --version | grep -o 'release [0-9.]*') cargo=$(cargo --version) go=$(go version 2>/dev/null || echo MISSING) protoc=$(protoc --version 2>/dev/null || echo MISSING) cmake=$(cmake --version 2>/dev/null | head -1 || echo MISSING) nproc=$(nproc) disk_avail=$(df -BG /opt | awk 'NR==2 {print $4}')" if [ ! -d "$SRC/.git" ]; then echo "STAGE clone $(stamp)" diff --git a/tools/prover-floor/pc2-floor-sweep3.ps1 b/tools/prover-floor/pc2-floor-sweep3.ps1 new file mode 100644 index 000000000..485e0f5c7 --- /dev/null +++ b/tools/prover-floor/pc2-floor-sweep3.ps1 @@ -0,0 +1,65 @@ +# Prover floor (5 October 2026): the peak GPU memory and the time of one compressed shard proof through the PATCHED +# sp1-gpu-server (/opt/igneum-floor/home/.sp1/bin, reached by HOME=/opt/igneum-floor/home: the SDK spawns the +# server it finds under $HOME/.sp1/bin, sp1-cuda-6.8.1/src/server.rs) on PC 2's RTX 5090, the miners STOPPED by the +# job (--stop-miners) and the live prover switched off for the run (its server would otherwise own the socket). +# Every point: every server killed and its socket unlinked, a 1-s nvidia-smi sampler, one `--mode compressed +# --shard 0` of the pv1 host (/opt/igneum-pv1, the UNPATCHED SDK and verifier: its VERIFIED is the unpatched +# verifier's word on the patched server's proof), the peak, the time, the FLOOR lines the server prints. +# The point list comes from the FLOOR_POINTS environment the job carries, else the default sweep below. +$ErrorActionPreference = 'Continue' +$urlFile = if ($env:IGNEUM_APP_DIR) { Join-Path $env:IGNEUM_APP_DIR 'app.url' } else { Join-Path $env:LOCALAPPDATA 'igneum\app\app.url' } +if (-not (Test-Path $urlFile)) { $urlFile = Join-Path $env:LOCALAPPDATA 'igneum\app\app.url' } +$base = (Get-Content $urlFile -Raw).Trim().TrimEnd('/') +function Stamp { (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ') } +function Prove($on) { try { (Invoke-RestMethod -Method Post -Uri "$base/api/prove" -ContentType 'application/json' -Body (@{on=$on} | ConvertTo-Json -Compress) -TimeoutSec 10) | ConvertTo-Json -Compress } catch { "error: $_" } } +"RESULT start $(Stamp) prover off for the run: $(Prove $false)" +Start-Sleep -Seconds 45 +"RESULT gpus $(Stamp) $((& nvidia-smi --query-gpu=index,name,memory.used,memory.total,utilization.gpu,power.draw --format=csv,noheader,nounits 2>$null) -join ' | ')" +$job = $env:IGNEUM_JOB_DIR; if (-not $job) { $job = Join-Path $env:TEMP 'igneum-floor-measure' }; New-Item -ItemType Directory -Force -Path $job | Out-Null +function WslPath($p) { $w = (& wsl.exe -d Ubuntu-24.04 -u root -- wslpath -a ($p -replace '\\', '/') 2>$null); if ($w) { ($w -replace "`0", '').Trim() } else { '/mnt/c' + ($p.Substring(2) -replace '\\', '/') } } +$jobW = WslPath $job +$emptyW = WslPath (Join-Path $env:LOCALAPPDATA 'igneum\app\jobs\chain-pc2-pv1c\block-83616.json') +$points = if ($env:FLOOR_POINTS) { $env:FLOOR_POINTS } else { 'run x12 "$EMPTY" SP1_GPU_MEMORY_BUDGET_GB=12;run x12 "$V1" SP1_GPU_MEMORY_BUDGET_GB=12;run x12 "$ONE" SP1_GPU_MEMORY_BUDGET_GB=12;run x12 "$FULL" SP1_GPU_MEMORY_BUDGET_GB=12;run xe26 "$V1" SP1_GPU_ELEMENT_THRESHOLD=67108864;run xe26 "$EMPTY" SP1_GPU_ELEMENT_THRESHOLD=67108864;run x16 "$V1" SP1_GPU_MEMORY_BUDGET_GB=16;run x32 "$V1" SP1_GPU_MEMORY_BUDGET_GB=32;run x12r "$V1" SP1_GPU_MEMORY_BUDGET_GB=12 SP1_GPU_RECURSION_TRACE_ALLOCATION=100663296' } +$bash = @' +set -uo pipefail +export PATH="$HOME/.cargo/bin:$PATH" +CUDA_DIR="$(ls -d /usr/local/cuda-12.* 2>/dev/null | sort -V | tail -1 || true)"; [ -n "$CUDA_DIR" ] && export PATH="$CUDA_DIR/bin:$PATH" && export LD_LIBRARY_PATH="$CUDA_DIR/lib64:/usr/lib/wsl/lib:${LD_LIBRARY_PATH:-}" +stamp() { date -u +%Y-%m-%dT%H:%M:%SZ; } +JOB='JOBW_PLACEHOLDER'; H=/opt/igneum-pv1/igneum-prove-host; FX="/root/igneum-prove-pv1/proving/fixtures" +FLOORHOME=/opt/igneum-floor/home; SRV=$FLOORHOME/.sp1/bin/sp1-gpu-server +EMPTY='EMPTY_PLACEHOLDER'; V1="$FX/fees-v1-shards2.json"; FULL="$FX/block-338-shard1.json"; ONE="$FX/block-56-transfers.json" +[ -x "$SRV" ] || { echo "RESULT measure_failed no patched server at $SRV"; exit 2; } +[ -x "$H" ] || { echo "RESULT measure_failed no pv1 host at $H"; exit 2; } +echo "RESULT patched_server sha256=$(sha256sum $SRV | cut -c1-64) version=$($SRV --version 2>/dev/null) host=$(sha256sum $H | cut -c1-16)" +echo "RESULT live_server sha256=$(sha256sum /root/.sp1/bin/sp1-gpu-server | cut -c1-16) untouched" +pkill -f sp1-gpu-server 2>/dev/null; sleep 2; rm -f /tmp/sp1-cuda-*.sock +echo "RESULT idle_mib $(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits | head -1)" +run() { # name fixture env... + local name="$1" fx="$2"; shift 2 + local tag="$name-$(basename $fx .json)" + pkill -f sp1-gpu-server 2>/dev/null; sleep 2; rm -f /tmp/sp1-cuda-*.sock + local csv="$JOB/smi-$tag.csv" log="$JOB/log-$tag.txt" + nvidia-smi --query-gpu=timestamp,memory.used,utilization.gpu --format=csv,noheader,nounits -l 1 > "$csv" 2>/dev/null & + local SMI=$! + local t0=$(date +%s) + env HOME=$FLOORHOME SP1_PROVER=cuda RUST_LOG=off SP1_GPU_FLOOR_LOG=1 "$@" $H "$fx" --mode compressed --shard 0 --out "$JOB/res-$tag.json" > "$log" 2>&1 + local rc=$? + local wall=$(( $(date +%s) - t0 )) + pkill -f sp1-gpu-server 2>/dev/null; sleep 1; kill $SMI 2>/dev/null; sleep 1; rm -f /tmp/sp1-cuda-*.sock + local peak=$(awk -F', *' '{ if ($2+0 > m) m=$2+0 } END { print m+0 }' "$csv") + local n=$(wc -l < "$csv") + local line=$(grep -E "^RESULT compressed shard" "$log" | tail -1 | sed -E 's/.*prove ([0-9.]+) s, proof ([0-9]+) bytes, verify ([0-9.]+) s, ([A-Z ]+);.*/prove_s=\1 bytes=\2 verify_s=\3 \4/') + local cyc=$(grep -E "^RESULT execute shard" "$log" | tail -1 | sed -E 's/.*: ([0-9]+) cycles.*/\1/') + local err=$(grep -iE "error|panick|out of memory|OOM|unsupported" "$log" | grep -v "^FLOOR" | head -1 | cut -c1-200) + echo "RESULT floor cfg=$name fixture=$(basename $fx .json) peak_mib=$peak samples=$n wall_s=$wall cycles=${cyc:-na} ${line:-no_result} exit=$rc env='$*' ${err:+err=$err}" + grep -E "^FLOOR" "$log" | sed "s/^/RESULT floorline cfg=$name fixture=$(basename $fx .json) /" | head -40 +} +POINTS_PLACEHOLDER_BASH +pkill -f sp1-gpu-server 2>/dev/null; sleep 1; rm -f /tmp/sp1-cuda-*.sock +echo "RESULT measure_end $(stamp)" +'@ +$bash = $bash.Replace('JOBW_PLACEHOLDER', $jobW).Replace('EMPTY_PLACEHOLDER', $emptyW).Replace('POINTS_PLACEHOLDER_BASH', ($points -replace ';', "`n")) +$bashFile = Join-Path $job 'measure.sh' +[IO.File]::WriteAllText($bashFile, ($bash -replace "`r`n", "`n"), (New-Object System.Text.UTF8Encoding $false)) +& wsl.exe -d Ubuntu-24.04 -u root -- bash (WslPath $bashFile) 2>&1 | ForEach-Object { ($_ -replace "`0", '') } +"RESULT end $(Stamp) prover back on: $(Prove $true)" diff --git a/tools/prover-floor/points-sweep3.txt b/tools/prover-floor/points-sweep3.txt new file mode 100644 index 000000000..6b5f0ee56 --- /dev/null +++ b/tools/prover-floor/points-sweep3.txt @@ -0,0 +1,9 @@ +run x12 "$EMPTY" SP1_GPU_MEMORY_BUDGET_GB=12 +run x12 "$V1" SP1_GPU_MEMORY_BUDGET_GB=12 +run x12 "$ONE" SP1_GPU_MEMORY_BUDGET_GB=12 +run x12 "$FULL" SP1_GPU_MEMORY_BUDGET_GB=12 +run xe26 "$V1" SP1_GPU_ELEMENT_THRESHOLD=67108864 +run xe26 "$EMPTY" SP1_GPU_ELEMENT_THRESHOLD=67108864 +run x16 "$V1" SP1_GPU_MEMORY_BUDGET_GB=16 +run x32 "$V1" SP1_GPU_MEMORY_BUDGET_GB=32 +run x12r "$V1" SP1_GPU_MEMORY_BUDGET_GB=12 SP1_GPU_RECURSION_TRACE_ALLOCATION=100663296