ruby-mpi 0.1.0 → 0.2.0

data/README.rdoc

@@ -1,8 +1,12 @@
-= ruby-mpi
+= Ruby-MPI
 
-Description goes here.
+Ruby-MPI is 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.
 
-== Contributing to ruby-mpi
+== Install
+
+ # gem install ruby-mpi
+
+== 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

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/ext/mpi/mpi.c

@@ -53,22 +53,43 @@ 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;
+  MPI_Comm Comm;
 };
 struct _Request {
-  MPI_Request request;
+  MPI_Request Request;
 };
 struct _Op {
-  MPI_Op op;
+  MPI_Op Op;
 };
 struct _Errhandler {
-  MPI_Errhandler errhandler;
+  MPI_Errhandler Errhandler;
 };
 
 static bool _initialized = false;
 static bool _finalized = false;
 
 
+#define DEF_FREE(name) \
+static void \
+name ## _free(void *ptr)\
+{\
+  struct _ ## name *obj;\
+  obj = (struct _ ## name*) ptr;\
+  if (!_finalized)\
+    MPI_ ## name ## _free(&(obj->name)); \
+  free(obj);\
+}
+DEF_FREE(Comm)
+DEF_FREE(Request)
+DEF_FREE(Op)
+DEF_FREE(Errhandler)
+static void
+Status_free(void *ptr)
+{
+  free((MPI_Status*) ptr);
+}
+
+
 #define CAE_ERR(type) case MPI_ERR_ ## type: rb_raise(e ## type,""); break
 static void
 check_error(int error)
@@ -129,19 +150,29 @@ check_error(int error)
     CAE_ERR(UNSUPPORTED_OPERATION);
     CAE_ERR(WIN);
     CAE_ERR(LASTCODE);
+#ifdef MPI_ERR_SYSRESOURCE
     CAE_ERR(SYSRESOURCE);
+#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown error");
   }
 }
 
-#define DEF_CONST(st, v, const, name, klass) \
+#define DEF_CONST(v, const, name) \
 {\
-  v = ALLOC(struct st);\
+  v = ALLOC(struct _ ## v);\
   v->v = const;\
-  rb_define_const(klass, #name, Data_Wrap_Struct(klass, 0, -1, v));	\
+  rb_define_const(c ## v, #name, Data_Wrap_Struct(c ## v, NULL, v ## _free, v));	\
 }
 
+static void
+_finalize()
+{
+  if(_initialized && !_finalized) {
+    _finalized = true;
+    check_error(MPI_Finalize());
+  }
+}
 static VALUE
 rb_m_init(int argc, VALUE *argv, VALUE self)
 {
@@ -151,11 +182,6 @@ rb_m_init(int argc, VALUE *argv, VALUE self)
   VALUE progname;
   int i;
 
-  if (_initialized)
-    return self;
-  else
-    _initialized = true;
-
   rb_scan_args(argc, argv, "01", &argary);
 
   if (NIL_P(argary)) {
@@ -178,45 +204,44 @@ rb_m_init(int argc, VALUE *argv, VALUE self)
   }
   cargc++;
 
-  MPI_Init(&cargc, &cargv);
+  check_error(MPI_Init(&cargc, &cargv));
+  if (_initialized)
+    return self;
+  else
+    _initialized = true;
+  atexit(_finalize);
+
+
 
   // define MPI::Comm::WORLD
-  struct _Comm *comm;
-  DEF_CONST(_Comm, comm, MPI_COMM_WORLD, WORLD, cComm);
+  struct _Comm *Comm;
+  DEF_CONST(Comm, MPI_COMM_WORLD, WORLD);
   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);
+  struct _Op *Op;
+  DEF_CONST(Op, MPI_MAX, MAX);
+  DEF_CONST(Op, MPI_MIN, MIN);
+  DEF_CONST(Op, MPI_SUM, SUM);
+  DEF_CONST(Op, MPI_PROD, PROD);
+  DEF_CONST(Op, MPI_LAND, LAND);
+  DEF_CONST(Op, MPI_BAND, BAND);
+  DEF_CONST(Op, MPI_LOR, LOR);
+  DEF_CONST(Op, MPI_BOR, BOR);
+  DEF_CONST(Op, MPI_LXOR, LXOR);
+  DEF_CONST(Op, MPI_BXOR, BXOR);
+  DEF_CONST(Op, MPI_MAXLOC, MAXLOC);
+  DEF_CONST(Op, MPI_MINLOC, MINLOC);
+  DEF_CONST(Op, MPI_REPLACE, REPLACE);
 
   // 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);
+  struct _Errhandler *Errhandler;
+  DEF_CONST(Errhandler, MPI_ERRORS_ARE_FATAL, ERRORS_ARE_FATAL);
+  DEF_CONST(Errhandler, MPI_ERRORS_RETURN, ERRORS_RETURN);
 
   return self;
 }
 
-static void
-_finalize()
-{
-  if(_initialized && !_finalized) {
-    _finalized = true;
-    check_error(MPI_Finalize());
-  }
-}
 static VALUE
 rb_m_finalize(VALUE self)
 {
@@ -230,7 +255,7 @@ static VALUE
 rb_comm_alloc(VALUE klass)
 {
   struct _Comm *ptr = ALLOC(struct _Comm);
-  return Data_Wrap_Struct(klass, 0, -1, ptr);
+  return Data_Wrap_Struct(klass, NULL, Comm_free, ptr);
 }
 static VALUE
 rb_comm_initialize(VALUE self)
@@ -244,7 +269,7 @@ 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));
+  check_error(MPI_Comm_size(comm->Comm, &size));
   return INT2NUM(size);
 }
 static VALUE
