bare-performance 1.2.1 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CMakeLists.txt CHANGED
@@ -1,9 +1,27 @@
1
- cmake_minimum_required(VERSION 3.25)
1
+ cmake_minimum_required(VERSION 4.0)
2
2
 
3
3
  find_package(cmake-bare REQUIRED PATHS node_modules/cmake-bare)
4
+ find_package(cmake-fetch REQUIRED PATHS node_modules/cmake-fetch)
4
5
 
5
6
  project(bare_performance C)
6
7
 
8
+ fetch_package(
9
+ "github:madler/zlib@1.3.1"
10
+ SOURCE_DIR zlib_SOURCE_DIR
11
+ BINARY_DIR zlib_BINARY_DIR
12
+ )
13
+
14
+ set(ZLIB_INCLUDE_DIR ${zlib_SOURCE_DIR} ${zlib_BINARY_DIR})
15
+ set(ZLIB_LIBRARY $<TARGET_FILE:zlibstatic>)
16
+
17
+ add_library(ZLIB::ZLIB ALIAS zlibstatic)
18
+
19
+ option(HDR_HISTOGRAM_BUILD_PROGRAMS OFF)
20
+ option(HDR_HISTOGRAM_INSTALL_SHARED OFF)
21
+ option(HDR_HISTOGRAM_INSTALL_STATIC OFF)
22
+
23
+ fetch_package("github:HdrHistogram/HdrHistogram_c#0.11.9")
24
+
7
25
  add_bare_module(bare_performance)
8
26
 
