prometheus-client-mmap 0.9.8 → 0.12.0

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 699286c1c257884747f07061bf5dcb7c078720b5c8c81826965e826b3c3e727a
4
- data.tar.gz: 61d2caba4d09883699471a4c631a60168fed152d38a59ff069be08527a3f65f5
3
+ metadata.gz: 3fec107115b6e90ebfbc109f0603bb44ca7d7165e637a2e6448ce463ab54c3c7
4
+ data.tar.gz: 9e9e0382069f57aebe0fb35508a1b82a8e1c61b4b228be573807241b2a434fb8
5
5
  SHA512:
6
- metadata.gz: ac048db43f14bc544fbd199b178e62536b6a4f2ebb1e13f33d7540d847bf3c0e44ee9af97693a26ea3b227aebc29568a9fbedce8fac467e591329090ce6aadbf
7
- data.tar.gz: 5185dbbd600e6fb91615361a5621feefb1ac2fd65f90439a9daf9e7b69d59a72e083ef7d174b97f92109056396c5afccfd0961a9c6d6bcc52267e43f9db9c19b
6
+ metadata.gz: 6747ece05958e5b65a92e7305e8edb167e7ffafa84d5f0b24ccc56e8c8977add781f7c88eab1ecca117ae88bb0bbd7150273307f0c5314f33249246cef317dbf
7
+ data.tar.gz: 7454daa53c15a7cf57e359ebec87dda164609ad43620ebf8a72e287cac4113caba08de8ca3ba2d1efdcf1c0a05f2bdbfb7c2b524d8eb27e63444844f06469ed5
@@ -1,20 +1,17 @@
1
1
  #include <errno.h>
2
+ #include <hashmap.h>
3
+ #include <jsmn.h>
2
4
  #include <ruby.h>
3
5
  #include <ruby/intern.h>
4
-
5
6
  #include <sys/mman.h>
6
7
 
7
- #include <hashmap.h>
8
- #include <jsmn.h>
9
-
10
- #include "globals.h"
11
- #include "utils.h"
12
- #include "value_access.h"
13
-
14
8
  #include "file_parsing.h"
15
9
  #include "file_reading.h"
10
+ #include "globals.h"
16
11
  #include "mmap.h"
17
12
  #include "rendering.h"
13
+ #include "utils.h"
14
+ #include "value_access.h"
18
15
 
19
16
  VALUE MMAPED_FILE = Qnil;
20
17
 
@@ -1,9 +1,9 @@
1
+ #include "file_parsing.h"
2
+
1
3
  #include <hashmap.h>
2
4
  #include <jsmn.h>
3
- #include <ruby.h>
4
5
 
5
6
  #include "file_format.h"
6
- #include "file_parsing.h"
7
7
  #include "globals.h"
8
8
  #include "utils.h"
9
9
 
@@ -2,6 +2,7 @@
2
2
  #define FILE_PARSING_H
3
3
  #include <file_reading.h>
4
4
  #include <hashmap.h>
5
+ #include <ruby.h>
5
6
 
6
7
  typedef struct {
7
8
  char *json;
@@ -1,8 +1,8 @@
1
+ #include "file_reading.h"
2
+
1
3
  #include <errno.h>
2
4
  #include <fcntl.h>
3
- #include <ruby.h>
4
5
 
5
- #include "file_reading.h"
6
6
  #include "utils.h"
7
7
 
8
8
  static int file_open(file_t *source, const char *filepath) {
@@ -0,0 +1,692 @@
1
+ /*
2
+ * Copyright (c) 2016-2017 David Leeds <davidesleeds@gmail.com>
3
+ *
4
+ * Hashmap is free software; you can redistribute it and/or modify
5
+ * it under the terms of the MIT license. See LICENSE for details.
6
+ */
7
+
8
+ #include <stdlib.h>
9
+ #include <stdint.h>
10
+ #include <stdbool.h>
11
+ #include <string.h>
12
+ #include <errno.h>
13
+
14
+ #include "hashmap.h"
15
+
16
+ #ifndef HASHMAP_NOASSERT
17
+ #include <assert.h>
18
+ #define HASHMAP_ASSERT(expr) assert(expr)
19
+ #else
20
+ #define HASHMAP_ASSERT(expr)
21
+ #endif
22
+
23
+ /* Table sizes must be powers of 2 */
24
+ #define HASHMAP_SIZE_MIN (1 << 5) /* 32 */
25
+ #define HASHMAP_SIZE_DEFAULT (1 << 8) /* 256 */
26
+ #define HASHMAP_SIZE_MOD(map, val) ((val) & ((map)->table_size - 1))
27
+
28
+ /* Limit for probing is 1/2 of table_size */
29
+ #define HASHMAP_PROBE_LEN(map) ((map)->table_size >> 1)
30
+ /* Return the next linear probe index */
31
+ #define HASHMAP_PROBE_NEXT(map, index) HASHMAP_SIZE_MOD(map, (index) + 1)
32
+
33
+ /* Check if index b is less than or equal to index a */
34
+ #define HASHMAP_INDEX_LE(map, a, b) \
35
+ ((a) == (b) || (((b) - (a)) & ((map)->table_size >> 1)) != 0)
36
+
37
+
38
+ struct hashmap_entry {
39
+ void *key;
40
+ void *data;
41
+ #ifdef HASHMAP_METRICS
42
+ size_t num_collisions;
43
+ #endif
44
+ };
45
+
46
+
47
+ /*
48
+ * Enforce a maximum 0.75 load factor.
49
+ */
50
+ static inline size_t hashmap_table_min_size_calc(size_t num_entries)
51
+ {
52
+ return num_entries + (num_entries / 3);
53
+ }
54
+
55
+ /*
56
+ * Calculate the optimal table size, given the specified max number
57
+ * of elements.
58
+ */
59
+ static size_t hashmap_table_size_calc(size_t num_entries)
60
+ {
61
+ size_t table_size;
62
+ size_t min_size;
63
+
64
+ table_size = hashmap_table_min_size_calc(num_entries);
65
+
66
+ /* Table size is always a power of 2 */
67
+ min_size = HASHMAP_SIZE_MIN;
68
+ while (min_size < table_size) {
69
+ min_size <<= 1;
70
+ }
71
+ return min_size;
72
+ }
73
+
74
+ /*
75
+ * Get a valid hash table index from a key.
76
+ */
77
+ static inline size_t hashmap_calc_index(const struct hashmap *map,
78
+ const void *key)
79
+ {
80
+ return HASHMAP_SIZE_MOD(map, map->hash(key));
81
+ }
82
+
83
+ /*
84
+ * Return the next populated entry, starting with the specified one.
85
+ * Returns NULL if there are no more valid entries.
86
+ */
87
+ static struct hashmap_entry *hashmap_entry_get_populated(
88
+ const struct hashmap *map, struct hashmap_entry *entry)
89
+ {
90
+ for (; entry < &map->table[map->table_size]; ++entry) {
91
+ if (entry->key) {
92
+ return entry;
93
+ }
94
+ }
95
+ return NULL;
96
+ }
97
+
98
+ /*
99
+ * Find the hashmap entry with the specified key, or an empty slot.
100
+ * Returns NULL if the entire table has been searched without finding a match.
101
+ */
102
+ static struct hashmap_entry *hashmap_entry_find(const struct hashmap *map,
103
+ const void *key, bool find_empty)
104
+ {
105
+ size_t i;
106
+ size_t index;
107
+ size_t probe_len = HASHMAP_PROBE_LEN(map);
108
+ struct hashmap_entry *entry;
109
+
110
+ index = hashmap_calc_index(map, key);
111
+
112
+ /* Linear probing */
113
+ for (i = 0; i < probe_len; ++i) {
114
+ entry = &map->table[index];
115
+ if (!entry->key) {
116
+ if (find_empty) {
117
+ #ifdef HASHMAP_METRICS
118
+ entry->num_collisions = i;
119
+ #endif
120
+ return entry;
121
+ }
122
+ return NULL;
123
+ }
124
+ if (map->key_compare(key, entry->key) == 0) {
125
+ return entry;
126
+ }
127
+ index = HASHMAP_PROBE_NEXT(map, index);
128
+ }
129
+ return NULL;
130
+ }
131
+
132
+ /*
133
+ * Removes the specified entry and processes the proceeding entries to reduce
134
+ * the load factor and keep the chain continuous. This is a required
135
+ * step for hash maps using linear probing.
136
+ */
137
+ static void hashmap_entry_remove(struct hashmap *map,
138
+ struct hashmap_entry *removed_entry)
139
+ {
140
+ size_t i;
141
+ #ifdef HASHMAP_METRICS
142
+ size_t removed_i = 0;
143
+ #endif
144
+ size_t index;
145
+ size_t entry_index;
146
+ size_t removed_index = (removed_entry - map->table);
147
+ struct hashmap_entry *entry;
148
+
149
+ /* Free the key */
150
+ if (map->key_free) {
151
+ map->key_free(removed_entry->key);
152
+ }
153
+ --map->num_entries;
154
+
155
+ /* Fill the free slot in the chain */
156
+ index = HASHMAP_PROBE_NEXT(map, removed_index);
157
+ for (i = 1; i < map->table_size; ++i) {
158
+ entry = &map->table[index];
159
+ if (!entry->key) {
160
+ /* Reached end of chain */
161
+ break;
162
+ }
163
+ entry_index = hashmap_calc_index(map, entry->key);
164
+ /* Shift in entries with an index <= to the removed slot */
165
+ if (HASHMAP_INDEX_LE(map, removed_index, entry_index)) {
166
+ #ifdef HASHMAP_METRICS
167
+ entry->num_collisions -= (i - removed_i);
168
+ removed_i = i;
169
+ #endif
170
+ memcpy(removed_entry, entry, sizeof(*removed_entry));
171
+ removed_index = index;
172
+ removed_entry = entry;
173
+ }
174
+ index = HASHMAP_PROBE_NEXT(map, index);
175
+ }
176
+ /* Clear the last removed entry */
177
+ memset(removed_entry, 0, sizeof(*removed_entry));
178
+ }
179
+
180
+ /*
181
+ * Reallocates the hash table to the new size and rehashes all entries.
182
+ * new_size MUST be a power of 2.
183
+ * Returns 0 on success and -errno on allocation or hash function failure.
184
+ */
185
+ static int hashmap_rehash(struct hashmap *map, size_t new_size)
186
+ {
187
+ size_t old_size;
188
+ struct hashmap_entry *old_table;
189
+ struct hashmap_entry *new_table;
190
+ struct hashmap_entry *entry;
191
+ struct hashmap_entry *new_entry;
192
+
193
+ HASHMAP_ASSERT(new_size >= HASHMAP_SIZE_MIN);
194
+ HASHMAP_ASSERT((new_size & (new_size - 1)) == 0);
195
+
196
+ new_table = (struct hashmap_entry *)calloc(new_size,
197
+ sizeof(struct hashmap_entry));
198
+ if (!new_table) {
199
+ return -ENOMEM;
200
+ }
201
+ /* Backup old elements in case of rehash failure */
202
+ old_size = map->table_size;
203
+ old_table = map->table;
204
+ map->table_size = new_size;
205
+ map->table = new_table;
206
+ /* Rehash */
207
+ for (entry = old_table; entry < &old_table[old_size]; ++entry) {
208
+ if (!entry->data) {
209
+ /* Only copy entries with data */
210
+ continue;
211
+ }
212
+ new_entry = hashmap_entry_find(map, entry->key, true);
213
+ if (!new_entry) {
214
+ /*
215
+ * The load factor is too high with the new table
216
+ * size, or a poor hash function was used.
217
+ */
218
+ goto revert;
219
+ }
220
+ /* Shallow copy (intentionally omits num_collisions) */
221
+ new_entry->key = entry->key;
222
+ new_entry->data = entry->data;
223
+ }
224
+ free(old_table);
225
+ return 0;
226
+ revert:
227
+ map->table_size = old_size;
228
+ map->table = old_table;
229
+ free(new_table);
230
+ return -EINVAL;
231
+ }
232
+
233
+ /*
234
+ * Iterate through all entries and free all keys.
235
+ */
236
+ static void hashmap_free_keys(struct hashmap *map)
237
+ {
238
+ struct hashmap_iter *iter;
239
+
240
+ if (!map->key_free) {
241
+ return;
242
+ }
243
+ for (iter = hashmap_iter(map); iter;
244
+ iter = hashmap_iter_next(map, iter)) {
245
+ map->key_free((void *)hashmap_iter_get_key(iter));
246
+ }
247
+ }
248
+
249
+ /*
250
+ * Initialize an empty hashmap. A hash function and a key comparator are
251
+ * required.
252
+ *
253
+ * hash_func should return an even distribution of numbers between 0
254
+ * and SIZE_MAX varying on the key provided.
255
+ *
256
+ * key_compare_func should return 0 if the keys match, and non-zero otherwise.
257
+ *
258
+ * initial_size is optional, and may be set to the max number of entries
259
+ * expected to be put in the hash table. This is used as a hint to
260
+ * pre-allocate the hash table to the minimum size needed to avoid
261
+ * gratuitous rehashes. If initial_size 0, a default size will be used.
262
+ *
263
+ * Returns 0 on success and -errno on failure.
264
+ */
265
+ int hashmap_init(struct hashmap *map, size_t (*hash_func)(const void *),
266
+ int (*key_compare_func)(const void *, const void *),
267
+ size_t initial_size)
268
+ {
269
+ HASHMAP_ASSERT(map != NULL);
270
+ HASHMAP_ASSERT(hash_func != NULL);
271
+ HASHMAP_ASSERT(key_compare_func != NULL);
272
+
273
+ if (!initial_size) {
274
+ initial_size = HASHMAP_SIZE_DEFAULT;
275
+ } else {
276
+ /* Convert init size to valid table size */
277
+ initial_size = hashmap_table_size_calc(initial_size);
278
+ }
279
+ map->table_size_init = initial_size;
280
+ map->table_size = initial_size;
281
+ map->num_entries = 0;
282
+ map->table = (struct hashmap_entry *)calloc(initial_size,
283
+ sizeof(struct hashmap_entry));
284
+ if (!map->table) {
285
+ return -ENOMEM;
286
+ }
287
+ map->hash = hash_func;
288
+ map->key_compare = key_compare_func;
289
+ map->key_alloc = NULL;
290
+ map->key_free = NULL;
291
+ return 0;
292
+ }
293
+
294
+ /*
295
+ * Free the hashmap and all associated memory.
296
+ */
297
+ void hashmap_destroy(struct hashmap *map)
298
+ {
299
+ if (!map) {
300
+ return;
301
+ }
302
+ hashmap_free_keys(map);
303
+ free(map->table);
304
+ memset(map, 0, sizeof(*map));
305
+ }
306
+
307
+ /*
308
+ * Enable internal memory management of hash keys.
309
+ */
310
+ void hashmap_set_key_alloc_funcs(struct hashmap *map,
311
+ void *(*key_alloc_func)(const void *),
312
+ void (*key_free_func)(void *))
313
+ {
314
+ HASHMAP_ASSERT(map != NULL);
315
+
316
+ map->key_alloc = key_alloc_func;
317
+ map->key_free = key_free_func;
318
+ }
319
+
320
+ /*
321
+ * Add an entry to the hashmap. If an entry with a matching key already
322
+ * exists and has a data pointer associated with it, the existing data
323
+ * pointer is returned, instead of assigning the new value. Compare
324
+ * the return value with the data passed in to determine if a new entry was
325
+ * created. Returns NULL if memory allocation failed.
326
+ */
327
+ void *hashmap_put(struct hashmap *map, const void *key, void *data)
328
+ {
329
+ struct hashmap_entry *entry;
330
+
331
+ HASHMAP_ASSERT(map != NULL);
332
+ HASHMAP_ASSERT(key != NULL);
333
+
334
+ /* Rehash with 2x capacity if load factor is approaching 0.75 */
335
+ if (map->table_size <= hashmap_table_min_size_calc(map->num_entries)) {
336
+ hashmap_rehash(map, map->table_size << 1);
337
+ }
338
+ entry = hashmap_entry_find(map, key, true);
339
+ if (!entry) {
340
+ /*
341
+ * Cannot find an empty slot. Either out of memory, or using
342
+ * a poor hash function. Attempt to rehash once to reduce
343
+ * chain length.
344
+ */
345
+ if (hashmap_rehash(map, map->table_size << 1) < 0) {
346
+ return NULL;
347
+ }
348
+ entry = hashmap_entry_find(map, key, true);
349
+ if (!entry) {
350
+ return NULL;
351
+ }
352
+ }
353
+ if (!entry->key) {
354
+ /* Allocate copy of key to simplify memory management */
355
+ if (map->key_alloc) {
356
+ entry->key = map->key_alloc(key);
357
+ if (!entry->key) {
358
+ return NULL;
359
+ }
360
+ } else {
361
+ entry->key = (void *)key;
362
+ }
363
+ ++map->num_entries;
364
+ } else if (entry->data) {
365
+ /* Do not overwrite existing data */
366
+ return entry->data;
367
+ }
368
+ entry->data = data;
369
+ return data;
370
+ }
371
+
372
+ /*
373
+ * Return the data pointer, or NULL if no entry exists.
374
+ */
375
+ void *hashmap_get(const struct hashmap *map, const void *key)
376
+ {
377
+ struct hashmap_entry *entry;
378
+
379
+ HASHMAP_ASSERT(map != NULL);
380
+ HASHMAP_ASSERT(key != NULL);
381
+
382
+ entry = hashmap_entry_find(map, key, false);
383
+ if (!entry) {
384
+ return NULL;
385
+ }
386
+ return entry->data;
387
+ }
388
+
389
+ /*
390
+ * Remove an entry with the specified key from the map.
391
+ * Returns the data pointer, or NULL, if no entry was found.
392
+ */
393
+ void *hashmap_remove(struct hashmap *map, const void *key)
394
+ {
395
+ struct hashmap_entry *entry;
396
+ void *data;
397
+
398
+ HASHMAP_ASSERT(map != NULL);
399
+ HASHMAP_ASSERT(key != NULL);
400
+
401
+ entry = hashmap_entry_find(map, key, false);
402
+ if (!entry) {
403
+ return NULL;
404
+ }
405
+ data = entry->data;
406
+ /* Clear the entry and make the chain contiguous */
407
+ hashmap_entry_remove(map, entry);
408
+ return data;
409
+ }
410
+
411
+ /*
412
+ * Remove all entries.
413
+ */
414
+ void hashmap_clear(struct hashmap *map)
415
+ {
416
+ HASHMAP_ASSERT(map != NULL);
417
+
418
+ hashmap_free_keys(map);
419
+ map->num_entries = 0;
420
+ memset(map->table, 0, sizeof(struct hashmap_entry) * map->table_size);
421
+ }
422
+
423
+ /*
424
+ * Remove all entries and reset the hash table to its initial size.
425
+ */
426
+ void hashmap_reset(struct hashmap *map)
427
+ {
428
+ struct hashmap_entry *new_table;
429
+
430
+ HASHMAP_ASSERT(map != NULL);
431
+
432
+ hashmap_clear(map);
433
+ if (map->table_size == map->table_size_init) {
434
+ return;
435
+ }
436
+ new_table = (struct hashmap_entry *)realloc(map->table,
437
+ sizeof(struct hashmap_entry) * map->table_size_init);
438
+ if (!new_table) {
439
+ return;
440
+ }
441
+ map->table = new_table;
442
+ map->table_size = map->table_size_init;
443
+ }
444
+
445
+ /*
446
+ * Return the number of entries in the hash map.
447
+ */
448
+ size_t hashmap_size(const struct hashmap *map)
449
+ {
450
+ HASHMAP_ASSERT(map != NULL);
451
+
452
+ return map->num_entries;
453
+ }
454
+
455
+ /*
456
+ * Get a new hashmap iterator. The iterator is an opaque
457
+ * pointer that may be used with hashmap_iter_*() functions.
458
+ * Hashmap iterators are INVALID after a put or remove operation is performed.
459
+ * hashmap_iter_remove() allows safe removal during iteration.
460
+ */
461
+ struct hashmap_iter *hashmap_iter(const struct hashmap *map)
462
+ {
463
+ HASHMAP_ASSERT(map != NULL);
464
+
465
+ if (!map->num_entries) {
466
+ return NULL;
467
+ }
468
+ return (struct hashmap_iter *)hashmap_entry_get_populated(map,
469
+ map->table);
470
+ }
471
+
472
+ /*
473
+ * Return an iterator to the next hashmap entry. Returns NULL if there are
474
+ * no more entries.
475
+ */
476
+ struct hashmap_iter *hashmap_iter_next(const struct hashmap *map,
477
+ const struct hashmap_iter *iter)
478
+ {
479
+ struct hashmap_entry *entry = (struct hashmap_entry *)iter;
480
+
481
+ HASHMAP_ASSERT(map != NULL);
482
+
483
+ if (!iter) {
484
+ return NULL;
485
+ }
486
+ return (struct hashmap_iter *)hashmap_entry_get_populated(map,
487
+ entry + 1);
488
+ }
489
+
490
+ /*
491
+ * Remove the hashmap entry pointed to by this iterator and return an
492
+ * iterator to the next entry. Returns NULL if there are no more entries.
493
+ */
494
+ struct hashmap_iter *hashmap_iter_remove(struct hashmap *map,
495
+ const struct hashmap_iter *iter)
496
+ {
497
+ struct hashmap_entry *entry = (struct hashmap_entry *)iter;
498
+
499
+ HASHMAP_ASSERT(map != NULL);
500
+
501
+ if (!iter) {
502
+ return NULL;
503
+ }
504
+ if (!entry->key) {
505
+ /* Iterator is invalid, so just return the next valid entry */
506
+ return hashmap_iter_next(map, iter);
507
+ }
508
+ hashmap_entry_remove(map, entry);
509
+ return (struct hashmap_iter *)hashmap_entry_get_populated(map, entry);
510
+ }
511
+
512
+ /*
513
+ * Return the key of the entry pointed to by the iterator.
514
+ */
515
+ const void *hashmap_iter_get_key(const struct hashmap_iter *iter)
516
+ {
517
+ if (!iter) {
518
+ return NULL;
519
+ }
520
+ return (const void *)((struct hashmap_entry *)iter)->key;
521
+ }
522
+
523
+ /*
524
+ * Return the data of the entry pointed to by the iterator.
525
+ */
526
+ void *hashmap_iter_get_data(const struct hashmap_iter *iter)
527
+ {
528
+ if (!iter) {
529
+ return NULL;
530
+ }
531
+ return ((struct hashmap_entry *)iter)->data;
532
+ }
533
+
534
+ /*
535
+ * Set the data pointer of the entry pointed to by the iterator.
536
+ */
537
+ void hashmap_iter_set_data(const struct hashmap_iter *iter, void *data)
538
+ {
539
+ if (!iter) {
540
+ return;
541
+ }
542
+ ((struct hashmap_entry *)iter)->data = data;
543
+ }
544
+
545
+ /*
546
+ * Invoke func for each entry in the hashmap. Unlike the hashmap_iter_*()
547
+ * interface, this function supports calls to hashmap_remove() during iteration.
548
+ * However, it is an error to put or remove an entry other than the current one,
549
+ * and doing so will immediately halt iteration and return an error.
550
+ * Iteration is stopped if func returns non-zero. Returns func's return
551
+ * value if it is < 0, otherwise, 0.
552
+ */
553
+ int hashmap_foreach(const struct hashmap *map,
554
+ int (*func)(const void *, void *, void *), void *arg)
555
+ {
556
+ struct hashmap_entry *entry;
557
+ size_t num_entries;
558
+ const void *key;
559
+ int rc;
560
+
561
+ HASHMAP_ASSERT(map != NULL);
562
+ HASHMAP_ASSERT(func != NULL);
563
+
564
+ entry = map->table;
565
+ for (entry = map->table; entry < &map->table[map->table_size];
566
+ ++entry) {
567
+ if (!entry->key) {
568
+ continue;
569
+ }
570
+ num_entries = map->num_entries;
571
+ key = entry->key;
572
+ rc = func(entry->key, entry->data, arg);
573
+ if (rc < 0) {
574
+ return rc;
575
+ }
576
+ if (rc > 0) {
577
+ return 0;
578
+ }
579
+ /* Run this entry again if func() deleted it */
580
+ if (entry->key != key) {
581
+ --entry;
582
+ } else if (num_entries != map->num_entries) {
583
+ /* Stop immediately if func put/removed another entry */
584
+ return -1;
585
+ }
586
+ }
587
+ return 0;
588
+ }
589
+
590
+ /*
591
+ * Default hash function for string keys.
592
+ * This is an implementation of the well-documented Jenkins one-at-a-time
593
+ * hash function.
594
+ */
595
+ size_t hashmap_hash_string(const void *key)
596
+ {
597
+ const char *key_str = (const char *)key;
598
+ size_t hash = 0;
599
+
600
+ for (; *key_str; ++key_str) {
601
+ hash += *key_str;
602
+ hash += (hash << 10);
603
+ hash ^= (hash >> 6);
604
+ }
605
+ hash += (hash << 3);
606
+ hash ^= (hash >> 11);
607
+ hash += (hash << 15);
608
+ return hash;
609
+ }
610
+
611
+ /*
612
+ * Default key comparator function for string keys.
613
+ */
614
+ int hashmap_compare_string(const void *a, const void *b)
615
+ {
616
+ return strcmp((const char *)a, (const char *)b);
617
+ }
618
+
619
+ /*
620
+ * Default key allocation function for string keys. Use free() for the
621
+ * key_free_func.
622
+ */
623
+ void *hashmap_alloc_key_string(const void *key)
624
+ {
625
+ return (void *)strdup((const char *)key);
626
+ }
627
+
628
+ #ifdef HASHMAP_METRICS
629
+ /*
630
+ * Return the load factor.
631
+ */
632
+ double hashmap_load_factor(const struct hashmap *map)
633
+ {
634
+ HASHMAP_ASSERT(map != NULL);
635
+
636
+ if (!map->table_size) {
637
+ return 0;
638
+ }
639
+ return (double)map->num_entries / map->table_size;
640
+ }
641
+
642
+ /*
643
+ * Return the average number of collisions per entry.
644
+ */
645
+ double hashmap_collisions_mean(const struct hashmap *map)
646
+ {
647
+ struct hashmap_entry *entry;
648
+ size_t total_collisions = 0;
649
+
650
+ HASHMAP_ASSERT(map != NULL);
651
+
652
+ if (!map->num_entries) {
653
+ return 0;
654
+ }
655
+ for (entry = map->table; entry < &map->table[map->table_size];
656
+ ++entry) {
657
+ if (!entry->key) {
658
+ continue;
659
+ }
660
+ total_collisions += entry->num_collisions;
661
+ }
662
+ return (double)total_collisions / map->num_entries;
663
+ }
664
+
665
+ /*
666
+ * Return the variance between entry collisions. The higher the variance,
667
+ * the more likely the hash function is poor and is resulting in clustering.
668
+ */
669
+ double hashmap_collisions_variance(const struct hashmap *map)
670
+ {
671
+ struct hashmap_entry *entry;
672
+ double mean_collisions;
673
+ double variance;
674
+ double total_variance = 0;
675
+
676
+ HASHMAP_ASSERT(map != NULL);
677
+
678
+ if (!map->num_entries) {
679
+ return 0;
680
+ }
681
+ mean_collisions = hashmap_collisions_mean(map);
682
+ for (entry = map->table; entry < &map->table[map->table_size];
683
+ ++entry) {
684
+ if (!entry->key) {
685
+ continue;
686
+ }
687
+ variance = (double)entry->num_collisions - mean_collisions;
688
+ total_variance += variance * variance;
689
+ }
690
+ return total_variance / map->num_entries;
691
+ }
692
+ #endif
@@ -0,0 +1,314 @@
1
+ #include "jsmn.h"
2
+
3
+ /**
4
+ * Allocates a fresh unused token from the token pull.
5
+ */
6
+ static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser,
7
+ jsmntok_t *tokens, size_t num_tokens) {
8
+ jsmntok_t *tok;
9
+ if (parser->toknext >= num_tokens) {
10
+ return NULL;
11
+ }
12
+ tok = &tokens[parser->toknext++];
13
+ tok->start = tok->end = -1;
14
+ tok->size = 0;
15
+ #ifdef JSMN_PARENT_LINKS
16
+ tok->parent = -1;
17
+ #endif
18
+ return tok;
19
+ }
20
+
21
+ /**
22
+ * Fills token type and boundaries.
23
+ */
24
+ static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type,
25
+ int start, int end) {
26
+ token->type = type;
27
+ token->start = start;
28
+ token->end = end;
29
+ token->size = 0;
30
+ }
31
+
32
+ /**
33
+ * Fills next available token with JSON primitive.
34
+ */
35
+ static int jsmn_parse_primitive(jsmn_parser *parser, const char *js,
36
+ size_t len, jsmntok_t *tokens, size_t num_tokens) {
37
+ jsmntok_t *token;
38
+ int start;
39
+
40
+ start = parser->pos;
41
+
42
+ for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
43
+ switch (js[parser->pos]) {
44
+ #ifndef JSMN_STRICT
45
+ /* In strict mode primitive must be followed by "," or "}" or "]" */
46
+ case ':':
47
+ #endif
48
+ case '\t' : case '\r' : case '\n' : case ' ' :
49
+ case ',' : case ']' : case '}' :
50
+ goto found;
51
+ }
52
+ if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
53
+ parser->pos = start;
54
+ return JSMN_ERROR_INVAL;
55
+ }
56
+ }
57
+ #ifdef JSMN_STRICT
58
+ /* In strict mode primitive must be followed by a comma/object/array */
59
+ parser->pos = start;
60
+ return JSMN_ERROR_PART;
61
+ #endif
62
+
63
+ found:
64
+ if (tokens == NULL) {
65
+ parser->pos--;
66
+ return 0;
67
+ }
68
+ token = jsmn_alloc_token(parser, tokens, num_tokens);
69
+ if (token == NULL) {
70
+ parser->pos = start;
71
+ return JSMN_ERROR_NOMEM;
72
+ }
73
+ jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
74
+ #ifdef JSMN_PARENT_LINKS
75
+ token->parent = parser->toksuper;
76
+ #endif
77
+ parser->pos--;
78
+ return 0;
79
+ }
80
+
81
+ /**
82
+ * Fills next token with JSON string.
83
+ */
84
+ static int jsmn_parse_string(jsmn_parser *parser, const char *js,
85
+ size_t len, jsmntok_t *tokens, size_t num_tokens) {
86
+ jsmntok_t *token;
87
+
88
+ int start = parser->pos;
89
+
90
+ parser->pos++;
91
+
92
+ /* Skip starting quote */
93
+ for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
94
+ char c = js[parser->pos];
95
+
96
+ /* Quote: end of string */
97
+ if (c == '\"') {
98
+ if (tokens == NULL) {
99
+ return 0;
100
+ }
101
+ token = jsmn_alloc_token(parser, tokens, num_tokens);
102
+ if (token == NULL) {
103
+ parser->pos = start;
104
+ return JSMN_ERROR_NOMEM;
105
+ }
106
+ jsmn_fill_token(token, JSMN_STRING, start+1, parser->pos);
107
+ #ifdef JSMN_PARENT_LINKS
108
+ token->parent = parser->toksuper;
109
+ #endif
110
+ return 0;
111
+ }
112
+
113
+ /* Backslash: Quoted symbol expected */
114
+ if (c == '\\' && parser->pos + 1 < len) {
115
+ int i;
116
+ parser->pos++;
117
+ switch (js[parser->pos]) {
118
+ /* Allowed escaped symbols */
119
+ case '\"': case '/' : case '\\' : case 'b' :
120
+ case 'f' : case 'r' : case 'n' : case 't' :
121
+ break;
122
+ /* Allows escaped symbol \uXXXX */
123
+ case 'u':
124
+ parser->pos++;
125
+ for(i = 0; i < 4 && parser->pos < len && js[parser->pos] != '\0'; i++) {
126
+ /* If it isn't a hex character we have an error */
127
+ if(!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */
128
+ (js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */
129
+ (js[parser->pos] >= 97 && js[parser->pos] <= 102))) { /* a-f */
130
+ parser->pos = start;
131
+ return JSMN_ERROR_INVAL;
132
+ }
133
+ parser->pos++;
134
+ }
135
+ parser->pos--;
136
+ break;
137
+ /* Unexpected symbol */
138
+ default:
139
+ parser->pos = start;
140
+ return JSMN_ERROR_INVAL;
141
+ }
142
+ }
143
+ }
144
+ parser->pos = start;
145
+ return JSMN_ERROR_PART;
146
+ }
147
+
148
+ /**
149
+ * Parse JSON string and fill tokens.
150
+ */
151
+ int jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
152
+ jsmntok_t *tokens, unsigned int num_tokens) {
153
+ int r;
154
+ int i;
155
+ jsmntok_t *token;
156
+ int count = parser->toknext;
157
+
158
+ for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
159
+ char c;
160
+ jsmntype_t type;
161
+
162
+ c = js[parser->pos];
163
+ switch (c) {
164
+ case '{': case '[':
165
+ count++;
166
+ if (tokens == NULL) {
167
+ break;
168
+ }
169
+ token = jsmn_alloc_token(parser, tokens, num_tokens);
170
+ if (token == NULL)
171
+ return JSMN_ERROR_NOMEM;
172
+ if (parser->toksuper != -1) {
173
+ tokens[parser->toksuper].size++;
174
+ #ifdef JSMN_PARENT_LINKS
175
+ token->parent = parser->toksuper;
176
+ #endif
177
+ }
178
+ token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
179
+ token->start = parser->pos;
180
+ parser->toksuper = parser->toknext - 1;
181
+ break;
182
+ case '}': case ']':
183
+ if (tokens == NULL)
184
+ break;
185
+ type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
186
+ #ifdef JSMN_PARENT_LINKS
187
+ if (parser->toknext < 1) {
188
+ return JSMN_ERROR_INVAL;
189
+ }
190
+ token = &tokens[parser->toknext - 1];
191
+ for (;;) {
192
+ if (token->start != -1 && token->end == -1) {
193
+ if (token->type != type) {
194
+ return JSMN_ERROR_INVAL;
195
+ }
196
+ token->end = parser->pos + 1;
197
+ parser->toksuper = token->parent;
198
+ break;
199
+ }
200
+ if (token->parent == -1) {
201
+ if(token->type != type || parser->toksuper == -1) {
202
+ return JSMN_ERROR_INVAL;
203
+ }
204
+ break;
205
+ }
206
+ token = &tokens[token->parent];
207
+ }
208
+ #else
209
+ for (i = parser->toknext - 1; i >= 0; i--) {
210
+ token = &tokens[i];
211
+ if (token->start != -1 && token->end == -1) {
212
+ if (token->type != type) {
213
+ return JSMN_ERROR_INVAL;
214
+ }
215
+ parser->toksuper = -1;
216
+ token->end = parser->pos + 1;
217
+ break;
218
+ }
219
+ }
220
+ /* Error if unmatched closing bracket */
221
+ if (i == -1) return JSMN_ERROR_INVAL;
222
+ for (; i >= 0; i--) {
223
+ token = &tokens[i];
224
+ if (token->start != -1 && token->end == -1) {
225
+ parser->toksuper = i;
226
+ break;
227
+ }
228
+ }
229
+ #endif
230
+ break;
231
+ case '\"':
232
+ r = jsmn_parse_string(parser, js, len, tokens, num_tokens);
233
+ if (r < 0) return r;
234
+ count++;
235
+ if (parser->toksuper != -1 && tokens != NULL)
236
+ tokens[parser->toksuper].size++;
237
+ break;
238
+ case '\t' : case '\r' : case '\n' : case ' ':
239
+ break;
240
+ case ':':
241
+ parser->toksuper = parser->toknext - 1;
242
+ break;
243
+ case ',':
244
+ if (tokens != NULL && parser->toksuper != -1 &&
245
+ tokens[parser->toksuper].type != JSMN_ARRAY &&
246
+ tokens[parser->toksuper].type != JSMN_OBJECT) {
247
+ #ifdef JSMN_PARENT_LINKS
248
+ parser->toksuper = tokens[parser->toksuper].parent;
249
+ #else
250
+ for (i = parser->toknext - 1; i >= 0; i--) {
251
+ if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT) {
252
+ if (tokens[i].start != -1 && tokens[i].end == -1) {
253
+ parser->toksuper = i;
254
+ break;
255
+ }
256
+ }
257
+ }
258
+ #endif
259
+ }
260
+ break;
261
+ #ifdef JSMN_STRICT
262
+ /* In strict mode primitives are: numbers and booleans */
263
+ case '-': case '0': case '1' : case '2': case '3' : case '4':
264
+ case '5': case '6': case '7' : case '8': case '9':
265
+ case 't': case 'f': case 'n' :
266
+ /* And they must not be keys of the object */
267
+ if (tokens != NULL && parser->toksuper != -1) {
268
+ jsmntok_t *t = &tokens[parser->toksuper];
269
+ if (t->type == JSMN_OBJECT ||
270
+ (t->type == JSMN_STRING && t->size != 0)) {
271
+ return JSMN_ERROR_INVAL;
272
+ }
273
+ }
274
+ #else
275
+ /* In non-strict mode every unquoted value is a primitive */
276
+ default:
277
+ #endif
278
+ r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
279
+ if (r < 0) return r;
280
+ count++;
281
+ if (parser->toksuper != -1 && tokens != NULL)
282
+ tokens[parser->toksuper].size++;
283
+ break;
284
+
285
+ #ifdef JSMN_STRICT
286
+ /* Unexpected char in strict mode */
287
+ default:
288
+ return JSMN_ERROR_INVAL;
289
+ #endif
290
+ }
291
+ }
292
+
293
+ if (tokens != NULL) {
294
+ for (i = parser->toknext - 1; i >= 0; i--) {
295
+ /* Unmatched opened object or array */
296
+ if (tokens[i].start != -1 && tokens[i].end == -1) {
297
+ return JSMN_ERROR_PART;
298
+ }
299
+ }
300
+ }
301
+
302
+ return count;
303
+ }
304
+
305
+ /**
306
+ * Creates a new parser based over a given buffer with an array of tokens
307
+ * available.
308
+ */
309
+ void jsmn_init(jsmn_parser *parser) {
310
+ parser->pos = 0;
311
+ parser->toknext = 0;
312
+ parser->toksuper = -1;
313
+ }
314
+
@@ -1,11 +1,11 @@
1
+ #include "mmap.h"
2
+
1
3
  #include <errno.h>
2
4
  #include <fcntl.h>
3
- #include <ruby.h>
4
5
  #include <ruby/util.h>
5
6
  #include <sys/mman.h>
6
7
 
7
8
  #include "file_format.h"
8
- #include "mmap.h"
9
9
  #include "utils.h"
10
10
 
11
11
  #if 0
@@ -42,7 +42,6 @@ static VALUE mm_str(VALUE obj, int modify) {
42
42
  GET_MMAP(obj, i_mm, modify & ~MM_ORIGIN);
43
43
  if (modify & MM_MODIFY) {
44
44
  if (i_mm->t->flag & MM_FROZEN) rb_error_frozen("mmap");
45
- if (!OBJ_TAINTED(ret) && rb_safe_level() >= 4) rb_raise(rb_eSecurityError, "Insecure: can't modify mmap");
46
45
  }
47
46
  ret = rb_obj_alloc(rb_cString);
48
47
  if (rb_obj_tainted(obj)) {
@@ -170,6 +169,35 @@ VALUE mm_s_alloc(VALUE obj) {
170
169
  return res;
171
170
  }
172
171
 
172
+ size_t next_page_boundary(size_t value) {
173
+ size_t page_size = sysconf(_SC_PAGESIZE);
174
+
175
+ while (page_size < value) {
176
+ page_size *= 2;
177
+ }
178
+
179
+ return page_size;
180
+ }
181
+
182
+ /* Reference implementations:
183
+ * mozilla: https://hg.mozilla.org/mozilla-central/file/3d846420a907/xpcom/glue/FileUtils.cpp#l71
184
+ * glibc: https://github.com/lattera/glibc/blob/master/sysdeps/posix/posix_fallocate.c
185
+ */
186
+ int reserve_mmap_file_bytes(int fd, size_t size) {
187
+ #if __linux__
188
+ /* From https://stackoverflow.com/a/22820221: The difference with
189
+ * ftruncate(2) is that (on file systems supporting it, e.g. Ext4)
190
+ * disk space is indeed reserved by posix_fallocate but ftruncate
191
+ * extends the file by adding holes (and without reserving disk
192
+ * space). */
193
+ return posix_fallocate(fd, 0, size);
194
+ #else
195
+ /* We simplify the reference implemnetations since we generally
196
+ * don't need to reserve more than a page size. */
197
+ return ftruncate(fd, size);
198
+ #endif
199
+ }
200
+
173
201
  VALUE mm_init(VALUE obj, VALUE fname) {
174
202
  struct stat st;
175
203
  int fd, smode = 0, pmode = 0, vscope, perm, init;
@@ -187,13 +215,6 @@ VALUE mm_init(VALUE obj, VALUE fname) {
187
215
  SafeStringValue(fname);
188
216
  path = StringValuePtr(fname);
189
217
 
190
- {
191
- if (rb_safe_level() > 0 && OBJ_TAINTED(fname)) {
192
- rb_raise(rb_eSecurityError, "Insecure operation");
193
- }
194
- rb_secure(1);
195
- }
196
-
197
218
  vscope = MAP_SHARED;
198
219
  size = 0;
199
220
  perm = 0666;
@@ -206,6 +227,7 @@ VALUE mm_init(VALUE obj, VALUE fname) {
206
227
  }
207
228
 
208
229
  if (fstat(fd, &st) == -1) {
230
+ close(fd);
209
231
  rb_raise(rb_eArgError, "Can't stat %s", path);
210
232
  }
211
233
  size = st.st_size;
@@ -215,17 +237,21 @@ VALUE mm_init(VALUE obj, VALUE fname) {
215
237
  offset = 0;
216
238
  init = 0;
217
239
 
218
- if (size == 0 && (smode & O_RDWR)) {
219
- if (lseek(fd, INITIAL_SIZE - 1, SEEK_END) == -1) {
220
- rb_raise(rb_eIOError, "Can't lseek %zu", INITIAL_SIZE - 1);
221
- }
222
- if (write(fd, "\000", 1) != 1) {
223
- rb_raise(rb_eIOError, "Can't extend %s", path);
224
- }
240
+ if (size == 0) {
225
241
  init = 1;
226
242
  size = INITIAL_SIZE;
227
243
  }
228
244
 
245
+ /* We need to ensure the underlying file descriptor is at least a page size.
246
+ * Otherwise, we could get a SIGBUS error if mmap() attempts to read or write
247
+ * past the file. */
248
+ size_t reserve_size = next_page_boundary(size);
249
+
250
+ if (reserve_mmap_file_bytes(fd, reserve_size) != 0) {
251
+ close(fd);
252
+ rb_raise(rb_eIOError, "Can't reserve %zu bytes for memory-mapped file in %s", reserve_size, path);
253
+ }
254
+
229
255
  addr = mmap(0, size, pmode, vscope, fd, offset);
230
256
 
231
257
  if (addr == MAP_FAILED || !addr) {
@@ -1,9 +1,10 @@
1
+ #include "rendering.h"
2
+
1
3
  #include <float.h>
2
4
  #include <jsmn.h>
3
5
 
4
6
  #include "file_parsing.h"
5
7
  #include "globals.h"
6
- #include "rendering.h"
7
8
  #include "utils.h"
8
9
 
9
10
  #ifndef DBL_DECIMAL_DIG
@@ -1,8 +1,7 @@
1
- #include <errno.h>
2
- #include <ruby.h>
3
-
4
1
  #include "utils.h"
5
2
 
3
+ #include <errno.h>
4
+
6
5
  static void rb_save_exception(VALUE exception, VALUE message) {
7
6
  VALUE current_thread = rb_thread_current();
8
7
 
@@ -1,5 +1,6 @@
1
1
  #ifndef UNUSED_H
2
2
  #define UNUSED_H
3
+ #include <ruby.h>
3
4
 
4
5
  #ifdef UNUSED
5
6
  #elif defined(__GNUC__)
@@ -1,15 +1,13 @@
1
- #include <ruby.h>
2
- #include <ruby/intern.h>
1
+ #include "value_access.h"
3
2
 
4
3
  #include <errno.h>
5
4
  #include <fcntl.h>
5
+ #include <ruby/intern.h>
6
6
  #include <sys/mman.h>
7
7
  #include <unistd.h>
8
8
 
9
9
  #include "file_format.h"
10
10
  #include "mmap.h"
11
- #include "value_access.h"
12
-
13
11
  #include "utils.h"
14
12
 
15
13
  static void close_file(mm_ipc *i_mm) {
@@ -1,5 +1,6 @@
1
1
  #ifndef VALUE_ACCESS_H
2
2
  #define VALUE_ACCESS_H
3
+ #include <ruby.h>
3
4
 
4
5
  VALUE method_load_used(VALUE self);
5
6
 
@@ -29,13 +29,25 @@ module Prometheus
29
29
  configuration.pid_provider.call
30
30
  end
31
31
 
32
+ # Resets the registry and reinitializes all metrics files.
33
+ # Use case: clean up everything in specs `before` block,
34
+ # to prevent leaking the state between specs which are updating metrics.
32
35
  def reset!
33
36
  @registry = nil
34
37
  ::Prometheus::Client::MmapedValue.reset_and_reinitialize
35
38
  end
36
39
 
37
- def reinitialize_on_pid_change
38
- ::Prometheus::Client::MmapedValue.reinitialize_on_pid_change
40
+ # With `force: false`: reinitializes metric files only for processes with the changed PID.
41
+ # With `force: true`: reinitializes all metrics files.
42
+ # Always keeps the registry.
43
+ # Use case (`force: false`): pick up new metric files on each worker start,
44
+ # without resetting already registered files for the master or previously initialized workers.
45
+ def reinitialize_on_pid_change(force: false)
46
+ if force
47
+ ::Prometheus::Client::MmapedValue.reset_and_reinitialize
48
+ else
49
+ ::Prometheus::Client::MmapedValue.reinitialize_on_pid_change
50
+ end
39
51
  end
40
52
  end
41
53
  end
@@ -19,14 +19,15 @@ module Prometheus
19
19
  end
20
20
 
21
21
  def valid?(labels)
22
- unless labels.respond_to?(:all?)
22
+ unless labels.is_a?(Hash)
23
23
  raise InvalidLabelSetError, "#{labels} is not a valid label set"
24
24
  end
25
25
 
26
- labels.all? do |key, _|
26
+ labels.all? do |key, value|
27
27
  validate_symbol(key)
28
28
  validate_name(key)
29
29
  validate_reserved_key(key)
30
+ validate_value(key, value)
30
31
  end
31
32
  end
32
33
 
@@ -65,6 +66,17 @@ module Prometheus
65
66
 
66
67
  raise ReservedLabelError, "#{key} is reserved"
67
68
  end
69
+
70
+ def validate_value(key, value)
71
+ return true if value.is_a?(String) ||
72
+ value.is_a?(Numeric) ||
73
+ value.is_a?(Symbol) ||
74
+ value.is_a?(FalseClass) ||
75
+ value.is_a?(TrueClass) ||
76
+ value.nil?
77
+
78
+ raise InvalidLabelError, "#{key} does not contain a valid value (type #{value.class})"
79
+ end
68
80
  end
69
81
  end
70
82
  end
@@ -57,6 +57,10 @@ module Prometheus
57
57
  Prometheus::Client.logger.warn("munmap raised error #{e}")
58
58
  end
59
59
 
60
+ def inspect
61
+ "#<#{self.class}:0x#{(object_id << 1).to_s(16)}>"
62
+ end
63
+
60
64
  private
61
65
 
62
66
  def init_value(key)
@@ -1,5 +1,5 @@
1
1
  module Prometheus
2
2
  module Client
3
- VERSION = '0.9.8'.freeze
3
+ VERSION = '0.12.0'.freeze
4
4
  end
5
5
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: prometheus-client-mmap
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.9.8
4
+ version: 0.12.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Tobias Schmidt
@@ -9,7 +9,7 @@ authors:
9
9
  autorequire:
10
10
  bindir: bin
11
11
  cert_chain: []
12
- date: 2019-07-08 00:00:00.000000000 Z
12
+ date: 2020-09-22 00:00:00.000000000 Z
13
13
  dependencies:
14
14
  - !ruby/object:Gem::Dependency
15
15
  name: fuzzbert
@@ -106,6 +106,8 @@ files:
106
106
  - ext/fast_mmaped_file/file_reading.c
107
107
  - ext/fast_mmaped_file/file_reading.h
108
108
  - ext/fast_mmaped_file/globals.h
109
+ - ext/fast_mmaped_file/hashmap.c
110
+ - ext/fast_mmaped_file/jsmn.c
109
111
  - ext/fast_mmaped_file/mmap.c
110
112
  - ext/fast_mmaped_file/mmap.h
111
113
  - ext/fast_mmaped_file/rendering.c
@@ -114,6 +116,7 @@ files:
114
116
  - ext/fast_mmaped_file/utils.h
115
117
  - ext/fast_mmaped_file/value_access.c
116
118
  - ext/fast_mmaped_file/value_access.h
119
+ - lib/fast_mmaped_file.bundle
117
120
  - lib/prometheus.rb
118
121
  - lib/prometheus/client.rb
119
122
  - lib/prometheus/client/configuration.rb