@@ -253,7 +278,7 @@ 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));
+  check_error(MPI_Comm_rank(comm->Comm, &rank));
   return INT2NUM(rank);
 }
 static VALUE
@@ -268,7 +293,7 @@ rb_comm_send(VALUE self, VALUE rb_obj, VALUE rb_dest, VALUE rb_tag)
   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));
+  check_error(MPI_Send(buffer, len, type, dest, tag, comm->Comm));
 
   return Qnil;
 }
@@ -286,8 +311,8 @@ rb_comm_isend(VALUE self, VALUE rb_obj, VALUE rb_dest, VALUE rb_tag)
   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)));
+  rb_request = Data_Make_Struct(cRequest, struct _Request, NULL, Request_free, request);
+  check_error(MPI_Isend(buffer, len, type, dest, tag, comm->Comm, &(request->Request)));
 
   return rb_request;
 }
@@ -306,9 +331,9 @@ rb_comm_recv(VALUE self, VALUE rb_obj, VALUE rb_source, VALUE 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));
+  check_error(MPI_Recv(buffer, len, type, source, tag, comm->Comm, status));
 
-  return Data_Wrap_Struct(cStatus, 0, -1, status);
+  return Data_Wrap_Struct(cStatus, NULL, Status_free, status);
 }
 static VALUE
 rb_comm_irecv(VALUE self, VALUE rb_obj, VALUE rb_source, VALUE rb_tag)
@@ -324,8 +349,8 @@ rb_comm_irecv(VALUE self, VALUE rb_obj, VALUE rb_source, VALUE rb_tag)
   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)));
+  rb_request = Data_Make_Struct(cRequest, struct _Request, NULL, Request_free, request);
+  check_error(MPI_Irecv(buffer, len, type, source, tag, comm->Comm, &(request->Request)));
 
   return rb_request;
 }
@@ -340,15 +365,15 @@ rb_comm_gather(VALUE self, VALUE rb_sendbuf, VALUE rb_recvbuf, VALUE rb_root)
   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));
+  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));
+  check_error(MPI_Gather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm->Comm));
   return Qnil;
 }
 static VALUE
@@ -361,13 +386,13 @@ rb_comm_allgather(VALUE self, VALUE rb_sendbuf, VALUE rb_recvbuf)
   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));
+  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));
+  check_error(MPI_Allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm->Comm));
   return Qnil;
 }
 static VALUE
@@ -381,7 +406,7 @@ rb_comm_bcast(VALUE self, VALUE rb_buffer, VALUE rb_root)
   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));
