hwloc 0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61e8806d799ed1d37e565e888eed0de26488116a
-  data.tar.gz: 541e27b80809c3d14acade623fbcdbaab8b25810
+  metadata.gz: '081b8121d7a652135e9b3737780c298fa7344cb6'
+  data.tar.gz: 17d522c1332cda3854e27599c77427c04f2d84e7
 SHA512:
-  metadata.gz: 0bf475374cc8559d3552ddb2810aee513b1a50aa2d22d23a95e9580f38e4797c171fb123cc32e63b9fc4e41bdfb1bc2c78a4bf18577a8342bd13f1140d2216f8
-  data.tar.gz: 917a4118dd5ea19bb4f95385cda8cf8ffc331534e9e77ed04c54b0c57f870de687db2406167c5bb8e26e79472afa069fc2a859f0611709ffeccc39fb63e6a062
+  metadata.gz: 425b74b3084abe8c680cdcd8b2179e892a87c3c2b27fa8350107be21e489c68664d87c21838399aeef66297d0e2dce1ce491a156893e3258c8ad92c5a6269ee6
+  data.tar.gz: 48d341cb5425bc74dc089183e476d37335e90255e699d5bbf734a18e261e2b78188dcb545756693d34e7fe7a3e67fd18cf4ec5ef57e4284824f578dbb3f0055b

data/README.md

@@ -27,7 +27,11 @@ def print_pointer_location(ptr, t)
 end
 
 t = Hwloc::Topology::new
-t.flags = Hwloc::Topology::FLAG_ICACHES
+if Hwloc::API_VERSION < Hwloc::API_VERSION_2_0
+  t.flags = Hwloc::Topology::FLAG_ICACHES
+else
+  t.set_icache_types_filter(:TYPE_FILTER_KEEP_ALL)
+end
 t.load
 
 $page_size = t.machines.first.memory.page_types.first.size
@@ -50,7 +54,7 @@ t.depth.times { |d|
 
 # 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 = first_core.ancestors.take_while{ |o| o.is_a_cache? }
 caches.each_with_index { |c,i|
   puts "#{c.type_name}: #{c.attr.size/1024}KiB"
 }

data/hwloc.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'hwloc'
-  s.version = "0.1"
+  s.version = "0.2.0"
   s.author = "Brice Videau"
   s.email = "brice.videau@imag.fr"
   s.homepage = "https://github.com/Nanosim-LIG/hwloc-ruby"

data/lib/hwloc/Bind.rb

@@ -6,15 +6,26 @@ module Hwloc
     :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
-  ] )
+  if API_VERSION < API_VERSION_2_0 then
+    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
+    ] )
+  else
+    MembindPolicy = enum( :membind_policy, [
+      :MEMBIND_DEFAULT,    0,
+      :MEMBIND_FIRSTTOUCH, 1,
+      :MEMBIND_BIND,       2,
+      :MEMBIND_INTERLEAVE, 3,
+      :MEMBIND_NEXTTOUCH,  4,
+      :MEMBIND_MIXED,      -1
+    ] )
+  end
 
   MembindFlags = enum( :membind_flags, [
     :MEMBIND_PROCESS,   1<<0,
@@ -43,9 +54,16 @@ module Hwloc
   class Topology
 
     def set_cpubind(cpuset, flags = 0)
-      err = Hwloc.hwloc_set_cpubind(@ptr, cpuset, flags)
-      raise CpubindError if err == -1
-      return self
+      if block_given? then
+        oldcpuset = get_cpubind(flags)
+        set_cpubind(cpuset, flags)
+        yield
+        set_cpubind(oldcpuset, flags)
+      else
+        err = Hwloc.hwloc_set_cpubind(@ptr, cpuset, flags)
+        raise CpubindError if err == -1
+        return self
+      end
     end
 
     def get_cpubind(flags = 0)
@@ -100,18 +118,21 @@ module Hwloc
   class MembindError < BindError
   end
 
-  attach_function :hwloc_set_membind_nodeset, [:topology, :nodeset, :membind_policy, :int], :int
+  if API_VERSION < API_VERSION_2_0 then
+    attach_function :hwloc_set_membind_nodeset, [:topology, :nodeset, :membind_policy, :int], :int
+    attach_function :hwloc_get_membind_nodeset, [:topology, :nodeset, :pointer, :int], :int
+    attach_function :hwloc_set_proc_membind_nodeset, [:topology, :hwloc_pid_t, :nodeset, :membind_policy, :int], :int
+    attach_function :hwloc_get_proc_membind_nodeset, [:topology, :hwloc_pid_t, :nodeset, :pointer, :int], :int
+    attach_function :hwloc_set_area_membind_nodeset, [:topology, :pointer, :size_t, :nodeset, :membind_policy, :int], :int
+    attach_function :hwloc_get_area_membind_nodeset, [:topology, :pointer, :size_t, :nodeset, :pointer, :int], :int
+    attach_function :hwloc_alloc_membind_nodeset, [:topology, :size_t, :nodeset, :membind_policy, :int], :pointer
+  end
   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
@@ -121,31 +142,88 @@ module Hwloc
   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
+    if API_VERSION < API_VERSION_2_0 then
+      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 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 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 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 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 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 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_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 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]]
+    def set_membind(set, policy, flags=0)
+      if block_given? then
+        oldset, oldpolicy = get_membind(flags)
+        set_membind(set, policy, flags)
+        yield
+        set_membind(oldset, oldpolicy, flags)
+      else
+        err = Hwloc.hwloc_set_membind(@ptr, set, policy, flags)
+        raise MembindError if err == -1
+        return self
+      end
     end
 
     def get_membind(flags=0)
