HDRHistogram 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d475c4c4cbb66898aeff2e9dfdeccbaf9b8e7e000920332076a63b05191ccc6f
-  data.tar.gz: a409b91d6a9fe2dd87ed4e4e74f2f6425dbea2743901540bcd0908915b1861ac
+  metadata.gz: 99f2a4bb0a67363e2249f38122fc2b18bf5cd49045386030c969b2bf8ac6edb1
+  data.tar.gz: 6bcfe26d7ed7c0abf786b100824a476d534c31aa86d94c9116d803d7f38d57f8
 SHA512:
-  metadata.gz: 4733bc0361f91f457b3fe462cac735296e9190a69f95cb8aab09ec864dec9e4da91e3935aae26f240397e7504bf3310da2e3f29d842dfb75c4c8a631efd39e4c
-  data.tar.gz: 4f1ec7b4af487e4a7034e1d552959dd3326757a9ac3760bb664779ec2ef73cc5284a644b241d43d76cb2bee47b4b48e33f70087cd9da020a640df086b0d39067
+  metadata.gz: 7b2e8a471d12a7689200361eb5a23197ca194ea11aa4d8e05beaa966877a37d84740018a6e72336ee2d092fdfdafdccd101440e946f4f06bdf549476f5aae20a
+  data.tar.gz: ab07d7649ded6ee83d6ac733a4ba3e534334e5a974b41ea622a8303c004cba6feac980fdab079908e44df79f60f1ac8510ae112367fc4f8f4711242013d65c6a

data/README.md

@@ -77,8 +77,9 @@ Create new HDRHistogram object.
 - `significant_figures`: The level of precision for this histogram, i.e. the number of figures in a decimal number that will be maintained.  E.g. a value of 3 will mean the results from the histogram will be accurate up to the first three digits. Must be a value between 1 and 5 (inclusive).
 - `:multiplier`: A multiplier to adjust all incoming values. If present, the raw value recorded in the histogram for `record(val)` will be `val * 1/multiplier`. Similarly, `percentile(pctl) => val * multiplier`. If `multiplier` < 1, `lowest_value` can be < 1 so that `lowest_value` * 1/`multiplier` == 1.
 - `:unit`: A unit for labeling histogram values. Useful for outputting things.
-  
-  
+
+#### `hdr = HDRHistogram.unserialize(serialized_histogram_string)`
+restore an HDRHistogram object and its data from serialized string.
 
 #### `hdr.record(value)`
 Records a `value` in the histogram, will round this `value` of to a precision at or better than the `significant_figures` specified at construction time.  