+  check_error(MPI_Bcast(buffer, count, type, root, comm->Comm));
   return Qnil;
 }
 static VALUE
@@ -395,35 +420,57 @@ rb_comm_scatter(VALUE self, VALUE rb_sendbuf, VALUE rb_recvbuf, VALUE rb_root)
   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));
+  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));
+  check_error(MPI_Scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm->Comm));
   return Qnil;
 }
 static VALUE
+rb_comm_sendrecv(VALUE self, VALUE rb_sendbuf, VALUE rb_dest, VALUE rb_sendtag, VALUE rb_recvbuf, VALUE rb_source, VALUE rb_recvtag)
+{
+  void *sendbuf, *recvbuf;
+  int sendcount, recvcount;
+  MPI_Datatype sendtype, recvtype;
+  int dest, source;
+  int sendtag, recvtag;
+  int size;
+  struct _Comm *comm;
+  MPI_Status *status;
+  OBJ2C(rb_sendbuf, sendcount, sendbuf, sendtype);
+  Data_Get_Struct(self, struct _Comm, comm);
+  check_error(MPI_Comm_size(comm->Comm, &size));
+  OBJ2C(rb_recvbuf, recvcount, recvbuf, recvtype);
+  dest = NUM2INT(rb_dest);
+  source = NUM2INT(rb_source);
+  sendtag = NUM2INT(rb_sendtag);
+  recvtag = NUM2INT(rb_recvtag);
+  status = ALLOC(MPI_Status);
+  check_error(MPI_Sendrecv(sendbuf, sendcount, sendtype, dest, sendtag, recvbuf, recvcount, recvtype, source, recvtag, comm->Comm, status));
+  return Data_Wrap_Struct(cStatus, NULL, Status_free, status);
+}
+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;
+  int 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));
+  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));
+  check_error(MPI_Alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm->Comm));
   return Qnil;
 }
 static VALUE
@@ -438,8 +485,8 @@ rb_comm_reduce(VALUE self, VALUE rb_sendbuf, VALUE rb_recvbuf, VALUE rb_op, VALU
   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));
+  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)
@@ -448,7 +495,7 @@ rb_comm_reduce(VALUE self, VALUE rb_sendbuf, VALUE rb_recvbuf, VALUE rb_op, VALU
       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));
+  check_error(MPI_Reduce(sendbuf, recvbuf, sendcount, sendtype, op->Op, root, comm->Comm));
   return Qnil;
 }
 static VALUE
@@ -462,15 +509,15 @@ rb_comm_allreduce(VALUE self, VALUE rb_sendbuf, VALUE rb_recvbuf, VALUE rb_op)
   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));
+  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));
+  check_error(MPI_Allreduce(sendbuf, recvbuf, recvcount, recvtype, op->Op, comm->Comm));
   return Qnil;
 }
 static VALUE
@@ -481,8 +528,8 @@ rb_comm_get_Errhandler(VALUE self)
   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));
+  rb_errhandler = Data_Make_Struct(cErrhandler, struct _Errhandler, NULL, Errhandler_free, errhandler);
+  MPI_Comm_get_errhandler(comm->Comm, &(errhandler->Errhandler));
   return rb_errhandler;
 }
 static VALUE
@@ -493,7 +540,15 @@ rb_comm_set_Errhandler(VALUE self, VALUE rb_errhandler)
 
   Data_Get_Struct(self, struct _Comm, comm);
   Data_Get_Struct(rb_errhandler, struct _Errhandler, errhandler);
-  MPI_Comm_set_errhandler(comm->comm, errhandler->errhandler);
+  MPI_Comm_set_errhandler(comm->Comm, errhandler->Errhandler);
+  return self;
+}
+static VALUE
+rb_comm_barrier(VALUE self)
+{
+  struct _Comm *comm;
+  Data_Get_Struct(self, struct _Comm, comm);
+  check_error(MPI_Barrier(comm->Comm));
   return self;
 }
 
@@ -505,8 +560,8 @@ rb_request_wait(VALUE self)
   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);
+  check_error(MPI_Wait(&(request->Request), status));
+  return Data_Wrap_Struct(cStatus, NULL, Status_free, status);
 }
 
 // MPI::Errhandler