@@ -157,27 +235,12 @@ module Hwloc
       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)
@@ -187,27 +250,12 @@ module Hwloc
       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)
@@ -233,13 +281,6 @@ module Hwloc
       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?
@@ -247,17 +288,6 @@ module Hwloc
       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)

data/lib/hwloc/Edition.rb

@@ -1,35 +1,75 @@
 module Hwloc
 
-  attach_function :hwloc_topology_insert_misc_object_by_cpuset, [:topology, :cpuset, :string], Obj.ptr
-  attach_function :hwloc_topology_insert_misc_object_by_parent, [:topology, Obj.ptr, :string], Obj.ptr
+  if API_VERSION < API_VERSION_2_0 then
+    attach_function :hwloc_topology_insert_misc_object_by_cpuset, [:topology, :cpuset, :string], Obj.ptr
+    attach_function :hwloc_topology_insert_misc_object_by_parent, [:topology, Obj.ptr, :string], Obj.ptr
+    attach_function :hwloc_custom_insert_topology, [:topology, Obj.ptr, :topology, Obj.ptr,], :int
+    attach_function :hwloc_custom_insert_group_object_by_parent, [:topology, Obj.ptr, :int], Obj.ptr
+  else
+    attach_function :hwloc_topology_insert_misc_object, [:topology, Obj.ptr, :string], Obj.ptr
+    attach_function :hwloc_topology_alloc_group_object, [:topology], Obj.ptr
+    attach_function :hwloc_topology_insert_group_object, [:topology, Obj.ptr], Obj.ptr
+    attach_function :hwloc_obj_add_other_obj_sets, [Obj.ptr, Obj.ptr], :int
+  end
 
-  RestrictFlags = enum( FFI::find_type(:ulong), :restrict_flags, [
-    :RESTRICT_FLAG_ADAPT_DISTANCES, 1<<0,
-    :RESTRICT_FLAG_ADAPT_MISC, 1<<1,
-    :RESTRICT_FLAG_ADAPT_IO, 1<<2
-  ] )
+  if API_VERSION < API_VERSION_2_0 then
+    RestrictFlags = enum( FFI::find_type(:ulong), :restrict_flags, [
+      :RESTRICT_FLAG_ADAPT_DISTANCES, 1<<0,
+      :RESTRICT_FLAG_ADAPT_MISC, 1<<1,
+      :RESTRICT_FLAG_ADAPT_IO, 1<<2
+    ] )
+  else
+    RestrictFlags = enum( FFI::find_type(:ulong), :restrict_flags, [
+      :RESTRICT_FLAG_REMOVE_CPULESS, 1<<0,
+      :RESTRICT_FLAG_ADAPT_MISC, 1<<1,
+      :RESTRICT_FLAG_ADAPT_IO, 1<<2
+    ] )
+  end
 
   attach_function :hwloc_topology_restrict, [:topology, :cpuset, :ulong], :int
-  attach_function :hwloc_custom_insert_topology, [:topology, Obj.ptr, :topology, Obj.ptr,], :int
-  attach_function :hwloc_custom_insert_group_object_by_parent, [:topology, Obj.ptr, :int], Obj.ptr
 
   class EditionError < TopologyError
   end
 
   class Topology
 
-    def insert_misc_object_by_cpuset(cpuset, name)
-      obj = Hwloc.hwloc_topology_insert_misc_object_by_cpuset(@ptr, cpuset, name)
-      raise EditionError if obj.to_ptr.null?
-      obj.instance_variable_set(:@topology, self)
-      return obj
-    end
+    if API_VERSION < API_VERSION_2_0 then
+      def insert_misc_object_by_cpuset(cpuset, name)
+        obj = Hwloc.hwloc_topology_insert_misc_object_by_cpuset(@ptr, cpuset, name)
+        raise EditionError if obj.to_ptr.null?
+        obj.instance_variable_set(:@topology, self)
+        return obj
+      end
+
+      def insert_misc_object_by_parent(parent, name)
+        obj = Hwloc.hwloc_topology_insert_misc_object_by_parent(@ptr, parent, name)
+        raise EditionError if obj.to_ptr.null?
+        obj.instance_variable_set(:@topology, self)
+        return obj
+      end
+
+      alias insert_misc_object insert_misc_object_by_parent
+
+      def custom_insert_topology(newparent, oldtopology, oldroot = nil)
+        err = Hwloc.hwloc_custom_insert_topology(@ptr, newparent, oldtopology.ptr, oldroot)
+        raise EditionError if err == -1
+        return self
+      end
+
+      def custom_insert_group_object_by_parent(parent, groupdepth)
+        obj = Hwloc.hwloc_custom_insert_group_object_by_parent(@ptr, parent, groupdepth)
+        raise EditionError if obj.to_ptr.null?
+        obj.instance_variable_set(:@topology, self)
+        return obj
+      end
 
