hwloc 0.1

data/lib/hwloc/Edition.rb

@@ -0,0 +1,68 @@
+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
+
+  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
+  ] )
+
+  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
+
+    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
+
+    def restrict(cpuset, flags)
+      err = Hwloc.hwloc_topology_restrict(@ptr, cpuset, flags)
+      raise EditionError if err == -1
+      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
+
+    def to_topo
+      new_topo = Topology::new
+      new_topo.set_custom
+      new_topo.custom_insert_topology( new_topo.root_obj , @topology, self)
+      new_topo.load
+      return new_topo
+    end
+
+  end
+
+end

data/lib/hwloc/Export.rb

@@ -0,0 +1,66 @@
+module Hwloc
+
+  attach_function :hwloc_topology_export_xml, [:topology, :string], :int
+  attach_function :hwloc_topology_export_xmlbuffer, [:topology, :pointer, :pointer], :int
+  attach_function :hwloc_free_xmlbuffer, [:topology, :pointer], :void
+
+  callback :hwloc_topology_set_userdata_export_callback_callback, [:pointer, :topology, Obj.ptr], :void
+  attach_function :hwloc_topology_set_userdata_export_callback, [:topology, :hwloc_topology_set_userdata_export_callback_callback], :void
+
+  attach_function :hwloc_export_obj_userdata, [:pointer, :topology, Obj.ptr, :string, :pointer, :size_t], :int
+  attach_function :hwloc_export_obj_userdata_base64, [:pointer, :topology, Obj.ptr, :string, :pointer, :size_t], :int
+
+  callback :hwloc_topology_set_userdata_import_callback_callback, [:topology, Obj.ptr, :string, :pointer, :size_t], :void
+  attach_function :hwloc_topology_set_userdata_import_callback, [:topology, :hwloc_topology_set_userdata_import_callback_callback], :void
+
+  TopologyExportSyntheticFlags = enum( FFI::find_type(:ulong), :topology_export_synthetic_flags, [
+    :TOPOLOGY_EXPORT_SYNTHETIC_FLAG_NO_EXTENDED_TYPES, 1<<0,
+    :TOPOLOGY_EXPORT_SYNTHETIC_FLAG_NO_ATTRS, 1<<1
+  ] )
+
+  attach_function :hwloc_topology_export_synthetic, [:topology, :pointer, :size_t, :uint], :int
+
+  class ExportError < TopologyError
+  end
+
+  class Topology
+
+    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))
+    end
+
+    def free_xmlbuffer(pointer)
+      Hwloc.hwloc_free_xmlbuffer(@self, pointer)
+    end
+
+    private :free_xmlbuffer
+
+    def export_synthetic(flags = 0)
+      str_ptr = FFI::MemoryPointer::new(:char, 2048)
+      err = Hwloc.hwloc_topology_export_synthetic(@ptr, str_ptr, str_ptr.size, flags)
+      raise ExportError, "Topology not symetric" if err == -1
+      return str_ptr.read_string
+    end
+
+    def to_s
+      begin
+        return export_synthetic
+      rescue ExportError
+        return super
+      end
+    end
+
+  end
+
+end

data/lib/hwloc/Hwloc.rb

@@ -0,0 +1,24 @@
+require 'ffi'
+
+module Hwloc
+  extend FFI::Library
+  ffi_lib '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
+
+  attach_function :strerror, [:int], :string
+
+  def self.error_string
+    return Hwloc.strerror(FFI::LastError::error)
+  end
+
+  class Error < RuntimeError
+    def initialize(msg = nil)
+      msg = Hwloc.error_string unless msg
+      super( msg )
+    end
+  end
+
+end

data/lib/hwloc/Obj.rb

@@ -0,0 +1,432 @@
+module Hwloc
+
+  class ObjError < Error
+  end
+
+  ObjType = enum( :obj_type, [
+    :OBJ_SYSTEM,
+    :OBJ_MACHINE,
+    :OBJ_NUMANODE,
+    :OBJ_PACKAGE,
+    :OBJ_CACHE,
+    :OBJ_CORE,
+    :OBJ_PU,
+    :OBJ_GROUP,
+    :OBJ_MISC,
+    :OBJ_BRIDGE,
+    :OBJ_PCI_DEVICE,
+    :OBJ_OS_DEVICE,
+    :OBJ_TYPE_MAX
+  ] )
+
+  attach_function :hwloc_compare_types, [:obj_type, :obj_type], :int
+
+  def self.compare_types(type1, type2)
+    return Hwloc.hwloc_compare_types(type1, type2)
+  end
+
+  ObjCacheType = enum( :obj_cache_type, [
+    :OBJ_CACHE_UNIFIED,
+    :OBJ_CACHE_DATA,
+    :OBJ_CACHE_INSTRUCTION
+  ] )
+
+  ObjBrigeType = enum( :obj_bridge_type, [
+    :OBJ_BRIDGE_HOST,
+    :OBJ_BRIDGE_PCI
+  ] )
+
+  ObjOsdevType = enum( :obj_osdev_type, [
+    :OBJ_OSDEV_BLOCK,
+    :OBJ_OSDEV_GPU,
+    :OBJ_OSDEV_NETWORK,
+    :OBJ_OSDEV_OPENFABRICS,
+    :OBJ_OSDEV_DMA,
+    :OBJ_OSDEV_COPROC
+  ] )
+
+  class Struct < FFI::Struct
+
+    def method_missing(m, *args, &block)
+      begin
+        return self[m]
+      rescue
+        super
+      end
+    end
+
+    def [](symbol)
+      o = super
+      o.instance_variable_set(:@topology, @topology) if o.kind_of?(Hwloc::Struct) || o.kind_of?(Hwloc::Union)
+      return o
+    end
+
+    attr_reader :topology
+
+  end
+
+  class Union < FFI::Union
+
+    def method_missing(m, *args, &block)
+      begin
+        return self[m]
+      rescue
+        super
+      end
+    end
+
+    def [](symbol)
+      o = super
+      o.instance_variable_set(:@topology, @topology) if o.kind_of?(Hwloc::Struct) || o.kind_of?(Hwloc::Union)
+      return o
+    end
+
+    attr_reader :topology
+
+  end
+
+  class BoolStruct < FFI::Struct
+
+    def method_missing(m, *args, &block)
+      begin
+        return self[m] == 1
+      rescue
+        super
+      end
+    end
+
+    def each
+      if block_given? then
+        members.each { |m|
+          yield m, (self[m] ==1)
+        }
+      else
+        to_enum(:each)
+      end
+    end
+
+    attr_reader :topology
+
+  end
+
+  class Distances < Struct
+    layout :relative_depth, :uint,
+           :nbobjs,         :uint,
+           :latency,        :pointer,
+           :latency_max,    :float,
+           :latency_base,   :float
+  end
+
+  class ObjInfo < Struct
+    layout :name, :string,
+           :value, :string
+
+    def to_s
+      return "#{self[:name]}:#{self[:value]}"
+    end
+
+  end
+
+  class ObjMemoryPageType < Struct
+    layout :size,  :uint64,
+           :count, :uint64
+    def size
+      return self[:size]
+    end
+  end
+
+  class ObjMemory < Struct
+    layout :total_memory, :uint64,
+           :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,
+           :linesize,      :uint,
+           :associativity, :int,
+           :type,          :obj_cache_type
+    def size
+      return self[:size]
+    end
+  end
+
+  class GroupAttr < Struct
+    layout :depth, :uint
+  end
+
+  class PcidevAttr < Struct
+    layout :domain,       :ushort,
+           :bus,          :uchar,
+           :dev,          :uchar,
+           :func,         :uchar,
+           :class_id,     :ushort,
+           :vendor_id,    :ushort,
+           :device_id,    :ushort,
+           :subvendor_id, :ushort,
+           :subdevice_id, :ushort,
+           :revision,     :uchar,
+           :linkspeed,    :float
+  end
+
+  class AnonBridgeAttrUpstream < Union
+    layout :pci, PcidevAttr
+  end
+
+  class AnonBridgeAttrDownstreamStruct < Struct
+    layout :domain,          :ushort,
+           :secondary_bus,   :uchar,
+           :subordinate_bus, :uchar
+  end
+
+  class AnonBridgeAttrDownstream < Union
+    layout :pci, AnonBridgeAttrDownstreamStruct
+  end
+
+  class BridgeAttr < Struct
+    layout :upstream,        AnonBridgeAttrUpstream,
+           :upstream_type,   :obj_bridge_type,
+           :downstream,      AnonBridgeAttrDownstream,
+           :downstream_type, :obj_bridge_type,
+           :depth,           :uint
+  end
+
+  class OsdevAttr < Struct
+    layout :type, :obj_osdev_type
+  end
+
+  class ObjAttr < Union
+    layout :cache,  CacheAttr,
+           :group,  GroupAttr,
+           :pcidev, PcidevAttr,
+           :bridge, BridgeAttr,
+           :osdev,  OsdevAttr
+  end
+
+  class Obj < Struct
+  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
+    ]
+
+    layout *layout_array
+
+    def ==(other)
+      return other.kind_of?(Obj) && to_ptr == other.to_ptr
+    end
+
+    def type_snprintf(verbose=0)
+      sz = Hwloc.hwloc_obj_type_snprintf(nil, 0, self, verbose) + 1
+      str_ptr = FFI::MemoryPointer::new(:char, sz)
+      Hwloc.hwloc_obj_type_snprintf(str_ptr, sz, self, verbose)
+      return str_ptr.read_string
+    end
+
+    alias type_name type_snprintf
+
+    def attr_snprintf(verbose=0, separator=",")
+      sz = Hwloc.hwloc_obj_attr_snprintf(nil, 0, self, separator, verbose) + 1
+      str_ptr = FFI::MemoryPointer::new(:char, sz)
+      Hwloc.hwloc_obj_attr_snprintf(str_ptr, sz, self, separator, verbose)
+      return str_ptr.read_string
+    end
+
+    def to_s(verbose=0)
+      attr_str = attr_snprintf(verbose)
+      str = "#{type_snprintf(verbose)} L##{logical_index}"
+      str += " (#{attr_str})" if attr_str != ""
+      return str
+    end
+
+    def inspect
+      return to_s(1)
+    end
+
+    layout_array.each_slice(2) { |f|
+      case f[1]
+      when :cpuset
+        define_method(f[0]) {
+          p = self[f[0]]
+          return nil if p.null?
+          return Cpuset::new(p)
+        }
+      when :nodeset
+        define_method(f[0]) {
+          p = self[f[0]]
+          return nil if p.null?
+          return Nodeset::new(p)
+        }
+      when Obj.ptr
+        define_method(f[0]) {
+          p = self[f[0]]
+          return nil if p.to_ptr.null?
+          return p
+        }
+      end
+    }
+
+    alias previous_sibling prev_sibling
+    alias previous_cousin prev_cousin
+
+    def children
+      arity = self[:arity]
+      if arity == 0 then
+        return []
+      else
+        return self[:children].read_array_of_pointer(arity).collect { |p|
+          c = Obj::new(p)
+          c.instance_variable_set(:@topology, @topology)
+          c
+        }
+      end
+    end
+
+    def each_child(*args, &block)
+      return children.each(*args, &block)
+    end
+
+    def each_parent(&block)
+      if block then
+        if parent then
+          block.call parent
+          parent.each_parent(&block)
+        end
+        return self
+      else
+        to_enum(:each_parent)
+      end
+    end
+
+    def parents
+      return each_parent.to_a
+    end
+
+    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
+        }
+      end
+    end
+
+    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
+    end
+
+    def each_info(*args, &block)
+      return infos.each(*args, &block)
+    end
+
+    def attr
+      at = self[:attr]
+      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
+        return at[:pcidev]
+      when :OBJ_BRIDGE
+        return at[:bridge]
+      when :OBJ_OS_DEVICE
+        return at[:osdev]
+      end
+      return nil
+    end
+
+  end
+
+end