@@ -516,7 +571,7 @@ 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;
+  return eh0->Errhandler == eh1->Errhandler ? Qtrue : Qfalse;
 }
 
 // MPI::Status
@@ -548,8 +603,6 @@ void Init_mpi()
 
   rb_require("narray");
 
-  atexit(_finalize);
-
   // MPI
   mMPI = rb_define_module("MPI");
   rb_define_module_function(mMPI, "Init", rb_m_init, -1);
@@ -557,6 +610,7 @@ void Init_mpi()
   rb_define_const(mMPI, "VERSION", INT2NUM(MPI_VERSION));
   rb_define_const(mMPI, "SUBVERSION", INT2NUM(MPI_SUBVERSION));
   rb_define_const(mMPI, "SUCCESS", INT2NUM(MPI_SUCCESS));
+  rb_define_const(mMPI, "PROC_NULL", INT2NUM(MPI_PROC_NULL));
 
   // MPI::Comm
   cComm = rb_define_class_under(mMPI, "Comm", rb_cObject);
@@ -572,11 +626,13 @@ void Init_mpi()
   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, "Sendrecv", rb_comm_sendrecv, 6);
   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);
+  rb_define_method(cComm, "Barrier", rb_comm_barrier, 0);
 
   // MPI::Request
   cRequest = rb_define_class_under(mMPI, "Request", rb_cObject);

data/ruby-mpi.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ruby-mpi}
-  s.version = "0.1.0"
+  s.version = "0.2.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.date = %q{2011-04-22}
   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"]
@@ -38,7 +38,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/seiya/ruby-mpi}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
+  s.rubygems_version = %q{1.7.2}
   s.summary = %q{A ruby binding of MPI}
   s.test_files = [
     "spec/ruby-mpi_spec.rb",
@@ -46,7 +46,6 @@ Gem::Specification.new do |s|
   ]
 
   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

data/spec/ruby-mpi_spec.rb

@@ -8,49 +8,49 @@ describe "MPI" do
     MPI.Finalize()
   end
 
+  before do
+    @world = MPI::Comm::WORLD
+  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
+  it "should give rank and size" do
+    @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}"
+    rank = @world.rank
+    message = "Hello from #{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)
+    @world.Send(message, 0, tag) if rank != 0
+    if rank == 0
+      (@world.size-1).times do |i|
+        str = " "*"Hello from #{i+1}".length
+        status = @world.Recv(str, i+1, tag)
+        status.source.should eql(i+1)
         status.tag.should eql(tag)
         status.error.should eq(MPI::SUCCESS)