-    def insert_misc_object_by_parent(parent, name)
-      obj = Hwloc.hwloc_topology_insert_misc_object_by_parent(@ptr, parent, name)
-      raise EditionError if obj.to_ptr.null?
-      obj.instance_variable_set(:@topology, self)
-      return obj
+    else
+      def insert_misc_object(parent, name)
+        obj = Hwloc.hwloc_topology_insert_misc_object(@ptr, parent, name)
+        raise EditionError if obj.to_ptr.null?
+        obj.instance_variable_set(:@topology, self)
+        return obj
+      end
     end
 
     def restrict(cpuset, flags)
@@ -38,19 +78,6 @@ module Hwloc
       return self
     end
 
-    def custom_insert_topology(newparent, oldtopology, oldroot = nil)
-      err = Hwloc.hwloc_custom_insert_topology(@ptr, newparent, oldtopology.ptr, oldroot)
-      raise EditionError if err == -1
-      return self
-    end
-
-    def custom_insert_group_object_by_parent(parent, groupdepth)
-      obj = Hwloc.hwloc_custom_insert_group_object_by_parent(@ptr, parent, groupdepth)
-      raise EditionError if obj.to_ptr.null?
-      obj.instance_variable_set(:@topology, self)
-      return obj
-    end
-
   end
 
   class Obj

data/lib/hwloc/Export.rb

@@ -1,7 +1,16 @@
 module Hwloc
 
-  attach_function :hwloc_topology_export_xml, [:topology, :string], :int
-  attach_function :hwloc_topology_export_xmlbuffer, [:topology, :pointer, :pointer], :int
+  if API_VERSION < API_VERSION_2_0 then
+    attach_function :hwloc_topology_export_xml, [:topology, :string], :int
+    attach_function :hwloc_topology_export_xmlbuffer, [:topology, :pointer, :pointer], :int
+  else
+    TopologyExportXmlFlags = enum( FFI::find_type(:ulong), :topology_export_xml_flags, [
+      :TOPOLOGY_EXPORT_XML_FLAG_V1, 1<<0
+    ] )
+    attach_function :hwloc_topology_export_xml, [:topology, :string, :ulong], :int
+    attach_function :hwloc_topology_export_xmlbuffer, [:topology, :pointer, :pointer, :ulong], :int
+  end
+
   attach_function :hwloc_free_xmlbuffer, [:topology, :pointer], :void
 
   callback :hwloc_topology_set_userdata_export_callback_callback, [:pointer, :topology, Obj.ptr], :void
@@ -25,19 +34,36 @@ module Hwloc
 
   class Topology
 
-    def export_xml(xmlpath)
-      err = Hwloc.hwloc_topology_export_xml(@ptr, xmlpath)
-      raise ExportError if err == -1
-      return self
-    end
+    if API_VERSION < API_VERSION_2_0 then
+      def export_xml(xmlpath)
+        err = Hwloc.hwloc_topology_export_xml(@ptr, xmlpath)
+        raise ExportError if err == -1
+        return self
+      end
 
-    def export_xmlbuffer
-      data_p = FFI::MemoryPointer::new(:pointer)
-      count_p = FFI::MemoryPointer::new(:int)
-      err = Hwloc.hwloc_topology_export_xmlbuffer(@ptr, data_p, count_p)
-      raise ExportError if err == -1
-      xmlbuffer_p = data_p.read_pointer.slice(0, count_p.read_int)
-      return FFI::AutoPointer::new(xmlbuffer_p, self.method(:free_xmlbuffer))
+      def export_xmlbuffer
+        data_p = FFI::MemoryPointer::new(:pointer)
+        count_p = FFI::MemoryPointer::new(:int)
+        err = Hwloc.hwloc_topology_export_xmlbuffer(@ptr, data_p, count_p)
+        raise ExportError if err == -1
+        xmlbuffer_p = data_p.read_pointer.slice(0, count_p.read_int)
+        return FFI::AutoPointer::new(xmlbuffer_p, self.method(:free_xmlbuffer))
+      end
+    else
+      def export_xml(xmlpath, flags=0)
+        err = Hwloc.hwloc_topology_export_xml(@ptr, xmlpath, flags)
+        raise ExportError if err == -1
+        return self
+      end
+
+      def export_xmlbuffer(flags = 0)
+        data_p = FFI::MemoryPointer::new(:pointer)
+        count_p = FFI::MemoryPointer::new(:int)
+        err = Hwloc.hwloc_topology_export_xmlbuffer(@ptr, data_p, count_p, flags)
+        raise ExportError if err == -1
+        xmlbuffer_p = data_p.read_pointer.slice(0, count_p.read_int)
+        return FFI::AutoPointer::new(xmlbuffer_p, self.method(:free_xmlbuffer))
+      end
     end
 
     def free_xmlbuffer(pointer)

data/lib/hwloc/Hwloc.rb

@@ -6,7 +6,11 @@ module Hwloc
 
   attach_function :hwloc_get_api_version, [], :uint
 
