ruby-mpi 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+  gem "narray", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,30 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    narray (0.5.9.9)
+    rake (0.8.7)
+    rcov (0.9.9)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  narray
+  rcov
+  rspec (~> 2.3.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Seiya Nishizawa
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,19 @@
+= ruby-mpi
+
+Description goes here.
+
+== Contributing to ruby-mpi
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Seiya Nishizawa. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'bundler'
+require "rake/clean"
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "ruby-mpi"
+  gem.homepage = "http://github.com/seiya/ruby-mpi"
+  gem.license = "MIT"
+  gem.summary = "A ruby binding of MPI"
+  gem.description = "A ruby binding of Message Passing Interface (MPI), which is an API specification that allows processes to communicate with one another by sending and receiving messages."
+  gem.email = "seiya@gfd-dennou.org"
+  gem.authors = ["Seiya Nishizawa"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ruby-mpi #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+CLEAN.include("ext/mpi/*.o")
+CLEAN.include("ext/mpi/mkmf.log")
+CLOBBER.include("ext/mpi/mpi.so")
+CLOBBER.include("ext/mpi/Makefile")

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/ext/mpi/extconf.rb

@@ -0,0 +1,15 @@
+require "mkmf"
+
+CONFIG['CC'] = "mpicc"
+gem_path = nil
+begin
+  require "rubygems"
+  if (spec = Gem.source_index.find_name("narray")).any?
+    gem_path = spec.last.full_gem_path
+  end
+rescue LoadError
+  dir_config("narray", Config::CONFIG["sitearchdir"])
+end
+find_header("narray.h", gem_path)
+
+create_makefile("mpi")

data/ext/mpi/mpi.c

@@ -0,0 +1,656 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+#include "ruby.h"
+#include "narray.h"
+#include "mpi.h"
+
+
+#define OBJ2C(rb_obj, len, buffer, typ) \
+{\
+  if (TYPE(rb_obj) == T_STRING) {\
+    len = RSTRING_LEN(rb_obj);\
+    buffer = (void*)StringValuePtr(rb_obj);\
+    typ = MPI_CHAR;\
+  } else if (IsNArray(rb_obj)) {		\
+    struct NARRAY *a;\
+    GetNArray(rb_obj, a);\
+    buffer = (void*)(a->ptr);\
+    len = a->total;\
+    switch (a->type) {\
+    case NA_BYTE:\
+      typ = MPI_BYTE;\
+      break;\
+    case NA_SINT:\
+      typ = MPI_SHORT;\
+      break;\
+    case NA_LINT:\
+      typ = MPI_LONG;\
+      break;\
+    case NA_SFLOAT:\
+      typ = MPI_FLOAT;\
+      break;\
+    case NA_DFLOAT:\
+      typ = MPI_DOUBLE;\
+      break;\
+    case NA_SCOMPLEX:\
+      typ = MPI_2COMPLEX;\
+      break;\
+    case NA_DCOMPLEX:\
+      typ = MPI_2DOUBLE_COMPLEX;\
+      break;\
+    default:\
+      rb_raise(rb_eArgError, "narray type is invalid");\
+    }\
+  } else {\
+    rb_raise(rb_eArgError, "Only String and NArray are supported");\
+  }\
+}
+
+static VALUE mMPI;
+static VALUE cComm, cRequest, cOp, cErrhandler, cStatus;
+
+static VALUE eBUFFER, eCOUNT, eTYPE, eTAG, eCOMM, eRANK, eREQUEST, eROOT, eGROUP, eOP, eTOPOLOGY, eDIMS, eARG, eUNKNOWN, eTRUNCATE, eOTHER, eINTERN, eIN_STATUS, ePENDING, eACCESS, eAMODE, eASSERT, eBAD_FILE, eBASE, eCONVERSION, eDISP, eDUP_DATAREP, eFILE_EXISTS, eFILE_IN_USE, eFILE, eINFO_KEY, eINFO_NOKEY, eINFO_VALUE, eINFO, eIO, eKEYVAL, eLOCKTYPE, eNAME, eNO_MEM, eNOT_SAME, eNO_SPACE, eNO_SUCH_FILE, ePORT, eQUOTA, eREAD_ONLY, eRMA_CONFLICT, eRMA_SYNC, eSERVICE, eSIZE, eSPAWN, eUNSUPPORTED_DATAREP, eUNSUPPORTED_OPERATION, eWIN, eLASTCODE, eSYSRESOURCE;
+
+struct _Comm {
+  MPI_Comm comm;
+};
+struct _Request {
+  MPI_Request request;
+};
+struct _Op {
+  MPI_Op op;
+};
+struct _Errhandler {
+  MPI_Errhandler errhandler;
+};
+
+static bool _initialized = false;
+static bool _finalized = false;
+
+
+#define CAE_ERR(type) case MPI_ERR_ ## type: rb_raise(e ## type,""); break
+static void
+check_error(int error)
+{
+  switch (error) {
+  case MPI_SUCCESS: break;
+    CAE_ERR(BUFFER);
+    CAE_ERR(COUNT);
+    CAE_ERR(TYPE);
+    CAE_ERR(TAG);
+    CAE_ERR(COMM);
+    CAE_ERR(RANK);
+    CAE_ERR(REQUEST);
+    CAE_ERR(ROOT);
+    CAE_ERR(GROUP);
+    CAE_ERR(OP);
+    CAE_ERR(TOPOLOGY);
+    CAE_ERR(DIMS);
+    CAE_ERR(ARG);
+    CAE_ERR(UNKNOWN);
+    CAE_ERR(TRUNCATE);
+    CAE_ERR(OTHER);
+    CAE_ERR(INTERN);
+    CAE_ERR(IN_STATUS);
+    CAE_ERR(PENDING);
+    CAE_ERR(ACCESS);
+    CAE_ERR(AMODE);
+    CAE_ERR(ASSERT);
+    CAE_ERR(BAD_FILE);
+    CAE_ERR(BASE);
+    CAE_ERR(CONVERSION);
+    CAE_ERR(DISP);
+    CAE_ERR(DUP_DATAREP);
+    CAE_ERR(FILE_EXISTS);
+    CAE_ERR(FILE_IN_USE);
+    CAE_ERR(FILE);
+    CAE_ERR(INFO_KEY);
+    CAE_ERR(INFO_NOKEY);
+    CAE_ERR(INFO_VALUE);
+    CAE_ERR(INFO);
+    CAE_ERR(IO);
+    CAE_ERR(KEYVAL);
+    CAE_ERR(LOCKTYPE);
+    CAE_ERR(NAME);
+    CAE_ERR(NO_MEM);
+    CAE_ERR(NOT_SAME);
+    CAE_ERR(NO_SPACE);
+    CAE_ERR(NO_SUCH_FILE);
+    CAE_ERR(PORT);
+    CAE_ERR(QUOTA);
+    CAE_ERR(READ_ONLY);
+    CAE_ERR(RMA_CONFLICT);
+    CAE_ERR(RMA_SYNC);
+    CAE_ERR(SERVICE);
+    CAE_ERR(SIZE);
+    CAE_ERR(SPAWN);
+    CAE_ERR(UNSUPPORTED_DATAREP);
+    CAE_ERR(UNSUPPORTED_OPERATION);
+    CAE_ERR(WIN);
+    CAE_ERR(LASTCODE);
+    CAE_ERR(SYSRESOURCE);
+  default:
+    rb_raise(rb_eRuntimeError, "unknown error");
+  }
+}
+
+#define DEF_CONST(st, v, const, name, klass) \
+{\
+  v = ALLOC(struct st);\
+  v->v = const;\
+  rb_define_const(klass, #name, Data_Wrap_Struct(klass, 0, -1, v));	\
+}
+
+static VALUE
+rb_m_init(int argc, VALUE *argv, VALUE self)
+{
+  VALUE argary;
+  int cargc;
+  char ** cargv;
+  VALUE progname;
+  int i;
+
+  if (_initialized)
+    return self;
+  else
+    _initialized = true;
+
+  rb_scan_args(argc, argv, "01", &argary);
+
+  if (NIL_P(argary)) {
+    argary = rb_const_get(rb_cObject, rb_intern("ARGV"));
+    cargc = RARRAY_LEN(argary);
+  } else {
+    Check_Type(argary, T_ARRAY);
+    cargc = RARRAY_LEN(argary);
+  }
+
+  cargv = ALLOCA_N(char *, cargc+1);
+  progname = rb_gv_get("$0");
+  cargv[0] = StringValueCStr(progname);
+
+  for(i=0; i<cargc; i++) {
+    if (TYPE(RARRAY_PTR(argary)[i]) == T_STRING)
+      cargv[i+1] = StringValueCStr(RARRAY_PTR(argary)[i]);
+    else
+      cargv[i+1] = (char*)"";
+  }
+  cargc++;
+
+  MPI_Init(&cargc, &cargv);
+
+  // define MPI::Comm::WORLD
+  struct _Comm *comm;
+  DEF_CONST(_Comm, comm, MPI_COMM_WORLD, WORLD, cComm);
+  MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
+
+  // define MPI::Op::???
+  struct _Op *op;
+  DEF_CONST(_Op, op, MPI_MAX, MAX, cOp);
+  DEF_CONST(_Op, op, MPI_MIN, MIN, cOp);
+  DEF_CONST(_Op, op, MPI_SUM, SUM, cOp);
+  DEF_CONST(_Op, op, MPI_PROD, PROD, cOp);
+  DEF_CONST(_Op, op, MPI_LAND, LAND, cOp);
+  DEF_CONST(_Op, op, MPI_BAND, BAND, cOp);
+  DEF_CONST(_Op, op, MPI_LOR, LOR, cOp);
+  DEF_CONST(_Op, op, MPI_BOR, BOR, cOp);
+  DEF_CONST(_Op, op, MPI_LXOR, LXOR, cOp);
+  DEF_CONST(_Op, op, MPI_BXOR, BXOR, cOp);
+  DEF_CONST(_Op, op, MPI_MAXLOC, MAXLOC, cOp);
+  DEF_CONST(_Op, op, MPI_MINLOC, MINLOC, cOp);
+  DEF_CONST(_Op, op, MPI_REPLACE, REPLACE, cOp);
+
+  // define MPI::Errhandler::ERRORS_ARE_FATAL, ERRORS_RETURN
+  struct _Errhandler *errhandler;
+  DEF_CONST(_Errhandler, errhandler, MPI_ERRORS_ARE_FATAL, ERRORS_ARE_FATAL, cErrhandler);
+  DEF_CONST(_Errhandler, errhandler, MPI_ERRORS_RETURN, ERRORS_RETURN, cErrhandler);
+
+  return self;
+}
+
+static void
+_finalize()
+{
+  if(_initialized && !_finalized) {
+    _finalized = true;
+    check_error(MPI_Finalize());
+  }
+}
+static VALUE
+rb_m_finalize(VALUE self)
+{
+  _finalize();
+  return self;
+}
+
+
+// MPI::Comm
+static VALUE
+rb_comm_alloc(VALUE klass)
+{
+  struct _Comm *ptr = ALLOC(struct _Comm);
+  return Data_Wrap_Struct(klass, 0, -1, ptr);
+}
+static VALUE
+rb_comm_initialize(VALUE self)
+{
+  rb_raise(rb_eRuntimeError, "not developed yet");
+  // MPI_Comm_create()
+}
+static VALUE
+rb_comm_size(VALUE self)
+{
+  struct _Comm *comm;
+  int size;
+  Data_Get_Struct(self, struct _Comm, comm);
+  check_error(MPI_Comm_size(comm->comm, &size));
+  return INT2NUM(size);
+}
+static VALUE
+rb_comm_rank(VALUE self)
+{
+  struct _Comm *comm;
+  int rank;
+  Data_Get_Struct(self, struct _Comm, comm);
+  check_error(MPI_Comm_rank(comm->comm, &rank));
+  return INT2NUM(rank);
+}
+static VALUE
+rb_comm_send(VALUE self, VALUE rb_obj, VALUE rb_dest, VALUE rb_tag)
+{
+  void* buffer;
+  int len, dest, tag;
+  MPI_Datatype type;
+  struct _Comm *comm;
+
+  OBJ2C(rb_obj, len, buffer, type);
+  dest = NUM2INT(rb_dest);
+  tag = NUM2INT(rb_tag);
+  Data_Get_Struct(self, struct _Comm, comm);
+  check_error(MPI_Send(buffer, len, type, dest, tag, comm->comm));
+
+  return Qnil;
+}
+static VALUE
+rb_comm_isend(VALUE self, VALUE rb_obj, VALUE rb_dest, VALUE rb_tag)
+{
+  void* buffer;
+  int len, dest, tag;
+  MPI_Datatype type;
+  struct _Comm *comm;
+  struct _Request *request;
+  VALUE rb_request;
+
+  OBJ2C(rb_obj, len, buffer, type);
+  dest = NUM2INT(rb_dest);
+  tag = NUM2INT(rb_tag);
+  Data_Get_Struct(self, struct _Comm, comm);
+  rb_request = Data_Make_Struct(cRequest, struct _Request, 0, -1, request);
+  check_error(MPI_Isend(buffer, len, type, dest, tag, comm->comm, &(request->request)));
+
+  return rb_request;
+}
+static VALUE
+rb_comm_recv(VALUE self, VALUE rb_obj, VALUE rb_source, VALUE rb_tag)
+{
+  void* buffer;
+  int len, source, tag;
+  MPI_Datatype type;
+  MPI_Status *status;
+  struct _Comm *comm;
+
+  OBJ2C(rb_obj, len, buffer, type);
+  source = NUM2INT(rb_source);
+  tag = NUM2INT(rb_tag);
+
+  Data_Get_Struct(self, struct _Comm, comm);
+  status = ALLOC(MPI_Status);
+  check_error(MPI_Recv(buffer, len, type, source, tag, comm->comm, status));
+
+  return Data_Wrap_Struct(cStatus, 0, -1, status);
+}
+static VALUE
+rb_comm_irecv(VALUE self, VALUE rb_obj, VALUE rb_source, VALUE rb_tag)
+{
+  void* buffer;
+  int len, source, tag;
+  MPI_Datatype type;
+  struct _Comm *comm;
+  struct _Request *request;
+  VALUE rb_request;
+
+  OBJ2C(rb_obj, len, buffer, type);
+  source = NUM2INT(rb_source);
+  tag = NUM2INT(rb_tag);
+  Data_Get_Struct(self, struct _Comm, comm);
+  rb_request = Data_Make_Struct(cRequest, struct _Request, 0, -1, request);
+  check_error(MPI_Irecv(buffer, len, type, source, tag, comm->comm, &(request->request)));
+
+  return rb_request;
+}
+static VALUE
+rb_comm_gather(VALUE self, VALUE rb_sendbuf, VALUE rb_recvbuf, VALUE rb_root)
+{
+  void *sendbuf, *recvbuf = NULL;
+  int sendcount, recvcount = 0;
+  MPI_Datatype sendtype, recvtype = NULL;
+  int root, rank, size;
+  struct _Comm *comm;
+  OBJ2C(rb_sendbuf, sendcount, sendbuf, sendtype);
+  root = NUM2INT(rb_root);
+  Data_Get_Struct(self, struct _Comm, comm);
+  check_error(MPI_Comm_rank(comm->comm, &rank));
+  check_error(MPI_Comm_size(comm->comm, &size));
+  if (rank == root) {
+    OBJ2C(rb_recvbuf, recvcount, recvbuf, recvtype);
+    if (recvcount < sendcount*size)
+      rb_raise(rb_eArgError, "recvbuf is too small");
+    recvcount = sendcount;
+  }
+  check_error(MPI_Gather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm->comm));
+  return Qnil;
+}
+static VALUE
+rb_comm_allgather(VALUE self, VALUE rb_sendbuf, VALUE rb_recvbuf)
+{
+  void *sendbuf, *recvbuf;
+  int sendcount, recvcount;
+  MPI_Datatype sendtype, recvtype;
+  int rank, size;
+  struct _Comm *comm;
+  OBJ2C(rb_sendbuf, sendcount, sendbuf, sendtype);
+  Data_Get_Struct(self, struct _Comm, comm);
+  check_error(MPI_Comm_rank(comm->comm, &rank));
+  check_error(MPI_Comm_size(comm->comm, &size));
+  OBJ2C(rb_recvbuf, recvcount, recvbuf, recvtype);
+  if (recvcount < sendcount*size)
+    rb_raise(rb_eArgError, "recvbuf is too small");
+  recvcount = sendcount;
+  check_error(MPI_Allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm->comm));
+  return Qnil;
+}
+static VALUE
+rb_comm_bcast(VALUE self, VALUE rb_buffer, VALUE rb_root)
+{
+  void *buffer;
+  int count;
+  MPI_Datatype type;
+  int root;
+  struct _Comm *comm;
+  OBJ2C(rb_buffer, count, buffer, type);
+  root = NUM2INT(rb_root);
+  Data_Get_Struct(self, struct _Comm, comm);
+  check_error(MPI_Bcast(buffer, count, type, root, comm->comm));
+  return Qnil;
+}
+static VALUE
+rb_comm_scatter(VALUE self, VALUE rb_sendbuf, VALUE rb_recvbuf, VALUE rb_root)
+{
+  void *sendbuf = NULL, *recvbuf;
+  int sendcount = 0, recvcount;
+  MPI_Datatype sendtype = NULL, recvtype;
+  int root, rank, size;
+  struct _Comm *comm;
+  OBJ2C(rb_recvbuf, recvcount, recvbuf, recvtype);
+  root = NUM2INT(rb_root);
+  Data_Get_Struct(self, struct _Comm, comm);
+  check_error(MPI_Comm_rank(comm->comm, &rank));
+  check_error(MPI_Comm_size(comm->comm, &size));
+  if (rank == root) {
+    OBJ2C(rb_sendbuf, sendcount, sendbuf, sendtype);
+    if (sendcount > recvcount*size)
+      rb_raise(rb_eArgError, "recvbuf is too small");
+    sendcount = recvcount;
+  }
+  check_error(MPI_Scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm->comm));
+  return Qnil;
+}
+static VALUE
+rb_comm_alltoall(VALUE self, VALUE rb_sendbuf, VALUE rb_recvbuf)
+{
+  void *sendbuf, *recvbuf;
+  int sendcount, recvcount;
+  MPI_Datatype sendtype, recvtype;
+  int rank, size;
+  struct _Comm *comm;
+  OBJ2C(rb_sendbuf, sendcount, sendbuf, sendtype);
+  Data_Get_Struct(self, struct _Comm, comm);
+  check_error(MPI_Comm_rank(comm->comm, &rank));
+  check_error(MPI_Comm_size(comm->comm, &size));
+  OBJ2C(rb_recvbuf, recvcount, recvbuf, recvtype);
+  if (recvcount < sendcount)
+    rb_raise(rb_eArgError, "recvbuf is too small");
+  recvcount = recvcount/size;
+  sendcount = sendcount/size;
+  check_error(MPI_Alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm->comm));
+  return Qnil;
+}
+static VALUE
+rb_comm_reduce(VALUE self, VALUE rb_sendbuf, VALUE rb_recvbuf, VALUE rb_op, VALUE rb_root)
+{
+  void *sendbuf, *recvbuf = NULL;
+  int sendcount, recvcount = 0;
+  MPI_Datatype sendtype, recvtype = NULL;
+  int root, rank, size;
+  struct _Comm *comm;
+  struct _Op *op;
+  OBJ2C(rb_sendbuf, sendcount, sendbuf, sendtype);
+  root = NUM2INT(rb_root);
+  Data_Get_Struct(self, struct _Comm, comm);
+  check_error(MPI_Comm_rank(comm->comm, &rank));
+  check_error(MPI_Comm_size(comm->comm, &size));
+  if (rank == root) {
+    OBJ2C(rb_recvbuf, recvcount, recvbuf, recvtype);
+    if (recvcount != sendcount)
+      rb_raise(rb_eArgError, "sendbuf and recvbuf has the same length");
+    if (recvtype != sendtype)
+      rb_raise(rb_eArgError, "sendbuf and recvbuf has the same type");
+  }
+  Data_Get_Struct(rb_op, struct _Op, op);
+  check_error(MPI_Reduce(sendbuf, recvbuf, sendcount, sendtype, op->op, root, comm->comm));
+  return Qnil;
+}
+static VALUE
+rb_comm_allreduce(VALUE self, VALUE rb_sendbuf, VALUE rb_recvbuf, VALUE rb_op)
+{
+  void *sendbuf, *recvbuf;
+  int sendcount, recvcount;
+  MPI_Datatype sendtype, recvtype;
+  int rank, size;
+  struct _Comm *comm;
+  struct _Op *op;
+  OBJ2C(rb_sendbuf, sendcount, sendbuf, sendtype);
+  Data_Get_Struct(self, struct _Comm, comm);
+  check_error(MPI_Comm_rank(comm->comm, &rank));
+  check_error(MPI_Comm_size(comm->comm, &size));
+  OBJ2C(rb_recvbuf, recvcount, recvbuf, recvtype);
+  if (recvcount != sendcount)
+    rb_raise(rb_eArgError, "sendbuf and recvbuf has the same length");
+  if (recvtype != sendtype)
+    rb_raise(rb_eArgError, "sendbuf and recvbuf has the same type");
+  Data_Get_Struct(rb_op, struct _Op, op);
+  check_error(MPI_Allreduce(sendbuf, recvbuf, recvcount, recvtype, op->op, comm->comm));
+  return Qnil;
+}
+static VALUE
+rb_comm_get_Errhandler(VALUE self)
+{
+  struct _Comm *comm;
+  struct _Errhandler *errhandler;
+  VALUE rb_errhandler;
+
+  Data_Get_Struct(self, struct _Comm, comm);
+  rb_errhandler = Data_Make_Struct(cErrhandler, struct _Errhandler, 0, -1, errhandler);
+  MPI_Comm_get_errhandler(comm->comm, &(errhandler->errhandler));
+  return rb_errhandler;
+}
+static VALUE
+rb_comm_set_Errhandler(VALUE self, VALUE rb_errhandler)
+{
+  struct _Comm *comm;
+  struct _Errhandler *errhandler;
+
+  Data_Get_Struct(self, struct _Comm, comm);
+  Data_Get_Struct(rb_errhandler, struct _Errhandler, errhandler);
+  MPI_Comm_set_errhandler(comm->comm, errhandler->errhandler);
+  return self;
+}
+
+// MPI::Request
+static VALUE
+rb_request_wait(VALUE self)
+{
+  MPI_Status *status;
+  struct _Request *request;
+  Data_Get_Struct(self, struct _Request, request);
+  status = ALLOC(MPI_Status);
+  check_error(MPI_Wait(&(request->request), status));
+  return Data_Wrap_Struct(cStatus, 0, -1, status);
+}
+
+// MPI::Errhandler
+static VALUE
+rb_errhandler_eql(VALUE self, VALUE other)
+{
+  struct _Errhandler *eh0, *eh1;
+  Data_Get_Struct(self, struct _Errhandler, eh0);
+  Data_Get_Struct(other, struct _Errhandler, eh1);
+  return eh0->errhandler == eh1->errhandler ? Qtrue : Qfalse;
+}
+
+// MPI::Status
+static VALUE
+rb_status_source(VALUE self)
+{
+  MPI_Status *status;
+  Data_Get_Struct(self, MPI_Status, status);
+  return INT2NUM(status->MPI_SOURCE);
+}
+static VALUE
+rb_status_tag(VALUE self)
+{
+  MPI_Status *status;
+  Data_Get_Struct(self, MPI_Status, status);
+  return INT2NUM(status->MPI_TAG);
+}
+static VALUE
+rb_status_error(VALUE self)
+{
+  MPI_Status *status;
+  Data_Get_Struct(self, MPI_Status, status);
+  return INT2NUM(status->MPI_ERROR);
+}
+
+
+void Init_mpi()
+{
+
+  rb_require("narray");
+
+  atexit(_finalize);
+
+  // MPI
+  mMPI = rb_define_module("MPI");
+  rb_define_module_function(mMPI, "Init", rb_m_init, -1);
+  rb_define_module_function(mMPI, "Finalize", rb_m_finalize, -1);
+  rb_define_const(mMPI, "VERSION", INT2NUM(MPI_VERSION));
+  rb_define_const(mMPI, "SUBVERSION", INT2NUM(MPI_SUBVERSION));
+  rb_define_const(mMPI, "SUCCESS", INT2NUM(MPI_SUCCESS));
+
+  // MPI::Comm
+  cComm = rb_define_class_under(mMPI, "Comm", rb_cObject);
+//  rb_define_alloc_func(cComm, rb_comm_alloc);
+  rb_define_private_method(cComm, "initialize", rb_comm_initialize, 0);
+  rb_define_method(cComm, "rank", rb_comm_rank, 0);
+  rb_define_method(cComm, "size", rb_comm_size, 0);
+  rb_define_method(cComm, "Send", rb_comm_send, 3);
+  rb_define_method(cComm, "Isend", rb_comm_isend, 3);
+  rb_define_method(cComm, "Recv", rb_comm_recv, 3);
+  rb_define_method(cComm, "Irecv", rb_comm_irecv, 3);
+  rb_define_method(cComm, "Gather", rb_comm_gather, 3);
+  rb_define_method(cComm, "Allgather", rb_comm_allgather, 2);
+  rb_define_method(cComm, "Bcast", rb_comm_bcast, 2);
+  rb_define_method(cComm, "Scatter", rb_comm_scatter, 3);
+  rb_define_method(cComm, "Alltoall", rb_comm_alltoall, 2);
+  rb_define_method(cComm, "Reduce", rb_comm_reduce, 4);
+  rb_define_method(cComm, "Allreduce", rb_comm_allreduce, 3);
+  rb_define_method(cComm, "Errhandler", rb_comm_get_Errhandler, 0);
+  rb_define_method(cComm, "Errhandler=", rb_comm_set_Errhandler, 1);
+
+  // MPI::Request
+  cRequest = rb_define_class_under(mMPI, "Request", rb_cObject);
+  rb_define_method(cRequest, "Wait", rb_request_wait, 0);
+
+  // MPI::Op
+  cOp = rb_define_class_under(mMPI, "Op", rb_cObject);
+
+  // MPI::Errhandler
+  cErrhandler = rb_define_class_under(mMPI, "Errhandler", rb_cObject);
+  rb_define_method(cErrhandler, "eql?", rb_errhandler_eql, 1);
+
+  // MPI::Status
+  cStatus = rb_define_class_under(mMPI, "Status", rb_cObject);
+  rb_define_method(cStatus, "source", rb_status_source, 0);
+  rb_define_method(cStatus, "tag", rb_status_tag, 0);
+  rb_define_method(cStatus, "error", rb_status_error, 0);
+
+
+  //MPI::ERR
+  VALUE mERR = rb_define_module_under(mMPI, "ERR");
+  eBUFFER = rb_define_class_under(mERR, "BUFFER", rb_eStandardError);
+  eCOUNT = rb_define_class_under(mERR, "COUNT", rb_eStandardError);
+  eTYPE = rb_define_class_under(mERR, "TYPE", rb_eStandardError);
+  eTAG = rb_define_class_under(mERR, "TAG", rb_eStandardError);
+  eCOMM = rb_define_class_under(mERR, "COMM", rb_eStandardError);
+  eRANK = rb_define_class_under(mERR, "RANK", rb_eStandardError);
+  eREQUEST = rb_define_class_under(mERR, "REQUEST", rb_eStandardError);
+  eROOT = rb_define_class_under(mERR, "ROOT", rb_eStandardError);
+  eGROUP = rb_define_class_under(mERR, "GROUP", rb_eStandardError);
+  eOP = rb_define_class_under(mERR, "OP", rb_eStandardError);
+  eTOPOLOGY = rb_define_class_under(mERR, "TOPOLOGY", rb_eStandardError);
+  eDIMS = rb_define_class_under(mERR, "DIMS", rb_eStandardError);
+  eARG = rb_define_class_under(mERR, "ARG", rb_eStandardError);
+  eUNKNOWN = rb_define_class_under(mERR, "UNKNOWN", rb_eStandardError);
+  eTRUNCATE = rb_define_class_under(mERR, "TRUNCATE", rb_eStandardError);
+  eOTHER = rb_define_class_under(mERR, "OTHER", rb_eStandardError);
+  eINTERN = rb_define_class_under(mERR, "INTERN", rb_eStandardError);
+  eIN_STATUS = rb_define_class_under(mERR, "IN_STATUS", rb_eStandardError);
+  ePENDING = rb_define_class_under(mERR, "PENDING", rb_eStandardError);
+  eACCESS = rb_define_class_under(mERR, "ACCESS", rb_eStandardError);
+  eAMODE = rb_define_class_under(mERR, "AMODE", rb_eStandardError);
+  eASSERT = rb_define_class_under(mERR, "ASSERT", rb_eStandardError);
+  eBAD_FILE = rb_define_class_under(mERR, "BAD_FILE", rb_eStandardError);
+  eBASE = rb_define_class_under(mERR, "BASE", rb_eStandardError);
+  eCONVERSION = rb_define_class_under(mERR, "CONVERSION", rb_eStandardError);
+  eDISP = rb_define_class_under(mERR, "DISP", rb_eStandardError);
+  eDUP_DATAREP = rb_define_class_under(mERR, "DUP_DATAREP", rb_eStandardError);
+  eFILE_EXISTS = rb_define_class_under(mERR, "FILE_EXISTS", rb_eStandardError);
+  eFILE_IN_USE = rb_define_class_under(mERR, "FILE_IN_USE", rb_eStandardError);
+  eFILE = rb_define_class_under(mERR, "FILE", rb_eStandardError);
+  eINFO_KEY = rb_define_class_under(mERR, "INFO_KEY", rb_eStandardError);
+  eINFO_NOKEY = rb_define_class_under(mERR, "INFO_NOKEY", rb_eStandardError);
+  eINFO_VALUE = rb_define_class_under(mERR, "INFO_VALUE", rb_eStandardError);
+  eINFO = rb_define_class_under(mERR, "INFO", rb_eStandardError);
+  eIO = rb_define_class_under(mERR, "IO", rb_eStandardError);
+  eKEYVAL = rb_define_class_under(mERR, "KEYVAL", rb_eStandardError);
+  eLOCKTYPE = rb_define_class_under(mERR, "LOCKTYPE", rb_eStandardError);
+  eNAME = rb_define_class_under(mERR, "NAME", rb_eStandardError);
+  eNO_MEM = rb_define_class_under(mERR, "NO_MEM", rb_eStandardError);
+  eNOT_SAME = rb_define_class_under(mERR, "NOT_SAME", rb_eStandardError);
+  eNO_SPACE = rb_define_class_under(mERR, "NO_SPACE", rb_eStandardError);
+  eNO_SUCH_FILE = rb_define_class_under(mERR, "NO_SUCH_FILE", rb_eStandardError);
+  ePORT = rb_define_class_under(mERR, "PORT", rb_eStandardError);
+  eQUOTA = rb_define_class_under(mERR, "QUOTA", rb_eStandardError);
+  eREAD_ONLY = rb_define_class_under(mERR, "READ_ONLY", rb_eStandardError);
+  eRMA_CONFLICT = rb_define_class_under(mERR, "RMA_CONFLICT", rb_eStandardError);
+  eRMA_SYNC = rb_define_class_under(mERR, "RMA_SYNC", rb_eStandardError);
+  eSERVICE = rb_define_class_under(mERR, "SERVICE", rb_eStandardError);
+  eSIZE = rb_define_class_under(mERR, "SIZE", rb_eStandardError);
+  eSPAWN = rb_define_class_under(mERR, "SPAWN", rb_eStandardError);
+  eUNSUPPORTED_DATAREP = rb_define_class_under(mERR, "UNSUPPORTED_DATAREP", rb_eStandardError);
+  eUNSUPPORTED_OPERATION = rb_define_class_under(mERR, "UNSUPPORTED_OPERATION", rb_eStandardError);
+  eWIN = rb_define_class_under(mERR, "WIN", rb_eStandardError);
+  eLASTCODE = rb_define_class_under(mERR, "LASTCODE", rb_eStandardError);
+  eSYSRESOURCE = rb_define_class_under(mERR, "SYSRESOURCE", rb_eStandardError);
+}

data/lib/mpi.rb

@@ -0,0 +1,6 @@
+begin
+  require "rubygems"
+rescue LoadError
+end
+require "narray"
+require "mpi.so"

data/ruby-mpi.gemspec

@@ -0,0 +1,73 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ruby-mpi}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Seiya Nishizawa"]
+  s.date = %q{2011-04-21}
+  s.description = %q{A ruby binding of Message Passing Interface (MPI), which is an API specification that allows processes to communicate with one another by sending and receiving messages.}
+  s.email = %q{seiya@gfd-dennou.org}
+  s.extensions = ["ext/mpi/extconf.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "ext/mpi/extconf.rb",
+    "ext/mpi/mpi.c",
+    "lib/mpi.rb",
+    "ruby-mpi.gemspec",
+    "samples/hello.rb",
+    "samples/narray.rb",
+    "spec/ruby-mpi_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/seiya/ruby-mpi}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A ruby binding of MPI}
+  s.test_files = [
+    "spec/ruby-mpi_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<narray>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<narray>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<narray>, [">= 0"])
+  end
+end
+

data/samples/hello.rb

@@ -0,0 +1,21 @@
+require "mpi"
+
+MPI.Init
+
+
+world = MPI::Comm::WORLD
+rank = world.rank
+
+if rank == 0
+  (world.size-1).times do |i|
+    str ="\x00"*100
+    world.Recv(str, i+1, 0) 
+    p str
+  end
+else
+  message = "Hello from #{rank}"
+  world.Send(message, 0, 0)
+end
+
+
+MPI.Finalize

data/samples/narray.rb

@@ -0,0 +1,20 @@
+require "mpi"
+
+MPI.Init
+
+
+world = MPI::Comm::WORLD
+rank = world.rank
+
+if rank == 0
+  (world.size-1).times do |i|
+    a = NArray.float(2)
+    world.Recv(a, i+1, 1)
+    p a
+  end
+else
+  world.Send(NArray[1.0,2], 0, 1)
+end
+
+
+MPI.Finalize

data/spec/ruby-mpi_spec.rb

@@ -0,0 +1,192 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "MPI" do
+  before(:all) do
+    MPI.Init()
+  end
+  after(:all) do
+    MPI.Finalize()
+  end
+
+  it "should give version" do
+    MPI.constants.should include("VERSION")
+    MPI.constants.should include("SUBVERSION")
+    MPI::VERSION.class.should eql(Fixnum)
+    MPI::SUBVERSION.class.should eql(Fixnum)
+  end
+
+  it "should have Comm:WORLD" do
+    MPI::Comm.constants.should include("WORLD")
+    world = MPI::Comm::WORLD
+    world.rank.class.should eql(Fixnum)
+    world.size.class.should eql(Fixnum)
+    world.size.should > 0
+  end
+
+  it "should send and receive String" do
+    world = MPI::Comm::WORLD
+    message = "Hello from #{world.rank}"
+    tag = 0
+    world.Send(message, 0, tag)
+    if world.rank == 0
+      world.size.times do |i|
+        str = " "*30
+        status = world.Recv(str, i, tag)
+        status.source.should eql(i)
+        status.tag.should eql(tag)
+        status.error.should eq(MPI::SUCCESS)
+        str.should match(/\AHello from #{i}+/)
+      end
+    end
+  end
+
+  it "should send and receive NArray" do
+    world = MPI::Comm::WORLD
+    tag = 0
+    [NArray[1,2,3], NArray[3.0,2.0,1.0]].each do |ary0|
+      ary0 = NArray[1,2,3]
+      world.Send(ary0, 0, tag)
+      if world.rank == 0
+        world.size.times do |i|
+          ary1 = NArray.new(ary0.typecode, ary0.total)
+          status = world.Recv(ary1, i, tag)
+          status.source.should eql(i)
+          status.tag.should eql(tag)
+          status.error.should eq(MPI::SUCCESS)
+          ary1.should == ary0
+        end
+      end
+    end
+  end
+
+  it "should send and receive without blocking" do
+    world = MPI::Comm::WORLD
+    message = "Hello from #{world.rank}"
+    tag = 0
+    request = world.Isend(message, 0, tag)
+    status = request.Wait
+    status.source.should eql(world.rank)
+    status.tag.should eql(tag)
+    if world.rank == 0
+      world.size.times do |i|
+        str = " "*30
+        request = world.Irecv(str, i, tag)
+        status = request.Wait
+        status.source.should eql(i)
+        status.tag.should eql(tag)
+        str.should match(/\AHello from #{i}+/)
+      end
+    end
+  end
+
+  it "should gather data" do
+    world = MPI::Comm::WORLD
+    rank = world.rank
+    size = world.size
+    root = 0
+    bufsize = 2
+    sendbuf = rank.to_s*bufsize
+    recvbuf = rank == root ? "?"*bufsize*size  : nil
+    world.Gather(sendbuf, recvbuf, root)
+    if rank == root
+      str = ""
+      size.times{|i| str << i.to_s*bufsize}
+      recvbuf.should eql(str)
+    end
+  end
+
+  it "should gather data to all processes (allgather)" do
+    world = MPI::Comm::WORLD
+    rank = world.rank
+    size = world.size
+    bufsize = 2
+    sendbuf = rank.to_s*bufsize
+    recvbuf = "?"*bufsize*size
+    world.Allgather(sendbuf, recvbuf)
+    str = ""
+    size.times{|i| str << i.to_s*bufsize}
+    recvbuf.should eql(str)
+  end
+
+  it "should broad cast data (bcast)" do
+    world = MPI::Comm::WORLD
+    rank = world.rank
+    root = 0
+    bufsize = 2
+    if rank == root
+      buffer = rank.to_s*bufsize
+    else
+      buffer = " "*bufsize
+    end
+    world.Bcast(buffer, root)
+    buffer.should eql(root.to_s*bufsize)
+  end
+
+  it "should scatter data" do
+    world = MPI::Comm::WORLD
+    rank = world.rank
+    size = world.size
+    root = 0
+    bufsize = 2
+    if rank == root
+      sendbuf = ""
+      size.times{|i| sendbuf << i.to_s*bufsize}
+    else
+      sendbuf = nil
+    end
+    recvbuf = " "*bufsize
+    world.Scatter(sendbuf, recvbuf, root)
+    recvbuf.should eql(rank.to_s*bufsize)
+  end
+
+  it "should change data between each others (alltoall)" do
+    world = MPI::Comm::WORLD
+    rank = world.rank
+    size = world.size
+    bufsize = 2
+    sendbuf = rank.to_s*bufsize*size
+    recvbuf = "?"*bufsize*size
+    world.Alltoall(sendbuf, recvbuf)
+    str = ""
+    size.times{|i| str << i.to_s*bufsize}
+    recvbuf.should eql(str)
+  end
+
+  it "should reduce data" do
+    world = MPI::Comm::WORLD
+    rank = world.rank
+    size = world.size
+    root = 0
+    bufsize = 2
+    sendbuf = NArray.to_na([rank]*bufsize)
+    recvbuf = rank == root ? NArray.new(sendbuf.typecode,bufsize) : nil
+    world.Reduce(sendbuf, recvbuf, MPI::Op::SUM, root)
+    if rank == root
+      ary = NArray.new(sendbuf.typecode,bufsize).fill(size*(size-1)/2.0)
+      recvbuf.should == ary
+    end
+  end
+
+  it "should reduce data and send to all processes (allreduce)" do
+    world = MPI::Comm::WORLD
+    rank = world.rank
+    size = world.size
+    bufsize = 2
+    sendbuf = NArray.to_na([rank]*bufsize)
+    recvbuf = NArray.new(sendbuf.typecode,bufsize)
+    world.Allreduce(sendbuf, recvbuf, MPI::Op::SUM)
+    ary = NArray.new(sendbuf.typecode,bufsize).fill(size*(size-1)/2.0)
+    recvbuf.should == ary
+  end
+
+
+
+
+  it "shoud raise exeption" do
+    world = MPI::Comm::WORLD
+    lambda{ world.Send("", -1, 0) }.should raise_error(MPI::ERR::RANK)
+    lambda{ world.Send("", world.size+1, 0) }.should raise_error(MPI::ERR::RANK)
+    world.Errhandler.should eql(MPI::Errhandler::ERRORS_RETURN)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'ext', 'mpi'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'mpi'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-mpi
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Seiya Nishizawa
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-21 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: rspec
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  requirement: *id001
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: bundler
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id002
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id003
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: rcov
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: narray
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id005
+  type: :development
+description: A ruby binding of Message Passing Interface (MPI), which is an API specification that allows processes to communicate with one another by sending and receiving messages.
+email: seiya@gfd-dennou.org
+executables: []
+
+extensions: 
+- ext/mpi/extconf.rb
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- ext/mpi/extconf.rb
+- ext/mpi/mpi.c
+- lib/mpi.rb
+- ruby-mpi.gemspec
+- samples/hello.rb
+- samples/narray.rb
+- spec/ruby-mpi_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/seiya/ruby-mpi
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A ruby binding of MPI
+test_files: 
+- spec/ruby-mpi_spec.rb
+- spec/spec_helper.rb