Struct DuplexSpongeGpu 

pub struct DuplexSpongeGpu { /* private fields */ }

GPU-accelerated duplex sponge that maintains state on both host and device.

The host-side state uses DeviceSpongeState which matches the behavior of DuplexSponge from openvm_stark_backend (and p3_challenger::DuplexChallenger). The device-side state is stored in GPU memory for CUDA kernel operations.

State Synchronization

The host and device states are independent and must be explicitly synchronized:

• Use sync_h2d to copy host state to device before GPU operations
• Use sync_d2h to copy device state back to host after GPU operations

Usage Example

let mut sponge = DuplexSpongeGpu::default();

// Do some host operations
sponge.observe(some_value);
let challenge = sponge.sample();

// Sync to device before GPU grinding
sponge.sync_h2d()?;

// ... GPU grinding kernel runs ...

// Sync back after GPU modifies state
sponge.sync_d2h()?;

// Continue with host operations
let next_challenge = sponge.sample();

Implementations

impl DuplexSpongeGpu

pub fn new() -> Self

Create a new GPU-accelerated duplex sponge with default (zeroed) state.

pub fn is_device_allocated(&self) -> bool

Returns true if the device buffer has been allocated.

pub fn sync_h2d( &mut self, device_ctx: &GpuDeviceCtx, ) -> Result<(), MemCopyError>

Synchronize state from host to device (H2D memcpy).

Call this before running GPU kernels that read/modify the sponge state.

This converts from DuplexChallenger’s representation (with buffered input/output) to DeviceSpongeState’s representation (with indices pointing into state).

pub fn device_ptr(&self) -> Option<*const DeviceSpongeState>

Get a pointer to the device state buffer.

Returns None if the device buffer hasn’t been allocated yet. Call sync_h2d to allocate and initialize the device buffer.

pub fn device_ptr_mut(&mut self) -> Option<*mut DeviceSpongeState>

Get a mutable pointer to the device state buffer.

Returns None if the device buffer hasn’t been allocated yet. Call sync_h2d to allocate and initialize the device buffer.

pub fn grind_gpu( &mut self, bits: usize, device_ctx: &GpuDeviceCtx, ) -> Result<F, GrindError>

Perform GPU-accelerated grinding to find a proof-of-work witness.

This syncs state to device, runs the grinding kernel, and updates the host state with the witness.

Arguments

• bits - Number of bits that must be zero in the sampled value

Returns

The PoW witness value that satisfies sample_bits(bits) == 0 after observing it.

Note

After this call, the host state will have observed the witness and sampled, matching the state after calling check_witness(bits, witness).

Trait Implementations

impl Clone for DuplexSpongeGpu

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DuplexSpongeGpu

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DuplexSpongeGpu

fn default() -> Self

Returns the “default value” for a type.

impl FiatShamirTranscript<BabyBearPoseidon2Config> for DuplexSpongeGpu

fn observe(&mut self, value: F)

fn sample(&mut self) -> F

fn observe_commit(&mut self, digest: Digest)

Implementations should pass through to Self::observe, but no default implementation is provided since an explicit conversion from Digest to array of F is required.

fn observe_ext(&mut self, value: <SC as StarkProtocolConfig>::EF)

fn sample_ext(&mut self) -> <SC as StarkProtocolConfig>::EF

fn sample_bits(&mut self, bits: usize) -> u64

Samples and returns an integer in the range [0, 2^bits).

fn check_witness( &mut self, bits: usize, witness: <SC as StarkProtocolConfig>::F, ) -> bool

Checks a proof-of-work witness: observes witness into the transcript and accepts iff the next Self::sample_bits is zero (probability ≈ 2^{-bits} for a random witness, so Self::grind tries ≈ 2^bits witnesses to find one).

fn grind(&mut self, bits: usize) -> <SC as StarkProtocolConfig>::F

Finds a proof-of-work witness w such that Self::check_witness(bits, w) holds, by brute force over the base field.

impl GpuFiatShamirTranscript<BabyBearPoseidon2Config> for DuplexSpongeGpu

fn grind_gpu( &mut self, bits: usize, device_ctx: &GpuDeviceCtx, ) -> Result<F, GrindError>

GPU-accelerated proof-of-work grinding.