-  raise RuntimeError, "Wrong hwloc api version (#{Hwloc.hwloc_get_api_version.to_a(16)})!" if Hwloc.hwloc_get_api_version < 0x00010a00
+  API_VERSION = Hwloc.hwloc_get_api_version
+  API_VERSION_1_10 = 0x00010a00
+  API_VERSION_2_0 = 0x00020000
+
+  raise RuntimeError, "Wrong hwloc api version (#{API_VERSION.to_s(16)})!" if API_VERSION < 0x00010a00
 
   attach_function :strerror, [:int], :string
 

data/lib/hwloc/Obj.rb

@@ -3,21 +3,39 @@ module Hwloc
   class ObjError < Error
   end
 
-  ObjType = enum( :obj_type, [
+  obj_types = [
     :OBJ_SYSTEM,
     :OBJ_MACHINE,
     :OBJ_NUMANODE,
-    :OBJ_PACKAGE,
-    :OBJ_CACHE,
+    :OBJ_PACKAGE
+  ]
+  obj_types.push :OBJ_CACHE if API_VERSION < API_VERSION_2_0
+  obj_types += [
     :OBJ_CORE,
-    :OBJ_PU,
+    :OBJ_PU
+  ]
+  if API_VERSION >= API_VERSION_2_0 then
+    obj_types += [
+      :OBJ_L1CACHE,
+      :OBJ_L2CACHE,
+      :OBJ_L3CACHE,
+      :OBJ_L4CACHE,
+      :OBJ_L5CACHE,
+      :OBJ_L1ICACHE,
+      :OBJ_L2ICACHE,
+      :OBJ_L3ICACHE
+    ]
+  end
+  obj_types += [
     :OBJ_GROUP,
     :OBJ_MISC,
     :OBJ_BRIDGE,
     :OBJ_PCI_DEVICE,
     :OBJ_OS_DEVICE,
     :OBJ_TYPE_MAX
-  ] )
+  ]
+
+  ObjType = enum( :obj_type, obj_types )
 
   attach_function :hwloc_compare_types, [:obj_type, :obj_type], :int
 
@@ -109,12 +127,57 @@ module Hwloc
 
   end
 
-  class Distances < Struct
-    layout :relative_depth, :uint,
-           :nbobjs,         :uint,
-           :latency,        :pointer,
-           :latency_max,    :float,
-           :latency_base,   :float
+  if API_VERSION < API_VERSION_2_0 then
+    class Distances < Struct
+      layout :relative_depth, :uint,
+             :nbobjs,         :uint,
+             :latency,        :pointer,
+             :latency_max,    :float,
+             :latency_base,   :float
+    end
+  else
+
+    DistancesKind = enum(FFI::find_type(:ulong), :distances_kind, [
+      :DISTANCES_KIND_FROM_OS,         1<<0,
+      :DISTANCES_KIND_FROM_USER,       1<<1,
+      :DISTANCES_KIND_MEANS_LATENCY,   1<<2,
+      :DISTANCES_KIND_MEANS_BANDWIDTH, 1<<3
+    ])
+
+    DistancesFlag = enum(FFI::find_type(:ulong), :distances_flag, [
+      :DISTANCES_FLAG_GROUP,            1<<0,
+      :DISTANCES_FLAG_GROUP_INACCURATE, 1<<1
+    ])
+
+    class Distances < Struct
+      layout :nbobjs, :uint,
+             :objs,   :pointer,
+             :kind,   :ulong,
+             :values, :pointer
+
+      def objs
+        arity = self[:nbobjs]
+        if arity == 0 then
+          return []
+        else
+          return self[:objs].read_array_of_pointer(arity).collect { |p|
+            c = Obj::new(p)
+            c.instance_variable_set(:@topology, @topology)
+            c
+          }
+        end
+      end
+
+      def values
+        arity = self[:nbobjs]
+        arity *= arity
+        if arity == 0 then
+          return []
+        else
+          return self[:values].read_array_of_uint64(arity)
+        end
+      end
+    end
   end
 
   class ObjInfo < Struct
@@ -162,7 +225,14 @@ module Hwloc
   end
 
   class GroupAttr < Struct
-    layout :depth, :uint
+    group_layout = [ :depth, :uint ]
+    if API_VERSION >= API_VERSION_2_0 then
+      group_layout += [
+        :kind, :uint,
+        :subkind, :uint
+      ]
+    end
+    layout( *group_layout )
   end
 
   class PcidevAttr < Struct
@@ -216,43 +286,86 @@ module Hwloc
   class Obj < Struct
   end
 
+  if API_VERSION < API_VERSION_2_0 then
+    attach_function :hwloc_obj_type_string, [:obj_type], :string
+  else
+    attach_function :hwloc_type_name, [:obj_type], :string
+  end
   attach_function :hwloc_obj_type_snprintf, [:pointer, :size_t, Obj.ptr, :int], :int
   attach_function :hwloc_obj_attr_snprintf, [:pointer, :size_t, Obj.ptr, :string, :int], :int
 
   class Obj
