MPI.py (49534B)
1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\carbon\common\lib\MPI.py 2 __docformat__ = 'reStructuredText' 3 __author__ = 'Lisandro Dalcin' 4 __credits__ = 'MPI Forum, MPICH Team, Open MPI Team.' 5 __date__ = '13 Oct 2006' 6 __version__ = '0.4.0' 7 __revision__ = '$Id: MPI.py 23 2007-02-24 00:18:19Z dalcinl $' 8 import mpilib, _mpi, _pickle, _marshal 9 import _op 10 11 class Pickle(object): 12 PROTOCOL = _pickle.HIGH_PROT 13 dump = classmethod(_pickle.dump) 14 load = classmethod(_pickle.load) 15 16 def __new__(cls, *targs, **kargs): 17 from types import MethodType as method 18 pkl = object.__new__(cls) 19 if cls is Pickle or 'dump' not in cls.__dict__: 20 pkl.dump = method(_pickle.dump, pkl, cls) 21 if cls is Pickle or 'load' not in cls.__dict__: 22 pkl.load = method(_pickle.load, pkl, cls) 23 return pkl 24 25 def __init__(self, protocol = _pickle.HIGH_PROT): 26 self.PROTOCOL = protocol 27 28 29 class Marshal(object): 30 PROTOCOL = _marshal.VERSION 31 dump = classmethod(_marshal.dump) 32 load = classmethod(_marshal.load) 33 34 def __new__(cls, *targs, **kargs): 35 from types import MethodType as method 36 msh = object.__new__(cls) 37 if cls is Marshal or 'dump' not in cls.__dict__: 38 msh.dump = method(_marshal.dump, msh, cls) 39 if cls is Marshal or 'load' not in cls.__dict__: 40 msh.load = method(_marshal.load, msh, cls) 41 return msh 42 43 def __init__(self, protocol = _marshal.VERSION): 44 self.PROTOCOL = protocol 45 46 47 def Buffer(*args): 48 data = None 49 count = None 50 datatype = BYTE 51 if args: 52 if len(args) == 1: 53 data, = args 54 if len(args) == 2: 55 data, datatype = args 56 elif len(args) == 3: 57 data, count, datatype = args 58 else: 59 raise TypeError('Buffer() takes at most 3 arguments (%d given))' % (len(args) + 1)) 60 return (data, count, datatype) 61 62 63 UNDEFINED = _mpi.UNDEFINED 64 PROC_NULL = _mpi.PROC_NULL 65 ANY_SOURCE = _mpi.ANY_SOURCE 66 ROOT = _mpi.ROOT 67 ANY_TAG = _mpi.ANY_TAG 68 BSEND_OVERHEAD = _mpi.BSEND_OVERHEAD 69 BOTTOM = _mpi.BOTTOM 70 IN_PLACE = _mpi.IN_PLACE 71 CART = _mpi.CART 72 GRAPH = _mpi.GRAPH 73 IDENT = _mpi.IDENT 74 CONGRUENT = _mpi.CONGRUENT 75 SIMILAR = _mpi.SIMILAR 76 UNEQUAL = _mpi.UNEQUAL 77 ORDER_C = _mpi.ORDER_C 78 ORDER_FORTRAN = _mpi.ORDER_FORTRAN 79 DISTRIBUTE_NONE = _mpi.DISTRIBUTE_NONE 80 DISTRIBUTE_BLOCK = _mpi.DISTRIBUTE_BLOCK 81 DISTRIBUTE_CYCLIC = _mpi.DISTRIBUTE_CYCLIC 82 DISTRIBUTE_DFLT_DARG = _mpi.DISTRIBUTE_DFLT_DARG 83 84 class Datatype(_mpi.Datatype): 85 86 def __init__(self, datatype = None): 87 _mpi.Datatype.__init__(self, datatype) 88 89 def Get_extent(self): 90 return _mpi.type_get_extent(self) 91 92 def Get_size(self): 93 return _mpi.type_size(self) 94 95 def Dup(self): 96 newtype = _mpi.type_dup(self) 97 return type(self)(newtype) 98 99 def Create_contiguous(self, count): 100 newtype = _mpi.type_contiguous(count, self) 101 return type(self)(newtype) 102 103 def Create_vector(self, count, blocklength, stride): 104 newtype = _mpi.type_vector(count, blocklength, stride, self) 105 return type(self)(newtype) 106 107 def Create_hvector(self, count, blocklength, stride): 108 newtype = _mpi.type_hvector(count, blocklength, stride, self) 109 return type(self)(newtype) 110 111 def Create_indexed(self, blocklengths, displacements): 112 newtype = _mpi.type_indexed(blocklengths, displacements, self) 113 return type(self)(newtype) 114 115 def Create_indexed_block(self, blocklength, displacements): 116 newtype = _mpi.type_indexed_block(blocklength, displacements, self) 117 return type(self)(newtype) 118 119 def Create_hindexed(self, blocklengths, displacements): 120 newtype = _mpi.type_hindexed(blocklengths, displacements, self) 121 return type(self)(newtype) 122 123 def Create_subarray(self, sizes, subsizes, starts, order = None): 124 newtype = _mpi.type_subarray(sizes, subsizes, starts, order, self) 125 return type(self)(newtype) 126 127 def Create_darray(self, size, rank, gsizes, distribs, dargs, psizes, order = None): 128 newtype = _mpi.type_darray(size, rank, gsizes, distribs, dargs, psizes, order, self) 129 return type(self)(newtype) 130 131 def Create_struct(cls, blocklengths, displacements, datatypes): 132 newtype = _mpi.type_struct(blocklengths, displacements, datatypes) 133 return cls(newtype) 134 135 Create_struct = classmethod(Create_struct) 136 137 def Commit(self): 138 _mpi.type_commit(self) 139 140 def Free(self): 141 _mpi.type_free(self) 142 143 def Create_resized(self, lb, extent): 144 newtype = _mpi.type_resized(self, lb, extent) 145 return type(self)(newtype) 146 147 Resized = Create_resized 148 149 def Get_true_extent(self): 150 return _mpi.type_true_extent(self) 151 152 def Pack(self, inbuf, outbuf, position, comm): 153 return _mpi.pack(inbuf, self, outbuf, position, comm) 154 155 def Unpack(self, inbuf, position, outbuf, comm): 156 return _mpi.unpack(inbuf, position, outbuf, self, comm) 157 158 def Pack_size(self, count, comm): 159 return _mpi.pack_size(count, self, comm) 160 161 def Pack_external(self, datarep, inbuf, outbuf, position): 162 return _mpi.pack_external(datarep, inbuf, self, outbuf, position) 163 164 def Unpack_external(self, datarep, inbuf, position, outbuf): 165 return _mpi.unpack_external(datarep, inbuf, position, outbuf, self) 166 167 def Pack_external_size(self, datarep, count): 168 return _mpi.pack_external_size(datarep, count, self) 169 170 def Get_name(self): 171 return _mpi.type_get_name(self) 172 173 def Set_name(self, name): 174 return _mpi.type_set_name(self, name) 175 176 size = property(_mpi.type_size, doc='datatype size, in bytes.') 177 extent = property(_mpi.type_ex, doc='datatype extent.') 178 lb = property(_mpi.type_lb, doc='datatype lower bound.') 179 ub = property(_mpi.type_ub, doc='datatype upper bound.') 180 name = property(_mpi.type_get_name, _mpi.type_set_name, doc='datatype name') 181 182 183 DATATYPE_NULL = Datatype(_mpi.DATATYPE_NULL) 184 CHAR = Datatype(_mpi.CHAR) 185 WCHAR = Datatype(_mpi.WCHAR) 186 SIGNED_CHAR = Datatype(_mpi.SIGNED_CHAR) 187 UNSIGNED_CHAR = Datatype(_mpi.UNSIGNED_CHAR) 188 SHORT = Datatype(_mpi.SHORT) 189 UNSIGNED_SHORT = Datatype(_mpi.UNSIGNED_SHORT) 190 INT = Datatype(_mpi.INT) 191 UNSIGNED = Datatype(_mpi.UNSIGNED) 192 LONG = Datatype(_mpi.LONG) 193 UNSIGNED_LONG = Datatype(_mpi.UNSIGNED_LONG) 194 FLOAT = Datatype(_mpi.FLOAT) 195 DOUBLE = Datatype(_mpi.DOUBLE) 196 LONG_DOUBLE = Datatype(_mpi.LONG_DOUBLE) 197 BYTE = Datatype(_mpi.BYTE) 198 PACKED = Datatype(_mpi.PACKED) 199 SHORT_INT = Datatype(_mpi.SHORT_INT) 200 TWOINT = Datatype(_mpi.TWOINT) 201 INT_INT = Datatype(_mpi.INT_INT) 202 LONG_INT = Datatype(_mpi.LONG_INT) 203 FLOAT_INT = Datatype(_mpi.FLOAT_INT) 204 DOUBLE_INT = Datatype(_mpi.DOUBLE_INT) 205 LONG_DOUBLE_INT = Datatype(_mpi.LONG_DOUBLE_INT) 206 LONG_LONG = Datatype(_mpi.LONG_LONG) 207 LONG_LONG_INT = Datatype(_mpi.LONG_LONG_INT) 208 UNSIGNED_LONG_LONG = Datatype(_mpi.UNSIGNED_LONG_LONG) 209 UB = Datatype(_mpi.UB) 210 LB = Datatype(_mpi.LB) 211 212 def Get_address(location): 213 return _mpi.get_address(location) 214 215 216 def Alloc_mem(size, info = None): 217 return _mpi.alloc_mem(size, info) 218 219 220 def Free_mem(base): 221 return _mpi.free_mem(base) 222 223 224 def Attach_buffer(buf): 225 return _mpi.buffer_attach(buf) 226 227 228 def Detach_buffer(): 229 return _mpi.buffer_detach() 230 231 232 class Status(_mpi.Status): 233 234 def __init__(self, status = None): 235 _mpi.Status.__init__(self, status) 236 237 def Get_source(self): 238 return self.MPI_SOURCE 239 240 def Get_tag(self): 241 return self.MPI_TAG 242 243 def Get_error(self): 244 return self.MPI_ERROR 245 246 def Set_source(self, source): 247 self.MPI_SOURCE = source 248 249 def Set_tag(self, tag): 250 self.MPI_TAG = tag 251 252 def Set_error(self, error): 253 self.MPI_ERROR = error 254 255 def Get_count(self, datatype = None): 256 if datatype is None: 257 datatype = BYTE 258 return _mpi.get_count(self, datatype) 259 260 def Get_elements(self, datatype = None): 261 if datatype is None: 262 datatype = BYTE 263 return _mpi.get_elements(self, datatype) 264 265 def Is_cancelled(self): 266 return _mpi.test_cancelled(self) 267 268 source = property(Get_source, Set_source, doc='message source') 269 tag = property(Get_tag, Set_tag, doc='message tag') 270 error = property(Get_error, Set_error, doc='message error') 271 272 273 class Request(_mpi.Request): 274 275 def __init__(self, request = None): 276 _mpi.Request.__init__(self, request) 277 278 def Wait(self, status = None): 279 return _mpi.wait(self, status) 280 281 def Test(self, status = None): 282 return _mpi.test(self, status) 283 284 def Free(self): 285 return _mpi.request_free(self) 286 287 def Get_status(self, status = None): 288 return _mpi.request_get_status(self, status) 289 290 def Waitany(requests, status = None): 291 return _mpi.waitany(requests, status) 292 293 Waitany = staticmethod(Waitany) 294 295 def Testany(requests, status = None): 296 return _mpi.testany(requests, status) 297 298 Testany = staticmethod(Testany) 299 300 def Waitall(requests, statuses = None): 301 return _mpi.waitall(requests, statuses) 302 303 Waitall = staticmethod(Waitall) 304 305 def Testall(requests, statuses = None): 306 return _mpi.testall(requests, statuses) 307 308 Testall = staticmethod(Testall) 309 310 def Waitsome(requests, statuses = None): 311 return _mpi.waitsome(requests, statuses) 312 313 Waitsome = staticmethod(Waitsome) 314 315 def Testsome(requests, statuses = None): 316 return _mpi.testsome(requests, statuses) 317 318 Testsome = staticmethod(Testsome) 319 320 def Cancel(self): 321 return _mpi.cancel(self) 322 323 324 class Prequest(Request): 325 326 def __init__(self, prequest = None): 327 Request.__init__(self, prequest) 328 329 def Start(self): 330 _mpi.start(self) 331 332 def Startall(requests): 333 _mpi.startall(requests) 334 335 Startall = staticmethod(Startall) 336 337 338 REQUEST_NULL = Request(_mpi.REQUEST_NULL) 339 340 class Op(_mpi.Op): 341 342 def __new__(cls, op = None, *targs, **kargs): 343 newop = _mpi.Op.__new__(cls, op) 344 if newop is not op: 345 if targs or kargs: 346 newop.Init(*targs, **kargs) 347 else: 348 newop.Init(None, False) 349 return newop 350 351 def __init__(self, op = None, *targs, **kargs): 352 _mpi.Op.__init__(self, op, *targs, **kargs) 353 354 def __call__(self, x, y): 355 return self.__function(x, y) 356 357 def Init(self, function, commute = False): 358 if callable(function): 359 self.__function = function 360 self.__commute = bool(commute) 361 else: 362 if function is not None: 363 _mpi.op_create(function, commute, self) 364 self.__function = lambda x, y: _mpi._raise(_mpi.ERR_OP) 365 self.__commute = bool(commute) 366 367 def Free(self): 368 _mpi.op_free(self) 369 370 371 OP_NULL = Op(_mpi.OP_NULL) 372 MAX = Op(_mpi.MAX, _op.MAX, True) 373 MIN = Op(_mpi.MIN, _op.MIN, True) 374 SUM = Op(_mpi.SUM, _op.SUM, True) 375 PROD = Op(_mpi.PROD, _op.PROD, True) 376 LAND = Op(_mpi.LAND, _op.LAND, True) 377 BAND = Op(_mpi.BAND, _op.BAND, True) 378 LOR = Op(_mpi.LOR, _op.LOR, True) 379 BOR = Op(_mpi.BOR, _op.BOR, True) 380 LXOR = Op(_mpi.LXOR, _op.LXOR, True) 381 BXOR = Op(_mpi.BXOR, _op.BXOR, True) 382 MAXLOC = Op(_mpi.MAXLOC, _op.MAXLOC, True) 383 MINLOC = Op(_mpi.MINLOC, _op.MINLOC, True) 384 REPLACE = Op(_mpi.REPLACE, _op.REPLACE, False) 385 386 class Info(_mpi.Info): 387 388 def __init__(self, info = None): 389 _mpi.Info.__init__(self, info) 390 391 def __len__(self): 392 if self == _mpi.INFO_NULL: 393 return 0 394 else: 395 return _mpi.info_get_nkeys(self) 396 397 def __getitem__(self, key): 398 value, flag = _mpi.info_get(self, key) 399 if not flag: 400 raise KeyError(key) 401 return value 402 403 def __setitem__(self, key, value): 404 return _mpi.info_set(self, key, value) 405 406 def __delitem__(self, key): 407 _mpi.info_delete(self, key) 408 409 def __contains__(self, key): 410 return _mpi.info_get_valuelen(self, key)[1] 411 412 def __iter__(self): 413 if self == _mpi.INFO_NULL: 414 return 415 nkeys = _mpi.info_get_nkeys(self) 416 for nthkey in xrange(nkeys): 417 yield _mpi.info_get_nthkey(self, nthkey) 418 419 def Create(cls): 420 info = _mpi.info_create() 421 return cls(info) 422 423 Create = classmethod(Create) 424 425 def Dup(self): 426 info = _mpi.info_dup(self) 427 return type(self)(info) 428 429 def Free(self): 430 _mpi.info_free(self) 431 432 def Set(self, key, value): 433 _mpi.info_set(self, key, value) 434 435 def Delete(self, key): 436 _mpi.info_delete(self, key) 437 438 def Get(self, key, maxlen = -1): 439 return _mpi.info_get(self, key, maxlen) 440 441 def Get_nkeys(self): 442 return _mpi.info_get_nkeys(self) 443 444 def Get_nthkey(self, n): 445 return _mpi.info_get_nthkey(self, n) 446 447 448 INFO_NULL = Info(_mpi.INFO_NULL) 449 450 class Group(_mpi.Group): 451 452 def __init__(self, group = None): 453 _mpi.Group.__init__(self, group) 454 455 def Get_size(self): 456 return _mpi.group_size(self) 457 458 def Get_rank(self): 459 return _mpi.group_rank(self) 460 461 def Translate_ranks(group1, ranks1, group2): 462 return _mpi.group_transl_rank(group1, ranks1, group2) 463 464 Translate_ranks = staticmethod(Translate_ranks) 465 466 def Compare(group1, group2): 467 return _mpi.group_compare(group1, group2) 468 469 Compare = staticmethod(Compare) 470 471 def Union(cls, group1, group2): 472 newgroup = _mpi.group_union(group1, group2) 473 return cls(newgroup) 474 475 Union = classmethod(Union) 476 477 def Intersect(cls, group1, group2): 478 newgroup = _mpi.group_intersection(group1, group2) 479 return cls(newgroup) 480 481 Intersect = classmethod(Intersect) 482 483 def Difference(cls, group1, group2): 484 newgroup = _mpi.group_difference(group1, group2) 485 return cls(newgroup) 486 487 Difference = classmethod(Difference) 488 489 def Incl(self, ranks): 490 newgroup = _mpi.group_incl(self, ranks) 491 return type(self)(newgroup) 492 493 def Excl(self, ranks): 494 newgroup = _mpi.group_excl(self, ranks) 495 return type(self)(newgroup) 496 497 def Range_incl(self, ranks): 498 newgroup = _mpi.group_range_incl(self, ranks) 499 return type(self)(newgroup) 500 501 def Range_excl(self, ranks): 502 newgroup = _mpi.group_range_excl(self, ranks) 503 return type(self)(newgroup) 504 505 def Free(self): 506 return _mpi.group_free(self) 507 508 size = property(_mpi.group_size, doc='number of processes in group') 509 rank = property(_mpi.group_rank, doc='rank of this process in group') 510 511 512 GROUP_NULL = Group(_mpi.GROUP_NULL) 513 GROUP_EMPTY = Group(_mpi.GROUP_EMPTY) 514 515 class Comm(_mpi.Comm): 516 517 def __init__(self, comm = None): 518 _mpi.Comm.__init__(self, comm) 519 _mpi.comm_check_any(self) 520 521 SERIALIZER = Pickle 522 523 def Get_group(self): 524 group = _mpi.comm_group(self) 525 return Group(group) 526 527 def Get_size(self): 528 return _mpi.comm_size(self) 529 530 def Get_rank(self): 531 return _mpi.comm_rank(self) 532 533 def Compare(comm1, comm2): 534 return _mpi.comm_compare(comm1, comm2) 535 536 Compare = staticmethod(Compare) 537 538 def Clone(self): 539 newcomm = _mpi.comm_dup(self) 540 return type(self)(newcomm) 541 542 def Free(self): 543 _mpi.comm_free(self) 544 545 def Send(self, buf, dest = 0, tag = 0): 546 buf, fastmode = _mpi.make_buf(buf) 547 if fastmode: 548 _mpi.send(buf, dest, tag, self) 549 return 550 else: 551 if dest != _mpi.PROC_NULL: 552 buf = self.SERIALIZER.dump(buf) 553 else: 554 buf = None 555 _mpi.send_string(buf, dest, tag, self) 556 return 557 558 def Recv(self, buf = None, source = 0, tag = 0, status = None): 559 buf, fastmode = _mpi.make_buf(buf) 560 if fastmode: 561 _mpi.recv(buf, source, tag, self, status) 562 return None 563 else: 564 buf = _mpi.recv_string(buf, source, tag, self, status) 565 if source != _mpi.PROC_NULL: 566 buf = self.SERIALIZER.load(buf) 567 return buf 568 569 def Sendrecv(self, sendbuf, dest = 0, sendtag = 0, recvbuf = None, source = 0, recvtag = 0, status = None): 570 sendbuf, sfastmode = _mpi.make_buf(sendbuf) 571 recvbuf, rfastmode = _mpi.make_buf(recvbuf) 572 if sfastmode or rfastmode: 573 _mpi.sendrecv(sendbuf, dest, sendtag, recvbuf, source, recvtag, self, status) 574 return 575 else: 576 serializer = self.SERIALIZER 577 if dest != _mpi.PROC_NULL: 578 sendbuf = serializer.dump(sendbuf) 579 else: 580 sendbuf = None 581 recvbuf = _mpi.sendrecv_string(sendbuf, dest, sendtag, recvbuf, source, recvtag, self, status) 582 if recvbuf is not None: 583 recvbuf = serializer.load(recvbuf) 584 return recvbuf 585 586 def Sendrecv_replace(self, buf, dest = 0, sendtag = 0, source = 0, recvtag = 0, status = None): 587 _mpi.sendrecv_replace(buf, dest, sendtag, source, recvtag, self, status) 588 589 def Isend(self, buf, dest = 0, tag = 0): 590 request = _mpi.isend(buf, dest, tag, self) 591 return Request(request) 592 593 def Irecv(self, buf, source = 0, tag = 0): 594 request = _mpi.irecv(buf, source, tag, self) 595 return Request(request) 596 597 def Probe(self, source = 0, tag = 0, status = None): 598 return _mpi.probe(source, tag, self, status) 599 600 def Iprobe(self, source = 0, tag = 0, status = None): 601 return _mpi.iprobe(source, tag, self, status) 602 603 def Send_init(self, buf, dest = 0, tag = 0): 604 prequest = _mpi.send_init(buf, dest, tag, self) 605 return Prequest(prequest) 606 607 def Recv_init(self, buf, source = 0, tag = 0): 608 prequest = _mpi.recv_init(buf, source, tag, self) 609 return Prequest(prequest) 610 611 def Bsend(self, buf, dest = 0, tag = 0): 612 return _mpi.send(buf, dest, tag, self, 'B') 613 614 def Ssend(self, buf, dest = 0, tag = 0): 615 return _mpi.send(buf, dest, tag, self, 'S') 616 617 def Rsend(self, buf, dest = 0, tag = 0): 618 return _mpi.send(buf, dest, tag, self, 'R') 619 620 def Ibsend(self, buf, dest = 0, tag = 0): 621 request = _mpi.isend(buf, dest, tag, self, 'B') 622 return Request(request) 623 624 def Issend(self, buf, dest = 0, tag = 0): 625 request = _mpi.isend(buf, dest, tag, self, 'S') 626 return Request(request) 627 628 def Irsend(self, buf, dest = 0, tag = 0): 629 request = _mpi.isend(buf, dest, tag, self, 'R') 630 return Request(request) 631 632 def Bsend_init(self, buf, dest = 0, tag = 0): 633 prequest = _mpi.send_init(buf, dest, tag, self, 'B') 634 return Prequest(prequest) 635 636 def Ssend_init(self, buf, dest = 0, tag = 0): 637 prequest = _mpi.send_init(buf, dest, tag, self, 'S') 638 return Prequest(prequest) 639 640 def Rsend_init(self, buf, dest = 0, tag = 0): 641 prequest = _mpi.send_init(buf, dest, tag, self, 'R') 642 return Prequest(prequest) 643 644 def Barrier(self): 645 _mpi.barrier(self) 646 647 def Bcast(self, buf = None, root = 0): 648 buf, fastmode = _mpi.make_buf(buf) 649 if fastmode: 650 _mpi.bcast(buf, root, self) 651 return 652 else: 653 serializer = self.SERIALIZER 654 if _mpi.comm_test_inter(self): 655 if root == _mpi.ROOT: 656 buf = serializer.dump(buf) 657 else: 658 buf = None 659 elif root == _mpi.comm_rank(self): 660 buf = serializer.dump(buf) 661 else: 662 buf = None 663 buf = _mpi.bcast_string(buf, root, self) 664 if buf is not None: 665 buf = serializer.load(buf) 666 return buf 667 668 def Gather(self, sendbuf, recvbuf = None, root = 0): 669 sendbuf, sfastmode = _mpi.make_buf(sendbuf) 670 recvbuf, rfastmode = _mpi.make_buf(recvbuf) 671 if sfastmode or rfastmode: 672 _mpi.gather(sendbuf, recvbuf, root, self) 673 return 674 else: 675 serializer = self.SERIALIZER 676 if _mpi.comm_test_inter(self): 677 if root != _mpi.ROOT and root != _mpi.PROC_NULL: 678 sendbuf = serializer.dump(sendbuf) 679 else: 680 sendbuf = None 681 else: 682 sendbuf = serializer.dump(sendbuf) 683 recvbuf = _mpi.gather_string(sendbuf, recvbuf, root, self) 684 if recvbuf is not None: 685 recvbuf = map(serializer.load, recvbuf) 686 return recvbuf 687 688 def Scatter(self, sendbuf = None, recvbuf = None, root = 0): 689 sendbuf, sfastmode = _mpi.make_buf(sendbuf) 690 recvbuf, rfastmode = _mpi.make_buf(recvbuf) 691 if sfastmode or rfastmode: 692 _mpi.scatter(sendbuf, recvbuf, root, self) 693 return 694 else: 695 serializer = self.SERIALIZER 696 if _mpi.comm_test_inter(self): 697 if root == _mpi.ROOT: 698 sendbuf = map(serializer.dump, sendbuf) 699 else: 700 sendbuf = None 701 elif root == _mpi.comm_rank(self): 702 sendbuf = map(serializer.dump, sendbuf) 703 else: 704 sendbuf = None 705 recvbuf = _mpi.scatter_string(sendbuf, recvbuf, root, self) 706 if recvbuf is not None: 707 recvbuf = serializer.load(recvbuf) 708 return recvbuf 709 710 def Allgather(self, sendbuf, recvbuf = None): 711 sendbuf, sfastmode = _mpi.make_buf(sendbuf) 712 recvbuf, rfastmode = _mpi.make_buf(recvbuf) 713 if sfastmode or rfastmode: 714 _mpi.allgather(sendbuf, recvbuf, self) 715 return None 716 else: 717 serializer = self.SERIALIZER 718 sendbuf = serializer.dump(sendbuf) 719 recvbuf = _mpi.allgather_string(sendbuf, recvbuf, self) 720 recvbuf = map(serializer.load, recvbuf) 721 return recvbuf 722 723 def Alltoall(self, sendbuf, recvbuf = None): 724 sendbuf, sfastmode = _mpi.make_buf(sendbuf) 725 recvbuf, rfastmode = _mpi.make_buf(recvbuf) 726 if sfastmode or rfastmode: 727 _mpi.alltoall(sendbuf, recvbuf, self) 728 return None 729 else: 730 serializer = self.SERIALIZER 731 sendbuf = map(serializer.dump, sendbuf) 732 recvbuf = _mpi.alltoall_string(sendbuf, recvbuf, self) 733 recvbuf = map(serializer.load, recvbuf) 734 return recvbuf 735 736 def Reduce(self, sendbuf, recvbuf = None, op = SUM, root = 0): 737 sendbuf, sfastmode = _mpi.make_buf(sendbuf) 738 recvbuf, rfastmode = _mpi.make_buf(recvbuf) 739 if sfastmode or rfastmode: 740 _mpi.reduce(sendbuf, recvbuf, op, root, self) 741 return 742 else: 743 recvbuf = self.Gather(sendbuf, None, root) 744 if recvbuf is not None: 745 if op in (MAXLOC, MINLOC): 746 recvbuf = zip(recvbuf, xrange(len(recvbuf))) 747 recvbuf = reduce(op, recvbuf) 748 return recvbuf 749 750 def Allreduce(self, sendbuf, recvbuf = None, op = SUM): 751 sendbuf, sfastmode = _mpi.make_buf(sendbuf) 752 recvbuf, rfastmode = _mpi.make_buf(recvbuf) 753 if sfastmode or rfastmode: 754 _mpi.allreduce(sendbuf, recvbuf, op, self) 755 return None 756 else: 757 serializer = self.SERIALIZER 758 sendbuf = serializer.dump(sendbuf) 759 recvbuf = _mpi.allgather_string(sendbuf, recvbuf, self) 760 recvbuf = map(serializer.load, recvbuf) 761 if op in (MAXLOC, MINLOC): 762 recvbuf = zip(recvbuf, xrange(len(recvbuf))) 763 recvbuf = reduce(op, recvbuf) 764 return recvbuf 765 766 def Get_errhandler(self): 767 eh = _mpi.comm_get_errhandler(self) 768 return Errhandler(eh) 769 770 def Set_errhandler(self, errhandler): 771 _mpi.comm_set_errhandler(self, errhandler) 772 773 def Abort(self, errorcode = 0): 774 _mpi.comm_abort(self, errorcode) 775 776 def Is_inter(self): 777 return _mpi.comm_test_inter(self) 778 779 def Is_intra(self): 780 return not _mpi.comm_test_inter(self) 781 782 def Get_topology(self): 783 return _mpi.topo_test(self) 784 785 def Get_parent(): 786 newcomm = _mpi.comm_get_parent() 787 return Intercomm(newcomm) 788 789 Get_parent = staticmethod(Get_parent) 790 791 def Disconnect(self): 792 _mpi.comm_disconnect(self) 793 794 def Join(fd): 795 newcomm = _mpi.comm_join(fd) 796 return Intercomm(newcomm) 797 798 Join = staticmethod(Join) 799 800 def Get_name(self): 801 return _mpi.comm_get_name(self) 802 803 def Set_name(self, name): 804 return _mpi.comm_set_name(self, name) 805 806 class Port(object): 807 TAG = _mpi.TAG_UB - 1 808 809 def __init__(self, comm, pid): 810 if pid not in xrange(len(comm)): 811 raise ValueError('port number out of range') 812 self._comm = comm 813 self._pid = pid 814 815 def Send(self, buf, tag = 0): 816 return self.comm.Send(buf, self.pid, tag) 817 818 def Recv(self, buf = None, tag = 0): 819 return self.comm.Recv(buf, self.pid, tag) 820 821 def Bcast(self, buf = None): 822 return self.comm.Bcast(buf, self.pid) 823 824 def Gather(self, sbuf, rbuf = None): 825 return self.comm.Gather(sbuf, rbuf, self.pid) 826 827 def Scatter(self, sbuf = None, rbuf = None): 828 return self.comm.Scatter(sbuf, rbuf, self.pid) 829 830 def Reduce(self, sbuf, rbuf = None, op = SUM): 831 return self.comm.Reduce(sbuf, rbuf, op, self.pid) 832 833 def __lshift__(self, stream): 834 if type(stream) is not list: 835 raise TypeError('input stream must be a list') 836 self.Send(stream, self.TAG) 837 838 def __rshift__(self, stream): 839 if type(stream) is not list: 840 raise TypeError('output stream must be a list') 841 stream.extend(self.Recv(None, self.TAG)) 842 843 comm = property(lambda self: self._comm, doc='associated communicator') 844 pid = property(lambda self: self._pid, doc='associated process *id*') 845 846 def __len__(self): 847 if self == _mpi.COMM_NULL: 848 return 0 849 elif _mpi.comm_test_inter(self): 850 return _mpi.comm_remote_size(self) 851 else: 852 return _mpi.comm_size(self) 853 854 def __getitem__(self, i): 855 if type(i) is not int: 856 raise TypeError('indices must be integers') 857 if i < 0: 858 i += len(self) 859 if i < 0 or i >= len(self): 860 raise IndexError('index out of range') 861 return self.__class__.Port(self, i) 862 863 def __iter__(self): 864 i = 0 865 port = self.__class__.Port 866 while i < len(self): 867 yield port(self, i) 868 i += 1 869 870 size = property(_mpi.comm_size, doc='number of processes in group') 871 rank = property(_mpi.comm_rank, doc='rank of this process in group') 872 is_inter = property(_mpi.comm_test_inter, doc='True if is an intercommunicator') 873 is_intra = property(_mpi.comm_test_intra, doc='True if is an intracommunicator') 874 topology = property(_mpi.topo_test, doc='type of topology (if any)') 875 name = property(_mpi.comm_get_name, _mpi.comm_set_name, doc='communicator name') 876 877 878 COMM_NULL = Comm(_mpi.COMM_NULL) 879 880 class Intracomm(Comm): 881 882 def __init__(self, comm = None): 883 Comm.__init__(self, comm) 884 _mpi.comm_check_intra(self) 885 886 def Dup(self): 887 newcomm = _mpi.comm_dup(self) 888 return Intracomm(newcomm) 889 890 def Create(self, group): 891 newcomm = _mpi.comm_create(self, group) 892 return Intracomm(newcomm) 893 894 def Split(self, color, key = 0): 895 newcomm = _mpi.comm_split(self, color, key) 896 return Intracomm(newcomm) 897 898 def Create_intercomm(self, local_leader, peer_comm, remote_leader, tag = 0): 899 newcomm = _mpi.intercomm_create(self, local_leader, peer_comm, remote_leader, tag) 900 return Intercomm(newcomm) 901 902 def Create_cart(self, dims, periods = None, reorder = False): 903 if periods is None: 904 periods = [False] * len(dims) 905 newcomm = _mpi.cart_create(self, dims, periods, reorder) 906 return Cartcomm(newcomm) 907 908 def Create_graph(self, index, edges, reorder = False): 909 newcomm = _mpi.graph_create(self, index, edges, reorder) 910 return Graphcomm(newcomm) 911 912 def Scan(self, sendbuf, recvbuf = None, op = SUM): 913 sendbuf, sfastmode = _mpi.make_buf(sendbuf) 914 recvbuf, rfastmode = _mpi.make_buf(recvbuf) 915 if sfastmode or rfastmode: 916 _mpi.scan(sendbuf, recvbuf, op, self) 917 return None 918 else: 919 recvbuf = self.Gather(sendbuf, root=0) 920 if _mpi.comm_rank(self) == 0: 921 if op in (MAXLOC, MINLOC): 922 recvbuf = zip(recvbuf, xrange(len(recvbuf))) 923 for i in xrange(1, len(recvbuf)): 924 recvbuf[i] = op(recvbuf[i - 1], recvbuf[i]) 925 926 recvbuf = self.Scatter(recvbuf, root=0) 927 return recvbuf 928 929 def Exscan(self, sendbuf, recvbuf = None, op = SUM): 930 sendbuf, sfastmode = _mpi.make_buf(sendbuf) 931 recvbuf, rfastmode = _mpi.make_buf(recvbuf) 932 if sfastmode or rfastmode: 933 _mpi.exscan(sendbuf, recvbuf, op, self) 934 return 935 else: 936 recvbuf = self.Gather(sendbuf, root=0) 937 if _mpi.comm_rank(self) == 0: 938 if op in (MAXLOC, MINLOC): 939 recvbuf = zip(recvbuf, xrange(len(recvbuf))) 940 for i in xrange(1, len(recvbuf)): 941 recvbuf[i] = op(recvbuf[i - 1], recvbuf[i]) 942 943 recvbuf.insert(0, None) 944 recvbuf.pop(-1) 945 recvbuf = self.Scatter(recvbuf, root=0) 946 return recvbuf 947 948 def Spawn(self, command, args = None, maxprocs = 1, info = None, root = 0): 949 newcomm = _mpi.comm_spawn(command, args, maxprocs, info, root, self) 950 return Intercomm(newcomm) 951 952 def Accept(self, port_name, info = None, root = 0): 953 newcomm = _mpi.comm_accept(port_name, info, root, self) 954 return Intercomm(newcomm) 955 956 def Connect(self, port_name, info = None, root = 0): 957 newcomm = _mpi.comm_connect(port_name, info, root, self) 958 return Intercomm(newcomm) 959 960 961 __COMM_SELF__ = Intracomm(_mpi.COMM_SELF) 962 __COMM_WORLD__ = Intracomm(_mpi.COMM_WORLD) 963 COMM_SELF = SELF = Intracomm(_mpi.COMM_SELF_DUP) 964 COMM_WORLD = WORLD = Intracomm(_mpi.COMM_WORLD_DUP) 965 966 def Compute_dims(nnodes, dims): 967 return _mpi.dims_create(nnodes, dims) 968 969 970 class Cartcomm(Intracomm): 971 972 def __init__(self, comm = None): 973 Intracomm.__init__(self, comm) 974 _mpi.comm_check_cart(self) 975 976 def Dup(self): 977 newcomm = _mpi.comm_dup(self) 978 return Cartcomm(newcomm) 979 980 def Get_dim(self): 981 return _mpi.cartdim_get(self) 982 983 def Get_topo(self): 984 return _mpi.cart_get(self) 985 986 def Get_cart_rank(self, coords): 987 return _mpi.cart_rank(self, coords) 988 989 def Get_coords(self, rank): 990 return _mpi.cart_coords(self, rank) 991 992 def Shift(self, direction, disp): 993 return _mpi.cart_shift(self, direction, disp) 994 995 def Sub(self, remain_dims): 996 newcomm = _mpi.cart_sub(self, remain_dims) 997 return Cartcomm(newcomm) 998 999 def Map(self, dims, periods): 1000 return _mpi.cart_map(self, dims, periods) 1001 1002 dim = property(_mpi.cartdim_get, doc='number of dimensions') 1003 topo = property(_mpi.cart_get, doc='Cartesian topology information') 1004 1005 1006 class Graphcomm(Intracomm): 1007 1008 def __init__(self, comm = None): 1009 Intracomm.__init__(self, comm) 1010 _mpi.comm_check_graph(self) 1011 1012 def Dup(self): 1013 newcomm = _mpi.comm_dup(self) 1014 return Graphcomm(newcomm) 1015 1016 def Get_dims(self): 1017 return _mpi.graphdims_get(self) 1018 1019 def Get_topo(self): 1020 return _mpi.graph_get(self) 1021 1022 def Get_neighbors_count(self, rank): 1023 return _mpi.graph_neigh_count(self, rank) 1024 1025 def Get_neighbors(self, rank): 1026 return _mpi.graph_neigh(self, rank) 1027 1028 def Map(self, index, edges): 1029 return _mpi.graph_map(self, index, edges) 1030 1031 dims = property(_mpi.graphdims_get, doc='number of nodes and edges') 1032 topo = property(_mpi.graph_get, doc='graph topology information') 1033 1034 1035 class Intercomm(Comm): 1036 1037 def __init__(self, comm = None): 1038 Comm.__init__(self, comm) 1039 _mpi.comm_check_inter(self) 1040 1041 def Get_remote_size(self): 1042 return _mpi.comm_remote_size(self) 1043 1044 def Get_remote_group(self): 1045 group = _mpi.comm_remote_group(self) 1046 return Group(group) 1047 1048 def Dup(self): 1049 newcomm = _mpi.comm_dup(self) 1050 return Intercomm(newcomm) 1051 1052 def Create(self, group): 1053 newcomm = _mpi.comm_create(self, group) 1054 return Intercomm(newcomm) 1055 1056 def Split(self, color = 0, key = 0): 1057 newcomm = _mpi.comm_split(self, color, key) 1058 return Intercomm(newcomm) 1059 1060 def Merge(self, high = False): 1061 intracomm = _mpi.intercomm_merge(self, high) 1062 return Intracomm(intracomm) 1063 1064 remote_size = property(_mpi.comm_remote_size, doc='size of remote group') 1065 1066 1067 def Open_port(info = None): 1068 return _mpi.open_port(info) 1069 1070 1071 def Close_port(port_name): 1072 return _mpi.close_port(port_name) 1073 1074 1075 def Publish_name(service_name, info, port_name): 1076 return _mpi.publish_name(service_name, info, port_name) 1077 1078 1079 def Unpublish_name(service_name, info, port_name): 1080 return _mpi.unpublish_name(service_name, info, port_name) 1081 1082 1083 def Lookup_name(service_name, info = None): 1084 return _mpi.lookup_name(service_name, info) 1085 1086 1087 MODE_NOCHECK = _mpi.MODE_NOCHECK 1088 MODE_NOSTORE = _mpi.MODE_NOSTORE 1089 MODE_NOPUT = _mpi.MODE_NOPUT 1090 MODE_NOPRECEDE = _mpi.MODE_NOPRECEDE 1091 MODE_NOSUCCEED = _mpi.MODE_NOSUCCEED 1092 LOCK_EXCLUSIVE = _mpi.LOCK_EXCLUSIVE 1093 LOCK_SHARED = _mpi.LOCK_SHARED 1094 1095 class Win(_mpi.Win): 1096 1097 def __init__(self, win = None): 1098 _mpi.Win.__init__(self, win) 1099 1100 def Create(cls, memory, disp, info, comm): 1101 win = _mpi.win_create(memory, disp, info, comm) 1102 return cls(win) 1103 1104 Create = classmethod(Create) 1105 1106 def Free(self): 1107 return _mpi.win_free(self) 1108 1109 def Get_base(self): 1110 return _mpi.win_get_base(self) 1111 1112 def Get_size(self): 1113 return _mpi.win_get_size(self) 1114 1115 def Get_disp_unit(self): 1116 return _mpi.win_get_disp(self) 1117 1118 def Get_group(self): 1119 group = _mpi.win_get_group(self) 1120 return Group(group) 1121 1122 def Put(self, origin_buf, target_rank, target_disp = 0, target_count = -1, target_datatype = None): 1123 return _mpi.win_put(origin_buf, target_rank, target_disp, target_count, target_datatype, self) 1124 1125 def Get(self, origin_buf, target_rank, target_disp = 0, target_count = -1, target_datatype = None): 1126 return _mpi.win_get(origin_buf, target_rank, target_disp, target_count, target_datatype, self) 1127 1128 def Accumulate(self, origin_buf, target_rank, target_disp = 0, target_count = -1, target_datatype = None, op = SUM): 1129 return _mpi.win_accumulate(origin_buf, target_rank, target_disp, target_count, target_datatype, op, self) 1130 1131 def Fence(self, assertion = 0): 1132 return _mpi.win_fence(assertion, self) 1133 1134 def Start(self, group, assertion = 0): 1135 return _mpi.win_start(group, assertion, self) 1136 1137 def Complete(self): 1138 return _mpi.win_complete(self) 1139 1140 def Post(self, group, assertion = 0): 1141 return _mpi.win_post(group, assertion, self) 1142 1143 def Wait(self): 1144 return _mpi.win_wait(self) 1145 1146 def Test(self): 1147 return _mpi.win_test(self) 1148 1149 def Lock(self, lock_type, rank, assertion = 0): 1150 return _mpi.win_lock(lock_type, rank, assertion, self) 1151 1152 def Unlock(self, rank): 1153 return _mpi.win_unlock(rank, self) 1154 1155 def Get_errhandler(self): 1156 eh = _mpi.win_get_errhandler(self) 1157 return Errhandler(eh) 1158 1159 def Set_errhandler(self, errhandler): 1160 _mpi.win_set_errhandler(self, errhandler) 1161 1162 def Get_name(self): 1163 return _mpi.win_get_name(self) 1164 1165 def Set_name(self, name): 1166 return _mpi.win_set_name(self, name) 1167 1168 base = property(_mpi.win_get_base, doc='window base address') 1169 size = property(_mpi.win_get_size, doc='window size, in bytes') 1170 disp_unit = property(_mpi.win_get_disp, doc='displacement unit') 1171 name = property(_mpi.win_get_name, _mpi.win_set_name, doc='window name') 1172 1173 1174 WIN_NULL = Win(_mpi.WIN_NULL) 1175 MODE_RDONLY = _mpi.MODE_RDONLY 1176 MODE_RDWR = _mpi.MODE_RDWR 1177 MODE_WRONLY = _mpi.MODE_WRONLY 1178 MODE_CREATE = _mpi.MODE_CREATE 1179 MODE_EXCL = _mpi.MODE_EXCL 1180 MODE_DELETE_ON_CLOSE = _mpi.MODE_DELETE_ON_CLOSE 1181 MODE_UNIQUE_OPEN = _mpi.MODE_UNIQUE_OPEN 1182 MODE_SEQUENTIAL = _mpi.MODE_SEQUENTIAL 1183 MODE_APPEND = _mpi.MODE_APPEND 1184 SEEK_SET = _mpi.SEEK_SET 1185 SEEK_CUR = _mpi.SEEK_CUR 1186 SEEK_END = _mpi.SEEK_END 1187 DISPLACEMENT_CURRENT = _mpi.DISPLACEMENT_CURRENT 1188 DISP_CUR = _mpi.DISPLACEMENT_CURRENT 1189 1190 class File(_mpi.File): 1191 1192 def __init__(self, file = None): 1193 _mpi.File.__init__(self, file) 1194 1195 def Open(cls, comm, filename, amode = None, info = None): 1196 fh = _mpi.file_open(comm, filename, amode, info) 1197 return cls(fh) 1198 1199 Open = classmethod(Open) 1200 1201 def Close(self): 1202 _mpi.file_close(self) 1203 1204 def Delete(filename, info = None): 1205 return _mpi.file_delete(filename, info) 1206 1207 Delete = staticmethod(Delete) 1208 1209 def Set_size(self, size): 1210 return _mpi.file_set_size(self, size) 1211 1212 def Preallocate(self, size): 1213 return _mpi.file_preallocate(self, size) 1214 1215 def Get_size(self): 1216 return _mpi.file_get_size(self) 1217 1218 def Get_group(self): 1219 group = _mpi.file_get_group(self) 1220 return Group(group) 1221 1222 def Get_amode(self): 1223 return _mpi.file_get_amode(self) 1224 1225 def Set_info(self, info): 1226 return _mpi.file_set_info(self, info) 1227 1228 def Get_info(self): 1229 info = _mpi.file_get_info(self) 1230 return Info(info) 1231 1232 def Set_view(self, disp = 0, etype = None, filetype = None, datarep = 'native', info = None): 1233 if etype is None: 1234 etype = _mpi.BYTE 1235 if filetype is None: 1236 filetype = etype 1237 return _mpi.file_set_view(self, disp, etype, filetype, datarep, info) 1238 1239 def Get_view(self): 1240 disp, etype, ftype, datarep = _mpi.file_get_view(self) 1241 return (disp, 1242 Datatype(etype), 1243 Datatype(ftype), 1244 datarep) 1245 1246 def Read_at(self, offset, buf, status = None): 1247 return _mpi.file_read(self, offset, buf, status, 0) 1248 1249 def Read_at_all(self, offset, buf, status = None): 1250 return _mpi.file_read(self, offset, buf, status, 1) 1251 1252 def Write_at(self, offset, buf, status = None): 1253 return _mpi.file_write(self, offset, buf, status, 0) 1254 1255 def Write_at_all(self, offset, buf, status = None): 1256 return _mpi.file_write(self, offset, buf, status, 1) 1257 1258 def Iread_at(self, offset, buf): 1259 request = _mpi.file_iread(self, offset, buf, 0) 1260 return Request(request) 1261 1262 def Iwrite_at(self, offset, buf): 1263 request = _mpi.file_iwrite(self, offset, buf, 0) 1264 return Request(request) 1265 1266 def Read(self, buf, status = None): 1267 return _mpi.file_read(self, buf, status, 0) 1268 1269 def Read_all(self, buf, status = None): 1270 return _mpi.file_read(self, buf, status, 1) 1271 1272 def Write(self, buf, status = None): 1273 return _mpi.file_write(self, buf, status, 0) 1274 1275 def Write_all(self, buf, status = None): 1276 return _mpi.file_write(self, buf, status, 1) 1277 1278 def Iread(self, buf): 1279 request = _mpi.file_iread(self, buf, 0) 1280 return Request(request) 1281 1282 def Iwrite(self, buf): 1283 request = _mpi.file_iwrite(self, buf, 0) 1284 return Request(request) 1285 1286 def Seek(self, offset, whence = None): 1287 return _mpi.file_seek(self, offset, whence, 0) 1288 1289 def Get_position(self): 1290 return _mpi.file_get_position(self, 0) 1291 1292 def Get_byte_offset(self, offset): 1293 return _mpi.file_get_byte_offset(self, offset) 1294 1295 def Read_shared(self, buf, status = None): 1296 return _mpi.file_read(self, buf, status, 2) 1297 1298 def Write_shared(self, buf, status = None): 1299 return _mpi.file_write(self, buf, status, 2) 1300 1301 def Iread_shared(self, buf): 1302 request = _mpi.file_iread(self, buf, 2) 1303 return Request(request) 1304 1305 def Iwrite_shared(self, buf): 1306 request = _mpi.file_iwrite(self, buf, 2) 1307 return Request(request) 1308 1309 def Read_ordered(self, buf, status = None): 1310 return _mpi.file_read(self, buf, status, 3) 1311 1312 def Write_ordered(self, buf, status = None): 1313 return _mpi.file_write(self, buf, status, 3) 1314 1315 def Seek_shared(self, offset, whence = None): 1316 return _mpi.file_seek(self, offset, whence, 2) 1317 1318 def Get_position_shared(self): 1319 return _mpi.file_get_position(self, 2) 1320 1321 def Read_at_all_begin(self, offset, buf): 1322 return _mpi.file_read_split(self, offset, buf, None, 1, 0) 1323 1324 def Read_at_all_end(self, buf, status = None): 1325 return _mpi.file_read_split(self, 0, buf, status, 1, 1) 1326 1327 def Write_at_all_begin(self, offset, buf): 1328 return _mpi.file_write_split(self, offset, buf, None, 1, 0) 1329 1330 def Write_at_all_end(self, buf, status = None): 1331 return _mpi.file_write_split(self, 0, buf, status, 1, 1) 1332 1333 def Read_all_begin(self, buf): 1334 return _mpi.file_read_split(self, buf, None, 1, 0) 1335 1336 def Read_all_end(self, buf, status = None): 1337 return _mpi.file_read_split(self, buf, status, 1, 1) 1338 1339 def Write_all_begin(self, buf): 1340 return _mpi.file_write_split(self, buf, None, 1, 0) 1341 1342 def Write_all_end(self, buf, status = None): 1343 return _mpi.file_write_split(self, buf, status, 1, 1) 1344 1345 def Read_ordered_begin(self, buf): 1346 return _mpi.file_read_split(self, buf, None, 3, 0) 1347 1348 def Read_ordered_end(self, buf, status = None): 1349 return _mpi.file_read_split(self, buf, status, 3, 1) 1350 1351 def Write_ordered_begin(self, buf): 1352 return _mpi.file_write_split(self, buf, None, 3, 0) 1353 1354 def Write_ordered_end(self, buf, status = None): 1355 return _mpi.file_write_split(self, buf, status, 3, 1) 1356 1357 def Get_type_extent(self, datatype): 1358 return _mpi.file_get_type_extent(self, datatype) 1359 1360 def Set_atomicity(self, flag): 1361 return _mpi.file_set_atomicity(self, flag) 1362 1363 def Get_atomicity(self): 1364 return _mpi.file_get_atomicity(self) 1365 1366 def Sync(self): 1367 return _mpi.file_sync(self) 1368 1369 def Get_errhandler(self): 1370 eh = _mpi.file_get_errhandler(self) 1371 return Errhandler(eh) 1372 1373 def Set_errhandler(self, errhandler): 1374 _mpi.file_set_errhandler(self, errhandler) 1375 1376 size = property(_mpi.file_get_size, doc='file size, in bytes') 1377 amode = property(_mpi.file_get_amode, doc='file access mode') 1378 1379 1380 FILE_NULL = File(_mpi.FILE_NULL) 1381 1382 def Init(): 1383 if getattr(Init, '__called', False): 1384 _func = (Init.__module__, Init.__name__) 1385 raise RuntimeError('%s.%s() already called' % _func) 1386 else: 1387 _mpi.init() 1388 _mpi._set_exception(Exception) 1389 setattr(Init, '__called', True) 1390 1391 1392 def Finalize(): 1393 global COMM_WORLD 1394 global COMM_SELF 1395 if getattr(Finalize, '__called', False): 1396 _func = (Finalize.__module__, Finalize.__name__) 1397 raise RuntimeError('%s.%s() already called' % _func) 1398 else: 1399 COMM_SELF = COMM_WORLD = COMM_NULL 1400 _mpi.COMM_SELF = _mpi.COMM_WORLD = _mpi.COMM_NULL 1401 _mpi._set_exception(RuntimeError) 1402 _mpi.finalize() 1403 setattr(Finalize, '__called', True) 1404 1405 1406 def Is_initialized(): 1407 return _mpi.initialized() 1408 1409 1410 def Is_finalized(): 1411 return _mpi.finalized() 1412 1413 1414 THREAD_SINGLE = _mpi.THREAD_SINGLE 1415 THREAD_FUNNELED = _mpi.THREAD_FUNNELED 1416 THREAD_SERIALIZED = _mpi.THREAD_SERIALIZED 1417 THREAD_MULTIPLE = _mpi.THREAD_MULTIPLE 1418 1419 def Init_thread(required): 1420 if getattr(Init_thread, '__called', False): 1421 _func = (Init_thread.__module__, Init_thread.__name__) 1422 raise RuntimeError('%s.%s() already called' % _func) 1423 else: 1424 provided = _mpi.init_thread(required) 1425 _mpi._set_exception(Exception) 1426 setattr(Init_thread, '__called', True) 1427 return provided 1428 1429 1430 def Query_thread(): 1431 return _mpi.query_thread() 1432 1433 1434 def Is_thread_main(): 1435 return _mpi.is_thread_main() 1436 1437 1438 def Get_version(): 1439 return _mpi.get_version() 1440 1441 1442 TAG_UB = _mpi.TAG_UB 1443 HOST = _mpi.HOST 1444 IO = _mpi.IO 1445 WTIME_IS_GLOBAL = _mpi.WTIME_IS_GLOBAL 1446 1447 def Get_processor_name(): 1448 return _mpi.get_processor_name() 1449 1450 1451 def Wtime(): 1452 return _mpi.wtime() 1453 1454 1455 def Wtick(): 1456 return _mpi.wtick() 1457 1458 1459 MAX_PROCESSOR_NAME = _mpi.MAX_PROCESSOR_NAME 1460 MAX_ERROR_STRING = _mpi.MAX_ERROR_STRING 1461 MAX_PORT_NAME = _mpi.MAX_PORT_NAME 1462 MAX_INFO_KEY = _mpi.MAX_INFO_KEY 1463 MAX_INFO_VAL = _mpi.MAX_INFO_VAL 1464 MAX_OBJECT_NAME = _mpi.MAX_OBJECT_NAME 1465 MAX_DATAREP_STRING = _mpi.MAX_DATAREP_STRING 1466 1467 class Errhandler(_mpi.Errhandler): 1468 1469 def __init__(self, errhandler = None): 1470 _mpi.Errhandler.__init__(self, errhandler) 1471 1472 def Free(self): 1473 _mpi.errhandler_free(self) 1474 1475 1476 ERRHANDLER_NULL = Errhandler(_mpi.ERRHANDLER_NULL) 1477 ERRORS_ARE_FATAL = Errhandler(_mpi.ERRORS_ARE_FATAL) 1478 ERRORS_RETURN = Errhandler(_mpi.ERRORS_RETURN) 1479 1480 class Exception(RuntimeError): 1481 1482 def __init__(self, ierr, *args): 1483 self.__ierr = _mpi.SUCCESS 1484 self.__ierr = int(ierr) 1485 RuntimeError.__init__(self, int(self), *args) 1486 1487 def __int__(self): 1488 return self.__ierr 1489 1490 def __str__(self): 1491 return _mpi.error_string(int(self)) 1492 1493 def __eq__(self, error): 1494 if isinstance(error, Exception): 1495 error = int(error) 1496 return int(self) == error 1497 1498 def __ne__(self, error): 1499 if isinstance(error, Exception): 1500 error = int(error) 1501 return int(self) != error 1502 1503 def Get_error_code(self): 1504 return int(self) 1505 1506 def Get_error_class(self): 1507 return _mpi.error_class(int(self)) 1508 1509 def Get_error_string(self): 1510 return _mpi.error_string(int(self)) 1511 1512 1513 SUCCESS = _mpi.SUCCESS 1514 ERR_BUFFER = _mpi.ERR_BUFFER 1515 ERR_COUNT = _mpi.ERR_COUNT 1516 ERR_TYPE = _mpi.ERR_TYPE 1517 ERR_TAG = _mpi.ERR_TAG 1518 ERR_COMM = _mpi.ERR_COMM 1519 ERR_RANK = _mpi.ERR_RANK 1520 ERR_ROOT = _mpi.ERR_ROOT 1521 ERR_TRUNCATE = _mpi.ERR_TRUNCATE 1522 ERR_IN_STATUS = _mpi.ERR_IN_STATUS 1523 ERR_PENDING = _mpi.ERR_PENDING 1524 ERR_GROUP = _mpi.ERR_GROUP 1525 ERR_OP = _mpi.ERR_OP 1526 ERR_REQUEST = _mpi.ERR_REQUEST 1527 ERR_DIMS = _mpi.ERR_DIMS 1528 ERR_TOPOLOGY = _mpi.ERR_TOPOLOGY 1529 ERR_ARG = _mpi.ERR_ARG 1530 ERR_INTERN = _mpi.ERR_INTERN 1531 ERR_OTHER = _mpi.ERR_OTHER 1532 ERR_UNKNOWN = _mpi.ERR_UNKNOWN 1533 ERR_KEYVAL = _mpi.ERR_KEYVAL 1534 ERR_NO_MEM = _mpi.ERR_NO_MEM 1535 ERR_NAME = _mpi.ERR_NAME 1536 ERR_PORT = _mpi.ERR_PORT 1537 ERR_SERVICE = _mpi.ERR_SERVICE 1538 ERR_SPAWN = _mpi.ERR_SPAWN 1539 ERR_INFO = _mpi.ERR_INFO 1540 ERR_INFO_KEY = _mpi.ERR_INFO_KEY 1541 ERR_INFO_VALUE = _mpi.ERR_INFO_VALUE 1542 ERR_INFO_NOKEY = _mpi.ERR_INFO_NOKEY 1543 ERR_WIN = _mpi.ERR_WIN 1544 ERR_BASE = _mpi.ERR_BASE 1545 ERR_SIZE = _mpi.ERR_SIZE 1546 ERR_DISP = _mpi.ERR_DISP 1547 ERR_LOCKTYPE = _mpi.ERR_LOCKTYPE 1548 ERR_ASSERT = _mpi.ERR_ASSERT 1549 ERR_RMA_CONFLICT = _mpi.ERR_RMA_CONFLICT 1550 ERR_RMA_SYNC = _mpi.ERR_RMA_SYNC 1551 ERR_FILE = _mpi.ERR_FILE 1552 ERR_NOT_SAME = _mpi.ERR_NOT_SAME 1553 ERR_AMODE = _mpi.ERR_AMODE 1554 ERR_UNSUPPORTED_DATAREP = _mpi.ERR_UNSUPPORTED_DATAREP 1555 ERR_UNSUPPORTED_OPERATION = _mpi.ERR_UNSUPPORTED_OPERATION 1556 ERR_NO_SUCH_FILE = _mpi.ERR_NO_SUCH_FILE 1557 ERR_FILE_EXISTS = _mpi.ERR_FILE_EXISTS 1558 ERR_BAD_FILE = _mpi.ERR_BAD_FILE 1559 ERR_ACCESS = _mpi.ERR_ACCESS 1560 ERR_NO_SPACE = _mpi.ERR_NO_SPACE 1561 ERR_QUOTA = _mpi.ERR_QUOTA 1562 ERR_READ_ONLY = _mpi.ERR_READ_ONLY 1563 ERR_FILE_IN_USE = _mpi.ERR_FILE_IN_USE 1564 ERR_DUP_DATAREP = _mpi.ERR_DUP_DATAREP 1565 ERR_CONVERSION = _mpi.ERR_CONVERSION 1566 ERR_IO = _mpi.ERR_IO 1567 ERR_LASTCODE = _mpi.ERR_LASTCODE 1568 1569 def Get_error_class(errorcode): 1570 return _mpi.error_class(errorcode) 1571 1572 1573 def Get_error_string(errorcode): 1574 return _mpi.error_string(errorcode) 1575 1576 1577 def SWIG(cls): 1578 try: 1579 import mpi4py._mpi_swig as _swig 1580 _as = getattr(_swig, 'as_' + cls.__name__) 1581 _from = getattr(_swig, 'from_' + cls.__name__) 1582 1583 def As_swig(self): 1584 return _as(self) 1585 1586 def From_swig(cls, obj): 1587 return cls(_from(obj)) 1588 1589 except ImportError: 1590 _swig = None 1591 1592 def As_swig(self): 1593 raise ImportError('SWIG support not available') 1594 1595 def From_swig(cls, obj): 1596 raise ImportError('SWIG support not available') 1597 1598 cls.As_swig = As_swig 1599 cls.From_swig = classmethod(From_swig) 1600 cls.this = property(As_swig, doc='SWIG handle') 1601 cls.thisown = property(lambda self: 0, doc='SWIG handle ownership') 1602 del _swig 1603 del As_swig 1604 del From_swig 1605 1606 1607 for klass in (Datatype, 1608 Status, 1609 Request, 1610 Op, 1611 Info, 1612 Group, 1613 Comm, 1614 Win, 1615 File, 1616 Errhandler): 1617 SWIG(klass) 1618 1619 del SWIG 1620 del klass 1621 WORLD_SIZE = _mpi.WORLD_SIZE 1622 WORLD_RANK = _mpi.WORLD_RANK 1623 size = _mpi.WORLD_SIZE 1624 rank = _mpi.WORLD_RANK 1625 zero = WORLD_RANK == 0 1626 last = WORLD_RANK == WORLD_SIZE - 1 1627 even = WORLD_RANK % 2 != 1 1628 odd = WORLD_RANK % 2 == 1 1629 1630 def _mpi_init(): 1631 try: 1632 _mpi._set_exception(Exception) 1633 except StandardError: 1634 pass 1635 1636 1637 _mpi_init() 1638 del _mpi_init 1639 1640 def _mpi_fini(): 1641 try: 1642 _mpi._del_exception() 1643 except StandardError: 1644 pass 1645 1646 try: 1647 if not _mpi.initialized(): 1648 return 1649 if _mpi.finalized(): 1650 return 1651 except StandardError: 1652 return 1653 1654 1655 import atexit 1656 atexit.register(_mpi_fini) 1657 del atexit 1658 del _mpi_fini 1659 1660 def distribute(N, B, i): 1661 return _mpi.distribute(N, B, i) 1662 1663 1664 def pprint(message = None, comm = None, root = 0): 1665 if comm is None: 1666 comm = COMM_WORLD 1667 inbuf = comm.SERIALIZER.dump(message) 1668 result = _mpi.gather_string(inbuf, None, root, comm) 1669 if comm.Get_rank() == root: 1670 for i in result: 1671 msg = comm.SERIALIZER.load(i) 1672 print msg 1673 1674 1675 def rprint(message = None, comm = None, root = 0): 1676 if comm is None: 1677 comm = COMM_WORLD 1678 if comm.Get_rank() == root: 1679 print message