stream_stats 0.0.3

data/ext/stream_stats/heap.h

@@ -0,0 +1,85 @@
+/*
+ * Author: Armon Dadgar
+ *
+ * Header for the Heap functions and data definitions
+ */
+
+#ifndef HEAP_H
+#define HEAP_H
+
+// Structure for a single heap entry
+typedef struct heap_entry {
+    void* key;   // Key for this entry
+    void* value; // Value for this entry
+} heap_entry;
+
+
+// Main struct for representing the heap
+typedef struct heap {
+    int (*compare_func)(void*, void*); // The key comparison function to use
+    int active_entries;  // The number of entries in the heap
+    int minimum_pages;   // The minimum number of pages to maintain, based on the initial cap.
+    int allocated_pages; // The number of pages in memory that are allocated
+    heap_entry* table; // Pointer to the table, which maps to the pages
+} heap;
+
+// Functions
+
+/**
+ * Creates a new heap
+ * @param h Pointer to a heap structure that is initialized
+ * @param initial_size What should the initial size of the heap be. If <= 0, then it will be set to the minimum
+ * permissable size, of 1 page (512 entries on 32bit system with 4K pages).
+ * @param comp_func A pointer to a function that can be used to compare the keys. If NULL, it will be set
+ * to a function which treats keys as signed ints. This function must take two keys, given as pointers and return an int.
+ * It should return -1 if key 1 is smaller, 0 if they are equal, and 1 if key 2 is smaller.
+ */
+void heap_create(heap* h, int initial_size, int (*comp_func)(void*,void*));
+
+/**
+ * Returns the size of the heap
+ * @param h Pointer to a heap structure
+ * @return The number of entries in the heap.
+ */
+int heap_size(heap* h);
+
+/**
+ * Inserts a new element into a heap.
+ * @param h The heap to insert into
+ * @param key The key of the new entry
+ * @param value The value of the new entry
+ */
+void heap_insert(heap* h, void* key, void* value);
+
+/**
+ * Returns the element with the smallest key in the heap.
+ * @param h Pointer to the heap structure
+ * @param key A pointer to a pointer, to set to the minimum key
+ * @param value Set to the value corresponding with the key
+ * @return 1 if the minimum element exists and is set, 0 if there are no elements.
+ */
+int heap_min(heap* h, void** key, void** value);
+
+/**
+ * Deletes the element with the smallest key from the heap.
+ * @param h Pointer to the heap structure
+ * @param key A pointer to a pointer, to set to the minimum key
+ * @param valu Set to the value corresponding with the key
+ * @return 1if the minimum element exists and is deleted, 0 if there are no elements.
+ */
+int heap_delmin(heap* h, void** key, void** value);
+
+/**
+ * Calls a function for each entry in the heap.
+ * @param h The heap to iterate over
+ * @param func The function to call on each entry. Should take a void* key and value.
+ */
+void heap_foreach(heap* h, void (*func)(void*,void*));
+
+/**
+ * Destroys and cleans up a heap.
+ * @param h The heap to destroy.
+ */
+void heap_destroy(heap* h);
+
+#endif

data/ext/stream_stats/stream_stats.c