-    layout_array = [
-      :type,             :obj_type,
-      :os_index,         :uint,
-      :name,             :string,
-      :memory,           ObjMemory,
-      :attr,             ObjAttr.ptr,
-      :depth,            :uint,
-      :logical_index,    :uint,
-      :os_level,         :int,
-      :next_cousin,      Obj.ptr,
-      :prev_cousin,      Obj.ptr,
-      :parent,           Obj.ptr,
-      :sibling_rank,     :uint,
-      :next_sibling,     Obj.ptr,
-      :prev_sibling,     Obj.ptr,
-      :arity,            :uint,
-      :children,         :pointer,
-      :first_child,      Obj.ptr,
-      :last_child,       Obj.ptr,
-      :user_data,        :pointer,
-      :cpuset,           :cpuset,
-      :complete_cpuset,  :cpuset,
-      :online_cpuset,    :cpuset,
-      :allowed_cpuset,   :cpuset,
-      :nodeset,          :nodeset,
-      :complete_nodeset, :nodeset,
-      :allowed_nodeset,  :nodeset,
-      :distances,        :pointer,
-      :distances_count,  :uint,
-      :infos,            :pointer,
-      :infos_count,      :uint,
-      :symmetric_subtree,:int
-    ]
+    if API_VERSION < API_VERSION_2_0 then
+      layout_array = [
+        :type,             :obj_type,
+        :os_index,         :uint,
+        :name,             :string,
+        :memory,           ObjMemory,
+        :attr,             ObjAttr.ptr,
+        :depth,            :uint,
+        :logical_index,    :uint,
+        :os_level,         :int,
+        :next_cousin,      Obj.ptr,
+        :prev_cousin,      Obj.ptr,
+        :parent,           Obj.ptr,
+        :sibling_rank,     :uint,
+        :next_sibling,     Obj.ptr,
+        :prev_sibling,     Obj.ptr,
+        :arity,            :uint,
+        :children,         :pointer,
+        :first_child,      Obj.ptr,
+        :last_child,       Obj.ptr,
+        :user_data,        :pointer,
+        :cpuset,           :cpuset,
+        :complete_cpuset,  :cpuset,
+        :online_cpuset,    :cpuset,
+        :allowed_cpuset,   :cpuset,
+        :nodeset,          :nodeset,
+        :complete_nodeset, :nodeset,
+        :allowed_nodeset,  :nodeset,
+        :distances,        :pointer,
+        :distances_count,  :uint,
+        :infos,            :pointer,
+        :infos_count,      :uint,
+        :symmetric_subtree,:int
+      ]
+    else
+      layout_array = [
+        :type,             :obj_type,
+        :subtype,          :string,
+        :os_index,         :uint,
+        :name,             :string,
+        :memory,           ObjMemory,
+        :attr,             ObjAttr.ptr,
+        :depth,            :uint,
+        :logical_index,    :uint,
+        :next_cousin,      Obj.ptr,
+        :prev_cousin,      Obj.ptr,
+        :parent,           Obj.ptr,
+        :sibling_rank,     :uint,
+        :next_sibling,     Obj.ptr,
+        :prev_sibling,     Obj.ptr,
+        :arity,            :uint,
+        :children,         :pointer,
+        :first_child,      Obj.ptr,
+        :last_child,       Obj.ptr,
+        :symmetric_subtree,:int,
+        :io_arity,         :uint,
+        :io_first_child,   Obj.ptr,
+        :misc_arity,       :uint,
+        :misc_first_child, Obj.ptr,
+        :cpuset,           :cpuset,
+        :complete_cpuset,  :cpuset,
+        :allowed_cpuset,   :cpuset,
+        :nodeset,          :nodeset,
+        :complete_nodeset, :nodeset,
+        :allowed_nodeset,  :nodeset,
+        :infos,            :pointer,
+        :infos_count,      :uint,
+        :user_data,        :pointer,
+        :gp_index,         :uint64
+      ]
+    end
 
     layout *layout_array
 
@@ -267,7 +380,16 @@ module Hwloc
       return str_ptr.read_string
     end
 
-    alias type_name type_snprintf
+    if API_VERSION < API_VERSION_2_0 then
+      def type_string
+        return Hwloc.hwloc_obj_type_string(type)
+      end
+      alias type_name type_string
+    else
+      def type_name
+        return Hwloc.hwloc_type_name(type)
+      end
+    end
 
     def attr_snprintf(verbose=0, separator=",")
       sz = Hwloc.hwloc_obj_attr_snprintf(nil, 0, self, separator, verbose) + 1
@@ -330,6 +452,83 @@ module Hwloc
       return children.each(*args, &block)
     end
 
