sp1-cuda 6.3.0

CUDA integration for SP1 GPU proving
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use std::sync::Arc;

use sp1_primitives::Elf;
use sp1_prover::SP1VerifyingKey;

use crate::client::CudaClient;

#[derive(Clone)]
pub struct CudaProvingKey {
    /// The inner session key type, tells the server
    /// to drop the key it holds when the last reference to this session is dropped.
    inner: Arc<SessionKey>,
}

impl CudaProvingKey {
    pub(crate) fn id(&self) -> [u8; 32] {
        self.inner.id
    }

    pub fn elf(&self) -> &Elf {
        &self.inner.elf
    }

    pub fn verifying_key(&self) -> &SP1VerifyingKey {
        &self.inner.vk
    }
}

impl CudaProvingKey {
    pub(crate) fn new(id: [u8; 32], elf: Elf, vk: SP1VerifyingKey, client: CudaClient) -> Self {
        Self { inner: Arc::new(SessionKey::new(id, elf, vk, client)) }
    }
}

/// A "reference" to a key held by the CUDA server.
pub(crate) struct SessionKey {
    /// THe ID of the actual proving key stored in the server.
    id: [u8; 32],
    /// The ELF of the program.
    elf: Elf,
    /// The verifying key of the program.
    vk: SP1VerifyingKey,
    /// A client to the server that created this key.
    client: CudaClient,
}

impl SessionKey {
    pub(crate) const fn new(
        id: [u8; 32],
        elf: Elf,
        vk: SP1VerifyingKey,
        client: CudaClient,
    ) -> Self {
        Self { id, elf, vk, client }
    }
}

impl Drop for SessionKey {
    fn drop(&mut self) {
        let client = self.client.clone();
        let id = std::mem::take(&mut self.id);

        tokio::spawn(async move {
            if let Err(e) = client.destroy(id).await {
                tracing::error!("Failed to destroy session key: {}", e);
            }
        });
    }
}