@@ -0,0 +1,135 @@
+#include <ruby.h>
+#include <stdio.h>
+
+#include "timer.h"
+
+VALUE timer_class;
+
+static void strstat_timer_free(void *ptr) {
+  destroy_timer(ptr);
+}
+
+static VALUE strstat_timer_init(VALUE self, VALUE rb_eps, VALUE rb_quantiles) {
+
+  timer *i_timer = (timer *) malloc(sizeof(timer));
+
+  double eps = NUM2DBL(rb_eps);
+  double *quantiles;
+  uint32_t num_quantiles;
+
+  switch (TYPE(rb_quantiles)) {
+    case T_ARRAY:
+      rb_iv_set(self, "@quantiles", rb_quantiles);
+      num_quantiles = RARRAY_LEN(rb_quantiles);
+      if (num_quantiles < 1)
+        rb_raise(rb_eRuntimeError, "no quantiles defined");
+      quantiles = malloc(sizeof(double) * num_quantiles);
+      for (int i = 0; i < num_quantiles; i++) {
+        quantiles[i] = NUM2DBL(rb_ary_entry(rb_quantiles, i));
+      }
+      break;
+    default:
+      /* raise exception */
+      rb_raise(rb_eTypeError, "not valid value");
+      break;
+  }
+
+  init_timer(eps, quantiles, num_quantiles, i_timer);
+
+  VALUE data = Data_Wrap_Struct(timer_class, NULL, strstat_timer_free, i_timer);
+  rb_ivar_set(self, rb_intern("timer"), data);
+
+  return Qnil;
+}
+
+static VALUE strstat_timer_add_sample(VALUE self, VALUE rb_sample) {
+
+  double sample = NUM2DBL(rb_sample);
+
+  timer *i_timer;
+
+  VALUE data = rb_ivar_get(self, rb_intern("timer"));
+  Data_Get_Struct(data, timer, i_timer);
+
+  int returned = timer_add_sample(i_timer, sample);
+  if (returned != 0) {
+    rb_raise(rb_eRuntimeError, "add sample returned %d", returned);
+  }
+
+  return Qnil;
+}
+
+static VALUE strstat_timer_count(VALUE self) {
+  timer *i_timer;
+
+  VALUE data = rb_ivar_get(self, rb_intern("timer"));
+  Data_Get_Struct(data, timer, i_timer);
+
+  return LONG2NUM(timer_count(i_timer));
+}
+
+static VALUE strstat_timer_query(VALUE self, VALUE rb_query) {
+  double query = NUM2DBL(rb_query);
+  if (query < 0 || query > 1)
+    rb_raise(rb_eRuntimeError, "invalid quantile");
+
+  timer *i_timer;
+
+  VALUE data = rb_ivar_get(self, rb_intern("timer"));
+  Data_Get_Struct(data, timer, i_timer);
+  return DBL2NUM(timer_query(i_timer, query));
+}
+
+static VALUE strstat_timer_percentile(VALUE self, VALUE rb_percentile) {
+  int percentile = NUM2INT(rb_percentile);
+  if (percentile < 0 || percentile > 100)
+    rb_raise(rb_eRuntimeError, "invalid percentile");
+
+  return strstat_timer_query(self, DBL2NUM(percentile / 100.0));
+}
+
+static VALUE strstat_timer_commoncall(VALUE self, double(*func)(timer*)) {
+  timer *i_timer;
+
+  VALUE data = rb_ivar_get(self, rb_intern("timer"));
+  Data_Get_Struct(data, timer, i_timer);
+  return DBL2NUM((*func)(i_timer));
+}
+
+static VALUE strstat_timer_min(VALUE self) {
+  return strstat_timer_commoncall(self, timer_min);
+}
+static VALUE strstat_timer_max(VALUE self) {
+  return strstat_timer_commoncall(self, timer_max);
+}
+static VALUE strstat_timer_mean(VALUE self) {
+  return strstat_timer_commoncall(self, timer_mean);
+}
+static VALUE strstat_timer_stddev(VALUE self) {
+  return strstat_timer_commoncall(self, timer_stddev);
+}
+static VALUE strstat_timer_sum(VALUE self) {
+  return strstat_timer_commoncall(self, timer_sum);
+}
+static VALUE strstat_timer_squared_sum(VALUE self) {
+  return strstat_timer_commoncall(self, timer_squared_sum);
+}
+
+void Init_stream_stats(void) {
+  VALUE module = rb_define_module("StreamStats");
+
+  timer_class = rb_define_class_under(module, "Stream", rb_cObject);
+
+  rb_define_method(timer_class, "initialize", strstat_timer_init, 2);
+  rb_define_method(timer_class, "<<", strstat_timer_add_sample, 1);
+  rb_define_method(timer_class, "count", strstat_timer_count, 0);
+  rb_define_method(timer_class, "quantile", strstat_timer_query, 1);
+  rb_define_method(timer_class, "percentile", strstat_timer_percentile, 1);
+  rb_define_method(timer_class, "min", strstat_timer_min, 0);
+  rb_define_method(timer_class, "max", strstat_timer_max, 0);
+  rb_define_method(timer_class, "mean", strstat_timer_mean, 0);
+  rb_define_method(timer_class, "stddev", strstat_timer_stddev, 0);
+  rb_define_method(timer_class, "sum", strstat_timer_sum, 0);
+  rb_define_method(timer_class, "squared_sum", strstat_timer_squared_sum, 0);
+
+}

data/ext/stream_stats/timer.c

@@ -0,0 +1,165 @@
+/*
+  Source: https://github.com/armon/statsite/blob/master/src/timer.c
+  Copyright (c) 2012, Armon Dadgar
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+      * Neither the name of the organization nor the
+        names of its contributors may be used to endorse or promote products
+        derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL ARMON DADGAR BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <math.h>
+#include "timer.h"
+
+/* Static declarations */
+static void finalize_timer(timer *timer);
+
+/**
+ * Initializes the timer struct
+ * @arg eps The maximum error for the quantiles
+ * @arg quantiles A sorted array of double quantile values, must be on (0, 1)
+ * @arg num_quants The number of entries in the quantiles array
+ * @arg timeer The timer struct to initialize
+ * @return 0 on success.
+ */
+int init_timer(double eps, double *quantiles, uint32_t num_quants, timer *timer) {
+    timer->count = 0;
+    timer->sum = 0;
+    timer->squared_sum = 0;
+    timer->finalized = 1;
+    int res = init_cm_quantile(eps, quantiles, num_quants, &timer->cm);
+    return res;
+}
+
+/**
+ * Destroy the timer struct.
+ * @arg timer The timer to destroy
+ * @return 0 on success.
+ */
+int destroy_timer(timer *timer) {
+    return destroy_cm_quantile(&timer->cm);
+}
+
+/**
+ * Adds a new sample to the struct
+ * @arg timer The timer to add to
+ * @arg sample The new sample value
+ * @return 0 on success.
+ */
+int timer_add_sample(timer *timer, double sample) {
+    timer->count += 1;
+    timer->sum += sample;
+    timer->squared_sum += pow(sample, 2);
+    timer->finalized = 0;
+    return cm_add_sample(&timer->cm, sample);
+}
+
+/**
+ * Queries for a quantile value
+ * @arg timer The timer to query
+ * @arg quantile The quantile to query
+ * @return The value on success or 0.
+ */
+double timer_query(timer *timer, double quantile) {
+    finalize_timer(timer);
+    return cm_query(&timer->cm, quantile);
+}
+
+/**
+ * Returns the number of samples in the timer
+ * @arg timer The timer to query
+ * @return The number of samples
+ */
+uint64_t timer_count(timer *timer) {
+    return timer->count;
+}
+
+/**
+ * Returns the minimum timer value
+ * @arg timer The timer to query
+ * @return The number of samples
+ */
+double timer_min(timer *timer) {
+    finalize_timer(timer);
+    if (!timer->cm.samples) return 0;
+    return timer->cm.samples->value;
+}
+
+/**
+ * Returns the mean timer value
+ * @arg timer The timer to query
+ * @return The mean value
+ */
+double timer_mean(timer *timer) {
+    return (timer->count) ? timer->sum / timer->count : 0;
+}
+
+/**
+ * Returns the sample standard deviation timer value
+ * @arg timer The timer to query
+ * @return The sample standard deviation
+ */
+double timer_stddev(timer *timer) {
+    double num = (timer->count * timer->squared_sum) - pow(timer->sum, 2);
+    double div = timer->count * (timer->count - 1);
+    if (div == 0) return 0;
+    return sqrt(num / div);
+}
+
+/**
+ * Returns the sum of the timer
+ * @arg timer The timer to query
+ * @return The sum of values
+ */
+double timer_sum(timer *timer) {
+    return timer->sum;
+}
+
+/**
+ * Returns the sum squared of the timer
+ * @arg timer The timer to query
+ * @return The sum squared of values
+ */
+double timer_squared_sum(timer *timer) {
+    return timer->squared_sum;
+}
+
+/**
+ * Returns the maximum timer value
+ * @arg timer The timer to query
+ * @return The maximum value
+ */
+double timer_max(timer *timer) {
+    finalize_timer(timer);
+    if (!timer->cm.end) return 0;
+    return timer->cm.end->value;
+}
+
+// Finalizes the timer for queries
+static void finalize_timer(timer *timer) {
+    if (timer->finalized) return;
+
+    // Force the quantile to flush internal
+    // buffers so that queries are accurate.
+    cm_flush(&timer->cm);
+
+    timer->finalized = 1;
+}

data/ext/stream_stats/timer.h

@@ -0,0 +1,96 @@
+#ifndef TIMER_H
+#define TIMER_H
+#include <stdint.h>
+#include "cm_quantile.h"
+
+typedef struct {
+    uint64_t count;     // Count of items
+    double sum;         // Sum of the values
+    double squared_sum; // Sum of the squared values
+    int finalized;      // Is the cm_quantile finalized
+    cm_quantile cm;     // Quantile we use
+} timer;
+
+/**
+ * Initializes the timer struct
+ * @arg eps The maximum error for the quantiles
+ * @arg quantiles A sorted array of double quantile values, must be on (0, 1)
+ * @arg num_quants The number of entries in the quantiles array
+ * @arg timeer The timer struct to initialize
+ * @return 0 on success.
+ */
+int init_timer(double eps, double *quantiles, uint32_t num_quants, timer *timer);
+
+/**
+ * Destroy the timer struct.
+ * @arg timer The timer to destroy
+ * @return 0 on success.
+ */
+int destroy_timer(timer *timer);
+
+/**
+ * Adds a new sample to the struct
+ * @arg timer The timer to add to
+ * @arg sample The new sample value
+ * @return 0 on success.
+ */
+int timer_add_sample(timer *timer, double sample);
+
+/**
+ * Queries for a quantile value
+ * @arg timer The timer to query
+ * @arg quantile The quantile to query
+ * @return The value on success or 0.
+ */
+double timer_query(timer *timer, double quantile);
+
+/**
+ * Returns the number of samples in the timer
+ * @arg timer The timer to query
+ * @return The number of samples
+ */
+uint64_t timer_count(timer *timer);
+
+/**
+ * Returns the minimum timer value
+ * @arg timer The timer to query
+ * @return The number of samples
+ */
+double timer_min(timer *timer);
+
+/**
+ * Returns the mean timer value
+ * @arg timer The timer to query
+ * @return The mean value
+ */
+double timer_mean(timer *timer);
+
+/**
+ * Returns the sample standard deviation timer value
+ * @arg timer The timer to query
+ * @return The sample standard deviation
+ */
+double timer_stddev(timer *timer);
+
+/**
+ * Returns the sum of the timer
+ * @arg timer The timer to query
+ * @return The sum of values
+ */
+double timer_sum(timer *timer);
+
+/**
+ * Returns the sum squared of the timer
+ * @arg timer The timer to query
+ * @return The sum squared of values
+ */
+double timer_squared_sum(timer *timer);
+
+/**
+ * Returns the maximum timer value
+ * @arg timer The timer to query
+ * @return The maximum value
+ */
+double timer_max(timer *timer);
+
+#endif