+    if API_VERSION < API_VERSION_2_0 then
+      def each_obj(&block)
+        if block then
+          block.call self
+          children.each { |c|
+            c.each_obj(&block)
+          }
+          return self
+        else
+          to_enum(:each_obj)
+        end
+      end
+
+      def each_descendant(&block)
+        if block then
+          children.each { |c|
+            c.each_obj(&block)
+          }
+        else
+          to_enum(:each_descendant)
+        end
+      end
+
+    else
+
+      def io_children
+        return [] if io_arity == 0
+        c = []
+        c.push( io_first_child )
+        (io_arity-1).times {
+          c.push( c[-1].next_sibling )
+        }
+        return c
+      end
+
+      def each_io_child(*args, &block)
+        return io_children.each(*args, &block)
+      end
+
+      def misc_children
+        return [] if misc_arity == 0
+        c = []
+        c.push( misc_first_child )
+        (misc_arity-1).times {
+          c.push( c[-1].next_sibling )
+        }
+        return c
+      end
+
+      def each_misc_child(*args, &block)
+        return misc_children.each(*args, &block)
+      end
+
+      def each_obj(&block)
+        if block then
+          block.call self
+          (children+io_children+misc_children).each { |c|
+            c.each_obj(&block)
+          }
+          return self
+        else
+          to_enum(:each_obj)
+        end
+      end
+
+      def each_descendant(&block)
+        if block then
+          (children+io_children+misc_children).each { |c|
+            c.each_obj(&block)
+          }
+        else
+          to_enum(:each_descendant)
+        end
+      end
+
+    end
+
     def each_parent(&block)
       if block then
         if parent then
@@ -349,44 +548,24 @@ module Hwloc
     alias ancestors parents
     alias each_ancestor each_parent
 
-    def each_obj(&block)
-      if block then
-        block.call self
-        children.each { |c|
-          c.each_obj(&block)
-        }
-        return self
-      else
-        to_enum(:each_obj)
-      end
-    end
-
     alias traverse each_obj
 
-    def each_descendant
-      if block then
-        children.each { |c|
-          c.each_obj(&block)
-        }
-      else
-        to_enum(:each_descendant)
-      end
-    end
-
     def descendants
       return each_descendant.to_a
     end
 
-    def distances
-      distances_count = self[:distances_count]
-      if distances_count == 0 then
-        return []
-      else
-        return self[:distances].read_array_of_pointer(distances_count).collect { |p|
-          d = Distances::new(p)
-          d.instance_variable_set(:@topology, @topology)
-          d
-        }
+    if API_VERSION < API_VERSION_2_0 then
+      def distances
+        distances_count = self[:distances_count]
+        if distances_count == 0 then
+          return []
+        else
+          return self[:distances].read_array_of_pointer(distances_count).collect { |p|
+            d = Distances::new(p)
+            d.instance_variable_set(:@topology, @topology)
+            d
+          }
+        end
       end
     end
 
@@ -413,8 +592,6 @@ module Hwloc
       return nil if at.to_ptr.null?
       t = self[:type]
       case t
-      when :OBJ_CACHE
-        return at[:cache]
       when :OBJ_GROUP
         return at[:group]
       when :OBJ_PCI_DEVICE
@@ -423,10 +600,26 @@ module Hwloc
         return at[:bridge]
       when :OBJ_OS_DEVICE
         return at[:osdev]
+      else
+        return at[:cache] if self.is_a_cache?
       end
       return nil
     end
 
+    ObjType.symbols[0..-1].each { |sym|
+      suffix = sym.to_s[4..-1].downcase
+      methname = "is_a_#{suffix}?"
+      define_method(methname) {
+        return type == sym
+      }
+    }
+
+    if API_VERSION >= API_VERSION_2_0 then
+      def is_a_cache?
+        (Hwloc::OBJ_L1CACHE..Hwloc::OBJ_L3ICACHE).include?(ObjType[type])
+      end
+    end
+
   end
 
 end

data/lib/hwloc/Topology.rb

@@ -27,22 +27,27 @@ module Hwloc
   end
 
   class TopologyMemSupport < BoolStruct
-    layout :set_thisproc_membind,   :uchar,
-           :get_thisproc_membind,   :uchar,
-           :set_proc_membind,       :uchar,
-           :get_proc_membind,       :uchar,
-           :set_thisthread_membind, :uchar,
-           :get_thisthread_membind, :uchar,
-           :set_area_membind,       :uchar,
-           :get_area_membind,       :uchar,
-           :alloc_membind,          :uchar,
-           :firsttouch_membind,     :uchar,
-           :bind_membind,           :uchar,
-           :interleave_membind,     :uchar,
-           :replicate_membind,      :uchar,
-           :nexttouch_membind,      :uchar,
-           :migrate_membind,        :uchar,
-           :get_area_memlocation,   :uchar
+    topology_mem_support_layout = [
+      :set_thisproc_membind,   :uchar,
+      :get_thisproc_membind,   :uchar,
+      :set_proc_membind,       :uchar,
+      :get_proc_membind,       :uchar,
+      :set_thisthread_membind, :uchar,
+      :get_thisthread_membind, :uchar,
+      :set_area_membind,       :uchar,
+      :get_area_membind,       :uchar,
+      :alloc_membind,          :uchar,
+      :firsttouch_membind,     :uchar,
+      :bind_membind,           :uchar,
+      :interleave_membind,     :uchar
+    ]
+    topology_mem_support_layout.push(:replicate_membind, :uchar) if API_VERSION < API_VERSION_2_0 
+    topology_mem_support_layout += [
+      :nexttouch_membind,      :uchar,
+      :migrate_membind,        :uchar,
+      :get_area_memlocation,   :uchar
+    ]
+    layout( *topology_mem_support_layout )
   end
 
   class TopologySupport < Struct
