jemal 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 77f60c008c7ce2c7830ad626989eadcee68e7b65
+  data.tar.gz: 092152b3eb68c593cc1078f2425a74358a261332
+SHA512:
+  metadata.gz: 1e0a37a570b342421d8c655b8598625177a6b3ce229739472aed54aa6314919e0666bfd7cf72186cb8949133e137799a9ee7a97365b8ec010be1e5d2f8ceffac
+  data.tar.gz: 80fb210de552cdb7513d4de2c54be69f9fdcc834d5c2c432ac2ff4b81a3ed9fefd4febbe6b4a64b3c150e4236800fd949c8ff8114829f308cadfa5c9e48e48dd

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.ruby-version

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jemal.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 oleg dashevskii
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,217 @@
+# Jemal
+
+This gem provides interface to your MRI built with [jemalloc](canonware.com/jemalloc/).
+Of course you heard that
+Ruby 2.2.0 [introduced jemalloc support](https://www.ruby-lang.org/en/news/2014/12/25/ruby-2-2-0-released/).
+
+Primary goal of this gem is to provide access to jemalloc statistics.
+
+Currently jemalloc 3.6.0 is supported (certain Ruby gems can't yet be built
+with 4.0.0 due to stdbool.h conflict).
+
+Note that there's another [jemalloc-related gem](https://github.com/kzk/jemalloc-rb) on RubyGems.
+It doesn't provide interface to builtin jemalloc, but rather aims at injecting jemalloc in runtime with LD_PRELOAD.
+
+## Jemalloc installation
+
+Ubuntu:
+
+    $ sudo apt-get install libjemalloc-dev
+
+OS X:
+
+    $ brew install jemalloc
+
+
+Note that if you want to use allocation profiling, you'll have to build
+jemalloc from source (`./configure --enable-prof`). Both ubuntu and homebrew versions
+are built without this option.
+
+## Ruby with jemalloc installation
+
+
+Instructions are [here](http://groguelon.fr/post/106221222318/how-to-install-ruby-220-with-jemalloc-support).
+
+## Gem installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jemal'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jemal
+
+## Usage
+
+To be sure that your Ruby is jemalloc-powered, use `Jemal.jemalloc_builtin?`.
+
+```ruby
+require 'jemal'
+
+Jemal.jemalloc_builtin?
+# => true
+```
+
+You can also check jemalloc version:
+
+```ruby
+Jemal.version
+# => "3.6.0-0-g46c0af68bd248b04df75e4f92d5fb804c3d75340"
+```
+
+Look at the flags jemalloc has been built with:
+
+```ruby
+Jemal.build_configuration
+# => {:debug=>false, :dss=>false, :fill=>true, :lazy_lock=>false, :mremap=>false, :munmap=>true,
+#     :prof=>false, :prof_libgcc=>false, :prof_libunwind=>false, :stats=>true, :tcache=>true,
+#     :tls=>false, :utrace=>false, :valgrind=>false, :xmalloc=>false}
+```
+
+Most of these options aren't very interesting, however be sure that `Jemal.build_configuration[:stats]` is `true`,
+otherwise you won't be able to collect statistics.
+
+Find out how many arenas are used by jemalloc:
+
+```ruby
+Jemal.arenas_count
+# => 16
+```
+
+Each arena is basically a separate allocator with its own memory. Multiple arenas provide more speed for heavily
+multithreaded applications by allowing parallel threads to allocate memory simultaneously. This doesn't help MRI much, because its heap is still shared between all threads, so we can set `MALLOC_CONF=narenas:1` in environment and have single arena.
+
+Now to statistics:
+
+```ruby
+Jemal.stats
+# => {:allocated=>23587776, :active=>24416256, :metadata=>0, :resident=>0, :mapped=>29360128,
+#     :cactive=>37748736, :chunks=>{:current=>7, :total=>7, :high=>7},
+#     :arenas=>[ ... ]}
+```
+
+The returned hash is quite big, it contains joint statistics, as well as statistics for each arena. Read 
+[jemalloc man page](http://www.unix.com/man-page/freebsd/3/jemalloc/) to be able to understand the figures (look for `stats.*`).
+
+If you just want human-compatible stats in text form and `STDERR` is okay, you are also covered:
+
+```ruby
+Jemal.stats_print
+```
+
+You'll get a jemalloc stats dump which looks like this:
+
+```
+___ Begin jemalloc statistics ___
+Version: 3.6.0-0-g46c0af68bd248b04df75e4f92d5fb804c3d75340
+Assertions disabled
+Run-time option settings:
+  opt.abort: false
+  opt.lg_chunk: 22
+  opt.dss: "secondary"
+  opt.narenas: 16
+  opt.lg_dirty_mult: 3
+  opt.stats_print: false
+  opt.junk: false
+  opt.quarantine: 0
+  opt.redzone: false
+  opt.zero: false
+  opt.tcache: true
+  opt.lg_tcache_max: 15
+CPUs: 4
+Arenas: 16
+Pointer size: 8
+Quantum size: 16
+Page size: 4096
+Min active:dirty page ratio per arena: 8:1
+Maximum thread-cached size class: 32768
+Chunk size: 4194304 (2^22)
+Allocated: 23781096, active: 25649152, mapped: 33554432
+Current active ceiling: 37748736
+chunks: nchunks   highchunks    curchunks
+              8            8            8
+huge: nmalloc      ndalloc    allocated
+            0            0            0
+
+arenas[0]:
+assigned threads: 1
+dss allocation precedence: disabled
+dirty pages: 6262:52 active:dirty, 0 sweeps, 0 madvises, 0 purged
+            allocated      nmalloc      ndalloc    nrequests
+small:       17493736       317316       120581       678822
+large:        6287360          432           56         1269
+total:       23781096       317748       120637       680091
+active:      25649152
+mapped:      29360128
+bins:     bin  size regs pgs    allocated      nmalloc      ndalloc    nrequests       nfills     nflushes      newruns       reruns      curruns
+            0     8  501   1        87688        12194         1233        19899          246           25           23           32           23
+            1    16  252   1       200480        22361         9831        31078          279          113           81          162           52
+            2    32  126   1      1017088        36067         4283        81314          433           57          267          373          264
+            3    48   84   1      4174848       137466        50490       250234         1644          603         1140         3707         1072
+            4    64   63   1       331392         9969         4791        35396          335           98          115          273          104
+            5    80   50   1       691840        14013         5365        52709          353          122          197          682          182
+            6    96   84   2       269664         3921         1112        12273           87           47           45           55           40
+            7   112   72   2       433664         4481          609         7083           95           32           61           65           57
+            8   128   63   2       207488         2086          465        11407           84           35           32           42           28
+            9   160   51   2      2482880        49495        33977       106753          997          672          486         2895          313
+           10   192   63   3       205632         1643          572         3659           61           42           24           24           19
+           11   224   72   4       422688         2339          452         3222           62           35           31           17           28
+           12   256   63   4       152320         1049          454         1383           51           39           19           11           11
+           13   320   63   5      2549760         8587          619        11026          179           27          135           39          132
+           14   384   63   6       167040          749          314         1105           29           38           11            3            8
+           15   448   63   7       689472         2861         1322         5053          227           51           38           39           29
+           16   512   63   8       161280          551          236          552           35           35           11            5            6
+           17   640   51   8       693120         3729         2646        39605          119           74           42          224           25
+           18   768   47   9       328704          677          249          723           36           36           15            8           10
+           19   896   45  10       272384          560          256          660           36           35           14            9            7
+           20  1024   63  16       273408          475          208          464           31           37            7            4            5
+           21  1280   51  16       478720          686          312         1367           39           38           14            9            8
+           22  1536   42  16       259584          323          154          545           40           34            6            3            5
+           23  1792   38  17       236544          304          172          454           30           30            7            5            4
+           24  2048   65  33       182272          236          147          198           29           30            3            1            2
+           25  2560   52  33       245760          227          131          393           24           30            4            1            3
+           26  3072   43  33       181248          156           97          173           30           30            3            7            2
+           27  3584   39  35        96768          111           84           94           21           24            2            0            1
+large:   size pages      nmalloc      ndalloc    nrequests      curruns
+         4096     1           63           21          520           42
+         8192     2           89           17          465           72
+        12288     3           21            9           23           12
+        16384     4          243            3          244          240
+        20480     5            2            2            2            0
+        24576     6            2            2            2            0
+        28672     7            3            1            3            2
+        32768     8            6            1            7            5
+[11]
+        81920    20            1            0            1            1
+[2]
+        94208    23            1            0            1            1
+[232]
+      1048576   256            1            0            1            1
+[762]
+--- End jemalloc statistics ---
+```
+
+Other methods of less interest:
+
+```ruby
+Jemal.options       # Returns runtime jemalloc options
+# => { :abort=>false, ... }
+
+Jemal.sizes         # Returns some constant sizes (page, bin, lrun)
+# => { :page_size=>4096, ... }
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/be9/jemal.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "jemal"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/jemal.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jemal/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jemal"
+  spec.version       = Jemal::VERSION
+  spec.authors       = ["oleg dashevskii"]
+  spec.email         = ["olegdashevskii@gmail.com"]
+
+  spec.summary       = %q{Interface to jemalloc}
+  spec.description   = %q{Means to access jemalloc options and statistics for MRI compiled with jemalloc support.}
+  spec.homepage      = "https://github.com/be9/jemal"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'ffi', '~> 1.9.10'
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "log_buddy"
+end

data/lib/jemal/interface.rb

@@ -0,0 +1,148 @@
+require 'ffi'
+
+module Jemal
+  module Interface
+    extend FFI::Library
+
+    ffi_lib [FFI::CURRENT_PROCESS, 'jemalloc']
+
+    # int mallctl(const char *name, void *oldp, size_t *oldlenp,
+    #             void *newp, size_t newlen);
+    attach_function :mallctl, [:string, :pointer, :pointer, :pointer, :size_t], :int
+
+    # void malloc_stats_print(void (*write_cb) (void *, const char *),
+    #                         void *cbopaque, const char *opts);
+    # TODO
+    attach_function :malloc_stats_print, [:pointer, :pointer, :pointer], :void
+
+    protected
+
+    # Private: Use mallctl to read boolean value.
+    #
+    # name - the String with parameter name.
+    #
+    # Returns true or false.
+    def get_bool(name)
+      ptr = FFI::MemoryPointer.new :bool
+      mallctl name, ptr, size_pointer(ptr), nil, 0
+      ptr.get_uchar(0) > 0
+    end
+
+    # Private: Use mallctl to read unsigned value.
+    #
+    # name - the String with parameter name.
+    #
+    # Returns Numeric value.
+    def get_uint(name)
+      ptr = FFI::MemoryPointer.new :uint
+      mallctl name, ptr, size_pointer(ptr), nil, 0
+
+      ptr.read_uint
+    end
+
+    # Private: Use mallctl to read unsigned 32-bit value.
+    #
+    # name - the String with parameter name.
+    #
+    # Returns Numeric value.
+    def get_uint32(name)
+      ptr = FFI::MemoryPointer.new :uint32
+      mallctl name, ptr, size_pointer(ptr), nil, 0
+      ptr.read_uint32
+    end
+
+    # Private: Use mallctl to read unsigned 64-bit value.
+    #
+    # name - the String with parameter name.
+    #
+    # Returns Numeric value.
+    def get_uint64(name)
+      ptr = FFI::MemoryPointer.new :uint64
+      mallctl name, ptr, size_pointer(ptr), nil, 0
+      ptr.read_uint64
+    end
+
+    # Private: Use mallctl to read size_t value.
+    #
+    # name - the String with parameter name.
+    #
+    # Returns Numeric value.
+    def get_size_t(name)
+      ptr = FFI::MemoryPointer.new :size_t
+      mallctl name, ptr, size_pointer(ptr), nil, 0
+
+      read_size_t(ptr)
+    end
+
+    # Private: Use mallctl to read size_t value.
+    #
+    # name - the String with parameter name.
+    #
+    # Returns Numeric value.
+    def get_ssize_t(name)
+      ptr = FFI::MemoryPointer.new :ssize_t
+      mallctl name, ptr, size_pointer(ptr), nil, 0
+
+      read_ssize_t(ptr)
+    end
+
+    # Private: Use mallctl to read string value.
+    #
+    # name - the String with parameter name.
+    #
+    # Returns String or nil.
+    def get_string(name)
+      ptr = FFI::MemoryPointer.new :pointer
+
+      mallctl name, ptr, size_pointer(ptr), nil, 0
+
+      strptr = ptr.read_pointer
+      strptr.null? ? nil : strptr.read_string
+    end
+
+    # Private: Set up a size_t pointer.
+    #
+    # Creates a pointer to size_t value, which is set to
+    # baseptr.size.
+    #
+    # baseptr - a FFI::MemoryPointer instance.
+    #
+    # Returns a FFI::MemoryPointer.
+    def size_pointer(baseptr)
+      sizeptr = FFI::MemoryPointer.new :size_t
+      write_size_t(sizeptr, baseptr.size)
+      sizeptr
+    end
+
+    case FFI::Platform::ADDRESS_SIZE
+    when 64
+      def read_size_t(ptr)
+        ptr.read_uint64
+      end
+
+      def write_size_t(ptr, value)
+        ptr.write_uint64 value
+      end
+
+      def read_ssize_t(ptr)
+        ptr.read_int64
+      end
+
+    when 32
+      def read_size_t(ptr)
+        ptr.read_uint32
+      end
+
+      def write_size_t(ptr, value)
+        ptr.write_uint32 value
+      end
+
+      def read_ssize_t(ptr)
+        ptr.read_int32
+      end
+
+    else
+      raise "Unsupported platform address size = #{FFI::Platform::ADDRESS_SIZE}"
+    end
+  end
+end

data/lib/jemal/version.rb

@@ -0,0 +1,3 @@
+module Jemal
+  VERSION = "0.1.0"
+end

data/lib/jemal.rb

@@ -0,0 +1,294 @@
+require 'set'
+require 'jemal/version'
+require 'jemal/interface'
+
+module Jemal
+  extend Jemal::Interface
+
+  # Public: Check if Ruby was built with jemalloc.
+  #
+  # Returns true if it was, false otherwise.
+  def self.jemalloc_builtin?
+    require 'rbconfig'
+
+    !!(RbConfig::CONFIG["configure_args"] =~ /jemalloc/)
+  end
+
+  # Public: Get jemalloc version.
+  #
+  # Examples
+  #
+  #   Jemal.version
+  #   # => "3.6.0-0-g46c0af68bd248b04df75e4f92d5fb804c3d75340"
+  #
+  # Returns the String version.
+  def self.version
+    get_string "version"
+  end
+
+  CFG_PARAMS = %i(debug dss fill lazy_lock mremap munmap prof prof_libgcc
+                  prof_libunwind stats tcache tls utrace valgrind xmalloc)
+
+  # Public: Get jemalloc build configuration.
+  #
+  # Returns all config.* parameters in a single Hash.
+  #
+  # Examples
+  #
+  #   Jemal.build_configuration
+  #   # => {:debug=>false, :dss=>false, :fill=>true, :lazy_lock=>false, ... }
+  #
+  # Returns a Hash with Symbol keys and boolean values.
+  def self.build_configuration
+    CFG_PARAMS.inject({}) do |hash, param|
+      hash[param] = get_bool("config.#{param}")
+      hash
+    end
+  end
+
+  # Public: Get options (opt.*) as a Hash
+  #
+  # Returns a Hash with 24 options.
+  def self.options
+    res = {}
+
+    OPT_BOOL.each    { |o| res[o] = get_bool("opt.#{o}") }
+    OPT_SIZE_T.each  { |o| res[o] = get_size_t("opt.#{o}") }
+    OPT_SSIZE_T.each { |o| res[o] = get_ssize_t("opt.#{o}") }
+    OPT_CHARP.each   { |o| res[o] = get_string("opt.#{o}") }
+
+    res
+  end
+
+  OPT_BOOL = %i(abort stats_print redzone zero utrace xmalloc tcache
+                prof prof_active prof_accum prof_gdump prof_final prof_leak)
+  # 4.0.0: prof_thread_active_init
+
+  OPT_SIZE_T = %i(lg_chunk narenas quarantine lg_tcache_max)
+  OPT_SSIZE_T = %i(lg_prof_sample lg_dirty_mult lg_prof_interval)
+  OPT_CHARP = %i(dss junk prof_prefix)
+
+  # Public: Get current number of arenas.
+  #
+  # Returns Integer value.
+  def self.arenas_count
+    get_uint "arenas.narenas"
+  end
+
+  # Public: Get initialized arenas.
+  #
+  # Returns a Set with integer arena indices. Every index is in
+  # [0, arenas_count-1] range.
+  def self.initialized_arenas
+    n = arenas_count
+    ptr = FFI::MemoryPointer.new :bool, n
+    mallctl "arenas.initialized", ptr, size_pointer(ptr), nil, 0
+
+    (0...n).inject(Set.new) do |indices, i|
+      if ptr.get_uchar(i) > 0
+        indices << i
+      else
+        indices
+      end
+    end
+  end
+
+  # Public: Get various sizes.
+  #
+  # Page size, bin sizes, large run sizes, etc.
+  #
+  # Sizes are believed to be constant, therefore this method result is cached.
+  # Second and successive calls will return cached value.
+  #
+  # Returns a Hash with all sizes.
+  def self.sizes
+    return @sizes if defined?(@sizes)
+
+    res = {
+      # Quantum size
+      quantum:   get_size_t("arenas.quantum"),
+      # Page size
+      page_size:  get_size_t("arenas.page"),
+      # Maximum thread-cached size class
+      tcache_max: get_size_t("arenas.tcache_max"),
+      # Total number of thread cache bin size classes.
+      nhbins: get_uint("arenas.nhbins")
+    }
+
+    # Number of bin size classes.
+    nbins = get_uint("arenas.nbins")
+
+    # Total number of large size classes.
+    nlruns = get_uint("arenas.nlruns")
+
+    # Total number of huge size classes (4.0.0)
+    #nhchunks = get_uint("arenas.nhchunks")
+
+    res[:bins] = (0...nbins).map do |i|
+      prefix = "arenas.bin.#{i}."
+      {
+        # Maximum size supported by size class
+        size: get_size_t("#{prefix}size"),
+        # Number of regions per page run
+        nregs: get_uint32("#{prefix}nregs"),
+        # Number of bytes per page run
+        run_size: get_size_t("#{prefix}run_size")
+      }
+    end
+
+    res[:lruns] = (0...nlruns).map do |i|
+      # Maximum size supported by this large size class
+      get_size_t("arenas.lrun.#{i}.size")
+    end
+
+    # 4.0.0
+    #res[:hchunks] = (0...nhchunks).map do |i|
+      ## Maximum size supported by this huge size class
+      #get_size_t("arenas.hchunk.#{i}.size")
+    #end
+
+    @sizes = res
+  end
+
+  # Public: Get current statistics.
+  #
+  # Returns stats as one big Hash.
+  def self.stats
+    res = {}
+
+    GLOBAL_STATS.each { |s| res[s] = get_size_t("stats.#{s}") }
+    res[:cactive] = read_size_t(cactive_ptr)
+
+    res[:chunks] = chunks = {}
+    CHUNK_STATS.each { |s| chunks[s] = get_size_t("stats.chunks.#{s}") }
+
+    res[:arenas] = arenas = Array.new(arenas_count)
+
+    initialized_arenas.each do |i|
+      arenas[i] = arena_stats(i)
+    end
+
+    res
+  end
+
+  GLOBAL_STATS = %i(allocated active metadata resident mapped)
+  CHUNK_STATS  = %i(current total high)
+
+  ARN_SIZE_T = %i(pactive pdirty mapped metadata.mapped metadata.allocated)
+  ARN_UINT64 = %i(npurge nmadvise purged)
+
+  BIN_PARAMS = %i(allocated nmalloc ndalloc nrequests)
+  BIN_SIZES = %i(small large)
+
+  # Public: Get arena stats.
+  #
+  # i - the Integer arena index (0..arenas_count-1).
+  #
+  # Returns stats as a Hash.
+  def self.arena_stats(i)
+    prefix = "stats.arenas.#{i}."
+
+    res = {
+      #dss:           get_string("#{prefix}dss"),
+      lg_dirty_mult: get_ssize_t("#{prefix}lg_dirty_mult"),
+      nthreads:      get_uint("#{prefix}nthreads"),
+    }
+
+    ARN_SIZE_T.each { |p| res[p] = get_size_t("#{prefix}#{p}") }
+    ARN_UINT64.each { |p| res[p] = get_uint64("#{prefix}#{p}") }
+
+    BIN_SIZES.each do |sz|
+      res[sz] = h = {}
+
+      BIN_PARAMS.each do |p|
+        h[p] = get_uint64("#{prefix}#{sz}.#{p}")
+      end
+    end
+
+    res[:bins] = bins = {}
+    bin_sizes = sizes[:bins]
+
+    (0...bin_sizes.size).each do |i|
+      binprefix = "#{prefix}bins.#{i}."
+      nruns = get_uint64("#{binprefix}nruns")
+      next if nruns == 0
+
+      bins[bin_sizes[i][:size]] = {
+        # Current number of bytes allocated by bin.
+        allocated: get_size_t("#{binprefix}allocated"),
+
+        # Cumulative number of allocations served by bin.
+        nmalloc: get_uint64("#{binprefix}nmalloc"),
+
+        # Cumulative number of allocations returned to bin.
+        ndalloc: get_uint64("#{binprefix}ndalloc"),
+
+        # Cumulative number of allocation requests.
+        nrequests: get_uint64("#{binprefix}nrequests"),
+
+        # Cumulative number of tcache fills.
+        nfills: get_uint64("#{binprefix}nfills"),
+
+        # Cumulative number of tcache flushes.
+        nflushes: get_uint64("#{binprefix}nflushes"),
+
+        # Cumulative number of times the current run from which to allocate changed.
+        nreruns: get_uint64("#{binprefix}nreruns"),
+
+        # Current number of runs.
+        curruns: get_size_t("#{binprefix}curruns"),
+
+        # Cumulative number of runs created.
+        nruns: nruns
+      }
+    end
+
+    res[:lruns] = lruns = {}
+    lrun_sizes = sizes[:lruns]
+
+    (0...lrun_sizes.size).each do |i|
+      lrunprefix = "#{prefix}lruns.#{i}."
+      nreqs = get_uint64("#{lrunprefix}nrequests")
+      next if nreqs == 0
+
+      lruns[lrun_sizes[i]] = {
+        # Cumulative number of allocation requests for this size class served
+        # directly by the arena.
+        nmalloc: get_uint64("#{lrunprefix}nmalloc"),
+
+        # Cumulative number of deallocation requests for this size class served
+        # directly by the arena.
+        ndalloc: get_uint64("#{lrunprefix}ndalloc"),
+
+        # Cumulative number of allocation requests for this size class.
+        nrequests: nreqs,
+
+        # Current number of runs for this size class.
+        curruns: get_size_t("#{lrunprefix}curruns"),
+      }
+    end
+
+    res
+  end
+
+  # Public: Print current stats.
+  #
+  # Invoke jemalloc's own stats reporting function, which
+  # prints all stats to STDERR.
+  #
+  # Returns nothing.
+  def self.stats_print
+    malloc_stats_print nil,nil,nil
+  end
+
+  protected
+
+  def self.cactive_ptr
+    @cactive_ptr ||=
+      begin
+        ptr = FFI::MemoryPointer.new :pointer
+        mallctl "stats.cactive", ptr, size_pointer(ptr), nil, 0
+        ptr.read_pointer
+      end
+  end
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: jemal
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- oleg dashevskii
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.10
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: log_buddy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Means to access jemalloc options and statistics for MRI compiled with
+  jemalloc support.
+email:
+- olegdashevskii@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- jemal.gemspec
+- lib/jemal.rb
+- lib/jemal/interface.rb
+- lib/jemal/version.rb
+homepage: https://github.com/be9/jemal
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Interface to jemalloc
+test_files: []