-        str.should match(/\AHello from #{i}+/)
+        str.should match(/\AHello from #{i+1}/)
       end
     end
   end
 
   it "should send and receive NArray" do
-    world = MPI::Comm::WORLD
     tag = 0
+    rank = @world.rank
     [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|
+      @world.Send(ary0, 0, tag) if rank != 0
+      if rank == 0
+        (@world.size-1).times do |i|
           ary1 = NArray.new(ary0.typecode, ary0.total)
-          status = world.Recv(ary1, i, tag)
-          status.source.should eql(i)
+          status = @world.Recv(ary1, i+1, tag)
+          status.source.should eql(i+1)
           status.tag.should eql(tag)
           status.error.should eq(MPI::SUCCESS)
           ary1.should == ary0
@@ -60,34 +60,35 @@ describe "MPI" do
   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)
+    rank = @world.rank
+    message = "Hello from #{rank}"
+    if rank != 0
+      request = @world.Isend(message, 0, tag)
+      status = request.Wait
+#      status.source.should eql(rank)
+      status.tag.should eql(tag)
+    end
+    if rank == 0
+      (@world.size-1).times do |i|
+        str = " "*"Hello from #{i+1}".length
+        request_recv = @world.Irecv(str, i+1, tag)
+        status = request_recv.Wait
+        status.source.should eql(i+1)
         status.tag.should eql(tag)
-        str.should match(/\AHello from #{i}+/)
+        str.should match(/\AHello from #{i+1}/)
       end
     end
   end
 
   it "should gather data" do
-    world = MPI::Comm::WORLD
-    rank = world.rank
-    size = world.size
+    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)
+    @world.Gather(sendbuf, recvbuf, root)
     if rank == root
       str = ""
       size.times{|i| str << i.to_s*bufsize}
@@ -96,21 +97,19 @@ describe "MPI" do
   end
 
   it "should gather data to all processes (allgather)" do
-    world = MPI::Comm::WORLD
-    rank = world.rank
-    size = world.size
+    rank = @world.rank
+    size = @world.size
     bufsize = 2
     sendbuf = rank.to_s*bufsize
     recvbuf = "?"*bufsize*size
-    world.Allgather(sendbuf, recvbuf)
+    @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
+    rank = @world.rank
     root = 0
     bufsize = 2
     if rank == root
@@ -118,14 +117,13 @@ describe "MPI" do
     else
       buffer = " "*bufsize
     end
-    world.Bcast(buffer, root)
+    @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
+    rank = @world.rank
+    size = @world.size
     root = 0
     bufsize = 2
     if rank == root
@@ -135,32 +133,50 @@ describe "MPI" do
       sendbuf = nil
     end
     recvbuf = " "*bufsize
-    world.Scatter(sendbuf, recvbuf, root)
+    @world.Scatter(sendbuf, recvbuf, root)
     recvbuf.should eql(rank.to_s*bufsize)
   end
 
+  it "should send and recv data (sendrecv)" do
+    rank = @world.rank
+    size = @world.size
+    dest = rank-1
+    dest = size-1 if dest < 0
+    #dest = MPI::PROC_NULL if dest < 0
+    source = rank+1
+    source = 0 if source > size-1
+    #source = MPI::PROC_NULL if source > size-1
+    sendtag = rank
+    recvtag = source
+    bufsize = 2
+    sendbuf = rank.to_s*bufsize
+    recvbuf = " "*bufsize
+    @world.Sendrecv(sendbuf, dest, sendtag, recvbuf, source, recvtag);
+    if source != MPI::PROC_NULL
+      recvbuf.should  eql(source.to_s*bufsize)
+    end
+  end
+
   it "should change data between each others (alltoall)" do
-    world = MPI::Comm::WORLD
-    rank = world.rank
-    size = world.size
+    rank = @world.rank
+    size = @world.size
     bufsize = 2
     sendbuf = rank.to_s*bufsize*size
     recvbuf = "?"*bufsize*size
-    world.Alltoall(sendbuf, recvbuf)
+    @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
+    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)
+    @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
@@ -168,25 +184,24 @@ describe "MPI" do
   end
 
   it "should reduce data and send to all processes (allreduce)" do
-    world = MPI::Comm::WORLD
-    rank = world.rank
-    size = world.size
+    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)
+    @world.Allreduce(sendbuf, recvbuf, MPI::Op::SUM)
     ary = NArray.new(sendbuf.typecode,bufsize).fill(size*(size-1)/2.0)
     recvbuf.should == ary
   end
 
-
+  it "should not raise exception in calling barrier" do
+    @world.Barrier
+  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)
+    lambda{ @world.Send("", @world.size+1, 0) }.should raise_error(MPI::ERR::RANK)
+    @world.Errhandler.should eql(MPI::Errhandler::ERRORS_RETURN)
   end
 
 end

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-mpi
 version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
+  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors: 
 - Seiya Nishizawa
@@ -15,85 +10,63 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-21 00:00:00 +09:00
-default_executable: 
+date: 2011-04-22 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  prerelease: false
   name: rspec
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  requirement: &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
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: bundler
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  requirement: &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
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: jeweler
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  requirement: &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
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: rcov
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
+  requirement: &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
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
   name: narray
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
-  requirement: *id005
   type: :development
+  prerelease: false
+  version_requirements: *id005
 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: []
@@ -120,7 +93,6 @@ files:
 - samples/narray.rb
 - spec/ruby-mpi_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/seiya/ruby-mpi
 licenses: 
 - MIT
@@ -134,7 +106,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: -3549605766415082841
       segments: 
       - 0
       version: "0"
@@ -143,14 +115,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: A ruby binding of MPI