@@ -61,33 +66,46 @@ module Hwloc
   attach_function :hwloc_topology_dup, [:pointer, :topology], :int
   attach_function :hwloc_topology_check, [:topology], :void
 
-  attach_function :hwloc_topology_ignore_type, [:topology, :obj_type], :int
-  attach_function :hwloc_topology_ignore_type_keep_structure, [:topology, :obj_type], :int
-  attach_function :hwloc_topology_ignore_all_keep_structure, [:topology], :int
-
-  TopologyFlags = enum( FFI::find_type(:ulong), :topology_flags, [
-    :TOPOLOGY_FLAG_WHOLE_SYSTEM, 1<<0,
-    :TOPOLOGY_FLAG_IS_THISSYSTEM, 1<<1,
-    :TOPOLOGY_FLAG_IO_DEVICES, 1<<2,
-    :TOPOLOGY_FLAG_IO_BRIDGES, 1<<3,
-    :TOPOLOGY_FLAG_WHOLE_IO, 1<<4,
-    :TOPOLOGY_FLAG_ICACHES, 1<<5
-  ] )
+  if API_VERSION < API_VERSION_2_0 then
+    TopologyFlags = enum( FFI::find_type(:ulong), :topology_flags, [
+      :TOPOLOGY_FLAG_WHOLE_SYSTEM, 1<<0,
+      :TOPOLOGY_FLAG_IS_THISSYSTEM, 1<<1,
+      :TOPOLOGY_FLAG_IO_DEVICES, 1<<2,
+      :TOPOLOGY_FLAG_IO_BRIDGES, 1<<3,
+      :TOPOLOGY_FLAG_WHOLE_IO, 1<<4,
+      :TOPOLOGY_FLAG_ICACHES, 1<<5
+    ] )
+  else
+    TopologyFlags = enum( FFI::find_type(:ulong), :topology_flags, [
+      :TOPOLOGY_FLAG_WHOLE_SYSTEM, 1<<0,
+      :TOPOLOGY_FLAG_IS_THISSYSTEM, 1<<1,
+      :TOPOLOGY_FLAG_THISSYSTEM_ALLOWED_RESOURCES, 1<<2
+    ] )
+  end
 
   attach_function :hwloc_topology_set_flags, [:topology, :ulong], :int
   attach_function :hwloc_topology_get_flags, [:topology], :ulong
 
   attach_function :hwloc_topology_set_pid, [:topology, :hwloc_pid_t], :int
-  attach_function :hwloc_topology_set_fsroot, [:topology, :string], :int
+  if API_VERSION < API_VERSION_2_0 then
+    attach_function :hwloc_topology_set_fsroot, [:topology, :string], :int
+  end
   attach_function :hwloc_topology_set_synthetic, [:topology, :string], :int
   attach_function :hwloc_topology_set_xml, [:topology, :string], :int
   attach_function :hwloc_topology_set_xmlbuffer, [:topology, :pointer, :size_t], :int
-  attach_function :hwloc_topology_set_custom, [:topology], :int
-  attach_function :hwloc_topology_set_distance_matrix, [:topology, :obj_type, :uint, :pointer, :pointer], :int
+  if API_VERSION < API_VERSION_2_0 then
+    attach_function :hwloc_topology_set_custom, [:topology], :int
+    attach_function :hwloc_topology_set_distance_matrix, [:topology, :obj_type, :uint, :pointer, :pointer], :int
+  else
+    attach_function :hwloc_distances_get, [:topology, :pointer, :pointer, :ulong, :ulong], :int
+    attach_function :hwloc_distances_get_by_depth, [:topology, :uint, :pointer, :pointer, :ulong, :ulong], :int
+    attach_function :hwloc_distances_release, [:topology, Distances.ptr], :void
+    attach_function :hwloc_distances_add, [:topology, :uint, :pointer, :pointer, :ulong, :ulong], :int
+    attach_function :hwloc_distances_remove, [:topology], :int
+    attach_function :hwloc_distances_remove_by_depth, [:topology, :uint], :int
+  end
   attach_function :hwloc_topology_is_thissystem, [:topology], :int
-
   attach_function :hwloc_topology_get_support, [:topology], TopologySupport.ptr
-
   attach_function :hwloc_topology_get_depth, [:topology], :uint
 
   GetTypeDepth = enum(:get_type_depth, [
@@ -96,7 +114,7 @@ module Hwloc
     :TYPE_DEPTH_BRIDGE, -3,
     :TYPE_DEPTH_PCI_DEVICE, -4,
     :TYPE_DEPTH_OS_DEVICE, -5
-  ] )
+  ] + ( API_VERSION >= API_VERSION_2_0 ? [ :TYPE_DEPTH_MISC, -6 ] : [] ) )
 
   attach_function :hwloc_get_type_depth, [:topology, :obj_type], :int
   attach_function :hwloc_get_depth_type, [:topology, :uint], :obj_type
@@ -104,6 +122,22 @@ module Hwloc
 
   attach_function :hwloc_get_obj_by_depth, [:topology, :uint, :uint], Obj.ptr
 
