slitter 0.1.0

A C- and Rust-callable slab allocator with a focus on safety
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

#pragma once

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <sys/types.h>

#include "constants.h"

/**
 * Matches `MagazineStorage` on the Rust side.
 */
struct magazine_storage {
	void *allocations[SLITTER__MAGAZINE_SIZE];
        /*
         * The `link` pointer is only used by the C side.
         * It's always NULL (None) on the Rust side.
         */
	struct magazine_storage *volatile link;
	uint32_t num_allocated_slow;
};

/**
 * Matches `MagazineImpl` on the Rust side.
 *
 * `top_of_stack` goes from SLITTER__MAGAZINE_SIZE to 0 when popping,
 * and from -SLITTER__MAGAZINE_SIZE to 0 when pushing.  In both cases,
 * `storage->allocations` is populated with cached objects
 * at low indices, and empty / garbage at high ones.
 */
struct magazine {
	ssize_t top_of_stack;
	struct magazine_storage *storage;
};

/**
 * Returns whether the magazine is exhausted (empty for push
 * magazines, full for pop ones).
 */
inline bool
slitter__magazine_is_exhausted(const struct magazine *restrict mag)
{

	return mag->top_of_stack == 0;
}

/**
 * Consumes one cached allocation from a non-exhausted "Pop" magazine.
 */
inline void *
slitter__magazine_get_non_empty(struct magazine *restrict mag)
{
	void *ret;

	ret = mag->storage->allocations[--mag->top_of_stack];
	if (ret == NULL)
		__builtin_unreachable();

	return ret;
}

/**
 * Pushes one cached allocation to a non-exhausted "Push" magazine.
 */
inline void
slitter__magazine_put_non_full(struct magazine *restrict mag, void *alloc)
{

	mag->storage->allocations
	    [SLITTER__MAGAZINE_SIZE + mag->top_of_stack++] = alloc;
	return;
}

/**
 * Attempts to consume one cached allocation from a "Pop" magazine.
 *
 * Returns the cached allocation on success, NULL on failure.
 */
void *slitter__magazine_get(struct magazine *restrict mag);

/**
 * Attempts to push one allocation to a "Push" magazine.
 *
 * Returns NULL on success, `alloc` on failure.
 */
void *slitter__magazine_put(struct magazine *restrict mag, void *alloc);

/**
 * Returns `sizeof(struct magazine_storage)`.
 */
size_t slitter__magazine_storage_sizeof(void);

/**
 * Returns `sizeof(struct magazine)`.
 */
size_t slitter__magazine_sizeof(void);