hwloc 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f89b0959a676f9e73b6106c10b5e01e3d8aaf481
-  data.tar.gz: 2c62e5c5a50b74ca18606641080c7f5b6ddd19c8
+SHA256:
+  metadata.gz: da58c0475ef675dc9333d71319fa2224a40f60faef278163bbfa63b85827ab46
+  data.tar.gz: 1ab3eb8ec7c39586d3a60198995cce73027c056d1199db8e4175180362b85a9d
 SHA512:
-  metadata.gz: 7a3701dac946fe6d69f99c1ea953879adfa189641f2ddd9c19496e06d7256dd9f8e63a89217bbdc0eda07cc377c4d03a6a741c5ebcbf4e49e49c7558671c4172
-  data.tar.gz: 90d9f7f805ed738b199ee2e82662303f7ef5633f077d38b388fa98d8f5d98f3f3366a32905de92841b3422c731da215aba6f132e39c84dfe1c6cc7e203bda48e
+  metadata.gz: ef53f35ef86622c63c20ff1f787d8f0dc71ca395009c226886185683afec6c616887ee2f5a4532cc90ea31fa26ae8be20085040f03d63c3d73934ca25efd7e5c
+  data.tar.gz: 3a91c268149748eeac76b9ff40787cb685e28e60dae668e61d3cd3d1f81b2a12cd4e82fe05efcf182dc10e15e64fc155193a67318176288f1e31c215c14a5974

data/hwloc.gemspec

@@ -1,13 +1,12 @@
 Gem::Specification.new do |s|
   s.name = 'hwloc'
-  s.version = "0.3.1"
+  s.version = "0.3.2"
   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'

data/lib/hwloc/Bind.rb

@@ -147,6 +147,7 @@ module Hwloc
   class Topology
 
     if API_VERSION < API_VERSION_2_0 then
+
       def set_membind_nodeset(nodeset, policy, *flags)
         err = Hwloc.hwloc_set_membind_nodeset(@ptr, nodeset, policy, flags)
         raise MembindError if err == -1
@@ -210,6 +211,51 @@ module Hwloc
         end
       end
 
+    else
+
+      def set_membind_nodeset(nodeset, policy, *flags)
+        flags.push :MEMBIND_BYNODESET
+        set_membind(nodeset, policy, *flags)
+        return self
+      end
+
+      def get_membind_nodeset(*flags)
+        flags.push :MEMBIND_BYNODESET
+        get_membind(*flags)
+      end
+
+      def set_proc_membind_nodeset(pid, nodeset, policy, *flags)
+        flags.push :MEMBIND_BYNODESET
+        set_proc_membind(pid, nodeset, policy, flags)
+        return self
+      end
+
+      def get_proc_membind_nodeset(pid, *flags)
+        flags.push :MEMBIND_BYNODESET
+        get_proc_membind(pid, *flags)
+      end
+
+      def set_area_membind_nodeset(pointer, nodeset, policy, *flags)
+        flags.push :MEMBIND_BYNODESET
+        set_area_membind(pointer, nodeset, policy, *flags)
+        return self
+      end
+
+      def get_area_membind_nodeset(pointer, *flags)
+        flags.push :MEMBIND_BYNODESET
+        get_area_membind(pointer, *flags)
+      end
+
+      def alloc_membind_nodeset(size, nodeset, policy, *flags)
+        flags.push :MEMBIND_BYNODESET
+        alloc_membind(size, nodeset, policy, *flags)
+      end
+
+      def alloc_membind_policy_nodeset(size, nodeset, policy, *flags)
+        flags.push :MEMBIND_BYNODESET
+        alloc_membind_policy_nodeset(size, nodeset, policy, *flags)
+      end
+
     end
 
     def set_membind(set, policy, *flags)

data/lib/hwloc/Bitmap.rb

@@ -113,11 +113,15 @@ module Hwloc
       s_ptr.read_string
     end
 
-    def to_a
+    def list_to_s
       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
+      s_ptr.read_string
+    end
+
+    def to_a
+      str = list_to_s
       str.split(",").collect { |e|
         if e.match("-") then
           rgs = e.split("-")

data/lib/hwloc/Export.rb

@@ -1,3 +1,5 @@
+require 'stringio'
+
 module Hwloc
 
   if API_VERSION < API_VERSION_2_0 then
@@ -66,6 +68,15 @@ module Hwloc
       end
     end
 
+    def to_xml(flags = 0)
+      a = if API_VERSION >= API_VERSION_2_0
+        export_xmlbuffer(flags)
+      else
+        export_xmlbuffer
+      end
+      a.read_string
+    end
+
     def free_xmlbuffer(pointer)
       Hwloc.hwloc_free_xmlbuffer(@self, pointer)
     end

data/lib/hwloc/Hwloc.rb

@@ -3,8 +3,12 @@ require 'ffi/bitmask'
 
 module Hwloc
   extend FFI::Library
-  ffi_lib 'hwloc'
 
+  if ENV['HWLOC_LIBRARY_PATH']
+    ffi_lib ENV['HWLOC_LIBRARY_PATH']
+  else
+    ffi_lib 'hwloc'
+  end
   attach_function :hwloc_get_api_version, [], :uint
 
   API_VERSION = Hwloc.hwloc_get_api_version

data/lib/hwloc/Obj.rb

@@ -3,42 +3,32 @@ module Hwloc
   class ObjError < Error
   end
 
-  obj_types = [
-    :OBJ_SYSTEM,
-    :OBJ_MACHINE,
-    :OBJ_NUMANODE,
-    :OBJ_PACKAGE
-  ]
-  obj_types.push :OBJ_CACHE if API_VERSION < API_VERSION_2_0
-  obj_types += [
-    :OBJ_CORE,
-    :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
-    ]
+  attach_function :hwloc_obj_type_string, [:int], :string
+
+  obj_types = []
+
+  i = 0
+  loop do
+    str = Hwloc.hwloc_obj_type_string(i)
+    break if str == "Unknown"
+    obj_types.push :"OBJ_#{str.upcase.gsub("PCIDEV", "PCI_DEVICE").gsub("OSDEV", "OS_DEVICE")}"
+    i += 1
   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_obj_type_string, [:obj_type], :string
   attach_function :hwloc_compare_types, [:obj_type, :obj_type], :int
 
+  if API_VERSION >= API_VERSION_2_0 then
+    attach_function :hwloc_obj_type_is_normal, [:obj_type], :int
+    attach_function :hwloc_obj_type_is_io, [:obj_type], :int
+    attach_function :hwloc_obj_type_is_memory, [:obj_type], :int
+    attach_function :hwloc_obj_type_is_cache, [:obj_type], :int
+    attach_function :hwloc_obj_type_is_dcache, [:obj_type], :int
+    attach_function :hwloc_obj_type_is_icache, [:obj_type], :int
+  end
+
   def self.compare_types(type1, type2)
     return Hwloc.hwloc_compare_types(type1, type2)
   end
@@ -144,9 +134,9 @@ module Hwloc
       :DISTANCES_KIND_MEANS_BANDWIDTH
     ])
 
-    DistancesFlag = bitmask(FFI::find_type(:ulong), :distances_flag, [
-      :DISTANCES_FLAG_GROUP,
-      :DISTANCES_FLAG_GROUP_INACCURATE
+    DistancesAddFlag = bitmask(FFI::find_type(:ulong), :distances_add_flag, [
+      :DISTANCES_ADD_FLAG_GROUP,
+      :DISTANCES_ADD_FLAG_GROUP_INACCURATE
     ])
 
     class Distances < Struct
@@ -157,26 +147,42 @@ module Hwloc
 
       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
+        return [] if arity == 0
+        return self[:objs].read_array_of_pointer(arity).collect { |p|
+          c = Obj::new(p)
+          c.instance_variable_set(:@topology, @topology)
+          c
+        }
+      end
+
+      def kind
+        self[:kind]
       end
 
       def values
         arity = self[:nbobjs]
-        arity *= arity
-        if arity == 0 then
-          return []
-        else
-          return self[:values].read_array_of_uint64(arity)
-        end
+        return [] if arity == 0
+        return self[:values].read_array_of_uint64(arity*arity).each_slice(arity).to_a
+      end
+
+      def self.release(ptr)
+        Hwloc.hwloc_distances_release(@topology.ptr, ptr)
       end
+
+      def obj_index(obj)
+        arity = self[:nbobjs]
+        return nil if arity == 0
+        self[:objs].read_array_of_pointer(arity).index(obj.to_ptr)
+      end
+
+      def obj_pair_values(obj1, obj2)
+        i1 = obj_index(obj1)
+        i2 = obj_index(obj2)
+        return nil unless i1 && i2
+        v = values
+        return [v[i1][i2], v[i2][i1]]
+      end
+
     end
   end
 
@@ -213,6 +219,20 @@ module Hwloc
     end
   end
 
+  class NumanodeAttr < Struct
+    layout :local_memory, :uint64,
+           :page_types_len, :uint,
+           :page_types, :pointer
+    def page_types
+      page_types_ptr = self[:page_types]
+      return page_types_len.times.collect { |i|
+        pt = ObjMemoryPageType::new(page_types_ptr+i*ObjMemoryPageType.size)
+        pt.instance_variable_set(:@topology, @topology)
+        pt
+      }
+    end
+  end
+
   class CacheAttr < Struct
     layout :size,          :uint64,
            :depth,         :uint,
@@ -276,23 +296,28 @@ module Hwloc
   end
 
   class ObjAttr < Union
-    layout :cache,  CacheAttr,
-           :group,  GroupAttr,
-           :pcidev, PcidevAttr,
-           :bridge, BridgeAttr,
-           :osdev,  OsdevAttr
+    if API_VERSION < API_VERSION_2_0 then
+      layout :cache,  CacheAttr,
+             :group,  GroupAttr,
+             :pcidev, PcidevAttr,
+             :bridge, BridgeAttr,
+             :osdev,  OsdevAttr
+    else
+      layout :numanode, NumanodeAttr,
+             :cache,  CacheAttr,
+             :group,  GroupAttr,
+             :pcidev, PcidevAttr,
+             :bridge, BridgeAttr,
+             :osdev,  OsdevAttr
+    end
   end
 
   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
+  attach_function :hwloc_obj_add_info, [Obj.ptr, :string, :string], :int
 
   class Obj
     if API_VERSION < API_VERSION_2_0 then
@@ -331,39 +356,39 @@ module Hwloc
       ]
     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
+        :type,              :obj_type,
+        :subtype,           :string,
+        :os_index,          :uint,
+        :name,              :string,
+        :total_memory,      :uint64,
+        :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,
+        :memory_arity,      :uint,
+        :memory_first_child,Obj.ptr,
+        :io_arity,          :uint,
+        :io_first_child,    Obj.ptr,
+        :misc_arity,        :uint,
+        :misc_first_child,  Obj.ptr,
+        :cpuset,            :cpuset,
+        :complete_cpuset,   :cpuset,
+        :nodeset,           :nodeset,
+        :complete_nodeset,  :nodeset,
+        :infos,             :pointer,
+        :infos_count,       :uint,
+        :user_data,         :pointer,
+        :gp_index,          :uint64
       ]
     end
 
@@ -380,16 +405,10 @@ module Hwloc
       return str_ptr.read_string
     end
 
-    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
+    def type_string
+      return Hwloc.hwloc_obj_type_string(type)
     end
+    alias type_name type_string
 
     def attr_snprintf(verbose=0, separator=",")
       sz = Hwloc.hwloc_obj_attr_snprintf(nil, 0, self, separator, verbose) + 1
@@ -477,6 +496,20 @@ module Hwloc
 
     else
 
+      def memory_children
+        return [] if memory_arity == 0
+        c = []
+        c.push( memory_first_child )
+        (memory_arity-1).times {
+          c.push( c[-1].next_sibling )
+        }
+        return c
+      end
+
+      def each_memory_child(*args, &block)
+        return memory_children.each(*args, &block)
+      end
+
       def io_children
         return [] if io_arity == 0
         c = []
@@ -571,22 +604,27 @@ module Hwloc
 
     def infos
       infos_count = self[:infos_count]
-      if infos_count == 0 then
-        return []
-      else
-        inf_array = infos_count.times.collect { |i|
-          o = ObjInfo::new(self[:infos] + i*ObjInfo.size)
-        }
-	inf_h = {}
-	inf_array.each { |e| inf_h[e[:name].to_sym] = e[:value] }
-	return inf_h
-      end
+      return {} if infos_count == 0
+      inf_array = infos_count.times.collect { |i|
+        o = ObjInfo::new(self[:infos] + i*ObjInfo.size)
+      }
+      inf_h = {}
+      inf_array.each { |e| inf_h[e[:name].to_sym] = e[:value] if e[:name] }
+      return inf_h
     end
 
     def each_info(*args, &block)
       return infos.each(*args, &block)
     end
 
+    def add_infos(**dict)
+      dict.each { |k, v|
+        err = Hwloc.hwloc_obj_add_info(self, k.to_s, v.to_s)
+        raise EditionError if err == -1
+      }
+      self
+    end
+
     def attr
       at = self[:attr]
       return nil if at.to_ptr.null?
@@ -601,6 +639,9 @@ module Hwloc
       when :OBJ_OS_DEVICE
         return at[:osdev]
       else
+        if API_VERSION >= API_VERSION_2_0 then
+          return at[:numanode] if t == :OBJ_NUMANODE
+        end
         return at[:cache] if self.is_a_cache?
       end
       return nil
@@ -618,6 +659,34 @@ module Hwloc
       def is_a_cache?
         (Hwloc::OBJ_L1CACHE..Hwloc::OBJ_L3ICACHE).include?(ObjType[type])
       end
+
+      def is_normal?
+        Hwloc::hwloc_obj_type_is_normal(ObjType[type]) == 1
+      end
+
+      def is_io?
+        Hwloc::hwloc_obj_type_is_io(ObjType[type]) == 1
+      end
+
+      def is_memory?
+        Hwloc::hwloc_obj_type_is_memory(ObjType[type]) == 1
+      end
+
+      def is_cache?
+        Hwloc::hwloc_obj_type_is_cache(ObjType[type]) == 1
+      end
+
+      def is_icache?
+        Hwloc::hwloc_obj_type_is_icache(ObjType[type]) == 1
+      end
+
+      def is_dcache?
+        Hwloc::hwloc_obj_type_is_dcache(ObjType[type]) == 1
+      end
+
+      def is_misc?
+        ObjType[type] == Hwloc::OBJ_MISC
+      end
     end
 
   end

data/lib/hwloc/Topology.rb

@@ -101,10 +101,10 @@ module Hwloc
     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_get, [:topology, :pointer, :pointer, :distances_kind, :ulong], :int
+    attach_function :hwloc_distances_get_by_depth, [:topology, :uint, :pointer, :pointer, :distances_kind, :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_add, [:topology, :uint, :pointer, :pointer, :distances_kind, :distances_add_flag], :int
     attach_function :hwloc_distances_remove, [:topology], :int
     attach_function :hwloc_distances_remove_by_depth, [:topology, :uint], :int
   end
@@ -182,6 +182,13 @@ module Hwloc
           err = Hwloc.hwloc_topology_dup(ptr, arg.ptr)
           raise TopologyError if err == -1
           @ptr = FFI::AutoPointer::new( ptr.read_pointer, Hwloc.method(:hwloc_topology_destroy) )
+        elsif arg.kind_of?( String ) then
+          ptr = FFI::MemoryPointer::new( :pointer )
+          err = Hwloc.hwloc_topology_init(ptr)
+          raise TopologyError if err == -1
+          @ptr = FFI::AutoPointer::new( ptr.read_pointer, Hwloc.method(:hwloc_topology_destroy) )
+          @xml_buffer = FFI::MemoryPointer::from_string(arg)
+          set_xmlbuffer(@xml_buffer)
         else
           raise TopologyError, "Invalid argument"
         end
@@ -193,6 +200,7 @@ module Hwloc
     def load
       err = Hwloc.hwloc_topology_load(@ptr)
       raise TopologyError if err == -1
+      @xml_buffer = nil if @xml_buffer
       return self
     end
 
@@ -446,20 +454,22 @@ module Hwloc
         end
         return self
       else
-        return Enumerator::new do |yielder|
-          idx = 0
-          while o = get_obj_by_depth(depth, idx) do
-            yielder << o
-            idx += 1
-          end
-        end
+        to_enum(:each_by_depth, depth)
       end
     end
 
     def each_by_type(type, &block)
-      depth = get_type_depth(type)
-      return each_obj.select{ |e| e.type == type }.each(&block) if depth == Hwloc::TYPE_DEPTH_MULTIPLE
-      return each_by_depth(depth, &block)
+      if block_given? then
+        depth = get_type_depth(type)
+        if depth == Hwloc::TYPE_DEPTH_MULTIPLE
+          each_obj.select{ |e| e.type == type }.each(&block)
+          return self
+        else
+          return each_by_depth(depth, &block)
+        end
+      else
+        to_enum(:each_by_type, type)
+      end
     end
 
     ObjType.symbols[0..-1].each { |sym|
@@ -487,6 +497,99 @@ module Hwloc
     alias traverse each_obj
     alias each each_obj
 
+    if API_VERSION >= API_VERSION_2_0 then
+
+      def distances_number(*kind)
+        res = nil
+        nr = FFI::MemoryPointer::new(:uint)
+        nr.write_uint 0
+        err = Hwloc.hwloc_distances_get(@ptr, nr, nil, kind, 0);
+        raise TopologyError if err == -1
+        res = nr.read_uint
+        res
+      end
+
+      def distances(*kind)
+        num_d = distances_number(*kind)
+        return [] if num_d == 0
+        nr = FFI::MemoryPointer::new(:uint)
+        nr.write_uint num_d
+        dis = FFI::MemoryPointer::new(:pointer, num_d)
+        err = Hwloc.hwloc_distances_get(@ptr, nr, dis, kind, 0);
+        raise TopologyError if err == -1
+        return dis.read_array_of_pointer(nr.read_uint).collect { |p|
+          d = Distances::new(p)
+          d.instance_variable_set(:@topology, self)
+          d
+        }
+      end
+
+      def distances_by_depth(depth, *kind)
+        nr = FFI::MemoryPointer::new(:uint)
+        nr.write_uint 0
+        err = Hwloc.hwloc_distances_get_by_depth(@ptr, depth, nr, nil, kind, 0);
+        raise TopologyError if err == -1
+        num_d = nr.read_uint
+        return [] if num_d == 0
+        dis = FFI::MemoryPointer::new(:pointer, num_d)
+        err = Hwloc.hwloc_distances_get_by_depth(@ptr, depth, nr, dis, kind, 0);
+        return dis.read_array_of_pointer(nr.read_uint).collect { |p|
+          d = Distances::new(p)
+          d.instance_variable_set(:@topology, self)
+          d
+        }
+      end
+
+      def distances_by_type(type, *kind)
+        depth = get_type_depth(type)
+        return [] if depth == Hwloc::TYPE_DEPTH_UNKNOWN
+        if depth == Hwloc::TYPE_DEPTH_MULTIPLE then
+          depth_list = each_obj.select{ |e| e.type == type }.collect{ |e| e.depth }.uniq
+          res = depth_list.collect { |d| distances_by_depth(d, *kind) }.reduce(:+)
+          return [] unless res
+          return res
+        end
+        return distances_by_depth(depth, *kind)
+      end
+
+      def distances_add(objs, values, *kind, flags: [])
+        nbobjs = objs.size
+        vals = values.flatten
+        raise TopologyError if vals.length != nbobjs * nbobjs
+        vals_p = FFI::MemoryPointer::new(:uint64, vals.length)
+        vals_p.write_array_of_uint64(vals)
+        objs_p = FFI::MemoryPointer::new(:pointer, objs.length)
+        objs_p.write_array_of_pointer(objs.collect(&:to_ptr))
+        err = Hwloc.hwloc_distances_add(@ptr, nbobjs, objs_p, vals_p, kind, flags)
+        raise TopologyError if err == -1
+        self
+      end
+
+      def distances_remove
+        err = Hwloc.hwloc_distances_remove(@ptr)
+        raise TopologyError if err == -1
+        self
+      end
+
+      def distances_remove_by_depth(depth)
+        err = Hwloc.hwloc_distances_remove_by_depth(@ptr, depth)
+        raise TopologyError if err == -1
+        self
+      end
+
+      def distances_remove_by_type(type)
+        depth = get_type_depth(type)
+        return self if depth == Hwloc::TYPE_DEPTH_UNKNOWN
+        if depth == Hwloc::TYPE_DEPTH_MULTIPLE then
+          depth_list = each_obj.select{ |e| e.type == type }.collect{ |e| e.depth }.uniq
+          depth_list.each { |d| distances_remove_by_depth(d) }
+          return self
+        end
+        return distances_remove_by_depth(depth)
+      end
+
+    end
+
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hwloc
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Brice Videau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-29 00:00:00.000000000 Z
+date: 2020-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -86,8 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: hwloc ruby bindings