+  if API_VERSION < API_VERSION_2_0 then
+    attach_function :hwloc_topology_ignore_type, [:topology, :obj_type], :int
+    attach_function :hwloc_topology_ignore_type_keep_structure, [:topology, :obj_type], :int
+    attach_function :hwloc_topology_ignore_all_keep_structure, [:topology], :int
+  else
+    TypeFilter = enum(:type_filter, [
+      :TYPE_FILTER_KEEP_ALL, 0,
+      :TYPE_FILTER_KEEP_NONE, 1,
+      :TYPE_FILTER_KEEP_STRUCTURE, 2,
+      :TYPE_FILTER_KEEP_IMPORTANT, 3
+    ] )
+    attach_function :hwloc_topology_set_type_filter, [:topology, :obj_type, :type_filter], :int
+    attach_function :hwloc_topology_get_type_filter, [:topology, :obj_type, :pointer], :int
+    attach_function :hwloc_topology_set_all_types_filter, [:topology, :type_filter], :int
+  end
+
 end
 
 module Hwloc
@@ -167,21 +201,76 @@ module Hwloc
       return self
     end
 
-    def ignore_type(type)
-      err = Hwloc.hwloc_topology_ignore_type(@ptr, type)
-      raise TopologyError if err == -1
-      return self
-    end
-
-    def ignore_type_keep_structure(type)
-      if type == :all then
-        err = Hwloc.hwloc_topology_ignore_all_keep_structure(@ptr)
+    if API_VERSION < API_VERSION_2_0 then
+      def ignore_type(type)
+        err = Hwloc.hwloc_topology_ignore_type(@ptr, type)
         raise TopologyError if err == -1
-      else
-        err = Hwloc.hwloc_topology_ignore_type_keep_structure(@ptr, type)
+        return self
+      end
+
+      def ignore_type_keep_structure(type)
+        if type == :all then
+          err = Hwloc.hwloc_topology_ignore_all_keep_structure(@ptr)
+          raise TopologyError if err == -1
+        else
+          err = Hwloc.hwloc_topology_ignore_type_keep_structure(@ptr, type)
+          raise TopologyError if err == -1
+        end
+        return self
+      end
+    else
+      def set_type_filter(type, filter)
+        if type == :all then
+          err = Hwloc.hwloc_topology_set_all_types_filter(@ptr, filter)
+          raise TopologyError if err == -1
+        else
+          err = Hwloc.hwloc_topology_set_type_filter(@ptr, type, filter)
+          raise TopologyError if err == -1
+        end
+        return self
+      end
+
+      def set_all_types_filter(filter)
+        return set_type_filter(:all, filter)
+      end
+
+      def get_type_filter(type)
+        filter_p = FFI::MemoryPointer::new(TypeFilter.native_type)
+        err = Hwloc.hwloc_topology_get_type_filter(@ptr, type, filter_p)
         raise TopologyError if err == -1
+        filter = filter_p.read_int
+        return TypeFilter[filter]
+      end
+
+      def set_cache_types_filter(filter)
+        (Hwloc::OBJ_L1CACHE..Hwloc::OBJ_L3ICACHE).each { |cl|
+          set_type_filter(cl, filter)
+        }
+        return self
+      end
+
+      def set_icache_types_filter(filter)
+        (Hwloc::OBJ_L1ICACHE..Hwloc::OBJ_L3ICACHE).each { |cl|
+          set_type_filter(cl, filter)
+        }
+        return self
+      end
+
+      def set_io_types_filter(filter)
+        set_type_filter(Hwloc::OBJ_MISC, filter)
+        set_type_filter(Hwloc::OBJ_BRIDGE, filter)
+        set_type_filter(Hwloc::OBJ_PCI_DEVICE, filter)
+        set_type_filter(Hwloc::OBJ_OS_DEVICE, filter)
+        return self
+      end
+
+      def ignore_type(type)
+        return set_type_filter(type, Hwloc::TYPE_FILTER_KEEP_NONE)
+      end
+
+      def ignore_type_keep_structure(type)
+        set_type_filter(type, Hwloc::TYPE_FILTER_KEEP_STRUCTURE)
       end
-      return self
     end
 
     def set_flags(flags)
@@ -204,10 +293,12 @@ module Hwloc
       return self
     end
 
-    def set_fsroot(fsroot_path)
-      err = Hwloc.hwloc_topology_set_fsroot(@ptr, fsroot_path)
-      raise TopologyError if err == -1
-      return self
+    if API_VERSION < API_VERSION_2_0 then
+      def set_fsroot(fsroot_path)
+        err = Hwloc.hwloc_topology_set_fsroot(@ptr, fsroot_path)
+        raise TopologyError if err == -1
+        return self
+      end
     end
 
     def set_synthetic(description)
@@ -228,10 +319,12 @@ module Hwloc
       return self
     end
 
-    def set_custom
-      err = Hwloc.hwloc_topology_set_custom(@ptr)
-      raise TopologyError if err == -1
-      return self
+    if API_VERSION < API_VERSION_2_0 then
+      def set_custom
+        err = Hwloc.hwloc_topology_set_custom(@ptr)
+        raise TopologyError if err == -1
+        return self
+      end
     end
 
 ## Will need some work to define properly...

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hwloc
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: 0.2.0
 platform: ruby
 authors:
 - Brice Videau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-06 00:00:00.000000000 Z
+date: 2017-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi