Simple.xs

filter: Statementstmt 68.4% 89 / 130 Branchbran 51.2% 40 / 78 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 62.0% 129 / 208 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« src/oa_hash.c ↑ Summary blib/lib/Shared/Simple.pm »
1 #define PERL_NO_GET_CONTEXT
2 #include "EXTERN.h"
3 #include "perl.h"
4 #include "XSUB.h"
5  
6 #include "ppport.h"
7  
8 #include <sys/mman.h>
9 #include <stdatomic.h>
10 #include "src/shared.h"
11 #include "src/log.h"
12  
13 uint64_t p_time;
14  
15 MODULE = Shared::Simple PACKAGE = Shared::Simple
16  
17 SV*
18 new(class, name, mode = SHM_OPEN_SHARED)
19 SV* class
20 char* name
21 int mode
22 PREINIT:
23 process* p;
24 shm_control_block* blk;
25 char ctrl_name[NAME_MAX + 2];
26 char data_name[NAME_MAX + 8];
27 int rc;
28 CODE:
29 2 ▶ if (snprintf(ctrl_name, sizeof(ctrl_name), "/%s", name) >= (int)sizeof(ctrl_name) ||
Branch: 1 branch
BranchTrueFalseTotal
if (snprintf(ctrl_name, sizeof(ctrl_name), "/%s", name) >= (int)sizeof(ctrl_name) || 2 0 2
30 2 ▶ snprintf(data_name, sizeof(data_name), "/%s_data", name) >= (int)sizeof(data_name)) {
Branch: 1 branch
BranchTrueFalseTotal
snprintf(data_name, sizeof(data_name), "/%s_data", name) >= (int)sizeof(data_name)) { 0 2 2
31 0 croak("Shared::Simple::new: name too long");
32 }
33  
34 2 ▶ if (mode == SHM_OPEN_EXCLUSIVE) {
Branch: 1 branch
BranchTrueFalseTotal
if (mode == SHM_OPEN_EXCLUSIVE) { 2 0 2
35 /* Wipe any existing segments so we always start with a clean slate.
36 Errors are ignored — the segments may not exist yet. */
37 2 shm_unlink(ctrl_name);
38 2 shm_unlink(data_name);
39 }
40  
41 2 Newxz(p, 1, process);
42  
43 2 ▶ if (open_shared_memory(&p->cntrl_blk, ctrl_name, sizeof(shm_control_block)) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (open_shared_memory(&p->cntrl_blk, ctrl_name, sizeof(shm_control_block)) != 0) { 0 2 2
44 0 Safefree(p);
45 0 croak("Shared::Simple::new: failed to open control block '%s'", ctrl_name);
46 }
47  
48 2 blk = (shm_control_block*) p->cntrl_blk.data;
49 2 rc = try_lock_shm_for_init(blk, 5000);
50  
51 2 ▶ if (rc == 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (rc == 1) { 2 0 2
52 /* won the init race — first process, set up a fresh table */
53 2 Sizes caps = { .index = 64, .data = 512 };
54 2 size_t data_size = ht_table_size(caps.index, caps.data);
55  
56 2 init_shared_mutex(&blk->lock);
57 2 strncpy(blk->name, data_name, NAME_MAX - 1);
58 2 blk->name[NAME_MAX - 1] = '\0';
59  
60 2 ▶ if (open_shared_memory(&p->data_blk, data_name, data_size) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (open_shared_memory(&p->data_blk, data_name, data_size) != 0) { 0 2 2
61 0 munmap(p->cntrl_blk.data, p->cntrl_blk.size);
62 0 Safefree(p);
63 0 croak("Shared::Simple::new: failed to create data block '%s'", data_name);
64 }
65 2 ht_init_table(&p->table, caps, p->data_blk.data);
66 /* data_size must be visible before init_state — release ordering ensures
67 that any process seeing SHM_INIT_DONE also sees the correct data_size. */
68 2 atomic_store_explicit(&blk->data_size, (uint64_t)data_size, memory_order_release);
69 2 atomic_store_explicit(&blk->init_state, SHM_INIT_DONE, memory_order_release);
70 2 ▶ LOG("create new shm %s with %llu\n", blk->name, (unsigned long long)blk->data_size);
Branch: 1 branch
BranchTrueFalseTotal
LOG("create new shm %s with %llu\n", blk->name, (unsigned long long)blk->data_size); 2 0 2
71  
72 0 ▶ } else if (rc == 0) {
Branch: 1 branch
BranchTrueFalseTotal
} else if (rc == 0) { 0 0 0
73 /* already initialized — acquire the mutex before attaching so we
74 cannot race with a concurrent reallocate() (Race 3a fix). */
75 0 ▶ LOG("attaching to already initialized shm %s with %llu\n", blk->name, (unsigned long long)blk->data_size);
Branch: 1 branch
BranchTrueFalseTotal
LOG("attaching to already initialized shm %s with %llu\n", blk->name, (unsigned long long)blk->data_size); 0 0 0
76 0 ▶ if (shared_lock(&blk->lock) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (shared_lock(&blk->lock) != 0) { 0 0 0
77 0 munmap(p->cntrl_blk.data, p->cntrl_blk.size);
78 0 Safefree(p);
79 0 croak("Shared::Simple::new: failed to acquire lock for attach");
80 }
81 0 int tbl_rc = open_table_in_shm(p);
82 0 pthread_mutex_unlock(&blk->lock);
83 0 ▶ if (tbl_rc != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (tbl_rc != 0) { 0 0 0
84 0 munmap(p->cntrl_blk.data, p->cntrl_blk.size);
85 0 Safefree(p);
86 0 croak("Shared::Simple::new: failed to open existing data block");
87 }
88 } else {
89 /* timeout waiting for another process to finish initializing */
90 0 munmap(p->cntrl_blk.data, p->cntrl_blk.size);
91 0 Safefree(p);
92 0 croak("Shared::Simple::new: timed out waiting for shared memory initialization");
93 }
94  
95 2 RETVAL = sv_bless(
96 newRV_noinc(newSViv(PTR2IV(p))),
97 gv_stashsv(class, GV_ADD)
98 );
99 OUTPUT:
100 RETVAL
101  
102 int
103 put(self, key, value)
104 SV* self
105 SV* key
106 SV* value
107 PREINIT:
108 process* p;
109 shm_control_block* blk;
110 const char* kstr;
111 STRLEN klen;
112 STRLEN vlen;
113 OA_HASH_ERR err;
114 Stats stats;
115 CODE:
116 8 ▶ if (!SvOK(key))
Branch: 1 branch
BranchTrueFalseTotal
if (!SvOK(key)) 1 7 8
117 1 croak("Shared::Simple::put: key must be defined");
118 7 kstr = SvPV(key, klen);
119 7 ▶ if (klen == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (klen == 0) 1 6 7
120 1 croak("Shared::Simple::put: key must not be empty");
121 6 ▶ if (!SvOK(value))
Branch: 1 branch
BranchTrueFalseTotal
if (!SvOK(value)) 0 6 6
122 0 croak("Shared::Simple::put: value must be defined");
123 6 const char* vstr = SvPV(value, vlen);
124 6 ▶ if (vlen == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (vlen == 0) 1 5 6
125 1 croak("Shared::Simple::put: value must not be empty");
126 5 ▶ if (vlen > VALUE_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (vlen > VALUE_SIZE) 1 4 5
127 1 croak("Shared::Simple::put: value must not exceed %d bytes", VALUE_SIZE);
128  
129 char val_buf[VALUE_SIZE];
130 4 memset(val_buf, 0, VALUE_SIZE);
131 4 memcpy(val_buf, vstr, vlen);
132  
133 4 p = INT2PTR(process*, SvIV(SvRV(self)));
134 4 blk = (shm_control_block*) p->cntrl_blk.data;
135 4 memset(&stats, 0, sizeof(stats));
136  
137 4 ▶ if (shared_lock(&blk->lock) != 0)
Branch: 1 branch
BranchTrueFalseTotal
if (shared_lock(&blk->lock) != 0) 0 4 4
138 0 croak("Shared::Simple::put: failed to acquire lock");
139  
140 /* Race 3b: re-attach if another process resized the data block */
141 4 if ((uint64_t)p->data_blk.size !=
142 4 ▶ atomic_load_explicit(&blk->data_size, memory_order_acquire)) {
Branch: 1 branch
BranchTrueFalseTotal
atomic_load_explicit(&blk->data_size, memory_order_acquire)) { 0 4 4
143 0 ▶ if (open_table_in_shm(p) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (open_table_in_shm(p) != 0) { 0 0 0
144 0 pthread_mutex_unlock(&blk->lock);
145 0 croak("Shared::Simple::put: failed to re-attach resized data block");
146 }
147 }
148  
149 4 err = ht_insert(&p->table, kstr, val_buf, &stats);
150 4 ▶ if (err == OA_HASH_ERR_INDEX_FULL || err == OA_HASH_ERR_DATA_FULL) {
Branch: 2 branches
BranchTrueFalseTotal
if (err == OA_HASH_ERR_INDEX_FULL || err == OA_HASH_ERR_DATA_FULL) { 4 0 4
if (err == OA_HASH_ERR_INDEX_FULL || err == OA_HASH_ERR_DATA_FULL) { 0 4 4
151 0 Sizes new_caps = ht_resize_table(&p->table, 2);
152 0 ▶ if (reallocate(blk, &p->data_blk, &p->table, new_caps) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (reallocate(blk, &p->data_blk, &p->table, new_caps) != 0) { 0 0 0
153 0 pthread_mutex_unlock(&blk->lock);
154 0 croak("Shared::Simple::put: failed to reallocate shared memory");
155 }
156 0 err = ht_insert(&p->table, kstr, val_buf, &stats);
157 }
158 4 pthread_mutex_unlock(&blk->lock);
159  
160 4 ▶ if (err != OA_HASH_OK)
Branch: 1 branch
BranchTrueFalseTotal
if (err != OA_HASH_OK) 0 4 4
161 0 croak("Shared::Simple::put: insert failed (%d)", (int)err);
162 4 ▶ RETVAL = 1;
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = 1; 0 4 4
163 OUTPUT:
164 RETVAL
165  
166 SV*
167 get(self, key)
168 SV* self
169 SV* key
170 PREINIT:
171 process* p;
172 shm_control_block* blk;
173 const char* kstr;
174 STRLEN klen;
175 HashEntry entry;
176 OA_HASH_ERR err;
177 CODE:
178 5 ▶ if (!SvOK(key))
Branch: 1 branch
BranchTrueFalseTotal
if (!SvOK(key)) 1 4 5
179 1 croak("Shared::Simple::get: key must be defined");
180 4 kstr = SvPV(key, klen);
181 4 ▶ if (klen == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (klen == 0) 1 3 4
182 1 croak("Shared::Simple::get: key must not be empty");
183  
184 3 p = INT2PTR(process*, SvIV(SvRV(self)));
185 3 blk = (shm_control_block*) p->cntrl_blk.data;
186  
187 3 ▶ if (shared_lock(&blk->lock) != 0)
Branch: 1 branch
BranchTrueFalseTotal
if (shared_lock(&blk->lock) != 0) 0 3 3
188 0 croak("Shared::Simple::get: failed to acquire lock");
189  
190 /* Race 3b: re-attach if another process resized the data block */
191 3 if ((uint64_t)p->data_blk.size !=
192 3 ▶ atomic_load_explicit(&blk->data_size, memory_order_acquire)) {
Branch: 1 branch
BranchTrueFalseTotal
atomic_load_explicit(&blk->data_size, memory_order_acquire)) { 0 3 3
193 0 ▶ if (open_table_in_shm(p) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (open_table_in_shm(p) != 0) { 0 0 0
194 0 pthread_mutex_unlock(&blk->lock);
195 0 croak("Shared::Simple::get: failed to re-attach resized data block");
196 }
197 }
198  
199 3 err = ht_lookup(&p->table, kstr, &entry);
200 3 pthread_mutex_unlock(&blk->lock);
201  
202 3 ▶ if (err == OA_HASH_ERR_NOT_FOUND) {
Branch: 1 branch
BranchTrueFalseTotal
if (err == OA_HASH_ERR_NOT_FOUND) { 1 2 3
203 1 RETVAL = newSV(0); /* undef — key not present */
204 2 ▶ } else if (err != OA_HASH_OK) {
Branch: 1 branch
BranchTrueFalseTotal
} else if (err != OA_HASH_OK) { 0 2 2
205 0 croak("Shared::Simple::get: lookup failed (%d)", (int)err);
206 } else {
207 2 RETVAL = newSVpvn(entry.value, strnlen(entry.value, VALUE_SIZE));
208 }
209 OUTPUT:
210 RETVAL
211  
212 IV
213 get_size(self)
214 SV* self
215 PREINIT:
216 process* p;
217 Sizes sizes;
218 CODE:
219 2 p = INT2PTR(process*, SvIV(SvRV(self)));
220 2 sizes.storable = atomic_load_explicit(&p->table.sizes->sizes, memory_order_acquire);
221 2 ▶ RETVAL = (IV)sizes.index;
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = (IV)sizes.index; 0 2 2
222 OUTPUT:
223 RETVAL
224  
225 SV*
226 get_all(self)
227 SV* self
228 PREINIT:
229 process* p;
230 shm_control_block* blk;
231 Sizes capacities;
232 HV* result;
233 uint32_t i;
234 HashEntry entry;
235 CODE:
236 1 p = INT2PTR(process*, SvIV(SvRV(self)));
237 1 blk = (shm_control_block*) p->cntrl_blk.data;
238  
239 1 ▶ if (shared_lock(&blk->lock) != 0)
Branch: 1 branch
BranchTrueFalseTotal
if (shared_lock(&blk->lock) != 0) 0 1 1
240 0 croak("Shared::Simple::get_all: failed to acquire lock");
241  
242 1 if ((uint64_t)p->data_blk.size !=
243 1 ▶ atomic_load_explicit(&blk->data_size, memory_order_acquire)) {
Branch: 1 branch
BranchTrueFalseTotal
atomic_load_explicit(&blk->data_size, memory_order_acquire)) { 0 1 1
244 0 ▶ if (open_table_in_shm(p) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (open_table_in_shm(p) != 0) { 0 0 0
245 0 pthread_mutex_unlock(&blk->lock);
246 0 croak("Shared::Simple::get_all: failed to re-attach resized data block");
247 }
248 }
249  
250 1 result = newHV();
251 1 capacities.storable = atomic_load_explicit(&p->table.sizes->capacities, memory_order_acquire);
252  
253 65 ▶ for (i = 0; i < capacities.index; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < capacities.index; i++) { 64 1 65
254 64 HashIndexEntry* idx = p->table.index_entries + i;
255 64 Key k = { .storable = atomic_load_explicit(&idx->key, memory_order_acquire) };
256 64 ▶ if (k.status != COMMITED)
Branch: 1 branch
BranchTrueFalseTotal
if (k.status != COMMITED) 61 3 64
257 61 continue;
258 3 ht_get_entry(&p->table, idx, &entry);
259 3 hv_store(result,
260 entry.key, strlen(entry.key),
261 newSVpvn(entry.value, strnlen(entry.value, VALUE_SIZE)),
262 0);
263 }
264  
265 1 pthread_mutex_unlock(&blk->lock);
266 1 RETVAL = newRV_noinc((SV*)result);
267 OUTPUT:
268 RETVAL
269  
270 void
271 DESTROY(self)
272 SV* self
273 PREINIT:
274 process* p;
275 CODE:
276 2 p = INT2PTR(process*, SvIV(SvRV(self)));
277 2 ▶ if (p->data_blk.data)
Branch: 1 branch
BranchTrueFalseTotal
if (p->data_blk.data) 2 0 2
278 2 munmap(p->data_blk.data, p->data_blk.size);
279 2 ▶ if (p->cntrl_blk.data)
Branch: 1 branch
BranchTrueFalseTotal
if (p->cntrl_blk.data) 2 0 2
280 2 munmap(p->cntrl_blk.data, p->cntrl_blk.size);
281 2 Safefree(p);
282  
283 BOOT:
284 {
285 3 HV *stash = gv_stashpv("Shared::Simple", GV_ADD);
286 3 newCONSTSUB(stash, "SHARED", newSViv(SHM_OPEN_SHARED));
287 3 newCONSTSUB(stash, "EXCLUSIVE", newSViv(SHM_OPEN_EXCLUSIVE));
288 }
« src/oa_hash.c ↑ Summary blib/lib/Shared/Simple.pm »