j2k-cuda-runtime 0.8.1

CUDA codec engine and Driver API runtime for j2k device adapters
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// SPDX-License-Identifier: MIT OR Apache-2.0

use super::*;

fn kernel_error() -> CudaError {
    CudaError::KernelStatus {
        kernel: "test_kernel",
        code: 7,
        detail: 11,
    }
}

fn release_error() -> CudaError {
    CudaError::StatePoisoned {
        message: "release failed".to_string(),
    }
}

#[test]
fn ht_cleanup_status_preserves_the_failing_descriptor_index() {
    let statuses = [
        CudaHtj2kStatus::default(),
        CudaHtj2kStatus {
            code: 7,
            detail: 11,
            ..CudaHtj2kStatus::default()
        },
    ];
    assert!(matches!(
        first_status_error(&statuses, "test_kernel"),
        Some(CudaError::KernelJobStatus {
            kernel: "test_kernel",
            job_index: 1,
            code: 7,
            detail: 11,
        })
    ));
}

#[test]
fn grouped_ht_cleanup_status_preserves_the_global_descriptor_index_and_kernel() {
    let statuses = [
        CudaHtj2kStatus::default(),
        CudaHtj2kStatus::default(),
        CudaHtj2kStatus {
            code: 9,
            detail: 17,
            ..CudaHtj2kStatus::default()
        },
    ];
    let spans = [
        CudaHtj2kStatusSpan {
            start: 0,
            count: 1,
            kernel: "cleanup_only",
        },
        CudaHtj2kStatusSpan {
            start: 1,
            count: 2,
            kernel: "refinement",
        },
    ];
    assert!(matches!(
        first_group_status_error(&statuses, &spans),
        Some(CudaError::KernelJobStatus {
            kernel: "refinement",
            job_index: 2,
            code: 9,
            detail: 17,
        })
    ));
}

#[test]
fn kernel_and_release_failures_are_both_preserved() {
    let error = select_status_release_result(
        CudaExecutionStats::default(),
        Some(kernel_error()),
        Err(release_error()),
    )
    .expect_err("compound failure");
    assert!(matches!(error, CudaError::ResourceReleaseFailed { .. }));
    let rendered = error.to_string();
    assert!(rendered.contains("status 7 detail 11"));
    assert!(rendered.contains("release failed"));
}

#[test]
fn single_failure_and_success_paths_keep_their_original_result() {
    assert!(matches!(
        select_status_release_result(CudaExecutionStats::default(), Some(kernel_error()), Ok(())),
        Err(CudaError::KernelStatus { .. })
    ));
    assert!(matches!(
        select_status_release_result(CudaExecutionStats::default(), None, Err(release_error())),
        Err(CudaError::StatePoisoned { .. })
    ));
    assert!(select_status_release_result(CudaExecutionStats::default(), None, Ok(())).is_ok());
}