9
27
  target_sources(
@@ -11,3 +29,9 @@ target_sources(
11
29
  PRIVATE
12
30
  binding.c
13
31
  )
32
+
33
+ target_link_libraries(
34
+ ${bare_performance}
35
+ PRIVATE
36
+ hdr_histogram_static
37
+ )
package/binding.c CHANGED
@@ -1,15 +1,46 @@
1
1
  #include <assert.h>
2
2
  #include <bare.h>
3
+ #include <hdr/hdr_histogram.h>
3
4
  #include <js.h>
4
5
  #include <stdlib.h>
5
6
  #include <uv.h>
6
7
 
8
+ typedef struct {
9
+ js_ref_t *ctx;
10
+
11
+ struct hdr_histogram *histogram;
12
+ } bare_performance_histogram_t;
13
+
14
+ typedef struct {
15
+ js_ref_t *ctx;
16
+
17
+ js_garbage_collection_type_t kind;
18
+ uint64_t start_time;
19
+ uint64_t duration;
20
+ } bare_performance_garbage_collection_entry_t;
21
+
22
+ typedef struct {
23
+ js_garbage_collection_tracking_options_t options;
24
+
25
+ struct {
26
+ uint64_t mark_compact;
27
+ uint64_t generational;
28
+ } start_time_per_type;
29
+
30
+ js_garbage_collection_tracking_t *tracking;
31
+
32
+ js_threadsafe_function_t *on_new_entry;
33
+
34
+ js_env_t *env;
35
+ js_ref_t *ctx;
36
+ } bare_performance_garbage_collection_tracking_t;
37
+
7
38
  static js_value_t *
8
39
  bare_performance_now(js_env_t *env, js_callback_info_t *info) {
9
40
  int err;
10
41
 
11
42
  js_value_t *result;
12
- err = js_create_double(env, uv_hrtime() / 1e6, &result);
43
+ err = js_create_double(env, uv_hrtime(), &result);
13
44
  assert(err == 0);
14
45
 
15
46
  return result;
@@ -17,7 +48,7 @@ bare_performance_now(js_env_t *env, js_callback_info_t *info) {
17
48
 
18
49
  static double
19
50
  bare_performance_now_typed(js_value_t *receiver, js_typed_callback_info_t *info) {
20
- return uv_hrtime() / 1e6;
51
+ return uv_hrtime();
21
52
  }
22
53
 
23
54
  static js_value_t *
@@ -83,6 +114,421 @@ bare_performance_metrics_info(js_env_t *env, js_callback_info_t *info) {
83
114
  return result;
84
115
  }
85
116
 
117
+ static js_value_t *
118
+ bare_performance_histogram_init(js_env_t *env, js_callback_info_t *info) {
119
+ int err;
120
+
121
+ size_t argc = 4;
122
+ js_value_t *argv[4];
123
+
124
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
125
+ assert(err == 0);
126
+
127
+ assert(argc == 4);
128
+
129
+ js_value_t *handle;
130
+
131
+ bare_performance_histogram_t *histogram;
132
+ err = js_create_arraybuffer(env, sizeof(bare_performance_histogram_t), (void **) &histogram, &handle);
133
+
134
+ err = js_create_reference(env, argv[0], 1, &histogram->ctx);
135
+ assert(err == 0);
136
+
137
+ int64_t lowest;
138
+ err = js_get_value_int64(env, argv[1], &lowest);
139
+ assert(err == 0);
140
+
141
+ int64_t highest;
142
+ err = js_get_value_int64(env, argv[2], &highest);
143
+ assert(err == 0);
144
+
145
+ int64_t figures;
146
+ err = js_get_value_int64(env, argv[3], &figures);
147
+ assert(err == 0);
148
+
149
+ err = hdr_init(lowest, highest, figures, &histogram->histogram);
150
+ assert(err == 0);
151
+
152
+ return handle;
153
+ }
154
+
155
+ static js_value_t *
156
+ bare_performance_histogram_percentiles(js_env_t *env, js_callback_info_t *info) {
157
+ int err;
158
+
159
+ size_t argc = 1;
160
+ js_value_t *argv[1];
161
+
162
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
163
+ assert(err == 0);
164
+
165
+ assert(argc == 1);
166
+
167
+ bare_performance_histogram_t *histogram;
168
+ err = js_get_arraybuffer_info(env, argv[0], (void **) &histogram, NULL);
169
+ assert(err == 0);
170
+
171
+ struct hdr_iter iter;
172
+ hdr_iter_percentile_init(&iter, histogram->histogram, 1.0);
173
+
174
+ js_value_t *result;
175
+ err = js_create_array(env, &result);
176
+ assert(err == 0);
177
+
178
+ uint32_t i = 0;
179
+
180
+ while (hdr_iter_next(&iter)) {
181
+ js_value_t *pair;
182
+ err = js_create_array_with_length(env, 2, &pair);
183
+ assert(err == 0);
184
+
185
+ js_value_t *key;
186
+ err = js_create_double(env, iter.specifics.percentiles.percentile, &key);
187
+ assert(err == 0);
188
+
189
+ err = js_set_element(env, pair, 0, key);
190
+ assert(err == 0);
191
+
192
+ js_value_t *value;
193
+ err = js_create_double(env, iter.value, &value);
194
+ assert(err == 0);
195
+
196
+ err = js_set_element(env, pair, 1, value);
197
+ assert(err == 0);
198
+
199
+ err = js_set_element(env, result, i++, pair);
200
+ assert(err == 0);
201
+ }
202
+
203
+ return result;
204
+ }
205
+
206
+ static js_value_t *
207
+ bare_performance_histogram_percentile(js_env_t *env, js_callback_info_t *info) {
208
+ int err;
209
+
210
+ size_t argc = 2;
211
+ js_value_t *argv[2];
212
+
213
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
214
+ assert(err == 0);
215
+
216
+ assert(argc == 2);
217
+
218
+ bare_performance_histogram_t *histogram;
219
+ err = js_get_arraybuffer_info(env, argv[0], (void **) &histogram, NULL);
220
+ assert(err == 0);
221
+
222
+ double percentile;
223
+ err = js_get_value_double(env, argv[1], &percentile);
224
+ assert(err == 0);
225
+
226
+ js_value_t *result;
227
+ err = js_create_int64(env, hdr_value_at_percentile(histogram->histogram, percentile), &result);
228
+ assert(err == 0);
229
+
230
+ return result;
231
+ }
232
+
233
+ static js_value_t *
234
+ bare_performance_histogram_min(js_env_t *env, js_callback_info_t *info) {
235
+ int err;
236
+
237
+ size_t argc = 1;
238
+ js_value_t *argv[1];
239
+
240
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
241
+ assert(err == 0);
242
+
243
+ assert(argc == 1);
244
+
245
+ bare_performance_histogram_t *histogram;
246
+ err = js_get_arraybuffer_info(env, argv[0], (void **) &histogram, NULL);
247
+ assert(err == 0);
248
+
249
+ js_value_t *result;
250
+ err = js_create_int64(env, hdr_min(histogram->histogram), &result);
251
+ assert(err == 0);
252
+
253
+ return result;
254
+ }
255
+
256
+ static js_value_t *
257
+ bare_performance_histogram_max(js_env_t *env, js_callback_info_t *info) {
258
+ int err;
259
+
260
+ size_t argc = 1;
261
+ js_value_t *argv[1];
262
+
263
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
264
+ assert(err == 0);
265
+
266
+ assert(argc == 1);
267
+
268
+ bare_performance_histogram_t *histogram;
269
+ err = js_get_arraybuffer_info(env, argv[0], (void **) &histogram, NULL);
270
+ assert(err == 0);
271
+
272
+ js_value_t *result;
273
+ err = js_create_int64(env, hdr_max(histogram->histogram), &result);
274
+ assert(err == 0);
275
+
276
+ return result;
277
+ }
278
+
279
+ static js_value_t *
280
+ bare_performance_histogram_mean(js_env_t *env, js_callback_info_t *info) {
281
+ int err;
282
+
283
+ size_t argc = 1;
284
+ js_value_t *argv[1];
285
+
286
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
287
+ assert(err == 0);
288
+
289
+ assert(argc == 1);
290
+
291
+ bare_performance_histogram_t *histogram;
292
+ err = js_get_arraybuffer_info(env, argv[0], (void **) &histogram, NULL);
293
+ assert(err == 0);
294
+
295
+ js_value_t *result;
296
+ err = js_create_double(env, hdr_mean(histogram->histogram), &result);
297
+ assert(err == 0);
298
+
299
+ return result;
300
+ }
301
+
302
+ static js_value_t *
303
+ bare_performance_histogram_stddev(js_env_t *env, js_callback_info_t *info) {
304
+ int err;
305
+
306
+ size_t argc = 1;
307
+ js_value_t *argv[1];
308
+
309
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
310
+ assert(err == 0);
311
+
312
+ assert(argc == 1);
313
+
314
+ bare_performance_histogram_t *histogram;
315
+ err = js_get_arraybuffer_info(env, argv[0], (void **) &histogram, NULL);
316
+ assert(err == 0);
317
+
318
+ js_value_t *result;
319
+ err = js_create_double(env, hdr_stddev(histogram->histogram), &result);
320
+ assert(err == 0);
321
+
322
+ return result;
323
+ }
324
+
325
+ static js_value_t *
326
+ bare_performance_histogram_record(js_env_t *env, js_callback_info_t *info) {
327
+ int err;
328
+
329
+ size_t argc = 2;
330
+ js_value_t *argv[2];
331
+
332
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
333
+ assert(err == 0);
334
+
335
+ assert(argc == 2);
336
+
337
+ bare_performance_histogram_t *histogram;
338
+ err = js_get_arraybuffer_info(env, argv[0], (void **) &histogram, NULL);
339
+ assert(err == 0);
340
+
341
+ int64_t value;
342
+ err = js_get_value_int64(env, argv[1], &value);
343
+ assert(err == 0);
344
+
345
+ js_value_t *result;
346
+ err = js_get_boolean(env, hdr_record_value(histogram->histogram, value), &result);
347
+ assert(err == 0);
348
+
349
+ return result;
350
+ }
351
+
352
+ static js_value_t *
353
+ bare_performance_histogram_add(js_env_t *env, js_callback_info_t *info) {
354
+ int err;
355
+
356
+ size_t argc = 2;
357
+ js_value_t *argv[2];
358
+
359
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
360
+ assert(err == 0);
361
+
362
+ assert(argc == 2);
363
+
364
+ bare_performance_histogram_t *histogram;
365
+ err = js_get_arraybuffer_info(env, argv[0], (void **) &histogram, NULL);
366
+ assert(err == 0);
367
+
368
+ bare_performance_histogram_t *from;
369
+ err = js_get_arraybuffer_info(env, argv[1], (void **) &from, NULL);
370
+ assert(err == 0);
371
+
372
+ hdr_add(histogram->histogram, from->histogram);
373
+
374
+ return NULL;
375
+ }
376
+
377
+ static js_value_t *
378
+ bare_performance_histogram_reset(js_env_t *env, js_callback_info_t *info) {
379
+ int err;
380
+
381
+ size_t argc = 1;
382
+ js_value_t *argv[1];
383
+
384
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
385
+ assert(err == 0);
386
+
387
+ assert(argc == 1);
388
+
389
+ bare_performance_histogram_t *histogram;
390
+ err = js_get_arraybuffer_info(env, argv[0], (void **) &histogram, NULL);
391
+ assert(err == 0);
392
+
393
+ hdr_reset(histogram->histogram);
394
+
395
+ return NULL;
396
+ }
397
+
398
+ static void
399
+ bare_performance_garbage_collection_tracking__on_new_entry(js_env_t *env, js_value_t *on_new_entry, void *context, void *data) {
400
+ int err;
401
+
402
+ bare_performance_garbage_collection_entry_t *entry = (bare_performance_garbage_collection_entry_t *) data;
403
+
404
+ js_value_t *ctx;
405
+ err = js_get_reference_value(env, entry->ctx, &ctx);
406
+ assert(err == 0);
407
+
408
+ js_value_t *args[3];
409
+
410
+ err = js_create_double(env, entry->start_time / 1e6, &args[0]);
411
+ assert(err == 0);
412
+
413
+ err = js_create_double(env, entry->duration / 1e6, &args[1]);
414
+ assert(err == 0);
415
+
416
+ err = js_create_int32(env, entry->kind, &args[2]);
417
+ assert(err == 0);
418
+
419
+ free(entry);
420
+
421
+ err = js_call_function(env, ctx, on_new_entry, 3, args, NULL);
422
+ assert(err == 0);
423
+ }
424
+
425
+ static void
426
+ bare_performance_garbage_collection_tracking__on_end(js_garbage_collection_type_t type, void *data) {
427
+ int err;
428
+
429
+ uint64_t current_timestamp = uv_hrtime();
430
+
431
+ bare_performance_garbage_collection_tracking_t *gc = (bare_performance_garbage_collection_tracking_t *) data;
432
+
433
+ uint64_t start_time;
434
+ if (type == js_garbage_collection_type_mark_compact) start_time = gc->start_time_per_type.mark_compact;
435
+ else start_time = gc->start_time_per_type.generational;
436
+
437
+ uint64_t duration = current_timestamp - start_time;
438
+
439
+ bare_performance_garbage_collection_entry_t *entry = malloc(sizeof(bare_performance_garbage_collection_entry_t));
440
+
441
+ entry->ctx = gc->ctx;
442
+ entry->start_time = start_time;
443
+ entry->duration = duration;
444
+ entry->kind = type;
445
+
446
+ err = js_call_threadsafe_function(gc->on_new_entry, entry, js_threadsafe_function_nonblocking);
447
+ assert(err == 0);
448
+ }
449
+
450
+ static void
451
+ bare_performance_garbage_collection_tracking__on_start(js_garbage_collection_type_t type, void *data) {
452
+ int err;
453
+
454
+ uint64_t current_timestamp = uv_hrtime();
455
+
456
+ bare_performance_garbage_collection_tracking_t *gc = (bare_performance_garbage_collection_tracking_t *) data;
457
+
458
+ if (type == js_garbage_collection_type_mark_compact) gc->start_time_per_type.mark_compact = current_timestamp;
459
+ else gc->start_time_per_type.generational = current_timestamp;
460
+ }
461
+
462
+ static js_value_t *
463
+ bare_performance_disable_garbage_collection_tracking(js_env_t *env, js_callback_info_t *info) {
464
+ int err;
465
+
466
+ size_t argc = 1;
467
+ js_value_t *argv[1];
468
+
469
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
470
+ assert(err == 0);
471
+
472
+ assert(argc == 1);
473
+
474
+ bare_performance_garbage_collection_tracking_t *gc;
475
+ err = js_get_arraybuffer_info(env, argv[0], (void **) &gc, NULL);
476
+ assert(err == 0);
477
+
478
+ err = js_disable_garbage_collection_tracking(env, gc->tracking);
479
+ assert(err == 0);
480
+
481
+ err = js_release_threadsafe_function(gc->on_new_entry, js_threadsafe_function_release);
482
+ assert(err == 0);
483
+
484
+ err = js_delete_reference(env, gc->ctx);
485
+ assert(err == 0);
486
+
487
+ return NULL;
488
+ }
489
+
490
+ static js_value_t *
491
+ bare_performance_enable_garbage_collection_tracking(js_env_t *env, js_callback_info_t *info) {
492
+ int err;
493
+
494
+ size_t argc = 2;
495
+ js_value_t *argv[2];
496
+
497
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
498
+ assert(err == 0);
499
+
500
+ assert(argc == 2);
501
+
502
+ js_value_t *handle;
503
+
504
+ bare_performance_garbage_collection_tracking_t *gc;
505
+ err = js_create_arraybuffer(env, sizeof(bare_performance_garbage_collection_tracking_t), (void **) &gc, &handle);
506
+ assert(err == 0);
507
+
508
+ gc->env = env;
509
+
510
+ const js_garbage_collection_tracking_options_t options = {
511
+ .start = bare_performance_garbage_collection_tracking__on_start,
512
+ .end = bare_performance_garbage_collection_tracking__on_end,
513
+ };
514
+
515
+ gc->options = options;
516
+
517
+ err = js_create_reference(env, argv[0], 1, &gc->ctx);
518
+ assert(err == 0);
519
+
520
+ err = js_create_threadsafe_function(env, argv[1], 64, 1, NULL, NULL, NULL, bare_performance_garbage_collection_tracking__on_new_entry, &gc->on_new_entry);
521
+ assert(err == 0);
522
+
523
+ err = js_unref_threadsafe_function(env, gc->on_new_entry);
524
+ assert(err == 0);
525
+
526
+ err = js_enable_garbage_collection_tracking(env, &gc->options, (void *) gc, &gc->tracking);
527
+ assert(err == 0);
528
+
529
+ return handle;
530
+ }
531
+
86
532
  static js_value_t *
87
533
  bare_performance_exports(js_env_t *env, js_value_t *exports) {
88
534
  int err;
@@ -144,6 +590,40 @@ bare_performance_exports(js_env_t *env, js_value_t *exports) {
144
590
  );
145
591
 
146
592
  V("metricsInfo", bare_performance_metrics_info, NULL, NULL);
593
+
594
+ V("histogramInit", bare_performance_histogram_init, NULL, NULL);
595
+ V("histogramPercentiles", bare_performance_histogram_percentiles, NULL, NULL);
596
+ V("histogramPercentile", bare_performance_histogram_percentile, NULL, NULL);
597
+ V("histogramMin", bare_performance_histogram_min, NULL, NULL);
598
+ V("histogramMax", bare_performance_histogram_max, NULL, NULL);
599
+ V("histogramMean", bare_performance_histogram_mean, NULL, NULL);
600
+ V("histogramStddev", bare_performance_histogram_stddev, NULL, NULL);
601
+ V("histogramRecord", bare_performance_histogram_record, NULL, NULL);
602
+ V("histogramAdd", bare_performance_histogram_add, NULL, NULL);
603
+ V("histogramReset", bare_performance_histogram_reset, NULL, NULL);
604
+
605
+ V("enableGarbageCollectionTracking", bare_performance_enable_garbage_collection_tracking, NULL, NULL);
606
+ V("disableGarbageCollectionTracking", bare_performance_disable_garbage_collection_tracking, NULL, NULL);
607
+ #undef V
608
+
609
+ js_value_t *constants;
610
+ err = js_create_object(env, &constants);
611
+ assert(err == 0);
612
+
613
+ err = js_set_named_property(env, exports, "constants", constants);
614
+ assert(err == 0);
615
+
616
+ #define V(name, n) \
617
+ { \
618
+ js_value_t *val; \
619
+ err = js_create_uint32(env, n, &val); \
620
+ assert(err == 0); \
621
+ err = js_set_named_property(env, constants, name, val); \
622
+ assert(err == 0); \
623
+ }
624
+
625
+ V("MARK_COMPACT", js_garbage_collection_type_mark_compact)
626
+ V("GENERATIONAL", js_garbage_collection_type_generational)
147
627
  #undef V
148
628
 
149
629
  return exports;