hwloc 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 61e8806d799ed1d37e565e888eed0de26488116a
+  data.tar.gz: 541e27b80809c3d14acade623fbcdbaab8b25810
+SHA512:
+  metadata.gz: 0bf475374cc8559d3552ddb2810aee513b1a50aa2d22d23a95e9580f38e4797c171fb123cc32e63b9fc4e41bdfb1bc2c78a4bf18577a8342bd13f1140d2216f8
+  data.tar.gz: 917a4118dd5ea19bb4f95385cda8cf8ffc331534e9e77ed04c54b0c57f870de687db2406167c5bb8e26e79472afa069fc2a859f0611709ffeccc39fb63e6a062

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2017, Brice Videau <brice.videau@imag.fr>
+All rights reserved.
+      
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. 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.
+        
+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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.

data/README.md

@@ -0,0 +1,100 @@
+# hwloc-ruby
+
+Simple example using only the compute topology.
+The pagemap tool can be found here: https://forge.imag.fr/projects/pagemap/
+Note that you will certainly need to be root to be able to use pagemap.
+
+```ruby
+require 'hwloc'
+require 'ffi'
+
+
+# helper function to print memory location (may need pagemap on older version of hwloc)
+def print_pointer_location(ptr, t)
+  if t.respond_to? :get_area_memlocation
+    page_number = (ptr.size.to_f / $page_size).ceil
+    base_address = ptr.address - ( ptr.address % $page_size )
+    ptrs = page_number.times.collect { |i|
+      FFI::Pointer::new(base_address + i*$page_size).slice(0, $page_size)
+    }
+    ptrs.each { |ptr|
+      p t.get_area_memlocation(ptr, :MEMBIND_BYNODESET)
+    }
+  else
+    puts "pagemap #{Process::pid} -n #{ptr.address.to_s(16)}-#{(ptr.address+ptr.size-1).to_s(16)}"
+    puts `pagemap #{Process::pid} -n #{ptr.address.to_s(16)}-#{(ptr.address+ptr.size-1).to_s(16)}`
+  end
+end
+
+t = Hwloc::Topology::new
+t.flags = Hwloc::Topology::FLAG_ICACHES
+t.load
+
+$page_size = t.machines.first.memory.page_types.first.size
+
+#Get some info on the machine:
+
+o = t.root_obj
+puts o.infos
+
+
+#Print all the object doing a depth first traversal:
+t.each { |o|
+  puts o
+}
+
+#Print all the objects doing a breadth first traversal:
+t.depth.times { |d|
+  puts t.each_by_depth(d).to_a.join(", ")
+}
+
+# find the number of level of caches on the machine and their size:
+first_core = t.cores.first
+caches = first_core.ancestors.take_while{ |o| o.type == :OBJ_CACHE }
+caches.each_with_index { |c,i|
+  puts "#{c.type_name}: #{c.attr.size/1024}KiB"
+}
+
+#migrate the execution to different OBJ_PU
+t.pus.shuffle.first(3).each { |pu|
+  t.set_cpubind(pu.cpuset)
+  puts "Processing on #{pu} #P#{pu.os_index}"
+  i = 0
+  (1<<26).times { i+=1 }
+}
+
+#allocate memory on different nodes using hwloc (if you have any)
+if t.numanodes.length > 0 then
+  ptrs = t.numanodes.collect { |n|
+    ptr = t.alloc_membind(10*4*1024, n.cpuset, :MEMBIND_BIND)
+    ptr.clear
+  }
+  sleep 1
+  ptrs.each { |ptr|
+    p t.get_area_membind(ptr)
+    print_pointer_location(ptr, t)
+    puts
+  }
+end
+
+#migrating memory using hwloc (We don't control alignment so last page of each allocation can be migrated twice because it overlaps two memory areas)
+if t.numanodes.length > 0 then
+  ptrs = t.numanodes.collect { |n|
+    ptr = FFI::MemoryPointer::new(10*4*1024)
+    t.set_area_membind(ptr, n.cpuset, :MEMBIND_BIND, :MEMBIND_MIGRATE)
+    ptr.clear
+  }
+  sleep 1
+  ptrs.each { |ptr|
+    p t.get_area_membind(ptr)
+    print_pointer_location(ptr, t)
+    puts
+  }
+end
+
+#allocate and migrate memory in an interleaved way
+ptr = FFI::MemoryPointer::new(10*4*1024)
+t.set_area_membind(ptr, t.machines.first.cpuset, :MEMBIND_INTERLEAVE, :MEMBIND_MIGRATE)
+p t.get_area_membind(ptr)
+print_pointer_location(ptr, t)
+```

data/hwloc.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = 'hwloc'
+  s.version = "0.1"
+  s.author = "Brice Videau"
+  s.email = "brice.videau@imag.fr"
+  s.homepage = "https://github.com/Nanosim-LIG/hwloc-ruby"
+  s.summary = "hwloc ruby bindings"
+  s.description = "hwloc ruby bindings for versions 1.10 onward"
+  s.files = Dir['hwloc.gemspec', 'LICENSE', 'README.md', 'lib/**/*']
+  s.has_rdoc = false
+  s.license = 'BSD-2-Clause'
+  s.required_ruby_version = '>= 1.9.3'
+  s.add_dependency 'ffi', '~> 1.9', '>=1.9.3'
+end

data/lib/hwloc.rb

@@ -0,0 +1,7 @@
+require_relative 'hwloc/Hwloc.rb'
+require_relative 'hwloc/Bitmap.rb'
+require_relative 'hwloc/Obj.rb'
+require_relative 'hwloc/Topology.rb'
+require_relative 'hwloc/Bind.rb'
+require_relative 'hwloc/Edition.rb'
+require_relative 'hwloc/Export.rb'

data/lib/hwloc/Bind.rb

@@ -0,0 +1,280 @@
+module Hwloc
+  CpubindFlags = enum( :cpubin_flags, [
+    :CPUBIND_PROCESS,   1<<0,
+    :CPUBIND_THREAD,    1<<1,
+    :CPUBIND_STRICT,    1<<2,
+    :CPUBIND_NOMEMBIND, 1<<3
+  ] )
+
+  MembindPolicy = enum( :membind_policy, [
+    :MEMBIND_DEFAULT,    0,
+    :MEMBIND_FIRSTTOUCH, 1,
+    :MEMBIND_BIND,       2,
+    :MEMBIND_INTERLEAVE, 3,
+    :MEMBIND_REPLICATE,  4,
+    :MEMBIND_NEXTTOUCH,  5,
+    :MEMBIND_MIXED,      -1
+  ] )
+
+  MembindFlags = enum( :membind_flags, [
+    :MEMBIND_PROCESS,   1<<0,
+    :MEMBIND_THREAD,    1<<1,
+    :MEMBIND_STRICT,    1<<2,
+    :MEMBIND_MIGRATE,   1<<3,
+    :MEMBIND_NOCPUBIND, 1<<4,
+    :MEMBIND_BYNODESET, 1<<5
+  ] )
+
+  attach_function :hwloc_set_cpubind, [:topology, :cpuset, :int], :int
+  attach_function :hwloc_get_cpubind, [:topology, :cpuset, :int], :int
+  attach_function :hwloc_set_proc_cpubind, [:topology, :hwloc_pid_t, :cpuset, :int], :int
+  attach_function :hwloc_get_proc_cpubind, [:topology, :hwloc_pid_t, :cpuset, :int], :int
+  attach_function :hwloc_set_thread_cpubind, [:topology, :hwloc_thread_t, :cpuset, :int], :int
+  attach_function :hwloc_get_thread_cpubind, [:topology, :hwloc_thread_t, :cpuset, :int], :int
+  attach_function :hwloc_get_last_cpu_location, [:topology, :cpuset, :int], :int
+  attach_function :hwloc_get_proc_last_cpu_location, [:topology, :hwloc_pid_t, :cpuset, :int], :int
+
+  class BindError < Error
+  end
+
+  class CpubindError < BindError
+  end
+
+  class Topology
+
+    def set_cpubind(cpuset, flags = 0)
+      err = Hwloc.hwloc_set_cpubind(@ptr, cpuset, flags)
+      raise CpubindError if err == -1
+      return self
+    end
+
+    def get_cpubind(flags = 0)
+      cpuset = Cpuset::new
+      err = Hwloc.hwloc_get_cpubind(@ptr, cpuset, flags)
+      raise CpubindError if err == -1
+      return cpuset
+    end
+
+    def set_proc_cpubind(pid, cpuset, flags = 0)
+      err = Hwloc.hwloc_set_proc_cpubind(@ptr, pid, cpuset, flags)
+      raise CpubindError if err == -1
+      return self
+    end
+
+    def get_proc_cpubind(pid, flags)
+      cpuset = Cpuset::new
+      err = Hwloc.hwloc_get_proc_cpubind(@ptr, pid, cpuset, flags)
+      raise CpubindError if err == -1
+      return cpuset
+    end
+
+    def set_thread_cpubind(thread, cpuset, flags = 0)
+      err = Hwloc.hwloc_set_thread_cpubind(@ptr, thread, cpuset, flags)
+      raise CpubindError if err == -1
+      return self
+    end
+
+    def get_thread_cpubind(thread, flags = 0)
+      cpuset = Cpuset::new
+      err = Hwloc.hwloc_get_thread_cpubind(@ptr, thread, cpuset, flags)
+      raise CpubindError if err == -1
+      return cpuset
+    end
+
+    def get_last_cpu_location(flags = 0)
+      cpuset = Cpuset::new
+      err = Hwloc.hwloc_get_last_cpu_location(@ptr, cpuset, flags)
+      raise CpubindError if err == -1
+      return cpuset
+    end
+
+    def get_proc_last_cpu_location(pid, flags = 0)
+      cpuset = Cpuset::new
+      err = Hwloc.hwloc_get_proc_last_cpu_location(@ptr, pid, cpuset, flags)
+      raise CpubindError if err == -1
+      return cpuset
+    end
+
+  end
+
+  class MembindError < BindError
+  end
+
+  attach_function :hwloc_set_membind_nodeset, [:topology, :nodeset, :membind_policy, :int], :int
+  attach_function :hwloc_set_membind, [:topology, :bitmap, :membind_policy, :int], :int
+  attach_function :hwloc_get_membind_nodeset, [:topology, :nodeset, :pointer, :int], :int
+  attach_function :hwloc_get_membind, [:topology, :bitmap, :pointer, :int], :int
+  attach_function :hwloc_set_proc_membind_nodeset, [:topology, :hwloc_pid_t, :nodeset, :membind_policy, :int], :int
+  attach_function :hwloc_set_proc_membind, [:topology, :hwloc_pid_t, :bitmap, :membind_policy, :int], :int
+  attach_function :hwloc_get_proc_membind_nodeset, [:topology, :hwloc_pid_t, :nodeset, :pointer, :int], :int
+  attach_function :hwloc_get_proc_membind, [:topology, :hwloc_pid_t, :bitmap, :pointer, :int], :int
+
+  attach_function :hwloc_set_area_membind_nodeset, [:topology, :pointer, :size_t, :nodeset, :membind_policy, :int], :int
+  attach_function :hwloc_set_area_membind, [:topology, :pointer, :size_t, :bitmap, :membind_policy, :int], :int
+  attach_function :hwloc_get_area_membind_nodeset, [:topology, :pointer, :size_t, :nodeset, :pointer, :int], :int
+  attach_function :hwloc_get_area_membind, [:topology, :pointer, :size_t, :bitmap, :pointer, :int], :int
+
+  begin
+    attach_function :hwloc_get_area_memlocation, [:topology, :pointer, :size_t, :bitmap, :int], :int
+  rescue FFI::NotFoundError
+    warn "Missing hwloc_get_area_memlocation support!"
+  end
+
+  attach_function :hwloc_alloc, [:topology, :size_t], :pointer
+  attach_function :hwloc_alloc_membind_nodeset, [:topology, :size_t, :nodeset, :membind_policy, :int], :pointer
+  attach_function :hwloc_alloc_membind, [:topology, :size_t, :bitmap, :membind_policy, :int], :pointer
+  attach_function :hwloc_free, [:topology, :pointer, :size_t], :int
+
+  class Topology
+
+    def set_membind_nodeset(nodeset, policy, flags=0)
+      err = Hwloc.hwloc_set_membind_nodeset(@ptr, nodeset, policy, flags)
+      raise MembindError if err == -1
+      return self
+    end
+
+    def set_membind(set, policy, flags=0)
+      err = Hwloc.hwloc_set_membind(@ptr, set, policy, flags)
+      raise MembindError if err == -1
+      return self
+    end
+
+    def get_membind_nodeset(flags=0)
+      nodeset = Nodeset::new
+      policy_p = FFI::MemoryPointer::new(MembindPolicy.native_type)
+      err = Hwloc.hwloc_get_membind_nodeset(@ptr, nodeset, policy_p, flags)
+      raise MembindError if err == -1
+      policy = policy_p.read_int
+      return [nodeset, MembindPolicy[policy]]
+    end
+
+    def get_membind(flags=0)
+      set = Bitmap::new
+      policy_p = FFI::MemoryPointer::new(MembindPolicy.native_type)
+      err = Hwloc.hwloc_get_membind(@ptr, set, policy_p, flags)
+      raise MembindError if err == -1
+      policy = policy_p.read_int
+      return [set, MembindPolicy[policy]]
+    end
+
+    def set_proc_membind_nodeset(pid, nodeset, policy, flags=0)
+      err = Hwloc.hwloc_set_proc_membind_nodeset(@ptr, pid, nodeset, policy, flags)
+      raise MembindError if err == -1
+      return self
+    end
+
+    def set_proc_membind(pid, set, policy, flags=0)
+      err = Hwloc.hwloc_set_proc_membind(@ptr, pid, set, policy, flags)
+      raise MembindError if err == -1
+      return self
+    end
+
+    def get_proc_membind_nodeset(pid, flags=0)
+      nodeset = Nodeset::new
+      policy_p = FFI::MemoryPointer::new(MembindPolicy.native_type)
+      err = Hwloc.hwloc_get_proc_membind_nodeset(@ptr, pid, nodeset, policy_p, flags)
+      raise MembindError if err == -1
+      policy = MembindPolicy[policy_p.read_int]
+      return [nodeset, policy]
+    end
+
+    def get_proc_membind(pid, flags=0)
+      set = Bitmap::new
+      policy_p = FFI::MemoryPointer::new(MembindPolicy.native_type)
+      err = Hwloc.hwloc_get_proc_membind(@ptr, pid, set, policy_p, flags)
+      raise MembindError if err == -1
+      policy = MembindPolicy[policy_p.read_int]
+      return [set, policy]
+    end
+
+    def set_area_membind_nodeset(pointer, nodeset, policy, flags=0)
+      err = Hwloc.hwloc_set_area_membind_nodeset(@ptr, pointer, pointer.size, nodeset, policy, flags)
+      raise MembindError if err == -1
+      return self
+    end
+
+    def set_area_membind(pointer, set, policy, flags=0)
+      err = Hwloc.hwloc_set_area_membind(@ptr, pointer, pointer.size, set, policy, flags)
+      raise MembindError if err == -1
+      return self
+    end
+
+    def get_area_membind_nodeset(pointer, flags=0)
+      nodeset = Nodeset::new
+      policy_p = FFI::MemoryPointer::new(MembindPolicy.native_type)
+      err = Hwloc.hwloc_get_area_membind_nodeset(@ptr, pointer, pointer.size, nodeset, policy_p, flags)
+      raise MembindError if err == -1
+      policy = MembindPolicy[policy_p.read_int]
+      return [nodeset, policy]
+    end
+
+    def get_area_membind(pointer, flags=0)
+      set = Bitmap::new
+      policy_p = FFI::MemoryPointer::new(MembindPolicy.native_type)
+      err = Hwloc.hwloc_get_area_membind(@ptr, pointer, pointer.size, set, policy_p, flags)
+      raise MembindError if err == -1
+      policy = MembindPolicy[policy_p.read_int]
+      return [set, policy]
+    end
+
+    if Hwloc.respond_to?(:hwloc_get_area_memlocation)
+      def get_area_memlocation(pointer, flags=0)
+        set = Bitmap::new
+        err = Hwloc.hwloc_get_area_memlocation(@ptr, pointer, pointer.size, set, flags)
+        raise MembindError if err == -1
+        return set
+      end
+    end
+
+    def alloc(size)
+      ptr = Hwloc.hwloc_alloc(@ptr, size)
+      raise MembindError if ptr.null?
+      ptr = ptr.slice(0, size)
+      return FFI::AutoPointer::new(ptr, self.method(:free))
+    end
+
+    def alloc_membind_nodeset(size, nodeset, policy, flags=0)
+      ptr = Hwloc.hwloc_alloc_membind_nodeset(@ptr, size, nodeset, policy, flags)
+      raise MembindError if ptr.null?
+      ptr = ptr.slice(0, size)
+      return FFI::AutoPointer::new(ptr, self.method(:free))
+    end
+
+    def alloc_membind(size, set, policy, flags=0)
+      ptr = Hwloc.hwloc_alloc_membind(@ptr, size, set, policy, flags)
+      raise MembindError if ptr.null?
+      ptr = ptr.slice(0, size)
+      return FFI::AutoPointer::new(ptr, self.method(:free))
+    end
+
+    def alloc_membind_policy_nodeset(size, nodeset, policy, flags=0)
+      begin
+        return alloc_membind_nodeset(size, nodeset, policy, flags)
+      rescue MembindError
+        set_membind_nodeset(nodeset, policy, flags)
+        ptr = alloc(size)
+        ptr.clear if policy != Hwloc::MEMBIND_FIRSTTOUCH
+        return ptr
+      end
+    end
+
+    def alloc_membind_policy(size, set, policy, flags=0)
+      begin
+        return alloc_membind(size, set, policy, flags)
+      rescue MembindError
+        set_membind(set, policy, flags)
+        ptr = alloc(size)
+        ptr.clear if policy != Hwloc::MEMBIND_FIRSTTOUCH
+        return ptr
+      end
+    end
+
+    def free(pointer)
+      Hwloc.hwloc_free(@ptr, pointer, pointer.size)
+    end
+
+    private :free
+
+  end
+
+end

data/lib/hwloc/Bitmap.rb

@@ -0,0 +1,352 @@
+module Hwloc
+
+  typedef :pointer, :bitmap
+  typedef :bitmap, :cpuset
+  typedef :bitmap, :nodeset
+
+  attach_function :hwloc_bitmap_alloc, [], :bitmap
+  attach_function :hwloc_bitmap_free, [:bitmap], :void
+
+  attach_function :hwloc_bitmap_dup, [:bitmap], :bitmap
+
+  attach_function :hwloc_bitmap_snprintf, [:pointer, :size_t, :bitmap], :int
+  attach_function :hwloc_bitmap_sscanf, [:bitmap, :pointer], :int
+  attach_function :hwloc_bitmap_list_snprintf, [:pointer, :size_t, :bitmap], :int
+  attach_function :hwloc_bitmap_list_sscanf, [:bitmap, :pointer], :int
+
+  attach_function :hwloc_bitmap_zero, [:bitmap], :void
+  attach_function :hwloc_bitmap_fill, [:bitmap], :void
+  attach_function :hwloc_bitmap_only, [:bitmap, :uint], :void
+  attach_function :hwloc_bitmap_allbut, [:bitmap, :uint], :void
+
+  attach_function :hwloc_bitmap_set, [:bitmap, :uint], :void
+  attach_function :hwloc_bitmap_clr, [:bitmap, :uint], :void
+
+  attach_function :hwloc_bitmap_set_range, [:bitmap, :uint, :int], :void
+  attach_function :hwloc_bitmap_clr_range, [:bitmap, :uint, :int], :void
+
+  attach_function :hwloc_bitmap_singlify, [:bitmap], :void
+
+  attach_function :hwloc_bitmap_to_ulong, [:bitmap], :ulong
+  attach_function :hwloc_bitmap_to_ith_ulong, [:bitmap, :uint], :ulong
+  attach_function :hwloc_bitmap_isset, [:bitmap, :uint], :int
+  attach_function :hwloc_bitmap_iszero, [:bitmap], :int
+  attach_function :hwloc_bitmap_isfull, [:bitmap], :int
+  attach_function :hwloc_bitmap_first, [:bitmap], :int
+  attach_function :hwloc_bitmap_next, [:bitmap, :int], :int
+  attach_function :hwloc_bitmap_last, [:bitmap], :int
+  attach_function :hwloc_bitmap_weight, [:bitmap], :int
+
+  attach_function :hwloc_bitmap_or, [:bitmap, :bitmap, :bitmap], :void
+  attach_function :hwloc_bitmap_and, [:bitmap, :bitmap, :bitmap], :void
+  attach_function :hwloc_bitmap_andnot, [:bitmap, :bitmap, :bitmap], :void
+  attach_function :hwloc_bitmap_xor, [:bitmap, :bitmap, :bitmap], :void
+  attach_function :hwloc_bitmap_not, [:bitmap, :bitmap], :void
+
+  attach_function :hwloc_bitmap_intersects, [:bitmap, :bitmap], :int
+  attach_function :hwloc_bitmap_isincluded, [:bitmap, :bitmap], :int
+  attach_function :hwloc_bitmap_isequal, [:bitmap, :bitmap], :int
+  attach_function :hwloc_bitmap_compare_first, [:bitmap, :bitmap], :int
+  attach_function :hwloc_bitmap_compare, [:bitmap, :bitmap], :int
+
+  class Bitmap
+    include Enumerable
+    attr_reader :ptr
+
+    alias to_ptr ptr
+
+    def inspect
+      return "#<#{self.class}: {#{to_a.join(",")}}>"
+    end
+
+    def initialize( *args )
+      if args.length == 0 then
+        @ptr = FFI::AutoPointer::new( Hwloc.hwloc_bitmap_alloc, Hwloc.method(:hwloc_bitmap_free) )
+      elsif args.length == 1 then
+        arg = args[0]
+        if arg.kind_of?( Bitmap ) then
+          @ptr = FFI::AutoPointer::new( Hwloc.hwloc_bitmap_dup(arg.ptr), Hwloc.method(:hwloc_bitmap_free) )
+        elsif arg.kind_of?( FFI::Pointer ) then
+          @ptr = FFI::AutoPointer::new( Hwloc.hwloc_bitmap_dup(arg), Hwloc.method(:hwloc_bitmap_free) )
+        elsif arg.kind_of?( String ) then
+          s_ptr = FFI::MemoryPointer::from_string(arg)
+          @ptr = FFI::AutoPointer::new( Hwloc.hwloc_bitmap_alloc, Hwloc.method(:hwloc_bitmap_free) )
+          Hwloc.hwloc_bitmap_sscanf(@ptr,s_ptr)
+        elsif arg.kind_of?( Array ) then
+          list = []
+          arg.each { |e|
+            if e.kind_of?(Range) then
+              if e.last == Float::INFINITY then
+                list << "#{e.first}-"
+              else
+                list << "#{e.first}-#{e.last - (e.exclude_end? ? 1 : 0)}"
+              end
+            else
+              list << e.to_s
+            end
+          }
+          str = list.join(",")
+          s_ptr = FFI::MemoryPointer::from_string(str)
+          @ptr = FFI::AutoPointer::new( Hwloc.hwloc_bitmap_alloc, Hwloc.method(:hwloc_bitmap_free) )
+          Hwloc.hwloc_bitmap_list_sscanf(@ptr,s_ptr)
+        elsif arg.kind_of?( Range ) then
+          if arg.last == Float::INFINITY then
+            str = "#{arg.first}-"
+          else
+            str = "#{arg.first}-#{arg.last - (arg.exclude_end? ? 1 : 0)}"
+          end
+          s_ptr = FFI::MemoryPointer::from_string(str)
+          @ptr = FFI::AutoPointer::new( Hwloc.hwloc_bitmap_alloc, Hwloc.method(:hwloc_bitmap_free) )
+          Hwloc.hwloc_bitmap_list_sscanf(@ptr,s_ptr)
+        end
+      end
+    end
+
+    def dup
+      return Bitmap::new( self )
+    end
+
+    def to_s
+      size = Hwloc.hwloc_bitmap_snprintf(nil, 0, @ptr)
+      s_ptr = FFI::MemoryPointer::new(size+1)
+      Hwloc.hwloc_bitmap_snprintf(s_ptr, size+1, @ptr)
+      s_ptr.read_string
+    end
+
+    def to_a
+      size = Hwloc.hwloc_bitmap_list_snprintf(nil, 0, @ptr)
+      s_ptr = FFI::MemoryPointer::new(size+1)
+      Hwloc.hwloc_bitmap_list_snprintf(s_ptr, size+1, @ptr)
+      str = s_ptr.read_string
+      str.split(",").collect { |e|
+        if e.match("-") then
+          rgs = e.split("-")
+          if rgs.length == 1 then
+            en = Float::INFINITY
+          else
+            en = rgs[1].to_i
+          end
+          Range::new(rgs[0].to_i,en)
+        else
+          e.to_i
+        end
+      }
+    end
+
+    def to_i
+      return to_s.to_i(16)
+    end
+
+    def zero!
+      Hwloc.hwloc_bitmap_zero(@ptr)
+      return self
+    end
+
+    alias clear zero!
+
+    def fill!
+      Hwloc.hwloc_bitmap_fill(@ptr)
+      return self
+    end
+
+    def only!(indx)
+      Hwloc.hwloc_bitmap_only(@ptr, indx)
+      return self
+    end
+
+    def all_but!(indx)
+      Hwloc.hwloc_bitmap_allbut(@ptr, indx)
+      return self
+    end
+
+    def set(indx, val)
+      if val then
+        Hwloc.hwloc_bitmap_set(@ptr, indx)
+      else
+        Hwloc.hwloc_bitmap_clr(@ptr, indx)
+      end
+      return val
+    end
+
+    def set_range(indx, val)
+      b = indx.first
+      if indx.last == Float::INFINITY then
+        e = -1
+      else
+        e = indx.last
+        e = e - 1 if indx.exclude_end?
+      end
+      if val then
+        Hwloc.hwloc_bitmap_set_range(@ptr, b, e)
+      else
+        Hwloc.hwloc_bitmap_clr_range(@ptr, b, e)
+      end
+      return val
+    end
+
+    private :set_range, :set
+
+    def []=(indx, val)
+      if indx.kind_of?(Range) then
+        set_range(indx, val)
+      else
+        set(indx, val)
+      end
+    end
+
+    def [](indx)
+      if Hwloc.hwloc_bitmap_isset(@ptr, indx) != 0 then
+        return true
+      else
+        return false
+      end
+    end
+
+    def singlify!
+      Hwloc.hwloc_bitmap_singlify(@ptr)
+      return self
+    end
+
+    def zero?
+      if Hwloc.hwloc_bitmap_iszero(@ptr) != 0 then
+        return true
+      else
+        return false
+      end
+    end
+
+    alias empty? zero?
+
+    def full?
+      if Hwloc.hwloc_bitmap_isfull(@ptr) != 0 then
+        return true
+      else
+        return false
+      end
+    end
+
+    def first
+      f = Hwloc.hwloc_bitmap_first(@ptr)
+      return nil if f == -1
+      return f
+    end
+
+    def last
+      f = Hwloc.hwloc_bitmap_last(@ptr)
+      if f == -1 then
+        if full? then
+          return Float::INFINITY
+        else
+          return nil
+        end
+      end
+      return f
+    end
+
+    def weight
+      w = Hwloc.hwloc_bitmap_weight(@ptr)
+      return Float::INFINITY if w == -1
+      return w
+    end
+
+    alias size weight
+
+    def each
+      if block_given? then
+        indx = -1
+        while (indx = Hwloc.hwloc_bitmap_next(@ptr, indx) ) != -1 do
+          yield indx
+        end
+        return self
+      else
+        return to_enum(:each)
+      end 
+    end
+
+    def &(other)
+      res = Bitmap::new
+      Hwloc.hwloc_bitmap_and(res.ptr, @ptr, other.ptr)
+      return res
+    end
+
+    alias intersection &
+
+    def |(other)
+      res = Bitmap::new
+      Hwloc.hwloc_bitmap_or(res.ptr, @ptr, other.ptr)
+      return res
+    end
+
+    alias + |
+
+    alias union |
+
+    def ^(other)
+      res = Bitmap::new
+      Hwloc.hwloc_bitmap_xor(res.ptr, @ptr, other.ptr)
+      return res
+    end
+
+    def ~
+      res = Bitmap::new
+      Hwloc.hwloc_bitmap_not(res.ptr, @ptr)
+      return res
+    end
+
+    def -(other)
+      res = Bitmap::new
+      Hwloc.hwloc_bitmap_andnot(res.ptr, @ptr, other.ptr)
+      return res
+    end
+
+    def ==(other)
+      return Hwloc.hwloc_bitmap_isequal(@ptr, other.ptr) != 0
+    end
+
+    def include?(other)
+      return Hwloc.hwloc_bitmap_isincluded(other.ptr, @ptr) != 0
+    end
+
+    alias >= include?
+
+    def >(other)
+      return self >= other && !(self == other)
+    end
+
+    def included?(other)
+      return Hwloc.hwloc_bitmap_isincluded(@ptr, other.ptr) != 0
+    end
+
+    alias <= included?
+
+    def <(other)
+      return self <= other && !(self == other)
+    end
+
+    def intersect?(other)
+      return Hwloc.hwloc_bitmap_intersects(@ptr, other.ptr) != 0
+    end
+
+    def disjoint?(other)
+      return Hwloc.hwloc_bitmap_intersects(@ptr, other.ptr) == 0
+    end
+
+    def compare_first(other)
+      return Hwloc.hwloc_bitmap_compare_first(@ptr, other.ptr)
+    end
+
+    def compare(other)
+      return Hwloc.hwloc_bitmap_compare(@ptr, other.ptr)
+    end
+
+    alias <=> compare
+
+  end
+
+  class Cpuset < Bitmap
+  end
+
+  class Nodeset < Bitmap
+  end
+
+end