rust-samp-sdk 3.0.0

Low-level FFI bindings for the SA-MP AMX virtual machine and open.mp native component ABI. Used internally by `rust-samp`; depend on it directly only if you need raw access without the higher-level macros and lifecycle.
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Benchmarks for Buffer/CellConvert operations.
//!
//! Compares performance of `get_as`, `set_as` and `iter_as` for typed types
//! (`f32`, `bool`, `i32`) across buffers of varying sizes.
//!
//! Run with:
//! ```sh
//! cargo bench -p samp-sdk --target i686-unknown-linux-gnu
//! ```

use std::hint::black_box;

use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
use samp_sdk::cell::repr::CellConvert;
use samp_sdk::cell::{Buffer, Ref};

// ---------------------------------------------------------------------------
// Construction helper (no real AMX)
// ---------------------------------------------------------------------------

fn make_buffer(data: &mut Vec<i32>) -> Buffer<'_> {
    let len = data.len();
    let r = unsafe { Ref::new(0, data.as_mut_ptr()) };
    Buffer::new(r, len)
}

// ---------------------------------------------------------------------------
// bench: get_as::<f32> — typed cell read
// ---------------------------------------------------------------------------

fn bench_get_as_f32(c: &mut Criterion) {
    let mut group = c.benchmark_group("buffer/get_as_f32");

    for size in [8usize, 64, 256, 1024] {
        // `size` is a small literal (max 1024) — `as f32` is exact.
        #[allow(clippy::cast_precision_loss)]
        let values: Vec<f32> = (0..size).map(|i| i as f32 * 0.5).collect();
        let mut data: Vec<i32> = values.iter().map(|&v| v.into_cell()).collect();

        group.bench_with_input(BenchmarkId::new("len", size), &size, |b, &size| {
            b.iter(|| {
                let buf = make_buffer(&mut data);
                let mut sum = 0.0f32;
                for i in 0..size {
                    if let Some(v) = buf.get_as::<f32>(i) {
                        sum += v;
                    }
                }
                black_box(sum);
            });
        });
    }
    group.finish();
}

// ---------------------------------------------------------------------------
// bench: set_as::<bool> — typed cell write
// ---------------------------------------------------------------------------

fn bench_set_as_bool(c: &mut Criterion) {
    let mut group = c.benchmark_group("buffer/set_as_bool");

    for size in [8usize, 64, 256, 1024] {
        group.bench_with_input(BenchmarkId::new("len", size), &size, |b, &size| {
            b.iter(|| {
                let mut data = vec![0i32; size];
                let mut buf = make_buffer(&mut data);
                for i in 0..size {
                    buf.set_as(i, i % 2 == 0);
                }
            });
        });
    }
    group.finish();
}

// ---------------------------------------------------------------------------
// bench: iter_as::<i32> — typed iteration over the whole buffer
// ---------------------------------------------------------------------------

fn bench_iter_as_i32(c: &mut Criterion) {
    let mut group = c.benchmark_group("buffer/iter_as_i32");

    for size in [8usize, 64, 256, 1024] {
        let size_i32 = i32::try_from(size).expect("size literal fits in i32");
        let mut data: Vec<i32> = (0..size_i32).collect();

        group.bench_with_input(BenchmarkId::new("len", size), &size, |b, _| {
            b.iter(|| {
                let buf = make_buffer(&mut data);
                let sum: i32 = buf.iter_as::<i32>().sum();
                black_box(sum);
            });
        });
    }
    group.finish();
}

// ---------------------------------------------------------------------------
// bench: iter_as::<f32> — typed iteration with bit conversion
// ---------------------------------------------------------------------------

fn bench_iter_as_f32(c: &mut Criterion) {
    let mut group = c.benchmark_group("buffer/iter_as_f32");

    for size in [8usize, 64, 256, 1024] {
        // `size` is a small literal (max 1024) — `as f32` is exact.
        #[allow(clippy::cast_precision_loss)]
        let values: Vec<f32> = (0..size).map(|i| i as f32).collect();
        let mut data: Vec<i32> = values.iter().map(|&v| v.into_cell()).collect();

        group.bench_with_input(BenchmarkId::new("len", size), &size, |b, _| {
            b.iter(|| {
                let buf = make_buffer(&mut data);
                let sum: f32 = buf.iter_as::<f32>().sum();
                black_box(sum);
            });
        });
    }
    group.finish();
}

criterion_group!(
    benches,
    bench_get_as_f32,
    bench_set_as_bool,
    bench_iter_as_i32,
    bench_iter_as_f32,
);
criterion_main!(benches);