rbmetis 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fbae1487ebf509c40e38f3f8faf4215cf990aeb2
+  data.tar.gz: c72a1b49ba3d6b7546fafbd0cf8c6d212056d316
+SHA512:
+  metadata.gz: e580d9355397280750f1643e5d112ffd8d175bd1a6f2787bfa8d0767110d8144c4b077c201425a377ad9eed35cc0277b223b4ce2c212450ccd940180bda8d2f4
+  data.tar.gz: 17def092502f7ec8cd3a55dce354151b4bb7f4afea8e1b641fac5bb9f07283c0b093385ef4a6b94bcb160549419c4f06f710097bfe4c9dbd9f00b7517f5a9369

data/.gitignore

@@ -0,0 +1,32 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.config
+*~
+*/*~
+*/*/*~
+*.bak
+*/*.bak
+*/*/*.bak
+.#*
+*/.#*
+*/*/.#*
+rhosts
+spec/*/*.dat
+spec/*/*.csv
+ext/Makefile
+lib/rbmetis/config.rb

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (c) 2014 Masahiro TANAKA
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0

data/README.md

@@ -0,0 +1,63 @@
+# RbMetis
+
+FFI wrapper of [METIS graph partitioning library](http://glaros.dtc.umn.edu/gkhome/metis/metis/overview)
+
+* [GitHub](https://github.com/masa16/rbmetis)
+* [RubyGems](https://rubygems.org/gems/rbmetis)
+* [Class Documentation](http://rubydoc.info/gems/rbmetis/frames/)
+
+## Requirement
+
+* [METIS version 5.1.0](http://glaros.dtc.umn.edu/gkhome/metis/metis/overview)
+* [Ruby-FFI](https://rubygems.org/gems/ffi)
+
+## Installation
+
+Install from RubyGems:
+
+    $ gem install rbmetis
+
+Or download source tree from [releases](https://github.com/masa16/rbmetis/releases),
+cd to tree top and run:
+
+    $ ruby setup.rb
+
+### Installation Option
+
+* Required METIS files:
+  * C header: metis.h
+  * Library: libmetis.so or libmetis.a
+
+* option for extconf.rb
+
+        --with-metis-dir=path
+        --with-metis-include=path
+        --with-metis-lib=path
+
+* How to pass option to extconf.rb
+
+        $ gem install rbmetis -- --with-metis-dir=/opt/metis
+        $ ruby setup.rb -- --with-metis-dir=/opt/metis
+
+## Usage
+
+Loading RbMeits:
+
+    require 'rbmetis'
+
+Currently implemented APIs:
+
+    RbMetis.part_graph_recursive(xadj, adjncy, npart, opts = {})
+    RbMetis.part_graph_kway(xadj, adjncy, npart, opts = {})
+    RbMetis.default_options
+
+See also [RbMeits API document](http://rubydoc.info/gems/rbmetis/frames)
+and [METIS manual](http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/manual.pdf)
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/rbmetis/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/ext/extconf.rb

@@ -0,0 +1,56 @@
+require "mkmf"
+
+# configure options:
+#  --with-metis-dir=path
+#  --with-metis-include=path
+#  --with-metis-lib=path
+
+dir_config("metis")
+
+libdirs = $LIBPATH.dup
+libdirs |= %w[/usr/lib64 /usr/lib /usr/local/lib]
+incdirs = $CPPFLAGS.scan(/(?<=^-I|\s-I)\S+/)
+incdirs |= %w[/usr/include /usr/local/include]
+
+libmetis = %w[libmetis.so libmetis.a]
+
+libdirs.each do |dir|
+  libmetis.each do |name|
+    path = File.join(dir,name)
+    if File.exist?(path)
+      $libmetis = path
+      break
+    end
+  end
+  break if $libmetis
+end
+
+incdirs.each do |dir|
+  path = File.join(dir,'metis.h')
+  if File.exist?(path)
+    puts "reading #{path}"
+    open(path,'r').each do |line|
+      case line
+      when /^\s*#define\s+IDXTYPEWIDTH\s+(\d+)/
+        $idxtypewidth = $1.to_i
+      when /^\s*#define\s+REALTYPEWIDTH\s+(\d+)/
+        $realtypewidth = $1.to_i
+      end
+    end
+    break
+  end
+end
+
+conf_file = File.join("..","lib","rbmetis","config.rb")
+print "creating #{conf_file}\n"
+open(conf_file, "w") do |f|
+  f.puts <<EOL
+module RbMetis
+  IDXTYPEWIDTH=#{$idxtypewidth}
+  REALTYPEWIDTH=#{$realtypewidth}
+  LIBMETIS='#{$libmetis}'
+end
+EOL
+end
+
+create_makefile("rbmetis")

data/lib/rbmetis.rb

@@ -0,0 +1,5 @@
+require 'ffi'
+require "rbmetis/version"
+require "rbmetis/config"
+require "rbmetis/lib"
+require "rbmetis/main"

data/lib/rbmetis/lib.rb

@@ -0,0 +1,135 @@
+module RbMetis
+
+  # @visibility private
+  module Lib
+
+    extend FFI::Library
+    ffi_lib LIBMETIS
+    attach_function :METIS_PartGraphRecursive, [:pointer]*13, :int
+    attach_function :METIS_PartGraphKway, [:pointer]*13, :int
+    attach_function :METIS_SetDefaultOptions, [:pointer], :int
+
+    case IDXTYPEWIDTH
+    when 32
+      def alloc_idx_ary(ary)
+        a = FFI::MemoryPointer.new(:int32, ary.size)
+        a.write_array_of_int32(ary)
+        a
+      end
+      def alloc_idx(num)
+        a = FFI::MemoryPointer.new(:int32)
+        a.write_int32(num)
+        a
+      end
+      def read_idx_ary(a,n)
+        a.read_array_of_int32(n)
+      end
+      def read_idx(a)
+        a.read_int32
+      end
+    when 64
+      def alloc_idx_ary(ary)
+        a = FFI::MemoryPointer.new(:int64, ary.size)
+        a.write_array_of_int64(ary)
+        a
+      end
+      def alloc_idx(num)
+        a = FFI::MemoryPointer.new(:int64)
+        a.write_int64(num)
+        a
+      end
+      def read_idx_ary(a,n)
+        a.read_array_of_int64(n)
+      end
+      def read_idx(a)
+        a.read_int64
+      end
+    end
+    module_function :alloc_idx
+    module_function :alloc_idx_ary
+    module_function :read_idx
+    module_function :read_idx_ary
+
+    case REALTYPEWIDTH
+    when 32
+      def alloc_real_ary(ary)
+        a = FFI::MemoryPointer.new(4, ary.size)
+        a.put_array_of_float32(0, ary)
+        a
+      end
+    when 64
+      def alloc_real_ary(ary)
+        a = FFI::MemoryPointer.new(8, ary.size)
+        a.put_array_of_float64(0, ary)
+        a
+      end
+    end
+    module_function :alloc_real_ary
+
+    def check_idx_array(args,name,size=nil,sizename=nil)
+      arg = args[name]
+      if arg
+        if !(Array===arg)
+          raise ArgumentError, "#{name} must be an array"
+        end
+        if size && arg.size != size
+          raise ArgumentError, "the size of #{name} must be #{sizename||size}"
+        end
+        alloc_idx_ary(arg)
+      else
+        nil
+      end
+    end
+    module_function :check_idx_array
+
+    def check_real_array(args,name,size=nil,sizename=nil)
+      arg = args[name]
+      if arg
+        if !(Array===arg)
+          raise ArgumentError, "#{name} must be an array"
+        end
+        if size && arg.size != size
+          raise ArgumentError, "the size of #{name} must be #{sizename||size}"
+        end
+        alloc_real_ary(arg)
+      else
+        nil
+      end
+    end
+    module_function :check_real_array
+
+    def check_idx(args,name,default_value=nil)
+      arg = args[name]
+      if arg
+        if !(Integer===arg)
+          raise ArgumentError, "#{name} must be an integer"
+        end
+        alloc_idx(arg)
+      else
+        if default_value
+          alloc_idx(default_value)
+        else
+          nil
+        end
+      end
+    end
+    module_function :check_idx
+
+    def postprocess(retval)
+      case retval
+      when METIS_OK
+        "that the function returned normally."
+      when METIS_ERROR_INPUT
+        raise MetisError, "input error"
+      when METIS_ERROR_MEMORY
+        raise MetisError, "memory allocation error"
+      when METIS_ERROR
+        raise MetisError, "other type of error"
+      else
+        raise MetisError, "unknown return code"
+      end
+    end
+    module_function :postprocess
+
+  end
+end

data/lib/rbmetis/main.rb

@@ -0,0 +1,259 @@
+module RbMetis
+  class MetisError < StandardError
+  end
+
+  #  Returned normally
+  METIS_OK              =  1
+  #  Returned due to erroneous inputs and/or options
+  METIS_ERROR_INPUT     = -2
+  #  Returned due to insufficient memory
+  METIS_ERROR_MEMORY    = -3
+  #  Some other errors
+  METIS_ERROR           = -4
+
+  NOPTIONS = 40
+
+  #/*! Operation type codes */
+  OP_PMETIS,
+  OP_KMETIS,
+  OP_OMETIS = 0..2
+
+  #/*! Options codes (i.e., options[]) */
+  OPTION_PTYPE,
+  OPTION_OBJTYPE,
+  OPTION_CTYPE,
+  OPTION_IPTYPE,
+  OPTION_RTYPE,
+  OPTION_DBGLVL,
+  OPTION_NITER,
+  OPTION_NCUTS,
+  OPTION_SEED,
+  OPTION_NO2HOP,
+  OPTION_MINCONN,
+  OPTION_CONTIG,
+  OPTION_COMPRESS,
+  OPTION_CCORDER,
+  OPTION_PFACTOR,
+  OPTION_NSEPS,
+  OPTION_UFACTOR,
+  OPTION_NUMBERING,
+  #/* Used for command-line parameter purposes */
+  OPTION_HELP,
+  OPTION_TPWGTS,
+  OPTION_NCOMMON,
+  OPTION_NOOUTPUT,
+  OPTION_BALANCE,
+  OPTION_GTYPE,
+  OPTION_UBVEC = 0..25
+
+  # /*! Partitioning Schemes */
+  PTYPE_RB,
+  PTYPE_KWAY = 0..1
+
+  # /*! Graph types for meshes */
+  GTYPE_DUAL,
+  GTYPE_NODAL = 0..1
+
+  # /*! Coarsening Schemes */
+  CTYPE_RM,
+  CTYPE_SHEM = 0..1
+
+  # /*! Initial partitioning schemes */
+  IPTYPE_GROW,
+  IPTYPE_RANDOM,
+  IPTYPE_EDGE,
+  IPTYPE_NODE,
+  IPTYPE_METISRB = 0..4
+
+  # /*! Refinement schemes */
+  RTYPE_FM,
+  RTYPE_GREEDY,
+  RTYPE_SEP2SIDED,
+  RTYPE_SEP1SIDED = 0..3
+
+  # /*! Debug Levels */
+  DBG_INFO       = 1
+  DBG_TIME       = 2
+  DBG_COARSEN    = 4
+  DBG_REFINE     = 8
+  DBG_IPART      = 16
+  DBG_MOVEINFO   = 32
+  DBG_SEPINFO    = 64
+  DBG_CONNINFO   = 128
+  DBG_CONTIGINFO = 256
+  DBG_MEMORY     = 2048
+
+  # /* Types of objectives */
+  OBJTYPE_CUT,
+  OBJTYPE_VOL,
+  OBJTYPE_NODE = 0..2
+
+  # @visibility private
+  module Lib
+    def part_graph_preprocess(xadj_arg, adjncy_arg, np, args={})
+      nv = xadj_arg.size - 1
+
+      # The number of vertices in the graph.
+      nvtxs  = alloc_idx(nv)
+      # The adjacency structure of the graph as described in Section 5.5.
+      xadj   = alloc_idx_ary(xadj_arg)
+      adjncy = alloc_idx_ary(adjncy_arg)
+      # The number of parts to partition the graph.
+      nparts = alloc_idx(np)
+
+      ncon = check_idx(args, :ncon, 1)
+      nc = read_idx(ncon)
+
+      # The weights of the vertices as described in Section 5.5.
+      vwgt = check_idx_array(args, :vwgt, nv*nc, "nvtxs*ncon")
+
+      # The number of balancing constraints. It should be at least 1.
+      ncon = alloc_idx(nc)
+
+      # The size of the vertices for computing the total communication
+      # volume as described in Section 5.7.
+      vsize = check_idx(args, :vsize, 1)
+
+      # The weights of the edges as described in Section 5.5.
+      adjwgt = check_idx_array(args, :adjwgt, adjncy_arg.size, "size of adjncy")
+
+      # This is an array of size nparts*ncon that specifies the desired
+      # weight for each partition and constraint.
+      # The target partition weight for the ith partition and jth
+      # constraint is specified at tpwgts[i*ncon+j]
+      # For each constraint, the sum of the tpwgts[] entries must be 1.0.
+      tpwgts = check_real_array(args, :tpwgts, np*nc, "nparts*ncon")
+
+      # This is an array of size ncon that specifies the allowed load
+      # imbalance tolerance for each constraint.
+      # For the ith partition and jth constraint the allowed weight is
+      # the ubvec[j]*tpwgts[i*ncon+j] fraction of the jth’s constraint
+      # total weight. The load imbalances must be greater than 1.0.
+      # A NULL value can be passed indicating that the load imbalance
+      # tolerance for each constraint should be 1.001 (for ncon=1) or
+      # 1.01 (for ncon>1).
+      ubvec = check_real_array(args, :ubvec, nc, "ncon")
+
+      # This is the array of options as described in Section 5.4.
+      options = check_idx_array(args, :options, 40)
+
+      # Upon successful completion, this variable stores the edge-cut or
+      # the total communication volume of the partitioning solution. The
+      # value returned depends on the partitioning’s objective
+      # function.
+      objval = alloc_idx(0)
+
+      # This is a vector of size nvtxs that upon successful completion
+      # stores the partition vector of the graph. The numbering of this
+      # vector starts from either 0 or 1, depending on the value of
+      # options[METIS OPTION NUMBERING].
+      part = alloc_idx_ary([0]*nv)
+
+      return [nvtxs, ncon, xadj, adjncy, vwgt, vsize, adjwgt, nparts,
+              tpwgts, ubvec, options, objval, part]
+    end
+    module_function :part_graph_preprocess
+  end
+
+  # partition a graph into k parts using multilevel recursive bisection.
+  # @overload part_graph_recursive(xadj, adjncy, npart, opts={})
+  # @param  [Array] xadj adjacency structure of the graph
+  # @param  [Array] adjncy adjacency structure of the graph
+  # @param  [Integer] npart the number of partitions
+  # @option opts [Array] :vwgt (nil) The weights of the vertices.
+  # @option opts [Array] :ncon (1) The number of balancing
+  #   constraints. It should be at least 1.
+  # @option opts [Array] :vsize (nil) The size of the vertices for
+  #   computing the total communication volume.
+  # @option opts [Array] :adjwgt (nil) The weights of the edges.
+  # @option opts [Array] :tpwgts (nil) an array of size nparts*ncon
+  #   that specifies the desired weight for each partition and
+  #   constraint.  The target partition weight for the ith partition
+  #   and jth constraint is specified at tpwgts[i*ncon+j] For each
+  #   constraint, the sum of the tpwgts[] entries must be 1.0.
+  # @option opts [Array] :ubvec (nil) an array of size ncon that
+  #   specifies the allowed load imbalance tolerance for each
+  #   constraint.  For the ith partition and jth constraint the allowed
+  #   weight is the ubvec[j]*tpwgts[i*ncon+j] fraction of the jth’s
+  #   constraint total weight. The load imbalances must be greater than
+  #   1.0.  A NULL value can be passed indicating that the load
+  #   imbalance tolerance for each constraint should be 1.001 (for
+  #   ncon=1) or 1.01 (for ncon>1).
+  # @option opts [Array] :options (nil) the array of options.
+  #   The following options are valid for METIS PartGraphRecursive:
+  #   METIS_OPTION_CTYPE, METIS_OPTION_IPTYPE, METIS_OPTION_RTYPE,
+  #   METIS_OPTION_NO2HOP, METIS_OPTION_NCUTS, METIS_OPTION_NITER,
+  #   METIS_OPTION_SEED, METIS_OPTION_UFACTOR, METIS_OPTION_NUMBERING,
+  #   METIS_OPTION_DBGLVL
+  # @return [Array] an array that stores the partition of the graph.
+  # @raise  [RbMetis::MetisError]
+  def part_graph_recursive(xadj, adjncy, npart, opts={})
+    # args = [ nvtxs, ncon, xadj, adjncy, vwgt, vsize, adjwgt, nparts,
+    #          tpwgts, ubvec, options, objval, part ]
+    args = Lib.part_graph_preprocess(xadj, adjncy, npart, opts)
+    retval = Lib.METIS_PartGraphRecursive(*args)
+    Lib.postprocess(retval)
+    part = args.last
+    nv = xadj.size - 1
+    #p read_idx(objval)
+    return Lib.read_idx_ary(part,nv)
+  end
+  module_function :part_graph_recursive
+
+
+  # partition a graph into k parts using multilevel k-way partitioning.
+  # @overload part_graph_kway(xadj, adjncy, npart, opts={})
+  # @param  [Array] xadj adjacency structure of the graph
+  # @param  [Array] adjncy adjacency structure of the graph
+  # @param  [Integer] npart the number of partitions
+  # @option opts [Array] :vwgt (nil) The weights of the vertices.
+  # @option opts [Array] :ncon (1) The number of balancing
+  #   constraints. It should be at least 1.
+  # @option opts [Array] :vsize (nil) The size of the vertices for
+  #   computing the total communication volume.
+  # @option opts [Array] :adjwgt (nil) The weights of the edges.
+  # @option opts [Array] :tpwgts (nil) an array of size nparts*ncon
+  #   that specifies the desired weight for each partition and
+  #   constraint.  The target partition weight for the ith partition
+  #   and jth constraint is specified at tpwgts[i*ncon+j] For each
+  #   constraint, the sum of the tpwgts[] entries must be 1.0.
+  # @option opts [Array] :ubvec (nil) an array of size ncon that
+  #   specifies the allowed load imbalance tolerance for each
+  #   constraint.  For the ith partition and jth constraint the allowed
+  #   weight is the ubvec[j]*tpwgts[i*ncon+j] fraction of the jth’s
+  #   constraint total weight. The load imbalances must be greater than
+  #   1.0.  A NULL value can be passed indicating that the load
+  #   imbalance tolerance for each constraint should be 1.001 (for
+  #   ncon=1) or 1.01 (for ncon>1).
+  # @option opts [Array] :options (nil) the array of options.
+  #   The following options are valid for METIS PartGraphKway:
+  #   METIS_OPTION_OBJTYPE, METIS_OPTION_CTYPE, METIS_OPTION_IPTYPE,
+  #   METIS_OPTION_RTYPE, METIS_OPTION_NO2HOP, METIS_OPTION_NCUTS,
+  #   METIS_OPTION_NITER, METIS_OPTION_UFACTOR, METIS_OPTION_MINCONN,
+  #   METIS_OPTION_CONTIG, METIS_OPTION_SEED, METIS_OPTION_NUMBERING,
+  #   METIS_OPTION_DBGLVL
+  # @return [Array] an array that stores the partition of the graph.
+  # @raise  [RbMetis::MetisError]
+  def part_graph_kway(xadj, adjncy, npart, opts={})
+    # args = [ nvtxs, ncon, xadj, adjncy, vwgt, vsize, adjwgt, nparts,
+    #          tpwgts, ubvec, options, objval, part ]
+    args = Lib.part_graph_preprocess(xadj, adjncy, npart, opts)
+    retval = Lib.METIS_PartGraphKway(*args)
+    Lib.postprocess(retval)
+    part = args.last
+    nv = xadj.size - 1
+    #p read_idx(objval)
+    return Lib.read_idx_ary(part,nv)
+  end
+  module_function :part_graph_kway
+
+  # Initializes the options array into its default values.
+  # @return [Array] The array of options that will be initialized.
+  # It’s size is METIS_NOPTIONS.
+  def default_options
+    options = Lib.alloc_idx_ary([0]*40)
+    Lib.METIS_SetDefaultOptions(options)
+    Lib.read_idx_ary(options,40)
+  end
+  module_function :default_options
+end