@@ -146,4 +147,9 @@ Get a formatted string with percentile stats of the histogram useful for latency
 #  99.999%     1000.447ms
 # 100.000%     1000.447ms
 ```
+
 The above output assumes a :multiplier of 0.001 and a :unit of `:ms`
+
+#### `hdr.serialize`
+serialize the HDRHistogram object and data into a string
+

data/ext/ruby_hdr_histogram/ruby_hdr_histogram.c

@@ -41,6 +41,61 @@ static VALUE histogram_new(int argc, VALUE* argv, VALUE class) {
   return self;
 }
 
+static VALUE histogram_clone(VALUE self_src) {
+  GET_HDRHIST(hdr_src, self_src);
+  VALUE                    self;
+  struct hdr_histogram    *hdrh;
+  int                      ret, i;
+  ret = hdr_init(hdr_src->lowest_trackable_value, hdr_src->highest_trackable_value, hdr_src->significant_figures, &hdrh);
+  if(ret == EINVAL) {
+    rb_raise(HDRHistogramError, "%s", "lowest_trackable_value must be >= 1");
+  }
+  else if(ret == ENOMEM) {
+    rb_raise(HDRHistogramError, "%s", "no memory");
+  }
+  else if(hdr_src->counts_len != hdrh->counts_len) {
+    rb_raise(HDRHistogramError, "%s", "bad hdrhistogram ccopy");
+  }
+  self = Data_Wrap_Struct(HDRHistogram, NULL, histogram_free, hdrh);
+  
+  hdrh->lowest_trackable_value = hdr_src->lowest_trackable_value;
+  hdrh->highest_trackable_value = hdr_src->highest_trackable_value;
+  hdrh->unit_magnitude = hdr_src->unit_magnitude;
+  hdrh->significant_figures = hdr_src->significant_figures;
+  hdrh->sub_bucket_half_count_magnitude = hdr_src->sub_bucket_half_count_magnitude;
+  hdrh->sub_bucket_half_count = hdr_src->sub_bucket_half_count;
+  hdrh->sub_bucket_mask = hdr_src->sub_bucket_mask;
+  hdrh->sub_bucket_count = hdr_src->sub_bucket_count;
+  hdrh->bucket_count = hdr_src->bucket_count;
+  hdrh->min_value = hdr_src->min_value;
+  hdrh->max_value = hdr_src->max_value;
+  hdrh->normalizing_index_offset = hdr_src->normalizing_index_offset;
+  hdrh->conversion_ratio = hdr_src->conversion_ratio;
+  hdrh->counts_len = hdr_src->counts_len;
+  hdrh->total_count = hdr_src->total_count;
+  
+  for(i=0; i<hdrh->counts_len; i++) {
+    hdrh->counts[i] = hdr_src->counts[i];
+  }
+  
+  VALUE lowest = INT2NUM(hdr_src->lowest_trackable_value);
+  VALUE highest = INT2NUM(hdr_src->highest_trackable_value);
+  VALUE sig = INT2NUM(hdr_src->significant_figures);
+  VALUE opt = rb_hash_new();
+  rb_hash_aset(opt, rb_intern("multiplier"), rb_iv_get(self, "@multiplier"));
+  rb_hash_aset(opt, rb_intern("unit"), rb_iv_get(self, "@unit"));
+  
+  VALUE argv[4];
+  VALUE argc = 4;
+  argv[0]=lowest;
+  argv[1]=highest;
+  argv[2]=sig;
+  argv[3]=opt;
+  
+  rb_obj_call_init(self, argc, argv);
+  return self;
+}
+
 static VALUE histogram_reset(VALUE self) {
   GET_HDRHIST(hdr, self);
   hdr_reset(hdr);
@@ -103,42 +158,38 @@ static VALUE histogram_merge(VALUE self, VALUE another ) {
   return INT2NUM(hdr_add(hdr, hdr2));
 }
 
-#define HISTOGRAM_GETINT_METHOD(int_name)                 \
-static VALUE histogram_##int_name(VALUE self) {           \
+#define HISTOGRAM_GETSETNUM_METHOD(num_name, num_type)       \
+static VALUE histogram_get_##num_name(VALUE self) {       \
   GET_HDRHIST(hdr, self);                                 \
-  return INT2NUM(hdr->int_name);                          \
-}
-
-#define HISTOGRAM_SETNUM_METHOD(num_name, num_type)       \
+  return num_type##2NUM(hdr->num_name);                   \
+}                                                         \
+                                                          \
 static VALUE histogram_set_##num_name(VALUE self, VALUE num) { \
   GET_HDRHIST(hdr, self);                                 \
   hdr->num_name = NUM2##num_type(num);                    \
   return Qtrue;                                           \
 }
 
-HISTOGRAM_SETNUM_METHOD(lowest_trackable_value, LL)
-HISTOGRAM_SETNUM_METHOD(highest_trackable_value, LL)
-HISTOGRAM_SETNUM_METHOD(unit_magnitude, LONG)
-HISTOGRAM_SETNUM_METHOD(significant_figures, LONG)
-HISTOGRAM_SETNUM_METHOD(sub_bucket_half_count_magnitude, LONG)
-HISTOGRAM_SETNUM_METHOD(sub_bucket_half_count, LONG)
-HISTOGRAM_SETNUM_METHOD(sub_bucket_mask, LL)
-HISTOGRAM_SETNUM_METHOD(sub_bucket_count, LONG)
-HISTOGRAM_SETNUM_METHOD(bucket_count, LONG)
-HISTOGRAM_SETNUM_METHOD(min_value, LL)
-HISTOGRAM_SETNUM_METHOD(max_value, LL)
-HISTOGRAM_SETNUM_METHOD(normalizing_index_offset, LONG)
-HISTOGRAM_SETNUM_METHOD(conversion_ratio, DBL)
-HISTOGRAM_SETNUM_METHOD(counts_len, LONG)
-HISTOGRAM_SETNUM_METHOD(total_count, LL)
-
-HISTOGRAM_GETINT_METHOD(lowest_trackable_value)
-HISTOGRAM_GETINT_METHOD(highest_trackable_value)
-HISTOGRAM_GETINT_METHOD(unit_magnitude)
-HISTOGRAM_GETINT_METHOD(significant_figures)
-HISTOGRAM_GETINT_METHOD(bucket_count)
-HISTOGRAM_GETINT_METHOD(sub_bucket_count)
-HISTOGRAM_GETINT_METHOD(counts_len)
+HISTOGRAM_GETSETNUM_METHOD(lowest_trackable_value, LL)
+HISTOGRAM_GETSETNUM_METHOD(highest_trackable_value, LL)
+HISTOGRAM_GETSETNUM_METHOD(unit_magnitude, LONG)
+HISTOGRAM_GETSETNUM_METHOD(significant_figures, LONG)
+HISTOGRAM_GETSETNUM_METHOD(sub_bucket_half_count_magnitude, LONG)
+HISTOGRAM_GETSETNUM_METHOD(sub_bucket_half_count, LONG)
+HISTOGRAM_GETSETNUM_METHOD(sub_bucket_mask, LL)
+HISTOGRAM_GETSETNUM_METHOD(sub_bucket_count, LONG)
+HISTOGRAM_GETSETNUM_METHOD(bucket_count, LONG)
+HISTOGRAM_GETSETNUM_METHOD(min_value, LL)
+HISTOGRAM_GETSETNUM_METHOD(max_value, LL)
+HISTOGRAM_GETSETNUM_METHOD(normalizing_index_offset, LONG)
+HISTOGRAM_GETSETNUM_METHOD(conversion_ratio, DBL)
+HISTOGRAM_GETSETNUM_METHOD(counts_len, LONG)
+HISTOGRAM_GETSETNUM_METHOD(total_count, LL)
+
+#define HISTOGRAM_RUBY_PRIVATE_GETSETTERS(num_name) \
+  rb_define_private_method(HDRHistogram, #num_name "=", histogram_set_##num_name, 1);\
+  rb_define_private_method(HDRHistogram, #num_name, histogram_get_##num_name, 0)
+
 
 static VALUE histogram_set_raw_count(VALUE self, VALUE index, VALUE count) {
   GET_HDRHIST(hdr, self);
@@ -147,6 +198,18 @@ static VALUE histogram_set_raw_count(VALUE self, VALUE index, VALUE count) {
   hdr->counts[i]=c;
   return Qtrue;
 }
+static VALUE histogram_get_raw_count(VALUE self, VALUE index) {
+  VALUE   count;
+  int     i = NUM2INT(index);
+  GET_HDRHIST(hdr, self);
+  if(i >= hdr->counts_len) {
+    return Qnil;
+  }
+  else {
+    count = LL2NUM(hdr->counts[i]);
+    return count;
+  }
+}
 
 void Init_ruby_hdr_histogram() {
   HDRHistogram = rb_define_class("HDRHistogram", rb_cObject);
@@ -160,6 +223,9 @@ void Init_ruby_hdr_histogram() {
   rb_define_method(HDRHistogram, "memsize", histogram_memsize, 0);
   rb_define_method(HDRHistogram, "count", histogram_count, 0);
   
+  rb_define_method(HDRHistogram, "clone", histogram_clone, 0);
+  rb_define_method(HDRHistogram, "dup", histogram_clone, 0);
+  
   rb_define_private_method(HDRHistogram, "raw_record", histogram_record_value, 1);
   rb_define_private_method(HDRHistogram, "raw_record_corrected", histogram_record_corrected_value, 2);
   rb_define_private_method(HDRHistogram, "raw_min", histogram_min, 0);
@@ -169,34 +235,23 @@ void Init_ruby_hdr_histogram() {
   rb_define_private_method(HDRHistogram, "raw_percentile", histogram_percentile, 1);
   rb_define_private_method(HDRHistogram, "raw_merge", histogram_merge, 1);
   
-  rb_define_private_method(HDRHistogram, "lowest_trackable_value=", histogram_set_lowest_trackable_value, 1);
-  rb_define_private_method(HDRHistogram, "highest_trackable_value=", histogram_set_highest_trackable_value, 1);
-  rb_define_private_method(HDRHistogram, "unit_magnitude=", histogram_set_unit_magnitude, 1);
-  rb_define_private_method(HDRHistogram, "significant_figures=", histogram_set_significant_figures, 1);
-  rb_define_private_method(HDRHistogram, "sub_bucket_half_count_magnitude=", histogram_set_sub_bucket_half_count_magnitude, 1);
-  rb_define_private_method(HDRHistogram, "sub_bucket_half_count=", histogram_set_sub_bucket_half_count, 1);
-  rb_define_private_method(HDRHistogram, "sub_bucket_mask=", histogram_set_sub_bucket_mask, 1);
-  rb_define_private_method(HDRHistogram, "sub_bucket_count=", histogram_set_sub_bucket_count, 1);
-  rb_define_private_method(HDRHistogram, "bucket_count=", histogram_set_bucket_count, 1);
-  rb_define_private_method(HDRHistogram, "min_value=", histogram_set_min_value, 1);
-  rb_define_private_method(HDRHistogram, "max_value=", histogram_set_max_value, 1);
-  rb_define_private_method(HDRHistogram, "normalizing_index_offset=", histogram_set_normalizing_index_offset, 1);
-  rb_define_private_method(HDRHistogram, "conversion_ratio=", histogram_set_conversion_ratio, 1);
-  rb_define_private_method(HDRHistogram, "counts_len=", histogram_set_counts_len, 1);
-  rb_define_private_method(HDRHistogram, "total_count=", histogram_set_total_count, 1);
-  rb_define_private_method(HDRHistogram, "set_raw_count", histogram_set_raw_count, 2);
-  
-  rb_define_method(HDRHistogram, "lowest_trackable_value", histogram_lowest_trackable_value, 0);
-  rb_define_method(HDRHistogram, "highest_trackable_value", histogram_highest_trackable_value, 0);
-  rb_define_private_method(HDRHistogram, "unit_magnitude", histogram_unit_magnitude, 0);
-  rb_define_method(HDRHistogram, "significant_figures", histogram_significant_figures, 0);
-  rb_define_private_method(HDRHistogram, "bucket_count", histogram_bucket_count, 0);
-  rb_define_private_method(HDRHistogram, "sub_bucket_count", histogram_sub_bucket_count, 0);
-  rb_define_private_method(HDRHistogram, "counts_len", histogram_counts_len, 0);
-  
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(lowest_trackable_value);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(highest_trackable_value);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(unit_magnitude);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(significant_figures);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(sub_bucket_half_count_magnitude);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(sub_bucket_half_count);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(sub_bucket_mask);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(sub_bucket_count);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(bucket_count);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(min_value);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(max_value);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(normalizing_index_offset);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(conversion_ratio);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(counts_len);
+  HISTOGRAM_RUBY_PRIVATE_GETSETTERS(total_count);
   
-  rb_define_private_method(HDRHistogram, "unit_magnitude", histogram_unit_magnitude, 0);
-  
-  //rb_define_private_method(HDRHistogram, "histogram_spectrum", histogram_spectrum, 2);
+  rb_define_private_method(HDRHistogram, "set_raw_count", histogram_set_raw_count, 2);
+  rb_define_private_method(HDRHistogram, "get_raw_count", histogram_get_raw_count, 1);
 }
 

data/lib/HDRHistogram.rb

@@ -21,6 +21,12 @@ class HDRHistogram
       counts_len = m[:counts_len].to_i
       self.counts_len= counts_len
       self.total_count= m[:total_count].to_i
+      if !opt[:multiplier] && m[:multiplier]
+        @multiplier = m[:multiplier].to_f
+      end
+      if !@unit && m[:unit]
+        @unit = m[:unit]
+      end
       
       counts = m[:counts].split " "
       i=0
@@ -99,22 +105,60 @@ class HDRHistogram
     str
   end
   
+  def serialize
+    attrs = [lowest_trackable_value, highest_trackable_value, unit_magnitude, significant_figures, sub_bucket_half_count_magnitude, sub_bucket_half_count, sub_bucket_mask, sub_bucket_count, bucket_count, min_value, max_value, normalizing_index_offset, ("%f" % conversion_ratio), counts_len, total_count]
+    
+    raw_counts = []
+    numrun="~!@#$%^&*"
+    
+    for i in 0...counts_len do
+      raw_counts << get_raw_count(i)
+    end
+    
+    counts = []
+    
+    while raw_counts.length > 0 do
+      num = raw_counts.shift
+      n = 1
+      if num < numrun.length
+        while raw_counts[0] == num
+          raw_counts.shift
+          n+=1
+        end
+        if n > 1
+          counts << "#{numrun[num]}#{n}"
+        else
+          counts << num
+        end
+      else
+        counts << num
+      end
+    end
+    
+    out = "#{attrs.join " "} [#{counts.join " "} ]"
+    if @unit || @multiplier != 1
+      out << " (#{unit} #{multiplier})"
+    end
+    out
+  end
+  
   def self.adjusted_boundary_val(val, opt={})
     return opt ? val * 1/(opt[:multiplier] || 1) : val
   end
   private_class_method :adjusted_boundary_val
   
   def self.unserialize(str, opt={})
-    regex = /^(?<lowest_trackable_value>\d+) (?<highest_trackable_value>\d+) (?<unit_magnitude>\d+) (?<significant_figures>\d+) (?<sub_bucket_half_count_magnitude>\d+) (?<sub_bucket_half_count>\d+) (?<sub_bucket_mask>\d+) (?<sub_bucket_count>\d+) (?<bucket_count>\d+) (?<min_value>\d+) (?<max_value>\d+) (?<normalizing_index_offset>\d+) (?<conversion_ratio>\S+) (?<counts_len>\d+) (?<total_count>\d+) \[(?<counts>([~!@#$%^&*]?\d+ )+)\]/
+    regex = /^(?<lowest_trackable_value>\d+) (?<highest_trackable_value>\d+) (?<unit_magnitude>\d+) (?<significant_figures>\d+) (?<sub_bucket_half_count_magnitude>\d+) (?<sub_bucket_half_count>\d+) (?<sub_bucket_mask>\d+) (?<sub_bucket_count>\d+) (?<bucket_count>\d+) (?<min_value>\d+) (?<max_value>\d+) (?<normalizing_index_offset>\d+) (?<conversion_ratio>\S+) (?<counts_len>\d+) (?<total_count>\d+) \[(?<counts>([~!@#$%^&*]?\d+ )+)\]( \((?<unit>.*) (?<multiplier>\S+)\))?/
     
     m = str.match regex
     
     raise HDRHistogramError, "invalid serialization pattern" if m.nil?
     
     opt[:unserialized]=m
+    multiplier = opt[:multiplier] || 1
     
-    low = m[:lowest_trackable_value].to_i * (opt[:multiplier] || 1)
-    high = m[:highest_trackable_value].to_i * (opt[:multiplier] || 1)
+    low = m[:lowest_trackable_value].to_i * multiplier
+    high = m[:highest_trackable_value].to_i * multiplier
     hdrh = self.new(low, high, m[:significant_figures].to_i, opt)
     
     return hdrh

data/lib/HDRHistogram/version.rb

@@ -1,3 +1,3 @@
 class HDRHistogram
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDRHistogram
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Leo P.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-30 00:00:00.000000000 Z
+date: 2018-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler