MPI4PY(3)

📦
version 4.1.1 · 3 versions
, in ubuntu resolute, ubuntu stonking

💖 MPI4PY — the manual, but make it make sense 💖

okay bestie, welcome to the MPI for Python page, aka MPI4PY(3), sitting pretty in the MPI for Python corner of the manual. pull up a chair, grab a boba, we're doing this together 🫶

Author: Lisandro Dalcin Contact: <dalcinl@gmail.com> Date: March 20, 2026

🎀 Abstract 🎀

okay so real talk: MPI for Python gives you Python bindings for the Message Passing Interface (MPI) standard. the whole point? letting your Python apps go absolutely feral across multiple processors on workstations, clusters, and supercomputers. slay. 👑

this package is built on top of the MPI specification and serves up an object oriented interface that's giving major MPI-2 C++ bindings energy. it handles:

  • point-to-point stuff (sends, receives) ✉️
  • collective stuff (broadcasts, scatters, gathers) 📢
  • communication of any picklable Python object
  • efficient communication of Python objects that expose the Python buffer interface — think NumPy arrays, plus builtin bytes/array/memoryview objects 💅

🌈 INTRODUCTION 🌈

so over the last few years, high performance computing went from "only the cool kids with money" to actually affordable for way more researchers in the scientific community than ever before. the combo of quality open source software + commodity hardware is literally why Beowulf <https://www.beowulf.org/> class clusters and cluster of workstations are so popular now. iconic behavior fr fr.

out of all the parallel computational models out there, message-passing has proven itself to be a genuinely effective one. this paradigm is especially suited for (but not limited to!!) distributed memory architectures, and it's used in today's most demanding scientific and engineering applications — modeling, simulation, design, signal processing, the whole vibe. but here's the tea: portable message-passing parallel programming used to be an actual nightmare because of all the incompatible options devs were stuck with. fortunately, that whole situation changed for good once the MPI Forum dropped its standard specification. ✨

high performance computing is traditionally associated with software development using compiled languages. but bestie, in typical application programs, only a small part of the code is actually time-critical enough to need the efficiency of compiled languages. the rest is generally about memory management, error handling, input/output, and user interaction — and those are usually the most error prone and time-consuming lines to write and debug in the entire development process. interpreted high-level languages can be really advantageous for this kind of task.

for implementing general-purpose numerical computations, MATLAB [1] is the dominant interpreted programming language. on the open source side, Octave and Scilab are well known, freely distributed packages providing compatibility with the MATLAB language. in this work, we present MPI for Python — a new package enabling applications to exploit multiple processors using standard MPI "look and feel" in Python scripts. 💅

[1] MATLAB is a registered trademark of The MathWorks, Inc.

🦋 What is MPI? 🦋

MPI <https://www.mpi-forum.org/>, [mpi-using] <#mpi-using> [mpi-ref] <#mpi-ref> — the Message Passing Interface — is a standardized and portable message-passing system designed to function on a wide variety of parallel computers. the standard defines the syntax and semantics of library routines and lets users write portable programs in the main scientific programming languages (Fortran, C, or C++).

since its release, the MPI specification [mpi-std1] <#mpi-std1> [mpi-std2] <#mpi-std2> has become the leading standard for message-passing libraries for parallel computers. implementations are available from vendors of high-performance computers and from well known open source projects like MPICH <https://www.mpich.org/> [mpi-mpich] <#mpi-mpich> and Open MPI <https://www.open-mpi.org/> [mpi-openmpi] <#mpi-openmpi>. 👑

🌸 What is Python? 🌸

Python <https://www.python.org/> is a modern, easy to learn, powerful programming language. it has efficient high-level data structures and a simple but effective approach to object-oriented programming with dynamic typing and dynamic binding. it supports modules and packages, which encourages program modularity and code reuse. Python's elegant syntax, together with its interpreted nature, make it an ideal language for scripting and rapid application development in many areas on most platforms.

the Python interpreter and the extensive standard library are available in source or binary form without charge for all major platforms, and can be freely distributed. it's easily extended with new functions and data types implemented in C or C++. Python is also suitable as an extension language for customizable applications.

Python is an ideal candidate for writing the higher-level parts of large-scale scientific applications [Hinsen97] <#hinsen97> and driving simulations in parallel architectures [Beazley97] <#beazley97> like clusters of PC's or SMP's. Python codes are quickly developed, easily maintained, and can achieve a high degree of integration with other libraries written in compiled languages. 🐍✨

as this work started and evolved, some ideas were borrowed from well known MPI and Python related open source projects from the Internet. credit where credit is due, bestie 🫶

  • OOMPI <https://web.archive.org/web/20100614170656/http://www.osl.iu.edu/research/oompi/overview.php>
    • it has no relation with Python, but is an excellent object oriented approach to MPI.
    • it's a C++ class library specification layered on top of the C bindings that encapsulates MPI into a functional class hierarchy.
    • it provides a flexible and intuitive interface by adding some abstractions, like Ports and Messages, which enrich and simplify the syntax.
  • Pypar <https://github.com/daleroberts/pypar>
    • its interface is rather minimal. there is no support for communicators or process topologies.
    • it does not require the Python interpreter to be modified or recompiled, but does not permit interactive parallel runs.
    • general (picklable) Python objects of any type can be communicated. there is good support for numeric arrays, practically full MPI bandwidth can be achieved. 🔥
  • pyMPI <https://sourceforge.net/projects/pympi/>
    • it rebuilds the Python interpreter providing a built-in module for message passing. it does permit interactive parallel runs, which are useful for learning and debugging.
    • it provides an interface suitable for basic parallel programming. there is not full support for defining new communicators or process topologies.
    • general (picklable) Python objects can be messaged between processors. there is native support for numeric arrays.
  • Scientific Python <http://dirac.cnrs-orleans.fr/ScientificPython.html>
    • it provides a collection of Python modules that are useful for scientific computing.
    • there is an interface to MPI and BSP (Bulk Synchronous Parallel programming).
    • the interface is simple but incomplete and does not resemble the MPI specification. there is support for numeric arrays.

additionally, we would like to mention some available tools for scientific computing and software development with Python. ✨

  • NumPy <https://numpy.org/> is a package that provides array manipulation and computational capabilities similar to those found in IDL, MATLAB, or Octave. using NumPy, it is possible to write many efficient numerical data processing applications directly in Python without using any C, C++ or Fortran code.
  • SciPy <https://scipy.org/> is an open source library of scientific tools for Python, gathering a variety of high level science and engineering modules together as a single package. it includes modules for graphics and plotting, optimization, integration, special functions, signal and image processing, genetic algorithms, ODE solvers, and others.
  • Cython <https://cython.org/> is a language that makes writing C extensions for the Python language as easy as Python itself. the Cython language is very close to the Python language, but Cython additionally supports calling C functions and declaring C types on variables and class attributes. this allows the compiler to generate very efficient C code from Cython code. this makes Cython the ideal language for wrapping for external C libraries, and for fast C modules that speed up the execution of Python code.
  • SWIG <https://www.swig.org/> is a software development tool that connects programs written in C and C++ with a variety of high-level programming languages like Perl, Tcl/Tk, Ruby and Python. issuing header files to SWIG is the simplest approach to interfacing C/C++ libraries from a Python module.

📚 the references, aka the receipts 📚

  • [mpi-std1] — MPI Forum. MPI: A Message Passing Interface Standard. International Journal of Supercomputer Applications, volume 8, number 3-4, pages 159-416, 1994.
  • [mpi-std2] — MPI Forum. MPI: A Message Passing Interface Standard. High Performance Computing Applications, volume 12, number 1-2, pages 1-299, 1998.
  • [mpi-using] — William Gropp, Ewing Lusk, and Anthony Skjellum. Using MPI: portable parallel programming with the message-passing interface. MIT Press, 1994.
  • [mpi-ref] — Mark Snir, Steve Otto, Steven Huss-Lederman, David Walker, and Jack Dongarra. MPI - The Complete Reference, volume 1, The MPI Core. MIT Press, 2nd. edition, 1998.
  • [mpi-mpich] — W. Gropp, E. Lusk, N. Doss, and A. Skjellum. A high-performance, portable implementation of the MPI message passing interface standard. Parallel Computing, 22(6):789-828, September 1996.
  • [mpi-openmpi] — Edgar Gabriel, Graham E. Fagg, George Bosilca, Thara Angskun, Jack J. Dongarra, Jeffrey M. Squyres, Vishal Sahay, Prabhanjan Kambadur, Brian Barrett, Andrew Lumsdaine, Ralph H. Castain, David J. Daniel, Richard L. Graham, and Timothy S. Woodall. Open MPI: Goals, Concept, and Design of a Next Generation MPI Implementation. In Proceedings, 11th European PVM/MPI Users' Group Meeting, Budapest, Hungary, September 2004.
  • [Hinsen97] — Konrad Hinsen. The Molecular Modelling Toolkit: a case study of a large scientific application in Python. In Proceedings of the 6th International Python Conference, pages 29-35, San Jose, Ca., October 1997.
  • [Beazley97] — David M. Beazley and Peter S. Lomdahl. Feeding a large-scale physics application to Python. In Proceedings of the 6th International Python Conference, pages 21-29, San Jose, Ca., October 1997.

🌈 OVERVIEW 🌈

okay bestie, buckle UP — MPI for Python gives you an object oriented way to do message passing, and it's built on top of the standard MPI-2 C++ bindings. The whole interface was designed with one mission: translating the syntax and semantics of those standard MPI-2 C++ bindings straight into Python. So if you already know the standard C/C++ MPI bindings, you can just… use this module. No new interface to learn, periodt. 💅

🐍 Communicating Python Objects and Array Data

The Python standard library has a bunch of different mechanisms for data persistence. A lot of them lean on disk storage, but pickling and marshaling can also work with memory buffers. ✨

The pickle module gives you user-extensible facilities to serialize general Python objects using ASCII or binary formats. The marshal module gives you facilities to serialize built-in Python objects using a binary format that's specific to Python, but independent of machine architecture issues. 🎀

MPI for Python can communicate any built-in or user-defined Python object by taking advantage of the features the pickle module provides. These facilities get routinely used to build binary representations of objects to communicate (that's the sending process's job), and to restore them back (that's the receiving process's job). 🔄

Now — as simple and general as that serialization approach (i.e. pickling and unpickling) is, it imposes important overheads in memory as well as processor usage, especially when the objects being communicated have large memory footprints. Pickling general Python objects — anything from primitive or container built-in types up to user-defined classes — necessarily eats computer resources. You also need processing power to dispatch the appropriate serialization method (which depends on the object's type) and to do the actual packing. Additional memory is always needed, and if its total amount isn't known a priori, you can get many reallocations. 💀 And for large numeric arrays? Yeah, that's just straight-up unacceptable, and it precludes communication of objects occupying half or more of the available memory resources. Not the vibe. 😭

Here's the glow-up: MPI for Python supports direct communication of any object exporting the single-segment buffer interface. That interface is a standard Python mechanism provided by some types (e.g. strings and numeric arrays), and it lets the C side access a contiguous memory buffer (i.e. address and length) holding the relevant data. Combine that with the ability to construct user-defined MPI datatypes describing complicated memory layouts, and you can implement so many algorithms involving multidimensional numeric arrays — image processing, fast Fourier transforms, finite difference schemes on structured Cartesian grids, the whole lineup — directly in Python, with negligible overhead, and almost as fast as compiled Fortran, C, or C++ codes. 🔥 slay.

👑 Communicators

In MPI for Python, Comm is the base class of communicators. The Intracomm and Intercomm classes are subclasses of the Comm class. The Comm.Is_inter method (and Comm.Is_intra, provided for convenience but not part of the MPI specification) is defined for communicator objects, and you can use it to figure out the particular communicator class. 🕵️‍♀️

There are two predefined intracommunicator instances ready for you: COMM_SELF and COMM_WORLD. From those, you can create new communicators whenever you need them. 🌱

Want the number of processes in a communicator, or the calling process rank? That's Comm.Get_size and Comm.Get_rank respectively. The associated process group comes from calling Comm.Get_group, which returns an instance of the Group class. Set operations with Group objects like Group.Union, Group.Intersection and Group.Difference are fully supported, and so is creating new communicators from those groups using Comm.Create and Intracomm.Create_group. 🫶

New communicator instances can come from the Comm.Clone, Comm.Dup and Comm.Split methods, plus the Intracomm.Create_intercomm and Intercomm.Merge methods. So many doors, bestie. 🚪✨

Virtual topologies are fully supported too — that's the Cartcomm, Graphcomm and Distgraphcomm classes, which are specializations of the Intracomm class. You get new instances from intracommunicator instances with the factory methods Intracomm.Create_cart and Intracomm.Create_graph. 🗺️

💌 Point-to-Point Communications

Point to point communication is a fundamental capability of message passing systems. This mechanism enables the transmission of data between a pair of processes: one side sending, the other receiving. 💌

MPI provides a set of send and receive functions that let you communicate typed data with an associated tag. The type information enables conversion of data representation from one architecture to another in heterogeneous computing environments — and bonus, it allows the representation of non-contiguous data layouts and user-defined datatypes, so you skip the overhead of the (otherwise unavoidable) packing/unpacking operations. The tag information lets the receiving end be selective about which messages it picks up. 🎯

🛑 Blocking Communications

MPI provides basic send and receive functions that are blocking. These functions block the caller until the data buffers involved in the communication can be safely reused by the application program. Like, actually wait. ⏳

In MPI for Python, the Comm.Send, Comm.Recv and Comm.Sendrecv methods of communicator objects provide support for blocking point-to-point communications within Intracomm and Intercomm instances. These methods can communicate memory buffers. The variants Comm.send, Comm.recv and Comm.sendrecv can communicate general Python objects. 🧸

⚡ Nonblocking Communications

On many systems, performance can be significantly increased by overlapping communication and computation. This is especially true on systems where communication can be executed autonomously by an intelligent, dedicated communication controller. 🤖

MPI provides nonblocking send and receive functions. They allow the possible overlap of communication and computation. Non-blocking communication always comes in two parts: posting functions, which begin the requested operation; and test-for-completion functions, which let you discover whether the requested operation has completed. 🏁

In MPI for Python, the Comm.Isend and Comm.Irecv methods initiate send and receive operations, respectively. These methods return a Request instance that uniquely identifies the started operation. Its completion can be managed using the Request.Test, Request.Wait, and Request.Cancel methods. But listen — managing Request objects and the associated memory buffers involved in communication requires a careful, rather low-level coordination. Users must ensure that objects exposing their memory buffers are not accessed at the Python level while they're involved in nonblocking message-passing operations. 🚨

bestie this is the part where you actually pay attention: no touching the buffer while it's mid-flight, okay? 🙈

🔁 Persistent Communications

Often a communication with the same argument list gets repeatedly executed inside an inner loop. In those cases, communication can be further optimized by using persistent communication — a particular case of nonblocking communication that allows the reduction of the overhead between processes and communication controllers. And furthermore, this kind of optimization can also alleviate the extra call overheads associated with interpreted, dynamic languages like Python. 🐍💨

In MPI for Python, the Comm.Send_init and Comm.Recv_init methods create persistent requests for a send and receive operation, respectively. These methods return an instance of the Prequest class, a subclass of the Request class. The actual communication can be effectively started using the Prequest.Start method, and its completion can be managed as previously described. 👑

🎉 Collective Communications

Collective communications allow the transmittal of data between multiple processes of a group simultaneously. The syntax and semantics of collective functions is consistent with point-to-point communication. Collective functions communicate typed data, but messages are not paired with an associated tag; selectivity of messages is implied in the calling order. 📞

The more commonly used collective communication operations are the following.

  • Barrier synchronization across all group members. 🧱
  • Global communication functions
    • Broadcast data from one member to all members of a group. 📢
    • Gather data from all members to one member of a group. 🧺
    • Scatter data from one member to all members of a group. 🌸
  • Global reduction operations such as sum, maximum, minimum, etc. ➕

Okay so let's talk collectives, because this is where mpi4py really ate 💅. When you wanna sling memory buffers around the whole squad at once, Comm.Bcast, Comm.Scatter, Comm.Gather, Comm.Allgather, and Comm.Alltoall have you covered 💖. And if your data isn't a plain buffer but a whole general Python object? The lower-case girlies Comm.bcast, Comm.scatter, Comm.gather, Comm.allgather, and Comm.alltoall handle that, no cap ✨.

Then there's the vector variants — these ones can send different amounts of data to each process, which is honestly so thoughtful of them 🫶 — and those are Comm.Scatterv, Comm.Gatherv, Comm.Allgatherv, Comm.Alltoallv, and Comm.Alltoallw. Small catch though: they can only communicate objects exposing memory buffers. No random Python objects, sorry bestie 😭.

Global reduction operations on memory buffers? Those come at you through Comm.Reduce, Comm.Reduce_scatter, Comm.Allreduce, Intracomm.Scan, and Intracomm.Exscan 👑. And their lower-case twins Comm.reduce, Comm.allreduce, Intracomm.scan, and Intracomm.exscan can pass general Python objects around, but heads up — the actual reduction computations required get performed sequentially at some process, so it's giving "convenient but not the scalability flex you were hoping for" 💀. Also, every single predefined reduction operation (SUM, PROD, MAX, etc.) can be applied. Periodt 🌟.

💜 Support for GPU-aware MPI 💜

Several MPI implementations — Open MPI and MVAPICH included — support passing GPU pointers straight into MPI calls, which means you get to skip the whole explicit data movement between host and device thing entirely 🦋. On the Python side, support for handling GPU arrays has already been implemented in a bunch of GPU-computation libraries like CuPy, Numba, PyTorch, and PyArrow 🌈.

And because interoperability across library boundaries is the moment, two kinds of zero-copy data exchange protocols have been defined and agreed upon: DLPack and CUDA Array Interface (CAI) ✨.

MPI for Python provides an experimental support for GPU-aware MPI. This feature requires:

  1. mpi4py is built against a GPU-aware MPI library.
  2. The Python GPU arrays are compliant with either of the protocols.

See the Tutorial section for further information. We note that:

  • Whether or not a MPI call can work for GPU arrays depends on the underlying MPI implementation, not on mpi4py 👀.
  • This support is currently experimental and subject to change in the future.
So like... don't build your whole personality on it yet, bestie 🙈.

🌀 Dynamic Process Management 🌀

In the context of the MPI-1 specification, a parallel application is static — meaning no processes can be added to or deleted from a running application after it has been started 🥲. Fortunately, this limitation got addressed in MPI-2, and the new specification added a process management model providing a basic interface between an application and external resources and process managers 💫.

This MPI-2 extension can be really useful, especially for sequential applications built on top of parallel modules, or parallel applications with a client/server model. The MPI-2 process model gives you a mechanism to create new processes and establish communication between them and the existing MPI application 👯. It also provides mechanisms to establish communication between two existing MPI applications, even when one did not start the other. Iconic behaviour, honestly.

In MPI for Python, new independent process groups can be created by calling the Intracomm.Spawn method within an intracommunicator. This call returns a new intercommunicator (i.e., an Intercomm instance) at the parent process group 💖. The child process group can retrieve the matching intercommunicator by calling the Comm.Get_parent class method. At each side, the new intercommunicator can be used to perform point to point and collective communications between the parent and child groups of processes 🫶.

Alternatively, disjoint groups of processes can establish communication using a client/server approach. Any server application must first call the Open_port function to open a port and the Publish_name function to publish a provided service, and next call the Intracomm.Accept method 📞. Any client applications can first find a published service by calling the Lookup_name function, which returns the port where a server can be contacted; and next call the Intracomm.Connect method. Both Intracomm.Accept and Intracomm.Connect methods return an Intercomm instance 🌸.

When connection between client/server processes is no longer needed, all of them must cooperatively call the Comm.Disconnect method — it's a group project, you can't just ghost 😤. Additionally, server applications should release resources by calling the Unpublish_name and Close_port functions 🧹.

🔮 One-Sided Communications 🔮

One-sided communications (also called Remote Memory Access, or RMA) supplements the traditional two-sided, send/receive based MPI communication model with a one-sided, put/get based interface 🌈. One-sided communication that can take advantage of the capabilities of highly specialized network hardware. Additionally, this extension lowers latency and software overhead in applications written using a shared-memory-like paradigm ⚡.

The MPI specification revolves around the use of objects called windows; they intuitively specify regions of a process's memory that have been made available for remote read and write operations 🪟. The published memory blocks can be accessed through three functions for put (remote send), get (remote write), and accumulate (remote update or reduction) data items. A much larger number of functions support different synchronization styles; the semantics of these synchronization operations are fairly complex, ngl 💀.

In MPI for Python, one-sided operations are available by using instances of the Win class 👑. New window objects are created by calling the Win.Create method at all processes within a communicator and specifying a memory buffer. When a window instance is no longer needed, the Win.Free method should be called 🧹.

The three one-sided MPI operations for remote write, read and reduction are available through calling the methods Win.Put, Win.Get, and Win.Accumulate respectively within a Win instance ✨. These methods need an integer rank identifying the target process and an integer offset relative the base address of the remote memory block being accessed 📍.

The one-sided operations read, write, and reduction are implicitly nonblocking, and must be synchronized by using two primary modes 🕰️. Active target synchronization requires the origin process to call the Win.Start and Win.Complete methods at the origin process, and target process cooperates by calling the Win.Post and Win.Wait methods 🤝. There is also a collective variant provided by the Win.Fence method. Passive target synchronization is more lenient — only the origin process calls the Win.Lock and Win.Unlock methods 🔒. Locks are used to protect remote accesses to the locked remote window and to protect local load/store accesses to a locked local window.

📂 Parallel Input/Output 📂

The POSIX standard provides a model of a widely portable file system 🗂️. However, the optimization needed for parallel input/output cannot be achieved with this generic interface 😭. In order to ensure efficiency and scalability, the underlying parallel input/output system must provide a high-level interface supporting partitioning of file data among processes and a collective interface supporting complete transfers of global data structures between process memories and files 💫. Additionally, further efficiencies can be gained via support for asynchronous input/output, strided accesses to data, and control over physical file layout on storage devices. This scenario motivated the inclusion in the MPI-2 standard of a custom interface in order to support more elaborated parallel input/output operations 🌸.

The MPI specification for parallel input/output revolves around the use objects called files. As defined by MPI, files are not just contiguous byte streams 🚫. Instead, they are regarded as ordered collections of typed data items. MPI supports sequential or random access to any integral set of these items. Furthermore, files are opened collectively by a group of processes 👯.

The common patterns for accessing a shared file (broadcast, scatter, gather, reduction) is expressed by using user-defined datatypes 🎀. Compared to the communication patterns of point-to-point and collective communications, this approach has the advantage of added flexibility and expressiveness ✨. Data access operations (read and write) are defined for different kinds of positioning (using explicit offsets, individual file pointers, and shared file pointers), coordination (non-collective and collective), and synchronism (blocking, nonblocking, and split collective with begin/end phases) 📋.

In MPI for Python, all MPI input/output operations are performed through instances of the File class 📁. File handles are obtained by calling the File.Open method at all processes within a communicator and providing a file name and the intended access mode 🔑. After use, they must be closed by calling the File.Close method. Files even can be deleted by calling method File.Delete 🗑️.

After creation, files are typically associated with a per-process view 👀. The view defines the current set of data visible and accessible from an open file as an ordered set of elementary datatypes. This data layout can be set and queried with the File.Set_view and File.Get_view methods respectively 🦋.

okay so the actual reading and writing?? that's done by a whole vibe of methods that mix read and write calls together, and they all behave differently depending on positioning, coordination, and synchronism. summing up the tea: MPI for Python hands you the thirty (30) methods defined in MPI-2 for reading from or writing to files, using either explicit offsets or file pointers (individual or shared), and in blocking or nonblocking and collective or noncollective versions. yes bestie, thirty. count them. 💅

🫶 ENVIRONMENTAL MANAGEMENT 🫶

✨ Initialization and Exit ✨

so the module functions Init and Init_thread and Finalize handle MPI initialization and finalization respectively — like, they're the ones doing the setup and the shutdown. and the module functions Is_initialized and Is_finalized give you the respective tests for initialization and finalization. iykyk. 🌸

Note: MPI_Init() or MPI_Init_thread() is actually called when you import the MPI module from the mpi4py package, but only if MPI is not already initialized. In such case, calling Init or Init_thread from Python is expected to generate an MPI error, and in turn an exception will be raised. so like, don't double-init, bestie, she will yell at you. 😭
Note: MPI_Finalize() is registered (by using Python C/API function Py_AtExit()) for being automatically called when Python processes exit, but only if mpi4py actually initialized MPI. Therefore, there is no need to call Finalize from Python to ensure MPI finalization. she cleans up after herself, periodt. 🧚

💖 Implementation Information 💖

  • The MPI version number can be retrieved from module function Get_version. It returns a two-integer tuple (version, subversion). cute little pair fr fr.
  • The Get_processor_name function can be used to access the processor name. iconic.
  • The values of predefined attributes attached to the world communicator can be obtained by calling the Comm.Get_attr method within the COMM_WORLD instance. yes, the whole world, literally. 🌈

⏰ Timers ⏰

MPI timer functionalities are available through the Wtime and Wtick functions. ticking away like a little clock emoji bestie 🕐✨

🚨 Error Handling 🚨

In order to facilitate handle sharing with other Python modules interfacing MPI-based parallel libraries, the predefined MPI error handlers ERRORS_RETURN and ERRORS_ARE_FATAL can be assigned to and retrieved from communicators using methods Comm.Set_errhandler and Comm.Get_errhandler, and similarly for windows and files. New custom error handlers can be created with Comm.Create_errhandler. like, you can literally make your own error handler. main character energy. 👑

When the predefined error handler ERRORS_RETURN is set, errors returned from MPI calls within Python code will raise an instance of the exception class Exception, which is a subclass of the standard Python exception RuntimeError. so it comes back as a whole exception, not just silently vibing.

Note: After import, mpi4py overrides the default MPI rules governing inheritance of error handlers. The ERRORS_RETURN error handler is set in the predefined COMM_SELF and COMM_WORLD communicators, as well as any new Comm, Win, or File instance created through mpi4py. If you ever pass such handles to C/C++/Fortran library code, it is recommended to set the ERRORS_ARE_FATAL error handler on them to ensure MPI errors do not pass silently. 🫶 so like, if you're handing your handles off to the C besties, switch to fatal so nothing gets swept under the rug, no cap.
Warning: Importing with from mpi4py.MPI import * will cause a name clashing with the standard Python Exception base class. so like… don't do that unless you want chaos. 💀🙈

🎀 TUTORIAL 🎀

Warning: Under construction. Contributions very welcome! 🚧 bestie it's a work in progress, come help us build it.
Tip: Rolf Rabenseifner at HLRS developed a comprehensive MPI-3.1/4.0 course with slides and a large set of exercises including solutions. This material is available online for self-study. The slides and exercises show the C, Fortran, and Python (mpi4py) interfaces. For performance reasons, most Python exercises use NumPy arrays and communication routines involving buffer-like objects. go off king, the exercises are so good. 📚✨
Tip: Victor Eijkhout at TACC authored the book Parallel Programming for Science and Engineering. This book is available online in PDF and HTML formats. The book covers parallel programming with MPI and OpenMP in C/C++ and Fortran, and MPI in Python using mpi4py. the way this book covers literally everything?? obsessed. 🦋

MPI for Python supports convenient, pickle-based communication of generic Python object as well as fast, near C-speed, direct array data communication of buffer-provider objects (e.g., NumPy arrays). like, both the cozy option AND the fast option. bestie you get to pick your vibe. 💅

  • Communication of generic Python objects

You have to use methods with all-lowercase names, like Comm.send, Comm.recv, Comm.bcast, Comm.scatter, Comm.gather. An object to be sent is passed as a parameter to the communication call, and the received object is simply the return value. lowercase = the pickle-y object vibe, got it. 🍓

The Comm.isend and Comm.irecv methods return Request instances; completion of these methods can be managed using the Request.test and Request.wait methods. non-blocking girlies rise. 🧚

The Comm.recv and Comm.irecv methods may be passed a buffer object that can be repeatedly used to receive messages avoiding internal memory allocation. This buffer must be sufficiently large to accommodate the transmitted messages; hence, any buffer passed to Comm.recv or Comm.irecv must be at least as long as the pickled data transmitted to the receiver. so like, size your buffer right or it's gonna be a whole mess. 😭

Collective calls like Comm.scatter, Comm.gather, Comm.allgather, Comm.alltoall expect a single value or a sequence of Comm.size elements at the root or all process. They return a single value, a list of Comm.size elements, or None. yes bestie, sometimes she just returns None. that's the whole vibe. 💀

Note: MPI for Python uses the highest protocol version available in the Python runtime (see the HIGHEST_PROTOCOL constant in the pickle module). The default protocol can be changed at import time by setting the MPI4PY_PICKLE_PROTOCOL environment variable, or at runtime by assigning a different value to the PROTOCOL attribute of the pickle object within the MPI module. so you got two levers to pull — one at import, one at runtime. pick your fighter. 🎀
  • Communication of buffer-like objects

You have to use method names starting with an upper-case letter, like Comm.Send, Comm.Recv, Comm.Bcast, Comm.Scatter, Comm.Gather. capital letters = the fast buffer vibe. slay. 🔥

In general, buffer arguments to these calls must be explicitly specified by using a 2/3-list/tuple like [data, MPI.DOUBLE], or [data, count, MPI.DOUBLE] (the former one uses the byte-size of data and the extent of the MPI datatype to define count). okay so 2-element or 3-element, and the short one does the count math for you. cute.

For vector collectives communication operations like Comm.Scatterv and Comm.Gatherv, buffer arguments are specified as [data, count, displ, datatype], where count and displ are sequences of integral values. four things, count and displ are sequences of ints. no cap. 🫶

Automatic MPI datatype discovery for NumPy/GPU arrays and PEP-3118 buffers is supported, but limited to basic C types (all C/C99-native signed/unsigned integral types and single/double precision real/complex floating types) and availability of matching datatypes in the underlying MPI implementation. In this case, the buffer-provider object can be passed directly as a buffer argument, the count and MPI datatype will be inferred. so she sniffs out the type for you, but only for the basics, and only if your MPI implementation actually has a matching datatype. 🦋

If mpi4py is built against a GPU-aware MPI implementation, GPU arrays can be passed to upper-case methods as long as they have either the __dlpack__ and __dlpack_device__ methods or the __cuda_array_interface__ attribute that are compliant with the respective standard specifications. Moreover, only C-contiguous or Fortran-contiguous GPU arrays are supported. It is important to note that GPU buffers must be fully ready before any MPI routines operate on them to avoid race conditions. This can be ensured by using the synchronization API of your array library. mpi4py does not have access to any GPU-specific functionality and thus cannot perform this operation automatically for users. 💀 so like, YOU gotta sync your GPU buffers before MPI touches them, mpi4py literally cannot do it for you. do not skip this step bestie, race conditions are not the vibe.

🏃 Running Python scripts with MPI 🏃

Most MPI programs can be run with the command mpiexec. In practice, running Python programs looks like:

$ mpiexec -n 4 python script.py

to run the program with 4 processors. four little workers, one little script. 🫶

💌 Point-to-Point Communication 💌

  • Python objects (pickle under the hood):
from mpi4py import MPI

comm = MPI.COMM_WORLD
rank = comm.Get_rank()

if rank == 0:
    data = {'a': 7, 'b': 3.14}
    comm.send(data, dest=1, tag=11)
elif rank == 1:
    data = comm.recv(source=0, tag=11)
  • Python objects with non-blocking communication:
from mpi4py import MPI

comm = MPI.COMM_WORLD
rank = comm.Get_rank()

if rank == 0:
    data = {'a': 7, 'b': 3.14}
    req = comm.isend(data, dest=1, tag=11)
    req.wait()
elif rank == 1:
    req = comm.irecv(source=0, tag=11)
    data = req.wait()
  • NumPy arrays (the fast way!): ✨

okay bestie we are STILL in point-to-point territory and the glow-up is real — mpi4py will either hold your datatype's hand or just read your mind and figure it out itself. pick your fighter 💅

from mpi4py import MPI
import numpy

comm = MPI.COMM_WORLD
rank = comm.Get_rank()

# passing MPI datatypes explicitly
if rank == 0:
    data = numpy.arange(1000, dtype='i')
    comm.Send([data, MPI.INT], dest=1, tag=77)
elif rank == 1:
    data = numpy.empty(1000, dtype='i')
    comm.Recv([data, MPI.INT], source=0, tag=77)

# automatic MPI datatype discovery
if rank == 0:
    data = numpy.arange(100, dtype=numpy.float64)
    comm.Send(data, dest=1, tag=13)
elif rank == 1:
    data = numpy.empty(100, dtype=numpy.float64)
    comm.Recv(data, source=0, tag=13)
ngl the second half is mpi4py doing automatic MPI datatype discovery — you hand it the buffer and it just knows. no cap. 🔥

🫶 Collective Communication 🫶

okay so point-to-point is giving "just us two" energy, but collective ops are the group chat — everybody eats at the same time. let's gooo:

  • Broadcasting a Python dictionary: rank 0 is holding the dict, and comm.bcast(data, root=0) beams it to literally everyone. the other ranks just sit there with data = None and wait for the serve. main character behavior fr fr.
from mpi4py import MPI

comm = MPI.COMM_WORLD
rank = comm.Get_rank()

if rank == 0:
    data = {'key1' : [7, 2.72, 2+3j],
            'key2' : ( 'abc', 'xyz')}
else:
    data = None
data = comm.bcast(data, root=0)
  • Scattering Python objects: root builds a whole list of squares [(i+1)**2 for i in range(size)], then comm.scatter(data, root=0) hands each rank its own lil slice, and the assert is there to make sure everybody got exactly what they were owed. vibe check passed ✨
from mpi4py import MPI

comm = MPI.COMM_WORLD
size = comm.Get_size()
rank = comm.Get_rank()

if rank == 0:
    data = [(i+1)**2 for i in range(size)]
else:
    data = None
data = comm.scatter(data, root=0)
assert data == (rank+1)**2
  • Gathering Python objects: the reverse serve 💫 — every rank computes its own (rank+1)**2 and hands it over, root collects the whole list with comm.gather(data, root=0), and the non-roots get None back. not me checking with assert data is None 😭
from mpi4py import MPI

comm = MPI.COMM_WORLD
size = comm.Get_size()
rank = comm.Get_rank()

data = (rank+1)**2
data = comm.gather(data, root=0)
if rank == 0:
    for i in range(size):
        assert data[i] == (i+1)**2
else:
    assert data is None
  • Broadcasting a NumPy array: root has np.arange(100, dtype='i'), everyone else pre-allocates np.empty(100, dtype='i'), then comm.Bcast(data, root=0) fills it in. lowercase bcast returns the object, uppercase Bcast fills your buffer — the caps version is the buffer queen 👑
from mpi4py import MPI
import numpy as np

comm = MPI.COMM_WORLD
rank = comm.Get_rank()

if rank == 0:
    data = np.arange(100, dtype='i')
else:
    data = np.empty(100, dtype='i')
comm.Bcast(data, root=0)
for i in range(100):
    assert data[i] == i
  • Scattering NumPy arrays: root makes a big [size, 100] sendbuf and does the lil sendbuf.T[:,:] = range(size) trick so every row is a rank number. then comm.Scatter(sendbuf, recvbuf, root=0) gives each rank its own recvbuf of 100, and np.allclose(recvbuf, rank) confirms it. obsessed with this one 🍓
from mpi4py import MPI
import numpy as np

comm = MPI.COMM_WORLD
size = comm.Get_size()
rank = comm.Get_rank()

sendbuf = None
if rank == 0:
    sendbuf = np.empty([size, 100], dtype='i')
    sendbuf.T[:,:] = range(size)
recvbuf = np.empty(100, dtype='i')
comm.Scatter(sendbuf, recvbuf, root=0)
assert np.allclose(recvbuf, rank)
  • Gathering NumPy arrays: every rank fills a sendbuf of 100 with np.zeros(100, dtype='i') + rank, root pre-allocates [size, 100] for the recvbuf, and comm.Gather(sendbuf, recvbuf, root=0) stacks it all up. then root double-checks every row. it's giving meticulous 💅
from mpi4py import MPI
import numpy as np

comm = MPI.COMM_WORLD
size = comm.Get_size()
rank = comm.Get_rank()

sendbuf = np.zeros(100, dtype='i') + rank
recvbuf = None
if rank == 0:
    recvbuf = np.empty([size, 100], dtype='i')
comm.Gather(sendbuf, recvbuf, root=0)
if rank == 0:
    for i in range(size):
        assert np.allclose(recvbuf[i,:], i)
  • Parallel matrix-vector product: the iconic matvec(comm, A, x) function — m = A.shape[0] is your local row count, p = comm.Get_size() is how many of us there are, xg = numpy.zeros(m*p, dtype='d') is where the full x gets rebuilt, comm.Allgather([x, MPI.DOUBLE], [xg, MPI.DOUBLE]) does the sharing, and then y = numpy.dot(A, xg) is the actual math. the way that Allgather just makes the whole vector appear everywhere… ate. 🔥
from mpi4py import MPI
import numpy

def matvec(comm, A, x):
    m = A.shape[0] # local rows
    p = comm.Get_size()
    xg = numpy.zeros(m*p, dtype='d')
    comm.Allgather([x,  MPI.DOUBLE],
                   [xg, MPI.DOUBLE])
    y = numpy.dot(A, xg)
    return y

🌈 Input/Output (MPI-IO) 🌈

yes bestie, we're doing file I/O in parallel and honestly it's a whole vibe.

  • Collective I/O with NumPy arrays: you set amode = MPI.MODE_WRONLY|MPI.MODE_CREATE, open the file with MPI.File.Open(comm, "./datafile.contig", amode), fill a buffer of 10 ints with your rank, then compute offset = comm.Get_rank()*buffer.nbytes so nobody's stepping on anyone's toes. fh.Write_at_all(offset, buffer) drops it in, then fh.Close() closes it out. clean. periodt. 🎀
from mpi4py import MPI
import numpy as np

amode = MPI.MODE_WRONLY|MPI.MODE_CREATE
comm = MPI.COMM_WORLD
fh = MPI.File.Open(comm, "./datafile.contig", amode)

buffer = np.empty(10, dtype=np.int)
buffer[:] = comm.Get_rank()

offset = comm.Get_rank()*buffer.nbytes
fh.Write_at_all(offset, buffer)

fh.Close()
  • Non-contiguous Collective I/O with NumPy arrays and datatypes: the ✨fancy✨ version. item_count = 10, buffer full of your rank, then filetype = MPI.INT.Create_vector(item_count, 1, size) makes a custom datatype and filetype.Commit() locks it in. displacement = MPI.INT.Get_size()*rank is where each rank starts, fh.Set_view(displacement, filetype=filetype) sets the view, fh.Write_all(buffer) writes it, and then filetype.Free() + fh.Close() clean everything up. iykyk 🦋
from mpi4py import MPI
import numpy as np

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()

amode = MPI.MODE_WRONLY|MPI.MODE_CREATE
fh = MPI.File.Open(comm, "./datafile.noncontig", amode)

item_count = 10

buffer = np.empty(item_count, dtype='i')
buffer[:] = rank

filetype = MPI.INT.Create_vector(item_count, 1, size)
filetype.Commit()

displacement = MPI.INT.Get_size()*rank
fh.Set_view(displacement, filetype=filetype)

fh.Write_all(buffer)
filetype.Free()
fh.Close()

🧚 Dynamic Process Management 🧚

this is the "we spawn our own friends" section and it's genuinely iconic.

  • Compute Pi - Master (or parent, or client) side: you MPI.COMM_SELF.Spawn(sys.executable, args=['cpi.py'], maxprocs=5) to boot up 5 lil workers, then comm.Bcast([N, MPI.INT], root=MPI.ROOT) sends N = numpy.array(100, 'i') out to them. comm.Reduce(None, [PI, MPI.DOUBLE], op=MPI.SUM, root=MPI.ROOT) collects the partial sums into PI = numpy.array(0.0, 'd'), print(PI) shows the tea, and comm.Disconnect() says bye. 💜
#!/usr/bin/env python
from mpi4py import MPI
import numpy
import sys

comm = MPI.COMM_SELF.Spawn(sys.executable,
                           args=['cpi.py'],
                           maxprocs=5)

N = numpy.array(100, 'i')
comm.Bcast([N, MPI.INT], root=MPI.ROOT)
PI = numpy.array(0.0, 'd')
comm.Reduce(None, [PI, MPI.DOUBLE],
            op=MPI.SUM, root=MPI.ROOT)
print(PI)

comm.Disconnect()
  • Compute Pi - Worker (or child, or server) side: the worker grabs its parent with comm = MPI.Comm.Get_parent(), checks size and rank, receives N = numpy.array(0, dtype='i') via comm.Bcast([N, MPI.INT], root=0), then does the classic h = 1.0 / N; s = 0.0 Riemann-sum loop over range(rank, N, size) computing x = h * (i + 0.5) and s += 4.0 / (1.0 + x**2). wraps it as PI = numpy.array(s * h, dtype='d'), sends it home with comm.Reduce([PI, MPI.DOUBLE], None, op=MPI.SUM, root=0), and dips with comm.Disconnect(). 😭 so proud of them
#!/usr/bin/env python
from mpi4py import MPI
import numpy

comm = MPI.Comm.Get_parent()
size = comm.Get_size()
rank = comm.Get_rank()

N = numpy.array(0, dtype='i')
comm.Bcast([N, MPI.INT], root=0)
h = 1.0 / N; s = 0.0
for i in range(rank, N, size):
    x = h * (i + 0.5)
    s += 4.0 / (1.0 + x**2)
PI = numpy.array(s * h, dtype='d')
comm.Reduce([PI, MPI.DOUBLE], None,
            op=MPI.SUM, root=0)

comm.Disconnect()

⭐ GPU-aware MPI + Python GPU arrays ⭐

yes we're on the GPU now, put your seatbelt on bestie 👑

  • Reduce-to-all CuPy arrays: import cupy as cp, make sendbuf = cp.arange(10, dtype='i') and recvbuf = cp.empty_like(sendbuf), then synchronize the stream with cp.cuda.get_current_stream().synchronize() before you do anything — do not skip this, the sync is the whole point. comm.Allreduce(sendbuf, recvbuf) runs the reduce-to-all, and assert cp.allclose(recvbuf, sendbuf*size) confirms everyone's numbers added up right. 🔥
from mpi4py import MPI
import cupy as cp

comm = MPI.COMM_WORLD
size = comm.Get_size()
rank = comm.Get_rank()

sendbuf = cp.arange(10, dtype='i')
recvbuf = cp.empty_like(sendbuf)
cp.cuda.get_current_stream().synchronize()
comm.Allreduce(sendbuf, recvbuf)

assert cp.allclose(recvbuf, sendbuf*size)

🎀 One-Sided Communication (RMA) 🎀

one-sided = you don't need the other guy to be "listening" in a matching call. it's giving independent woman energy 💅

  • Read from (write to) the entire RMA window: set datatype = MPI.FLOAT, grab np_dtype = dtlib.to_numpy_dtype(datatype) and itemsize = datatype.Get_size(). with N = 10, only rank 0 allocates the window: win_size = N * itemsize if rank == 0 else 0, then win = MPI.Win.Allocate(win_size, comm=comm). rank 0 fills buf with 42, win.Lock(rank=0), win.Put(buf, target_rank=0), win.Unlock(rank=0), then comm.Barrier(). everybody else hits the comm.Barrier() first, then locks, win.Get(buf, target_rank=0), unlocks, and assert np.all(buf == 42). beautiful. no notes. 🦋
import numpy as np
from mpi4py import MPI
from mpi4py.util import dtlib

comm = MPI.COMM_WORLD
rank = comm.Get_rank()

datatype = MPI.FLOAT
np_dtype = dtlib.to_numpy_dtype(datatype)
itemsize = datatype.Get_size()

N = 10
win_size = N * itemsize if rank == 0 else 0
win = MPI.Win.Allocate(win_size, comm=comm)

buf = np.empty(N, dtype=np_dtype)
if rank == 0:
    buf.fill(42)
    win.Lock(rank=0)
    win.Put(buf, target_rank=0)
    win.Unlock(rank=0)
    comm.Barrier()
else:
    comm.Barrier()
    win.Lock(rank=0)
    win.Get(buf, target_rank=0)
    win.Unlock(rank=0)
    assert np.all(buf == 42)
  • Accessing a part of the RMA window using the target argument, which is defined as (offset, count, datatype) — this is the "I only want a slice of the window" move. here N = comm.Get_size() + 1, and the window gets allocated with size=win_size, disp_unit=itemsize, comm=comm. rank 0 reaches in with mem = np.frombuffer(win, dtype=np_dtype) and fills it with mem[:] = np.arange(len(mem), dtype=np_dtype), then comm.Barrier(). everybody sets buf = np.zeros(3, dtype=np_dtype) and target = (rank, 2, datatype) — that's offset, count, datatype — then lock / win.Get(buf, target_rank=0, target=target) / unlock, and assert np.all(buf == [rank, rank+1, 0]). the 0 at the end is the untouched window cell. chef's kiss 👑
import numpy as np
from mpi4py import MPI
from mpi4py.util import dtlib

comm = MPI.COMM_WORLD
rank = comm.Get_rank()

datatype = MPI.FLOAT
np_dtype = dtlib.to_numpy_dtype(datatype)
itemsize = datatype.Get_size()

N = comm.Get_size() + 1
win_size = N * itemsize if rank == 0 else 0
win = MPI.Win.Allocate(
    size=win_size,
    disp_unit=itemsize,
    comm=comm,
)
if rank == 0:
    mem = np.frombuffer(win, dtype=np_dtype)
    mem[:] = np.arange(len(mem), dtype=np_dtype)
comm.Barrier()

buf = np.zeros(3, dtype=np_dtype)
target = (rank, 2, datatype)
win.Lock(rank=0)
win.Get(buf, target_rank=0, target=target)
win.Unlock(rank=0)
assert np.all(buf == [rank, rank+1, 0])

🌸 Wrapping with SWIG 🌸

you can wrap your own C code and let Python call it. it's giving "i made this" 🫶

  • C source:
/* file: helloworld.c */
void sayhello(MPI_Comm comm)
{
  int size, rank;
  MPI_Comm_size(comm, &size);
  MPI_Comm_rank(comm, &rank);
  printf("Hello, World! "
         "I am process %d of %d.\n",
         rank, size);
}
  • SWIG interface file:
// file: helloworld.i
%module helloworld
%{
#include <mpi.h>
#include "helloworld.c"
}%

%include mpi4py/mpi4py.i
%mpi4py_typemap(Comm, MPI_Comm);
void sayhello(MPI_Comm comm);
  • Try it in the Python prompt:
>>> from mpi4py import MPI
>>> import helloworld
>>> helloworld.sayhello(MPI.COMM_WORLD)
Hello, World! I am process 0 of 1.

💖 Wrapping with F2Py 💖

same energy but Fortran. bestie we contain multitudes ✨

  • Fortran 90 source:
! file: helloworld.f90
subroutine sayhello(comm)
  use mpi
  implicit none
  integer :: comm, rank, size, ierr
  call MPI_Comm_size(comm, size, ierr)
  call MPI_Comm_rank(comm, rank, ierr)
  print *, 'Hello, World! I am process ',rank,' of ',size,'.'
end subroutine sayhello
  • Compiling example using f2py:
$ f2py -c --f90exec=mpif90 helloworld.f90 -m helloworld
  • Try it in the Python prompt: notice the MPI.COMM_WORLD.py2f() move — that's you converting the Python communicator into the Fortran handle the wrapped code expects 👑
>>> from mpi4py import MPI
>>> import helloworld
>>> fcomm = MPI.COMM_WORLD.py2f()
>>> helloworld.sayhello(fcomm)
Hello, World! I am process 0 of 1.

💜 MPI4PY 💜

The MPI for Python package.

okay so real talk, what even is this. let me put you on:

The Message Passing Interface (MPI) is a standardized and portable message-passing system designed to function on a wide variety of parallel computers. The MPI standard defines the syntax and semantics of library routines and allows users to write portable programs in the main scientific programming languages (Fortran, C, or C++). Since its release, the MPI specification has become the leading standard for message-passing libraries for parallel computers.

MPI for Python provides MPI bindings for the Python programming language, allowing any Python program to exploit multiple processors. This package build on the MPI specification and provides an object oriented interface which closely follows MPI-2 C++ bindings.

⚙️ Runtime configuration options ⚙️

  • mpi4py.rc — This object has attributes exposing runtime configuration options that become effective at import time of the MPI module.
tl;dr: you tweak mpi4py.rc before you import MPI, and that's when the settings actually kick in. timing is everything bestie 💜

🎀 Attributes Summary 🎀

okay bestie, here's the whole squad at a glance, no scrolling required 💅

  • initialize — Automatic MPI initialization at import ✨
  • threads — Request initialization with thread support 🧵
  • thread_level — Level of thread support to request
  • finalize — Automatic MPI finalization at exit
  • fast_reduce — Use tree-based reductions for objects 🌳
  • recv_mprobe — Use matched probes to receive objects 🔍
  • irecv_bufsz — Default buffer size in bytes for irecv() 📦
  • errors — Error handling policy 🚨

💖 Attributes Documentation 💖

mpi4py.rc.initialize

Automatic MPI initialization at import.

  • Type: bool
  • Default: True

See also: MPI4PY_RC_INITIALIZE

mpi4py.rc.threads

Request initialization with thread support.

  • Type: bool
  • Default: True

See also: MPI4PY_RC_THREADS

mpi4py.rc.thread_level

Level of thread support to request.

  • Type: str
  • Default: "multiple"
  • Choices: "multiple", "serialized", "funneled", "single"

See also: MPI4PY_RC_THREAD_LEVEL

mpi4py.rc.finalize

Automatic MPI finalization at exit.

If set to None, the value of mpi4py.rc.initialize is used.

  • Type: None or bool
  • Default: None

See also: MPI4PY_RC_FINALIZE

mpi4py.rc.fast_reduce

Use tree-based reductions for objects.

  • Type: bool
  • Default: True

See also: MPI4PY_RC_FAST_REDUCE

mpi4py.rc.recv_mprobe

Use matched probes to receive objects.

  • Type: bool
  • Default: True

See also: MPI4PY_RC_RECV_MPROBE

mpi4py.rc.irecv_bufsz

Default buffer size in bytes for irecv().

  • Type: int
  • Default: 32768

See also: MPI4PY_RC_IRECV_BUFSZ

Added in version 4.0.0.

mpi4py.rc.errors

Error handling policy.

  • Type: str
  • Default: "exception"
  • Choices: "exception", "default", "abort", "fatal"

See also: MPI4PY_RC_ERRORS

✨ Example ✨

MPI for Python features automatic initialization and finalization of the MPI execution environment — iconic behaviour, honestly 👑. But if you wanna be the main character and drive the wheel yourself, you can use the mpi4py.rc object to handle MPI initialization and finalization programmatically:

import mpi4py
mpi4py.rc.initialize = False  # do not initialize MPI automatically
mpi4py.rc.finalize = False    # do not finalize MPI automatically

from mpi4py import MPI # import the 'MPI' module

MPI.Init()      # manual initialization of the MPI environment
...             # your finest code here ...
MPI.Finalize()  # manual finalization of the MPI environment

🌈 Environment variables 🌈

The following environment variables override the corresponding attributes of the mpi4py.rc and MPI.pickle objects at import time of the MPI module. fr fr, they get the final say 🫶

Note: For variables of boolean type, accepted values are 0 and 1 (interpreted as False and True, respectively), and strings specifying a YAML boolean value (case-insensitive). So y, yes, on, true… all of that counts, lowercase or not 💅

MPI4PY_RC_INITIALIZE

  • Type: bool
  • Default: True

Whether to automatically initialize MPI at import time of the mpi4py.MPI module.

See also: mpi4py.rc.initialize

Added in version 4.0.0.

MPI4PY_RC_FINALIZE

  • Type: None | bool
  • Default: None
  • Choices: None, True, False

Whether to automatically finalize MPI at exit time of the Python process.

See also: mpi4py.rc.finalize

Added in version 4.0.0.

MPI4PY_RC_THREADS

  • Type: bool
  • Default: True

Whether to initialize MPI with thread support.

See also: mpi4py.rc.threads

Added in version 3.1.0.

MPI4PY_RC_THREAD_LEVEL

  • Default: "multiple"
  • Choices: "single", "funneled", "serialized", "multiple"

The level of required thread support.

See also: mpi4py.rc.thread_level

Added in version 3.1.0.

MPI4PY_RC_FAST_REDUCE

  • Type: bool
  • Default: True

Whether to use tree-based reductions for objects. 🌳

See also: mpi4py.rc.fast_reduce

Added in version 3.1.0.

MPI4PY_RC_RECV_MPROBE

  • Type: bool
  • Default: True

Whether to use matched probes to receive objects.

See also: mpi4py.rc.recv_mprobe

MPI4PY_RC_IRECV_BUFSZ

  • Type: int
  • Default: 32768

Default buffer size in bytes for irecv().

See also: mpi4py.rc.irecv_bufsz

Added in version 4.0.0.

MPI4PY_RC_ERRORS

  • Default: "exception"
  • Choices: "exception", "default", "abort", "fatal"

Controls default MPI error handling policy.

See also: mpi4py.rc.errors

Added in version 3.1.0.

MPI4PY_PICKLE_PROTOCOL

  • Type: int
  • Default: pickle.HIGHEST_PROTOCOL

Controls the default pickle protocol to use when communicating Python objects.

See also: PROTOCOL attribute of the MPI.pickle object within the MPI module.

Added in version 3.1.0.

MPI4PY_PICKLE_THRESHOLD

  • Type: int
  • Default: 262144

Controls the default buffer size threshold for switching from in-band to out-of-band buffer handling when using pickle protocol version 5 or higher.

See also: THRESHOLD attribute of the MPI.pickle object within the MPI module.

Added in version 3.1.2.

💅 Miscellaneous functions 💅

These are the lil' helper besties that don't fit anywhere else but still eat every time. 🫶

  • mpi4py.profile(name, *, path=None) — support for the MPI profiling interface, iykyk.

Parameters

  • name (str) — the name of the profiler library to load. Like, the actual thing you want loaded, bestie.
  • path (sequence of str, optional) — extra paths to go searching through for the profiler. Give it a whole list if you want.

Return type: None — she gives you nothing back, she just does the thing. 💀

  • mpi4py.get_include() — returns the directory inside the package that holds the header files. 🎀

Extension modules that need to compile against mpi4py should use this function to locate the appropriate include directory. So like, if your extension is trying to link up with mpi4py, this is the function that hands you the address. Using Python distutils (or maybe NumPy distutils):

import mpi4py
Extension('extension_name', ...
          include_dirs=[..., mpi4py.get_include()])

Return type: str — a path string, bestie. ✨

  • mpi4py.get_config() — returns a dictionary stuffed with info about MPI.
Changed in version 4.0.0: By default, this function returns an empty dictionary. No cap. But downstream packagers and distributors may alter such behavior — so if yours isn't empty, that's them, not her.

To that end, MPI information must be provided under an mpi section within a UTF-8 encoded INI-style configuration file named mpi.cfg located at the top-level package directory. The configuration file is read and parsed using the configparser module. 📖

Return type: dict[str, str] — keys are strings, values are strings, that's the whole vibe. 🌸

💖 MPI4PY.MPI 💖

Okay bestie, this is the main event. The MPI subpackage. Everything you actually came for lives down here. 👑

👑 Classes 👑

Ancillary

The supporting cast. They don't run the show but the show does not run without them. ✨

  • Datatype — Datatype object.
  • Status — Status object.
  • Request — Request handler.
  • Prequest — Persistent request handler.
  • Grequest — Generalized request handler.
  • Op — Reduction operation.
  • Group — Group of processes.
  • Info — Info object.
  • Session — Session context.

Communication

The talking-to-each-other girlies. This is where the whole "MPI" part actually happens. 🗣️💬

  • Comm — Communication context.
  • Intracomm — Intracommunicator.
  • Topocomm — Topology intracommunicator.
  • Cartcomm — Cartesian topology intracommunicator.
  • Graphcomm — General graph topology intracommunicator.
  • Distgraphcomm — Distributed graph topology intracommunicator.
  • Intercomm — Intercommunicator.
  • Message — Matched message.

One-sided operations

She does things to your memory without asking you for a turn first. Iconic behavior, honestly. 🙈

  • Win — Remote memory access context.

Input/Output

Reading and writing, but make it parallel. 📂

  • File — File I/O context.

Error handling

For when things go sideways — and bestie, sometimes they do. 😭

  • Errhandler — Error handler.
  • Exception — Exception class.

Auxiliary

The lil' extras. The sprinkles on the cupcake. 🧁

  • Pickle — Pickle/unpickle Python objects.
  • buffer — Buffer.

🌟 Functions 🌟

Version inquiry

Asking the library who she is and where she came from. Main character energy fr fr. 💅

  • Get_version() — Obtain the version number of the MPI standard.
  • Get_library_version() — Obtain the version string of the MPI library.

🌈⭐💜

✨ Initialization and finalization ✨

Okay bestie, this is the get the party started section, and also the okay everybody go home section. Every MPI program has a whole lifecycle and these are the functions that run it. 💖

  • Init() — Initialize the MPI execution environment. This is the "lights on, everyone in the group chat" moment.
  • Init_thread([required]) — Initialize the MPI execution environment. Same energy as Init(), but you get to ask for a level of thread support via required.
  • Finalize() — Terminate the MPI execution environment. The "okay goodnight, love you, bye" of the whole program.
  • Is_initialized() — Indicate whether Init() has been called.
  • Is_finalized() — Indicate whether Finalize() has completed.
  • Query_thread() — Return the level of thread support provided by the MPI library.
  • Is_thread_main() — Indicate whether this thread called Init() or Init_thread(). Like, are you the one who started all this? 👑

🎀 Memory allocation 🎀

For when you need memory that MPI itself is gonna care about — message passing and remote memory access want their own special little space, not just whatever random buffer you had lying around. 🫶

  • Alloc_mem(size[, info]) — Allocate memory for message passing and remote memory access.
  • Free_mem(mem) — Free memory allocated with Alloc_mem(). And yes, you have to use this one to free it — the matching energy is the whole point. 💅

🌸 Address manipulation 🌸

Memory addresses, but make it arithmetic you're not allowed to do by hand. MPI wants you to use its own helpers here because pointer math on these things is not a "just wing it" situation. 🌈

  • Get_address(location) — Get the address of a location in memory.
  • Aint_add(base, disp) — Return the sum of base address and displacement.
  • Aint_diff(addr1, addr2) — Return the difference between absolute addresses.

⏰ Timer ⏰

It's giving how long did that even take. Two functions, both absolute icons, both here so you can measure your own stuff instead of trusting time.time() on a cluster where the clocks are lowkey not your friend. 🦋

  • Wtick() — Return the resolution of Wtime().
  • Wtime() — Return an elapsed time on the calling processor.

💀 Error handling 💀

This whole section is the what went wrong and why department. Error codes, error classes, error strings — it's a whole little ecosystem and ngl, most of the time you'll just read the string and move on. But if you're building something fancy, all of these are here for you. 🔥

  • Get_error_class(errorcode) — Convert an error code into an error class.
  • Get_error_string(errorcode) — Return the error string for a given error class or error code. Yes, it takes either one. It's flexible like that. ✨
  • Add_error_class() — Add an error class to the known error classes.
  • Add_error_code(errorclass) — Add an error code to an error class.
  • Add_error_string(errorcode, string) — Associate an error string with an error class or error code.
  • Remove_error_class(errorclass) — Remove an error class from the known error classes.
  • Remove_error_code(errorcode) — Remove an error code from the known error codes.
  • Remove_error_string(errorcode) — Remove error string association from error class or error code.
Okay so like — add/remove pairs are a thing here. If you add a class, a code, or a string, there's a matching remove waiting for it. Keep track of what you registered bestie, because nobody else is gonna do it for you. 🍓

💫 Dynamic process management 💫

okay bestie, this is the whole "who even are my processes and how do we find each other" corner of the library. it's giving matchmaker energy fr fr 🫶

  • Open_port([info]) — hands you back an address you can use to connect a whole lil group of processes together. the info is optional, no pressure 💅
  • Close_port(port_name) — shut that port down. bye bye 👋
  • Publish_name(service_name, port_name[, info]) — put a service name out into the world so other folks can find it. info is optional here too ✨
  • Unpublish_name(service_name, port_name[, info]) — take that published service name back down. info optional, as always 🎀
  • Lookup_name(service_name[, info]) — got a service name and need the port name? this is the one that finds it for you. info optional, iykyk 🔍

🧚 Miscellanea 🧚

the grab-bag section!! random but iconic. every single one of these is a real one, no cap 💖

  • Attach_buffer(buf) — attach a buffer that you provided, for sending stuff in buffered mode. it's giving "i brought my own bag" 👜
  • Detach_buffer() — rip out a buffer that was already attached. no args, just vibes 🙈
  • Flush_buffer() — block right there until every single buffered message has actually been transmitted. patience, queen 👑
  • Iflush_buffer() — the nonblocking version of that flush, for your buffered messages. main character energy, doesn't wait around 🔥
  • Compute_dims(nnodes, dims) — returns a balanced distribution of processes per coordinate direction. math but make it fair ⚖️
  • Get_processor_name() — gets you the name of the processor that's calling. literally just a name tag 🏷️
  • Register_datarep(datarep, read_fn, write_fn, ...) — register user-defined data representations. yes bestie, you bring the read_fn, the write_fn, and the rest ✨
  • Pcontrol(level) — controls profiling. that's it, that's the whole job 💅

⭐ Utilities ⭐

  • get_vendor() — info about the underlying MPI implementation. like a little "who made this" card for your MPI 🌈

Attributes ✨

okay so this is the little constants shelf of mpi4py.MPI — all the magic values that the library hands you so you never have to hardcode a weird number yourself 💅 every single one of them lives right here on the module, and here's the whole roster, no skips, no cuts, fr fr:

  • UNDEFINED — Constant UNDEFINED of type int. 🫶
  • ANY_SOURCE — Constant ANY_SOURCE of type int.
  • ANY_TAG — Constant ANY_TAG of type int.
  • PROC_NULL — Constant PROC_NULL of type int.
  • ROOT — Constant ROOT of type int.
  • BOTTOM — Object BOTTOM of type BottomType. not an int bestie, it's got its own whole type 💀
  • IN_PLACE — Object IN_PLACE of type InPlaceType. again, its own type, iconic ✨
  • BUFFER_AUTOMATIC — Object BUFFER_AUTOMATIC of type BufferAutomaticType. yep, another one with a dedicated type 🎀
  • KEYVAL_INVALID — Constant KEYVAL_INVALID of type int.
  • TAG_UB — Constant TAG_UB of type int.
  • IO — Constant IO of type int.
  • WTIME_IS_GLOBAL — Constant WTIME_IS_GLOBAL of type int.
  • UNIVERSE_SIZE — Constant UNIVERSE_SIZE of type int.
  • APPNUM — Constant APPNUM of type int.
  • LASTUSEDCODE — Constant LASTUSEDCODE of type int.
  • WIN_BASE — Constant WIN_BASE of type int.
  • WIN_SIZE — Constant WIN_SIZE of type int.
  • WIN_DISP_UNIT — Constant WIN_DISP_UNIT of type int.
  • WIN_CREATE_FLAVOR — Constant WIN_CREATE_FLAVOR of type int.
  • WIN_FLAVOR — Constant WIN_FLAVOR of type int.
  • WIN_MODEL — Constant WIN_MODEL of type int.
  • SUCCESS — Constant SUCCESS of type int.
  • ERR_LASTCODE — Constant ERR_LASTCODE of type int.
  • ERR_COMM — Constant ERR_COMM of type int.

like, that's a lot of constants, and the vibe check says: most of them are just plain old int, a few of them got their own fancy type because they're built different 🦋 lowkey obsessed with how BOTTOM, IN_PLACE and BUFFER_AUTOMATIC refused to be basic 💖

okay bestie, the constant parade continues 💅 and real talk? every single one of these is an int — yes, that int, the Python built-in, the one whose docs live over at docs.python.org/3/library/functions.html#int. So I'm saying it once up here, and then we're just gonna vibe through the list together. no skipping, no "you get the idea", we list all of them. periodt. 🎀

  • ERR_SPAWN — a constant, and its type is int.
  • ERR_BASE — constant, type int, living its best life.
  • ERR_SIZE — yep, another constant, and yes, it's an int.
  • ERR_DISP — constant. type: int. moving on 🦋
  • ERR_ASSERT — constant of type int, no cap.
  • ERR_LOCKTYPE — constant, int, iconic.
  • ERR_RMA_CONFLICT — constant, type int.
  • ERR_RMA_SYNC — constant, type int.
  • ERR_RMA_RANGE — constant, type int.
  • ERR_RMA_ATTACH — constant, type int.
  • ERR_RMA_SHARED — constant, type int.
  • ERR_RMA_FLAVOR — constant, type int.
  • ORDER_C — a constant, and it's an int.
  • ORDER_F — constant, type int.
  • ORDER_FORTRAN — constant, type int.
  • TYPECLASS_INTEGER — constant, type int.
  • TYPECLASS_REAL — constant, type int.
  • TYPECLASS_COMPLEX — constant, type int.
  • DISTRIBUTE_NONE — constant, type int.
  • DISTRIBUTE_BLOCK — constant, type int.
  • DISTRIBUTE_CYCLIC — constant, type int.
  • DISTRIBUTE_DFLT_DARG — constant, type int.
  • COMBINER_NAMED — constant, type int.
  • COMBINER_DUP — constant, type int.

and the list keeps going, bestie, we're not done yet — the next chunk is right behind this one 🫶

okay pausing the COMBINER marathon for a sec, new vibe category unlocked ✨

okay continuing the constant lineup 💅 every single one of these is a constant of type int, and the Python docs link for int is literally the same every time, so here we go, one bullet per icon, nothing skipped, periodt ✨

Like, more constants bestie, all of them int typed, all of them yours 💖 keep scrolling, the list does not stop:

  • MODE_DELETE_ON_CLOSE — Constant MODE_DELETE_ON_CLOSE of type int. yes babe, another one 💅
  • MODE_UNIQUE_OPEN — Constant MODE_UNIQUE_OPEN of type int. ✨
  • MODE_SEQUENTIAL — Constant MODE_SEQUENTIAL of type int. 🌸
  • MODE_APPEND — Constant MODE_APPEND of type int. 🎀
  • SEEK_SET — Constant SEEK_SET of type int. the classic trio begins 🦋
  • SEEK_CUR — Constant SEEK_CUR of type int. 💜
  • SEEK_END — Constant SEEK_END of type int. 🌈
  • DISPLACEMENT_CURRENT — Constant DISPLACEMENT_CURRENT of type int. long name, tiny type 🍓
  • DISP_CUR — Constant DISP_CUR of type int. its little nickname fr fr ✨
  • THREAD_SINGLE — Constant THREAD_SINGLE of type int. threading era incoming 👑
  • THREAD_FUNNELED — Constant THREAD_FUNNELED of type int. 🧚
  • THREAD_SERIALIZED — Constant THREAD_SERIALIZED of type int. 💖
  • THREAD_MULTIPLE — Constant THREAD_MULTIPLE of type int. the most unhinged one, iconic 🔥
  • VERSION — Constant VERSION of type int. ⭐
  • SUBVERSION — Constant SUBVERSION of type int. ⭐
  • MAX_PROCESSOR_NAME — Constant MAX_PROCESSOR_NAME of type int. 🌸
  • MAX_ERROR_STRING — Constant MAX_ERROR_STRING of type int. 😭
  • MAX_PORT_NAME — Constant MAX_PORT_NAME of type int. 🦋
  • MAX_INFO_KEY — Constant MAX_INFO_KEY of type int. 🎀
  • MAX_INFO_VAL — Constant MAX_INFO_VAL of type int. 🎀
  • MAX_OBJECT_NAME — Constant MAX_OBJECT_NAME of type int. 💜
  • MAX_DATAREP_STRING — Constant MAX_DATAREP_STRING of type int. say that three times fast, I dare you 🙈
  • MAX_LIBRARY_VERSION_STRING — Constant MAX_LIBRARY_VERSION_STRING of type int. the longest name in the building and it ATE 💅
ngl bestie, every single one of these is just an int constant. No cap. They live at <pink>mpi4py.MPI</pink>, and that's the whole vibe of this chunk 🫶

…and the roster keeps going, bestie, because MPI has a datatype for everything 💅 here's the rest of the lineup, each one just vibing as an object of type Datatype:

  • DATATYPE_NULL — Object DATATYPE_NULL of type Datatype 🫥 (yes she's here, yes she's still a Datatype)
  • PACKED — Object PACKED of type Datatype 📦
  • BYTE — Object BYTE of type Datatype 🧱
  • AINT — Object AINT of type Datatype ✨
  • OFFSET — Object OFFSET of type Datatype 📐
  • COUNT — Object COUNT of type Datatype 🔢
  • CHAR — Object CHAR of type Datatype 🔤
  • WCHAR — Object WCHAR of type Datatype 🈶
  • SIGNED_CHAR — Object SIGNED_CHAR of type Datatype ✍️
  • SHORT — Object SHORT of type Datatype 🐣
  • INT — Object INT of type Datatype 👑
  • LONG — Object LONG of type Datatype 📏
  • LONG_LONG — Object LONG_LONG of type Datatype 📏📏
  • UNSIGNED_CHAR — Object UNSIGNED_CHAR of type Datatype 🎀
  • UNSIGNED_SHORT — Object UNSIGNED_SHORT of type Datatype 🍓
  • UNSIGNED — Object UNSIGNED of type Datatype 🌸
  • UNSIGNED_LONG — Object UNSIGNED_LONG of type Datatype 🦋
  • UNSIGNED_LONG_LONG — Object UNSIGNED_LONG_LONG of type Datatype 🦋🦋
  • FLOAT — Object FLOAT of type Datatype 🎈
  • DOUBLE — Object DOUBLE of type Datatype 🎈🎈
  • LONG_DOUBLE — Object LONG_DOUBLE of type Datatype 🎈🎈🎈
  • C_BOOL — Object C_BOOL of type Datatype ✅
  • INT8_T — Object INT8_T of type Datatype 💜
  • INT16_T — Object INT16_T of type Datatype 💜
  • INT32_T — Object INT32_T of type Datatype 💜
  • INT64_T — Object INT64_T of type Datatype 💜
  • UINT8_T — Object UINT8_T of type Datatype 🌈

Okay bestie the datatype menu continues and it is long — every one of these is an object of type Datatype, and honestly they're all giving "same energy, different name". Here's the rest of the lineup: 💖

  • UINT16_T — the UINT16_T object, and yep, it's of type Datatype. ✨
  • UINT32_T — the UINT32_T object, type Datatype. 💅
  • UINT64_T — the UINT64_T object, type Datatype. 🦋
  • C_COMPLEX — the C_COMPLEX object, of type Datatype. 🎀
  • C_FLOAT_COMPLEX — the C_FLOAT_COMPLEX object, of type Datatype. 🌸
  • C_DOUBLE_COMPLEX — the C_DOUBLE_COMPLEX object, of type Datatype. 💜
  • C_LONG_DOUBLE_COMPLEX — the C_LONG_DOUBLE_COMPLEX object, of type Datatype. ⭐
  • CXX_BOOL — the CXX_BOOL object, of type Datatype. 🔥
  • CXX_FLOAT_COMPLEX — the CXX_FLOAT_COMPLEX object, of type Datatype. 🌈
  • CXX_DOUBLE_COMPLEX — the CXX_DOUBLE_COMPLEX object, of type Datatype. 👑
  • CXX_LONG_DOUBLE_COMPLEX — the CXX_LONG_DOUBLE_COMPLEX object, of type Datatype. 💀
  • SHORT_INT — the SHORT_INT object, of type Datatype. 🙈
  • INT_INT — the INT_INT object, of type Datatype. 🍓
  • TWOINT — the TWOINT object, of type Datatype. 🧚
  • LONG_INT — the LONG_INT object, of type Datatype. ✨
  • FLOAT_INT — the FLOAT_INT object, of type Datatype. 💖
  • DOUBLE_INT — the DOUBLE_INT object, of type Datatype. 🫶
  • LONG_DOUBLE_INT — the LONG_DOUBLE_INT object, of type Datatype. 🌸
  • CHARACTER — the CHARACTER object, of type Datatype. 🎀
  • LOGICAL — the LOGICAL object, of type Datatype. 💅
  • INTEGER — the INTEGER object, of type Datatype. 🦋
  • REAL — the REAL object, of type Datatype. 💜
  • DOUBLE_PRECISION — the DOUBLE_PRECISION object, of type Datatype. ⭐
  • COMPLEX — the COMPLEX object, of type Datatype. 🔥
  • DOUBLE_COMPLEX — the DOUBLE_COMPLEX object, of type Datatype. 🌈
  • LOGICAL1 — the LOGICAL1 object, of type Datatype. 👑
  • LOGICAL2 — the LOGICAL2 object, of type Datatype. 💀

Not me listing out the entire datatype alphabet like it's a stan list 😭 every single one of these is an object of type <code>Datatype</code> and that's the whole vibe, no cap.

  • LOGICAL4 — bestie, this is object LOGICAL4, and it's a Datatype 💖
  • LOGICAL8 — object LOGICAL8, type Datatype ✨
  • INTEGER1 — object INTEGER1, and yup, it's a Datatype 🎀
  • INTEGER2 — object INTEGER2, type Datatype 🌸
  • INTEGER4 — object INTEGER4, type Datatype 🦋
  • INTEGER8 — object INTEGER8, type Datatype 💜
  • INTEGER16 — object INTEGER16, type Datatype ⭐
  • REAL2 — object REAL2, type Datatype 🌈
  • REAL4 — object REAL4, type Datatype ✨
  • REAL8 — object REAL8, type Datatype 🍓
  • REAL16 — object REAL16, type Datatype 🧚
  • COMPLEX4 — object COMPLEX4, type Datatype 💅
  • COMPLEX8 — object COMPLEX8, type Datatype 🫶
  • COMPLEX16 — object COMPLEX16, type Datatype 🌸
  • COMPLEX32 — object COMPLEX32, type Datatype 💖
  • UNSIGNED_INT — object UNSIGNED_INT, type Datatype 🔥
  • SIGNED_SHORT — object SIGNED_SHORT, type Datatype ⭐
  • SIGNED_INT — object SIGNED_INT, type Datatype 💜
  • SIGNED_LONG — object SIGNED_LONG, type Datatype 🎀
  • SIGNED_LONG_LONG — object SIGNED_LONG_LONG, type Datatype 🦋
  • BOOL — object BOOL, type Datatype ✨
  • SINT8_T — object SINT8_T, type Datatype 🌈
  • SINT16_T — object SINT16_T, type Datatype 🍓
  • SINT32_T — object SINT32_T, type Datatype 🧚
  • SINT64_T — object SINT64_T, type Datatype 💅
  • F_BOOL — object F_BOOL, type Datatype 🫶
  • F_INT — object F_INT, type Datatype 💖
  • F_FLOAT — object F_FLOAT, type Datatype 🔥

and the constant drop continues, bestie, no cap 💅

  • F_DOUBLE — Object F_DOUBLE of type Datatype 💖
  • F_COMPLEX — Object F_COMPLEX of type Datatype ✨
  • F_FLOAT_COMPLEX — Object F_FLOAT_COMPLEX of type Datatype 🦋
  • F_DOUBLE_COMPLEX — Object F_DOUBLE_COMPLEX of type Datatype 🌸
  • REQUEST_NULL — Object REQUEST_NULL of type Request 💅
  • MESSAGE_NULL — Object MESSAGE_NULL of type Message 🫶
  • MESSAGE_NO_PROC — Object MESSAGE_NO_PROC of type Message 😭
  • OP_NULL — Object OP_NULL of type Op 🔥
  • MAX — Object MAX of type Op 👑
  • MIN — Object MIN of type Op 🌈
  • SUM — Object SUM of type Op ⭐
  • PROD — Object PROD of type Op 💀
  • LAND — Object LAND of type Op 🙈
  • BAND — Object BAND of type Op 🍓
  • LOR — Object LOR of type Op 🧚
  • BOR — Object BOR of type Op 💜
  • LXOR — Object LXOR of type Op 💖
  • BXOR — Object BXOR of type Op ✨
  • MAXLOC — Object MAXLOC of type Op 🦋
  • MINLOC — Object MINLOC of type Op 🌸
  • REPLACE — Object REPLACE of type Op 💅
  • NO_OP — Object NO_OP of type Op 🫶
  • GROUP_NULL — Object GROUP_NULL of type Group 😭
  • GROUP_EMPTY — Object GROUP_EMPTY of type Group 🔥
  • INFO_NULL — Object INFO_NULL of type Info 👑
  • INFO_ENV — Object INFO_ENV of type Info 🌈
  • ERRHANDLER_NULL — Object ERRHANDLER_NULL of type Errhandler ⭐
  • ERRORS_RETURN — Object ERRORS_RETURN of type Errhandler 💀
  • ERRORS_ARE_FATAL — Object ERRORS_ARE_FATAL of type Errhandler 🙈
  • COMM_NULL — Object COMM_NULL of type Comm 🍓
  • COMM_SELF — Object COMM_SELF of type Intracomm 🧚

│ COMM_WORLD │ Object COMM_WORLD of type │ │ <#mpi4py.MPI.COMM_WORLD> │ Intracomm <#mpi4py.MPI │ │ │ .Intracomm> │ ├──────────────────────────────┼────────────────────────────┤ │ WIN_NULL <#mpi4py.MPI │ Object WIN_NULL of type │ │ .WIN_NULL> │ Win <#mpi4py.MPI.Win> │ ├──────────────────────────────┼────────────────────────────┤ │ FILE_NULL <#mpi4py.MPI │ Object FILE_NULL of type │ │ .FILE_NULL> │ File <#mpi4py.MPI.File> │ ├──────────────────────────────┼────────────────────────────┤ │ pickle <#mpi4py.MPI.pickle>│ Object pickle of type │ │ │ Pickle <#mpi4py.MPI │ │ │ .Pickle> │ └──────────────────────────────┴────────────────────────────┘

✨ MPI4PY.TYPING ✨

Added in version 4.0.0. 🎀

Okay so bestie, this module is the one that hands out type aliases <https://docs.python.org/3/glossary.html#term-type-alias> that get used to add type hints <https://docs.python.org/3/glossary.html#term-type-hint> onto all the various functions and methods living inside the MPI <#module-mpi4py.MPI> module. It's giving ✨type safety era✨ and we are obsessed. 💅

See also:

🌸 Types Summary 🌸

┌────────────────┬────────────────────────────┐ │ SupportsBuffer │ Python buffer protocol. │ ├────────────────┼────────────────────────────┤ │ SupportsDLPack │ DLPack data interchange │ │ │ protocol. │ ├────────────────┼────────────────────────────┤ │ SupportsCAI │ CUDA Array Interface (CAI) │ │ │ protocol. │ ├────────────────┼────────────────────────────┤ │ Buffer │ Buffer-like object. │ ├────────────────┼────────────────────────────┤ │ Bottom │ Start of the address │ │ │ range. │ ├────────────────┼────────────────────────────┤ │ InPlace │ In-place buffer argument. │ ├────────────────┼────────────────────────────┤ │ Aint │ Address-sized integral │ │ │ type. │ ├────────────────┼────────────────────────────┤ │ Count │ Integral type for counts. │ ├────────────────┼────────────────────────────┤ │ Displ │ Integral type for │ │ │ displacements. │ ├────────────────┼────────────────────────────┤ │ Offset │ Integral type for offsets. │ ├────────────────┼────────────────────────────┤ │ TypeSpec │ Datatype specification. │ ├────────────────┼────────────────────────────┤ │ BufSpec │ Buffer specification. │ ├────────────────┼────────────────────────────┤ │ BufSpecB │ Buffer specification │ │ │ (block). │ ├────────────────┼────────────────────────────┤ │ BufSpecV │ Buffer specification │ │ │ (vector). │ ├────────────────┼────────────────────────────┤ │ BufSpecW │ Buffer specification │ │ │ (generalized). │ ├────────────────┼────────────────────────────┤ │ TargetSpec │ Target specification. │ └────────────────┴────────────────────────────┘

💖 Types Documentation 💖

🦋 mpi4py.typing.SupportsBuffer = <class 'mpi4py.typing.SupportsBuffer'>

Python buffer protocol. 🧚

See also:

🦋 mpi4py.typing.SupportsDLPack = <class 'mpi4py.typing.SupportsDLPack'>

DLPack data interchange protocol. 🌈

See also:

  • dlpack:python-spec

🦋 mpi4py.typing.SupportsCAI = <class 'mpi4py.typing.SupportsCAI'>

CUDA Array Interface (CAI) protocol. ⚡

See also:

  • numba:cuda-array-interface

🦋 mpi4py.typing.Buffer = mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack | mpi4py.typing.SupportsCAI

Buffer-like object. 🫶

🦋 mpi4py.typing.Bottom = mpi4py.MPI.BottomType | None

Start of the address range. 🎀

🦋 mpi4py.typing.InPlace = mpi4py.MPI.InPlaceType | None

In-place buffer argument. ✨

🦋 mpi4py.typing.Aint = <class 'typing.SupportsIndex'>

Address-sized integral type. 💜

alias of SupportsIndex <https://docs.python.org/3/library/typing.html#typing.SupportsIndex>

🦋 mpi4py.typing.Count = <class 'typing.SupportsIndex'>

Integral type for counts. 🔢

alias of SupportsIndex <https://docs.python.org/3/library/typing.html#typing.SupportsIndex>

🦋 mpi4py.typing.Displ = <class 'typing.SupportsIndex'>

Integral type for displacements. 📏

alias of SupportsIndex <https://docs.python.org/3/library/typing.html#typing.SupportsIndex>

🦋 mpi4py.typing.Offset = <class 'typing.SupportsIndex'>

Integral type for offsets. 🧮

alias of SupportsIndex <https://docs.python.org/3/library/typing.html#typing.SupportsIndex>

🦋 mpi4py.typing.TypeSpec = mpi4py.MPI.Datatype | str

Datatype specification. 💎

🦋 mpi4py.typing.BufSpec = mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack | mpi4py.typing.SupportsCAI | typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack | mpi4py.typing.SupportsCAI, typing.SupportsIndex] | typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack | mpi4py.typing.SupportsCAI, mpi4py.MPI.Datatype | str] | typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack | mpi4py.typing.SupportsCAI, typing.SupportsIndex, mpi4py.MPI.Datatype | str] | typing.Tuple[mpi4py.MPI.BottomType | None, typing.SupportsIndex, mpi4py.MPI.Datatype] | typing.List[typing.Any]

Buffer specification. 🎁

  • Buffer
  • Tuple[Buffer, Count]
  • Tuple[Buffer, TypeSpec]
  • Tuple[Buffer, Count, TypeSpec]
  • Tuple[Bottom, Count, Datatype <#mpi4py.MPI.Datatype>]

🦋 mpi4py.typing.BufSpecB = mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack | mpi4py.typing.SupportsCAI | typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack | mpi4py.typing.SupportsCAI, typing.SupportsIndex] | typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack | mpi4py.typing.SupportsCAI, mpi4py.MPI.Datatype | str] | typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack | mpi4py.typing.SupportsCAI, typing.SupportsIndex, mpi4py.MPI.Datatype | str] | typing.List[typing.Any]

Buffer specification (block). 🧱

  • Buffer
  • Tuple[Buffer, Count]
  • Tuple[Buffer, TypeSpec]
  • Tuple[Buffer, Count, TypeSpec]

mpi4py.typing.BufSpecV

okay bestie, this one is the buffer-spec-but-vectorized situation, and yes it's a whole paragraph of union types, but we do NOT skip it, we eat it 💅

mpi4py.typing.BufSpecV = mpi4py.typing.SupportsBuffer |
mpi4py.typing.SupportsDLPack | mpi4py.typing.SupportsCAI |
typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack
| mpi4py.typing.SupportsCAI, typing.Sequence[typing.SupportsIndex]] |
typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack
| mpi4py.typing.SupportsCAI,
typing.Tuple[typing.Sequence[typing.SupportsIndex],
typing.Sequence[typing.SupportsIndex]]] |
typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack
| mpi4py.typing.SupportsCAI, mpi4py.MPI.Datatype | str] |
typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack
| mpi4py.typing.SupportsCAI, typing.Sequence[typing.SupportsIndex],
mpi4py.MPI.Datatype | str] | typing.Tuple[mpi4py.typing.SupportsBuffer |
mpi4py.typing.SupportsDLPack | mpi4py.typing.SupportsCAI,
typing.Tuple[typing.Sequence[typing.SupportsIndex],
typing.Sequence[typing.SupportsIndex]], mpi4py.MPI.Datatype | str] |
typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack
| mpi4py.typing.SupportsCAI, typing.Sequence[typing.SupportsIndex],
typing.Sequence[typing.SupportsIndex], mpi4py.MPI.Datatype | str] |
typing.Tuple[mpi4py.MPI.BottomType | None,
typing.Tuple[typing.Sequence[typing.SupportsIndex],
typing.Sequence[typing.SupportsIndex]], mpi4py.MPI.Datatype] |
typing.Tuple[mpi4py.MPI.BottomType | None,
typing.Sequence[typing.SupportsIndex],
typing.Sequence[typing.SupportsIndex], mpi4py.MPI.Datatype] |
typing.List[typing.Any]

Buffer specification (vector). periodt. And here's the whole roster of shapes it can take, no gatekeeping:

  • Buffer
  • Tuple[Buffer, Sequence[Count]]
  • Tuple[Buffer, Tuple[Sequence[Count], Sequence[Displ]]]
  • Tuple[Buffer, TypeSpec]
  • Tuple[Buffer, Sequence[Count], TypeSpec]
  • Tuple[Buffer, Tuple[Sequence[Count], Sequence[Displ]], TypeSpec]
  • Tuple[Buffer, Sequence[Count], Sequence[Displ], TypeSpec]
  • Tuple[Bottom, Tuple[Sequence[Count], Sequence[Displ]], Datatype <#mpi4py.MPI.Datatype>]
  • Tuple[Bottom, Sequence[Count], Sequence[Displ], Datatype <#mpi4py.MPI.Datatype>]

mpi4py.typing.BufSpecW

and THIS one is the generalized version, the glow-up, the ✨deluxe✨ buffer spec 🎀

mpi4py.typing.BufSpecW = typing.Tuple[mpi4py.typing.SupportsBuffer |
mpi4py.typing.SupportsDLPack | mpi4py.typing.SupportsCAI,
typing.Sequence[mpi4py.MPI.Datatype]] |
typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack
| mpi4py.typing.SupportsCAI,
typing.Tuple[typing.Sequence[typing.SupportsIndex],
typing.Sequence[typing.SupportsIndex]],
typing.Sequence[mpi4py.MPI.Datatype]] |
typing.Tuple[mpi4py.typing.SupportsBuffer | mpi4py.typing.SupportsDLPack
| mpi4py.typing.SupportsCAI, typing.Sequence[typing.SupportsIndex],
typing.Sequence[typing.SupportsIndex],
typing.Sequence[mpi4py.MPI.Datatype]] |
typing.Tuple[mpi4py.MPI.BottomType | None,
typing.Tuple[typing.Sequence[typing.SupportsIndex],
typing.Sequence[typing.SupportsIndex]],
typing.Sequence[mpi4py.MPI.Datatype]] |
typing.Tuple[mpi4py.MPI.BottomType | None,
typing.Sequence[typing.SupportsIndex],
typing.Sequence[typing.SupportsIndex],
typing.Sequence[mpi4py.MPI.Datatype]] | typing.List[typing.Any]

Buffer specification (generalized). And the shapes it accepts, bestie:

  • Tuple[Buffer, Sequence[Datatype <#mpi4py.MPI.Datatype>]]
  • Tuple[Buffer, Tuple[Sequence[Count], Sequence[Displ]], Sequence[Datatype <#mpi4py.MPI.Datatype>]]
  • Tuple[Buffer, Sequence[Count], Sequence[Displ], Sequence[Datatype <#mpi4py.MPI.Datatype>]]
  • Tuple[Bottom, Tuple[Sequence[Count], Sequence[Displ]], Sequence[Datatype <#mpi4py.MPI.Datatype>]]
  • Tuple[Bottom, Sequence[Count], Sequence[Displ], Sequence[Datatype <#mpi4py.MPI.Datatype>]]

mpi4py.typing.TargetSpec

the one that tells everyone where to aim, no cap 🎯

mpi4py.typing.TargetSpec = typing.SupportsIndex | typing.Tuple[()] |
typing.Tuple[typing.SupportsIndex] | typing.Tuple[typing.SupportsIndex,
typing.SupportsIndex] | typing.Tuple[typing.SupportsIndex,
typing.SupportsIndex, mpi4py.MPI.Datatype | str] |
typing.List[typing.Any]

Target specification. And the vibes it comes in:

  • Displ
  • Tuple[()]
  • Tuple[Displ]
  • Tuple[Displ, Count]
  • Tuple[Displ, Count, TypeSpec]

mpi4py.typing.S

mpi4py.typing.S = TypeVar("S")

Invariant TypeVar <https://docs.python.org/3/library/typing.html#typing.TypeVar>. That's it, that's the whole thing 🫶

mpi4py.typing.T

mpi4py.typing.T = TypeVar("T")

Invariant TypeVar <https://docs.python.org/3/library/typing.html#typing.TypeVar>.

mpi4py.typing.U

mpi4py.typing.U = TypeVar("U")

Invariant TypeVar <https://docs.python.org/3/library/typing.html#typing.TypeVar>.

mpi4py.typing.V

mpi4py.typing.V = TypeVar("V")

Invariant TypeVar <https://docs.python.org/3/library/typing.html#typing.TypeVar>.

🚀 MPI4PY.FUTURES 🚀

Added in version 3.0.0.

okay so THIS package is the one that lets you run callables asynchronously on a whole pool of worker processes, using MPI for the inter-process communication. it's giving main character energy for your parallel code 🔥

The mpi4py.futures package is based on concurrent.futures <https://docs.python.org/3/library/concurrent.futures.html#module-concurrent.futures> from the Python standard library. More precisely, mpi4py.futures provides the MPIPoolExecutor class as a concrete implementation of the abstract class Executor <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Executor>. The submit() <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Executor.submit> interface schedules a callable to be executed asynchronously and returns a Future <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Future> object representing the execution of the callable. Future <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Future> instances can be queried for the call result or exception. Sets of Future <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Future> instances can be passed to the wait() <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.wait> and as_completed() <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.as_completed> functions.

See also:

MPIPoolExecutor

The MPIPoolExecutor class uses a pool of MPI processes to execute calls asynchronously. By performing computations in separate processes, it allows to side-step the global interpreter lock <https://docs.python.org/3/glossary.html#term-global-interpreter-lock> but also means that only picklable objects can be executed and returned. The __main__ <https://docs.python.org/3/library/__main__.html#module-__main__> module must be importable by worker processes, thus MPIPoolExecutor instances may not work in the interactive interpreter. 😭 (yeah, RIP to REPL girlies, we know)

MPIPoolExecutor takes advantage of the dynamic process management features introduced in the MPI-2 standard. In particular, the MPI.Intracomm.Spawn <#mpi4py.MPI.Intracomm.Spawn> method of MPI.COMM_SELF <#mpi4py.MPI.COMM_SELF> is used in the master (or parent) process to spawn new worker (or child) processes running a Python interpreter. The master process uses a separate thread (one for each MPIPoolExecutor instance) to communicate back and forth with the workers. The worker processes serve the execution of tasks in the main (and only) thread until they are signaled for completion. iconic behavior honestly 👑

Note: The worker processes must import the main script in order to unpickle any callable defined in the __main__ <https://docs.python.org/3/library/__main__.html#module-__main__> module and submitted from the master process. Furthermore, the callables may need access to other global variables. At the worker processes, mpi4py.futures executes the main script code (using the runpy <https://docs.python.org/3/library/runpy.html#module-runpy> module) under the __worker__ namespace to define the __main__ <https://docs.python.org/3/library/__main__.html#module-__main__> module. The __main__ <https://docs.python.org/3/library/__main__.html#module-__main__> and __worker__ modules are added to sys.modules <https://docs.python.org/3/library/sys.html#sys.modules> (both at the master and worker processes) to ensure proper pickling and unpickling.
Warning: During the initial import phase at the workers, the main script cannot create and use new MPIPoolExecutor instances. Otherwise, each worker would attempt to spawn a new pool of workers, leading to infinite recursion. mpi4py.futures detects such recursive attempts to spawn new workers and aborts the MPI execution environment. As the main script code is run under the __worker__ namespace, the easiest way to avoid spawn recursion is using the idiom if __name__ == '__main__': ... in the main script. 💀 do NOT skip this one bestie, infinite recursion is not the serve you think it is

class mpi4py.futures.MPIPoolExecutor(max_workers=None, initializer=None, initargs=(), **kwargs)

class mpi4py.futures.MPIPoolExecutor(max_workers=None, initializer=None,
initargs=(), **kwargs)

An Executor <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Executor> subclass that executes calls asynchronously using a pool of at most max_workers processes. If max_workers is None <https://docs.python.org/3/library/constants.html#None> or not given, its value is determined from the MPI4PY_FUTURES_MAX_WORKERS environment variable if set, or the MPI universe size if set, otherwise a single worker process is spawned. If max_workers is lower than or equal to 0, then a ValueError <https://docs.python.org/3/library/exceptions.html#ValueError> will be raised. 🫠

initializer is an optional callable that is called at the start of each worker process before executing any tasks; initargs is a tuple of arguments passed to the initializer. If initializer raises an exception, all pending tasks and any attempt to submit new tasks to the pool will raise a BrokenExecutor <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.BrokenExecutor> exception. 😵‍💫 yeah, that's a whole mood ruiner.

Other parameters:

okay so, bestie, here are the extra kwargs you can pass to MPIPoolExecutor 💖

  • python_args — a list or iterable with additional command line flags to pass to the Python executable. Command line flags determined from inspection of sys.flags, sys.warnoptions and sys._xoptions are passed unconditionally. ✨
  • mpi_info — a dict or iterable yielding (key, value) pairs. These (key, value) pairs are passed (through an MPI.Info object) to the MPI.Intracomm.Spawn call used to spawn worker processes. This mechanism allows telling the MPI runtime system where and how to start the processes. Check the documentation of the backend MPI implementation about the set of keys it interprets and the corresponding format for values. 💅
  • globals — a dict or iterable yielding (name, value) pairs to initialize the main module namespace in worker processes. 🌸
  • main — If set to False, do not import the __main__ module in worker processes. Setting main to False prevents worker processes from accessing definitions in the parent __main__ namespace. 🫶
  • path — a list or iterable with paths to append to sys.path in worker processes to extend the module search path. 🦋
  • wdir — Path to set the current working directory in worker processes using os.chdir(). The initial working directory is set by the MPI implementation. Quality MPI implementations should honor a wdir info key passed through mpi_info, although such feature is not mandatory. 😭
  • env — a dict or iterable yielding (name, value) pairs with environment variables to update os.environ in worker processes. The initial environment is set by the MPI implementation. MPI implementations may allow setting the initial environment through mpi_info, however such feature is not required nor recommended by the MPI standard. 💀
  • use_pkl5 — If set to True, use pickle with out-of-band buffers for interprocess communication. If use_pkl5 is set to None or not given, its value is determined from the MPI4PY_FUTURES_USE_PKL5 environment variable. Using pickle with out-of-band buffers may benefit applications dealing with large buffer-like objects like NumPy arrays. See mpi4py.util.pkl5 for additional information. 🔥
  • backoff — a float value specifying the maximum number of seconds a worker thread or process suspends execution with time.sleep() while idle-waiting. If not set, its value is determined from the MPI4PY_FUTURES_BACKOFF environment variable if set, otherwise the default value of 0.001 seconds is used. Lower values will reduce latency and increase execution throughput for very short-lived tasks, albeit at the expense of spinning CPU cores and increased energy consumption. 👑

✨ submit(fn, /, *args, **kwargs) ✨

Schedule the callable fn to be executed as fn(*args, **kwargs) and returns a Future object representing the execution of the callable. 💖

executor = MPIPoolExecutor(max_workers=1)
future = executor.submit(pow, 321, 1234)
print(future.result())

✨ map(fn, *iterables, timeout=None, chunksize=1, buffersize=None, **kwargs) ✨

Similar to map(fn, *iterables) except:

  • The iterables are consumed immediately rather than lazily, unless buffersize is specified to limit the number of submitted tasks whose results have not yet been yielded. If the task buffer is full, the caller blocks and iteration over the iterables pauses until a result is yielded from the buffer. 🐢
  • fn is executed asynchronously and several calls to fn may be made concurrently, out-of-order, in separate processes. 🚀

The returned iterator raises a TimeoutError if __next__() is called and the result isn’t available after timeout seconds from the original call to map(). timeout can be an int or a float. If timeout is not specified or None, there is no limit to the wait time. ⏳

If fn raises an exception, then that exception will be raised when its value is retrieved from the iterator. 😱

This method chops iterables into a number of chunks which it submits to the pool as separate tasks. The (approximate) size of these chunks can be specified by setting chunksize to a positive integer. For very long iterables, using a large value for chunksize can significantly improve performance compared to the default size of one. 🍰

By default, the returned iterator yields results in-order, waiting for successive tasks to complete. This behavior can be changed by passing the keyword argument unordered as True, then the result iterator will yield a result as soon as any of the tasks complete. 🎢

executor = MPIPoolExecutor(max_workers=3)
for result in executor.map(pow, [2] * 32, range(32)):
    print(result)

Changed in version 4.1.0: Added the buffersize parameter. 🆕

✨ starmap(fn, iterable, timeout=None, chunksize=1, buffersize=None, **kwargs) ✨

Similar to itertools.starmap(fn, iterable). Used instead of map() when argument parameters are already grouped in tuples from a single iterable (the data has been “pre-zipped”). map(fn, *iterable) is equivalent to starmap(fn, zip(*iterable)). 🌟

executor = MPIPoolExecutor(max_workers=3)
iterable = ((2, n) for n in range(32))
for result in executor.starmap(pow, iterable):
    print(result)

Changed in version 4.1.0: Added the buffersize parameter. 🆕

✨ shutdown(wait=True, cancel_futures=False) ✨

Signal the executor that it should free any resources that it is using when the currently pending futures are done executing. Calls to submit() and map() made after shutdown() will raise RuntimeError. 🛑

If wait is True then this method will not return until all the pending futures are done executing and the resources associated with the executor have been freed. If wait is False then this method will return immediately and the resources associated with the executor will be freed when all pending futures are done executing. Regardless of the value of wait, the entire Python program will not exit until all pending futures are done executing. ⏸️

If cancel_futures is True, this method will cancel all pending futures that the executor has not started running. Any futures that are completed or running won’t be cancelled, regardless of the value of cancel_futures. 🚫

You can avoid having to call this method explicitly if you use the with statement, which will shutdown the executor instance (waiting as if shutdown() were called with wait set to True). 🎀

import time
with MPIPoolExecutor(max_workers=1) as executor:
    future = executor.submit(time.sleep, 2)
assert future.done()
  • bootup(wait=True) — tells the executor to go ahead and allocate all the resources it needs eagerly, like right now, no waiting (especially the MPI worker processes, they're the whole point 💅). If wait is True <https://docs.python.org/3/library/constants.html#True>, then bootup() literally will not come back until the executor's resources are ready to handle submissions. But here's the thing — resources get allocated automatically on the first call to submit(), so calling bootup() yourself is seldom needed. It's giving optional, bestie. ✨
  • num_workers — number of worker processes in the pool. 🫶

🌈 MPI4PY_FUTURES_MAX_WORKERS

If the max_workers parameter to MPIPoolExecutor is None <https://docs.python.org/3/library/constants.html#None> or you just didn't pass it at all (no judgment 🙈), then the MPI4PY_FUTURES_MAX_WORKERS environment variable steps in as the fallback value for the maximum number of MPI worker processes to spawn. iykyk.

Added in version 3.1.0.

🦋 MPI4PY_FUTURES_USE_PKL5

If the use_pkl5 keyword argument to MPIPoolExecutor is None <https://docs.python.org/3/library/constants.html#None> or not given, the MPI4PY_FUTURES_USE_PKL5 environment variable provides a fallback value for whether the executor should use pickle <https://docs.python.org/3/library/pickle.html#module-pickle> with out-of-band buffers for interprocess communication.

Accepted values are:

Using pickle <https://docs.python.org/3/library/pickle.html#module-pickle> with out-of-band buffers may benefit applications dealing with large buffer-like objects like NumPy arrays. See mpi4py.util.pkl5 <#module-mpi4py.util.pkl5> for additional information. 🔥

Added in version 4.0.0.

🍓 MPI4PY_FUTURES_BACKOFF

If the backoff keyword argument to MPIPoolExecutor is not given, the MPI4PY_FUTURES_BACKOFF environment variable can be set to a float <https://docs.python.org/3/library/functions.html#float> value specifying the maximum number of seconds a worker thread or process suspends execution with time.sleep() <https://docs.python.org/3/library/time.html#time.sleep> while idle-waiting.

If it's not set, the default backoff value is 0.001 seconds. Lower values will reduce latency and increase execution throughput for very short-lived tasks — but at the expense of spinning CPU cores and increased energy consumption. so like, trade-offs, it's giving chaos vs. efficiency 💀

Added in version 4.0.0.

Note: 📌 As the master process uses a separate thread to perform MPI communication with the workers, the backend MPI implementation should provide support for MPI.THREAD_MULTIPLE <#mpi4py.MPI.THREAD_MULTIPLE>. However, some popular MPI implementations do not support yet concurrent MPI calls from multiple threads. Additionally, users may decide to initialize MPI with a lower level of thread support. If the level of thread support in the backend MPI is less than MPI.THREAD_MULTIPLE <#mpi4py.MPI.THREAD_MULTIPLE>, mpi4py.futures will use a global lock to serialize MPI calls. If the level of thread support is less than MPI.THREAD_SERIALIZED <#mpi4py.MPI.THREAD_SERIALIZED>, mpi4py.futures will emit a RuntimeWarning <https://docs.python.org/3/library/exceptions.html#RuntimeWarning>.
Warning: ⚠️ If the level of thread support in the backend MPI is less than MPI.THREAD_SERIALIZED <#mpi4py.MPI.THREAD_SERIALIZED> (i.e, it is either MPI.THREAD_SINGLE <#mpi4py.MPI.THREAD_SINGLE> or MPI.THREAD_FUNNELED <#mpi4py.MPI.THREAD_FUNNELED>), in theory mpi4py.futures cannot be used. Rather than raising an exception, mpi4py.futures emits a warning and takes a “cross-fingers” attitude 🤞 to continue execution in the hope that serializing MPI calls with a global lock will actually work. iconic behaviour honestly.

👑 MPICommExecutor

So like, legacy MPI-1 implementations (and also some vendor MPI-2 implementations, not naming names 💅) do not support the dynamic process management features introduced in the MPI-2 standard. And on top of that, job schedulers and batch systems in supercomputing facilities may pose additional complications to applications using the MPI_Comm_spawn() routine. it's giving suffering.

With these issues in mind, mpi4py.futures supports an additional, more traditional, SPMD-like usage pattern requiring MPI-1 calls only. Python applications are started the usual way, e.g., using the mpiexec command. Python code should make a collective call to the MPICommExecutor context manager to partition the set of MPI processes within a MPI communicator in one master processes and many workers processes. The master process gets access to an MPIPoolExecutor instance to submit tasks. Meanwhile, the worker process follow a different execution path and team-up to execute the tasks submitted from the master. slay, teamwork fr fr 🫶

Besides alleviating the lack of dynamic process management features in legacy MPI-1 or partial MPI-2 implementations, the MPICommExecutor context manager may be useful in classic MPI-based Python applications willing to take advantage of the simple, task-based, master/worker approach available in the mpi4py.futures package.

class mpi4py.futures.MPICommExecutor(comm=None, root=0)

Context manager for MPIPoolExecutor. This context manager splits a MPI (intra)communicator comm (defaults to MPI.COMM_WORLD <#mpi4py.MPI.COMM_WORLD> if not provided or None <https://docs.python.org/3/library/constants.html#None>) in two disjoint sets: a single master process (with rank root in comm) and the remaining worker processes. These sets are then connected through an intercommunicator.

The target of the with <https://docs.python.org/3/reference/compound_stmts.html#with> statement is assigned either an MPIPoolExecutor instance (at the master) or None <https://docs.python.org/3/library/constants.html#None> (at the workers). bestie the workers get nothing, that's literally the deal 💀

from mpi4py import MPI
from mpi4py.futures import MPICommExecutor

with MPICommExecutor(MPI.COMM_WORLD, root=0) as executor:
    if executor is not None:
       future = executor.submit(abs, -42)
       assert future.result() == 42
       answer = set(executor.map(abs, [-42, 42]))
       assert answer == {42}
Warning: ⚠️ If MPICommExecutor is passed a communicator of size one (e.g., MPI.COMM_SELF <#mpi4py.MPI.COMM_SELF>), then the executor instance assigned to the target of the with <https://docs.python.org/3/reference/compound_stmts.html#with> statement will execute all submitted tasks in a single worker thread, thus ensuring that task execution still progress asynchronously. However, the GIL <https://docs.python.org/3/glossary.html#term-GIL> will prevent the main and worker threads from running concurrently in multicore processors. Moreover, the thread context switching may harm noticeably the performance of CPU-bound tasks. In case of I/O-bound tasks, the GIL <https://docs.python.org/3/glossary.html#term-GIL> is not usually an issue, however, as a single worker thread is used, it progress one task at a time. We advice against using MPICommExecutor with communicators of size one and suggest refactoring your code to use instead a ThreadPoolExecutor <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor>. don't do it, we're begging 🙏

🎀 Command line

Recalling the issues related to the lack of support for dynamic process management features in MPI implementations (yeah, the whole saga from before 😭), mpi4py.futures supports an alternative usage pattern where Python code (either from scripts, modules, or zip files) is run under command line control of the mpi4py.futures package by passing -m mpi4py.futures to the python executable.

The mpi4py.futures invocation should be passed a pyfile path to a script (or a zipfile/directory containing a __main__.py file). Additionally, mpi4py.futures accepts -m mod to execute a module named mod, -c cmd to execute a command string cmd, or even - to read commands from standard input (sys.stdin <https://docs.python.org/3/library/sys.html#sys.stdin>). Summarizing, mpi4py.futures can be invoked in the following ways:

  • $ mpiexec -n numprocs python -m mpi4py.futures pyfile [arg] ...
  • $ mpiexec -n numprocs python -m mpi4py.futures -m mod [arg] ...
  • $ mpiexec -n numprocs python -m mpi4py.futures -c cmd [arg] ...
  • $ mpiexec -n numprocs python -m mpi4py.futures - [arg] ...

Before starting the main script execution, mpi4py.futures splits MPI.COMM_WORLD <#mpi4py.MPI.COMM_WORLD> in one master (the process with rank 0 in MPI.COMM_WORLD <#mpi4py.MPI.COMM_WORLD>) and numprocs - 1 workers and connects them through an MPI intercommunicator.

Afterwards, the master process proceeds with the execution of the user script code, which eventually creates MPIPoolExecutor instances to submit tasks. Meanwhile, the worker processes follow a different execution path to serve the master. Upon successful termination of the main script at the master, the entire MPI execution environment exists gracefully. In case of any unhandled exception in the main script, the master process calls MPI.COMM_WORLD.Abort(1) to prevent deadlocks and force termination of entire MPI execution environment. yeah it just nukes everything, respectfully 💥

Warning: ⚠️ Running scripts under command line control of mpi4py.futures is quite similar to executing a single-process application that spawn additional workers as required. However, there is a very important difference users should be aware of. All MPIPoolExecutor instances created at the master will share the pool of workers. Tasks submitted at the master from many different executors will be scheduled for execution in random order as soon as a worker is idle. Any executor can easily starve all the workers (e.g., by calling MPIPoolExecutor.map() with long iterables). If that ever happens, submissions from other executors will not be serviced until free workers are available. lowkey terrifying ngl 😭

See also: 👀

Command line <https://docs.python.org/3/using/cmdline.html#using-on-cmdline> : Documentation on Python command line interface.

✨ Parallel tasks ✨

Okay bestie, plot twist incoming 💅 — the mpi4py.futures package is normally all about that embarrassingly parallel life: a whole bunch of sequential tasks that don't care about each other, running asynchronously, living their own truth. But! Even though it's kind of not what it was built for, MPIPoolExecutor can still handle workloads that involve parallel tasks — the kind where worker processes actually talk to each other and coordinate via MPI. It's giving "we're all in this together" energy 🫶

  • mpi4py.futures.get_comm_workers() — grab yourself an intracommunicator that groups the MPI worker processes together.

Now, running parallel tasks with mpi4py.futures comes with RULES, bestie. You don't just vibe your way through this one — check the highlighted lines in the example cpi.py:

  • Use MPIPoolExecutor.num_workers to figure out how many worker processes the executor has, then submit exactly one callable per worker process using the MPIPoolExecutor.submit() method. One each. No double-dipping. 🍓
  • The callable you submit has to use get_comm_workers() to get that intracommunicator grouping the MPI worker processes. And then? Highly recommend calling the Barrier() method on the communicator. Why? Because that barrier synchronization is what guarantees every single worker process is executing the submitted callable exactly once ✨. After that's locked in, the parallel task can safely do literally any kind of point-to-point or collective operation using the returned communicator. Iconic.
  • The Future instances that MPIPoolExecutor.submit() hands back should be collected into a sequence. Then use wait() with that sequence of Future instances to make sure the parallel task is logically complete. Periodt.

🧰 Utilities 🧰

The mpi4py.futures package also hooks you up with some extra utilities for wrangling Future instances 💖

  • mpi4py.futures.collect(fs) — gather a whole collection of futures into one shiny new future.

Parameters

  • fs – Collection of futures.

Returns

  • New future producing as result a list with results from fs.
  • mpi4py.futures.compose(future, resulthook=None, excepthook=None) — compose the completion of a future with result and exception handlers. Very "main character orchestrating her own plot" of it.

Parameters

  • future – Input future instance.
  • resulthook – Function to be called once the input future completes with success. Once the input future finish running with success, its result value is the input argument for resulthook. The result of resulthook is set as the result of the output future. If resulthook is None, the output future is completed directly with the result of the input future.
  • excepthook – Function to be called once the input future completes with failure. Once the input future finish running with failure, its exception value is the input argument for excepthook. If excepthook returns an Exception instance, it is set as the exception of the output future. Otherwise, the result of excepthook is set as the result of the output future. If excepthook is None, the output future is set as failed with the exception from the input future.

Returns

  • Output future instance to be completed once the input future is completed and either resulthook or excepthook finish executing.

🌈 Examples 🌈

🎨 Computing the Julia set 🎨

So the julia.py script below computes the Julia set and dumps an image to disk in binary PGM format. Let's walk through it, bestie 🌸

First it imports MPIPoolExecutor from the mpi4py.futures package. Then there's some global constants and functions implementing the Julia set computation. All the computation is protected with the standard if __name__ == '__main__': ... idiom (you know the one, don't skip it 🙈). The image gets computed scanline by scanline — wait, whole scanlines — submitting all these tasks at once using the map method. The result iterator yields scanlines in-order as the tasks complete. And finally, each scanline is dumped to disk. Slay.

julia.py

from mpi4py.futures import MPIPoolExecutor

x0, x1, w = -2.0, +2.0, 640*2
y0, y1, h = -1.5, +1.5, 480*2
dx = (x1 - x0) / w
dy = (y1 - y0) / h

c = complex(0, 0.65)

def julia(x, y):
    z = complex(x, y)
    n = 255
    while abs(z) < 3 and n > 1:
        z = z**2 + c
        n -= 1
    return n

def julia_line(k):
    line = bytearray(w)
    y = y1 - k * dy
    for j in range(w):
        x = x0 + j * dx
        line[j] = julia(x, y)
    return line

if __name__ == '__main__':

    with MPIPoolExecutor() as executor:
        image = executor.map(julia_line, range(h))
        with open('julia.pgm', 'wb') as f:
            f.write(b'P5 %d %d %d\n' % (w, h, 255))
            for line in image:
                f.write(line)

The recommended way to run this script? Use the mpiexec command, specifying one MPI process (the master) and — optional but recommended, bestie, do it — the desired MPI universe size. That universe size determines how many additional dynamically spawned processes (the workers) you get. The MPI universe size comes either from a batch system or gets set by the user via command-line arguments to mpiexec, or via environment variables. Below are examples for MPICH and Open MPI implementations [1].

In all of these examples, the mpiexec command launches a single master process running the Python interpreter and executing the main script. When required, mpi4py.futures spawns the pool of 16 worker processes. The master submits tasks to the workers and waits for the results. The workers receive incoming tasks, execute them, and send back the results to the master. That's the whole little ecosystem, it's giving community 🐝

When using the MPICH implementation or its derivatives based on the Hydra process manager, users can set the MPI universe size via the -usize argument to mpiexec:

$ mpiexec -n 1 -usize 17 python julia.py

or, alternatively, by setting the MPIEXEC_UNIVERSE_SIZE environment variable:

$ env MPIEXEC_UNIVERSE_SIZE=17 mpiexec -n 1 python julia.py

In the Open MPI implementation, the MPI universe size can be set via the -host argument to mpiexec:

$ mpiexec -n 1 -host localhost:17 python julia.py

Another way to specify the number of workers is to use the mpi4py.futures-specific environment variable MPI4PY_FUTURES_MAX_WORKERS:

$ env MPI4PY_FUTURES_MAX_WORKERS=16 mpiexec -n 1 python julia.py
Heads up bestie! 👀 Note that in this case, the MPI universe size is ignored. Like, fully ignored. Don't come for me.

Alternatively, users may decide to execute the script in a more traditional way — that is, all the MPI processes are started at once. The user script is run under command-line control of mpi4py.futures by passing the -m flag to the python executable:

$ mpiexec -n 17 python -m mpi4py.futures julia.py

As explained previously, the 17 processes are partitioned into one master and 16 workers. The master process executes the main script while the workers execute the tasks submitted by the master. ✨

[1] When using an MPI implementation other than MPICH or Open MPI, please check the documentation of the implementation and/or batch system for the ways to specify the desired MPI universe size.

🔢 Computing Pi (parallel task) 🔢

The number \pi can be approximated via numerical integration with the simple midpoint rule, that is:

\pi = \int_{0}^{1} \frac{4}{1+x^2} \,dx \approx
\frac{1}{n} \sum_{i=1}^{n} \frac{4}{1 + \left[\frac{1}{n}
\left(i-\frac{1}{2}\right) \right]^2} .

The following cpi.py script computes such approximations using mpi4py.futures with a parallel task involving a collective reduction operation. The highlighted lines correspond to the rules we discussed up in Parallel tasks — go back and reread them if you need, no shame 💜

cpi.py

import math
import sys
from mpi4py.futures import MPIPoolExecutor, wait
from mpi4py.futures import get_comm_workers

def compute_pi(n):
    # Access intracommunicator and synchronize
    comm = get_comm_workers()
    comm.Barrier()

    rank = comm.Get_rank()
    size = comm.Get_size()

    # Local computation
    h = 1.0 / n
    s = 0.0
    for i in range(rank + 1, n + 1, size):
        x = h * (i - 0.5)
        s += 4.0 / (1.0 + x**2)
    pi_partial = s * h

    # Parallel reduce-to-all
    pi = comm.allreduce(pi_partial)

    # All workers return the same value
    return pi

if __name__ == '__main__':
    n = int(sys.argv[1]) if len(sys.argv) > 1 else 256

    with MPIPoolExecutor() as executor:
        # Submit exactly one callable per worker
        P = executor.num_workers
        fs = [executor.submit(compute_pi, n) for _ in range(P)]

        # Wait for all workers to finish
        wait(fs)

        # Get result from the first future object.
        # In this particular example, due to using reduce-to-all,
        # all the other future objects hold the same result value.
        pi = fs[0].result()
        print(
            f"pi: {pi:.16f}, error: {abs(pi - math.pi):.3e}",
            f"({n:d} intervals, {P:d} workers)",
        )

To run in modern MPI-2 mode:

$ env MPI4PY_FUTURES_MAX_WORKERS=4 mpiexec -n 1 python cpi.py 128
pi: 3.1415977398528137, error: 5.086e-06 (128 intervals, 4 workers)

$ env MPI4PY_FUTURES_MAX_WORKERS=8 mpiexec -n 1 python cpi.py 512
pi: 3.1415929714812316, error: 3.179e-07 (512 intervals, 8 workers)

To run in legacy MPI-1 mode:

$ mpiexec -n 5 python -m mpi4py.futures cpi.py 128
pi: 3.1415977398528137, error: 5.086e-06 (128 intervals, 4 workers)

$ mpiexec -n 9 python -m mpi4py.futures cpi.py 512
pi: 3.1415929714812316, error: 3.179e-07 (512 intervals, 8 workers)

📚 Citation 📚

Okay so if mpi4py.futures has been significant to a project that leads to an academic publication, please acknowledge our work by citing the following article [mpi4py-futures]:

  • [mpi4py-futures] — M. Rogowski, S. Aseeri, D. Keyes, and L. Dalcin, mpi4py.futures: MPI-Based Asynchronous Task Execution for Python, IEEE Transactions on Parallel and Distributed Systems, 34(2):611-622, 2023. <https://doi.org/10.1109/TPDS.2022.3225481>

🧰 MPI4PY.UTIL 🧰

Added in version 3.1.0.

ok so the mpi4py.util package is literally the grab-bag drawer of the whole library — it collects miscellaneous utilities that live right in the intersection of Python and MPI. bestie, it's giving "junk drawer but make it useful" and honestly? we're obsessed. 💅

🐍 mpi4py.util.dtlib 🐍

Added in version 3.1.0.

the mpi4py.util.dtlib module is your little translator between NumPy and MPI datatypes — converter routines, that's the whole job, no cap. ✨

mpi4py.util.dtlib.from_numpy_dtype(dtype)

Convert NumPy datatype to MPI datatype. girl math but for types. 🦋

Parameters

Return type

  • Datatype <#mpi4py.MPI.Datatype>

mpi4py.util.dtlib.to_numpy_dtype(datatype)

Convert MPI datatype to NumPy datatype. the reverse pipeline, periodt. 💜

Parameters

  • datatype (Datatype <#mpi4py.MPI.Datatype>) – MPI datatype.

Return type

🥒 mpi4py.util.pkl5 🥒

Added in version 3.1.0.

so pickle <https://docs.python.org/3/library/pickle.html#module-pickle> protocol 5 (peep PEP 574 <https://peps.python.org/pep-0574/>) rolled in support for out-of-band buffers, which lets you handle certain object types with large memory footprints wayyy more efficiently. it's giving glow-up. ✨

MPI for Python uses the traditional in-band handling of buffers. That approach is appropriate for communicating non-buffer Python objects, or buffer-like objects with small memory footprints. For point-to-point communication, in-band buffer handling lets you communicate a pickled stream with a single MPI message — at the expense of additional CPU and memory overhead in the pickling and unpickling steps. trade-offs, bestie, always trade-offs. 😭

the mpi4py.util.pkl5 module provides communicator wrapper classes that reimplement pickle-based point-to-point and collective communication methods using pickle protocol 5. Handling out-of-band buffers necessarily involves multiple MPI messages, which increases latency and hurts performance in the case of small size data. BUT. in the case of large size data, the zero-copy savings of out-of-band buffer handling more than offset the extra latency costs. additionally, these wrapper methods overcome the infamous 2 GiB message count limit (MPI-1 to MPI-3). slay. 👑

class mpi4py.util.pkl5.Request

Request.

Custom request class for nonblocking communications.

Note: Request is not a subclass of mpi4py.MPI.Request <#mpi4py.MPI.Request>

class mpi4py.util.pkl5.Message

Message.

Custom message class for matching probes.

Note: Message is not a subclass of mpi4py.MPI.Message <#mpi4py.MPI.Message>

class mpi4py.util.pkl5.Comm

Communicator.

Base communicator wrapper class.

Return type: Any

irecv(buf=None, source=ANY_SOURCE, tag=ANY_TAG)

Nonblocking receive.

🚨 Warning, bestie, listen up: this method cannot be supported reliably and it raises RuntimeError. Like, it's just gonna yell at you. No cap.

Parameters:

  • buf (Buffer | None)
  • source (int)
  • tag (int)

Return type: Request

sendrecv(sendobj, dest, sendtag=0, recvbuf=None, source=ANY_SOURCE, recvtag=ANY_TAG, status=None)

Send and receive. Both at once, main character energy. 💅

Parameters:

  • sendobj (Any)
  • dest (int)
  • sendtag (int)
  • recvbuf (Buffer | None)
  • source (int)
  • recvtag (int)
  • status (Status | None)

Return type: Any

mprobe(source=ANY_SOURCE, tag=ANY_TAG, status=None)

Blocking test for a matched message. Sits there and waits like your bestie outside the bathroom. 🚪

Parameters:

  • source (int)
  • tag (int)
  • status (Status | None)

Return type: Message

improbe(source=ANY_SOURCE, tag=ANY_TAG, status=None)

Nonblocking test for a matched message. Same vibe, but it does NOT wait around. ✨

Parameters:

  • source (int)
  • tag (int)
  • status (Status | None)

Return type: Message | None

bcast(obj, root=0)

Broadcast.

Added in version 3.1.0.

Parameters:

  • obj (Any)
  • root (int)

Return type: Any

gather(sendobj, root=0)

Gather.

Added in version 4.0.0.

Parameters:

  • sendobj (Any)
  • root (int)

Return type: list[Any] | None

scatter(sendobj, root=0)

Scatter.

Added in version 4.0.0.

Parameters:

  • sendobj (Sequence[Any] | None)
  • root (int)

Return type: Any

allgather(sendobj)

Gather to All. Everybody gets the tea, nobody's left on read. 🫶

Added in version 4.0.0.

Parameters:

  • sendobj (Any)

Return type: list[Any]

alltoall(sendobj)

All to All Scatter/Gather. Chaotic in the best way, fr fr. 🔥

Added in version 4.0.0.

Parameters:

  • sendobj (Sequence[Any])

Return type: list[Any]

class mpi4py.util.pkl5.Intracomm

Intracommunicator.

Intracommunicator wrapper class. It's literally just a lil glow-up wrapper around the comm you already know. 🎀

class mpi4py.util.pkl5.Intercomm

Intercommunicator.

Intercommunicator wrapper class. Same energy, different topology. 🦋

✨ Examples ✨

test-pkl5-1.py

import numpy as np
from mpi4py import MPI
from mpi4py.util import pkl5

comm = pkl5.Intracomm(MPI.COMM_WORLD)  # comm wrapper
size = comm.Get_size()
rank = comm.Get_rank()
dst = (rank + 1) % size
src = (rank - 1) % size

sobj = np.full(1024**3, rank, dtype='i4')  # > 4 GiB
sreq = comm.isend(sobj, dst, tag=42)
robj = comm.recv (None, src, tag=42)
sreq.Free()

assert np.min(robj) == src
assert np.max(robj) == src

test-pkl5-2.py

import numpy as np
from mpi4py import MPI
from mpi4py.util import pkl5

comm = pkl5.Intracomm(MPI.COMM_WORLD)  # comm wrapper
size = comm.Get_size()
rank = comm.Get_rank()
dst = (rank + 1) % size
src = (rank - 1) % size

sobj = np.full(1024**3, rank, dtype='i4')  # > 4 GiB
sreq = comm.isend(sobj, dst, tag=42)

status = MPI.Status()
rmsg = comm.mprobe(status=status)
assert status.Get_source() == src
assert status.Get_tag() == 42
rreq = rmsg.irecv()
robj = rreq.wait()

sreq.Free()
assert np.max(robj) == src
assert np.min(robj) == src

🌈 mpi4py.util.pool 🌈

Added in version 4.0.0.

See also:

This module intends to be a drop-in replacement for the multiprocessing.pool interface from the Python standard library. The Pool class exposed here is implemented as a thin wrapper around MPIPoolExecutor. So like, if your code already speaks multiprocessing.pool, it just... works. Slay. 💅

Note:

The mpi4py.futures package offers a higher level interface for asynchronously pushing tasks to MPI worker process, allowing for a clear separation between submitting tasks and waiting for the results. iykyk — if you want the fancier setup, go there.

class mpi4py.util.pool.Pool

Pool using MPI processes as workers. Your little squad of worker processes, assembled and ready. 👑

__init__(processes=None, initializer=None, initargs=(), **kwargs)

Initialize a new Pool instance.

Parameters:

  • processes (int | None) – Number of worker processes.
  • initializer (Callable[[...], object] | None) – An callable used to initialize workers processes.
  • initargs (Iterable[Any]) – A tuple of arguments to pass to the initializer.
  • kwargs (Any)

Return type: None

Note:

Additional keyword arguments are passed down to the MPIPoolExecutor constructor. So all that extra stuff you're passing? It goes straight to the executor. Periodt. ✨

Warning, bestie, read this one: the maxtasksperchild and context arguments of multiprocessing.pool.Pool are not supported. If you pass maxtasksperchild or context with anything other than None, you'll get a warning of category UserWarning. Not a vibe. Don't do it. 🫶

apply(func, args=(), kwds={})

Calls func with the arguments args and the keyword arguments kwds. ✨

It's literally equivalent to func(*args, **kwds). No cap.

Parameters 🎀

  • func — a Callable[[...], T]
  • args — an Iterable[Any]
  • kwds — a Mapping[str, Any]

Return type — T 💖

apply_async(func, args=(), kwds={}, callback=None, error_callback=None)

The asynchronous version of apply(), and it hands you back an ApplyResult. 🦋

Parameters 🎀

  • func — a Callable[..., T]
  • args — an Iterable[Any]
  • kwds — a Mapping[str, Any]
  • callback — a Callable[[T], object] | None
  • error_callback — a Callable[[BaseException], object] | None

Return type — AsyncResult[T] 💜

map(func, iterable, chunksize=None)

Applies func to every single element in iterable. 💅

Equivalent to list(map(func, iterable)).

It blocks until all the results are ready, then returns them in a list. Yes bestie, it will just sit there and wait for you. 🧚

The iterable gets choped (their spelling, not mine 😭) into a number of chunks which are submitted as separate tasks. The (approximate) size of these chunks can be specified by setting chunksize to a positive integer.

Hot tip from the docs: consider using imap() or imap_unordered() with an explicit chunksize for better efficiency. Efficiency is the moment. ⭐

Parameters 🎀

  • func — a Callable[[S], T]
  • iterable — an Iterable[S]
  • chunksize — an int | None

Return type — list[T] 🌸

map_async(func, iterable, chunksize=None, callback=None, error_callback=None)

The asynchronous version of map(), and it hands you back a MapResult. 🦋

Parameters 🎀

  • func — a Callable[[S], T]
  • iterable — an Iterable[S]
  • chunksize — an int | None
  • callback — a Callable[[T], None] | None
  • error_callback — a Callable[[BaseException], None] | None

Return type — MapResult[T] 💜

imap(func, iterable, chunksize=1)

Like map() but it returns an iterator instead of blocking on you. Main character behaviour, honestly. ✨

Equivalent to map(func, iterable).

Parameters 🎀

  • func — a Callable[[S], T]
  • iterable — an Iterable[S]
  • chunksize — an int

Return type — Iterator[T] 🦋

imap_unordered(func, iterable, chunksize=1)

Like imap() but the ordering of the results is arbitrary. 🎲

Read that again bestie: arbitrary. The results come back in whatever order they finish, not the order you sent them. If order matters to you, this is not the one. 💀

Parameters 🎀

  • func — a Callable[[S], T]
  • iterable — an Iterable[S]
  • chunksize — an int

Return type — Iterator[T] 💜

starmap(func, iterable, chunksize=None)

Applies func to each argument tuple in iterable. 🌟

Equivalent to list(itertools.starmap(func, iterable)).

It blocks until all the results are ready and returns them in a list. Patience, queen. 👑

The iterable gets choped into a number of chunks which are submitted as separate tasks. The (approximate) size of these chunks can be specified by setting chunksize to a positive integer.

Same tip as before: consider using istarmap() or istarmap_unordered() with an explicit chunksize for better efficiency. 🔥

Parameters 🎀

  • func — a Callable[[...], T]
  • iterable — an Iterable[Iterable[Any]]
  • chunksize — an int | None

Return type — list[T] 🌸

starmap_async(func, iterable, chunksize=None, callback=None, error_callback=None)

The asynchronous version of starmap(), and it hands you back a MapResult. 🦋

Parameters 🎀

  • func — a Callable[..., T]
  • iterable — an Iterable[Iterable[Any]]
  • chunksize — an int | None
  • callback — a Callable[[T], None] | None
  • error_callback — a Callable[[BaseException], None] | None

Return type — MapResult[T] 💜

istarmap(func, iterable, chunksize=1)

Like starmap() but it returns an iterator. 🌈

Equivalent to itertools.starmap(func, iterable).

Parameters 🎀

  • func — a Callable[[...], T]

istarmap_unordered(func, iterable, chunksize=1)

okay so bestie, this one is literally istarmap() — but the ordering of results is arbitrary. They arrive whenever they arrive. chaos as a feature ✨

Parameters

  • func — Callable[[...], T]
  • iterable — Iterable[Iterable[Any]]
  • chunksize — int

Return type: Iterator[T]

close()

Prevent any more tasks from being submitted to the pool. doors? closed. that's the whole function 💅

Return type: None

terminate()

Stop the worker processes without completing pending tasks. No cleanup arc, we just end it 😭

Return type: None

join()

Wait for the worker processes to exit. just sit there and let them go, okay? 🦋

Return type: None

class mpi4py.util.pool.ThreadPool

Bases: Pool

A pool that uses threads as its workers. 🧚

class mpi4py.util.pool.AsyncResult

Asynchronous result. a lil container for a value that hasn't shown up yet 🎀

get(timeout=None) — Return the result when it arrives.

  • If timeout is not None and the result does not arrive within timeout seconds then raise TimeoutError.
  • If the remote call raised an exception then that exception will be reraised.

Parameters

  • timeout — float | None

Return type: T

wait(timeout=None) — Wait until the result is available or timeout seconds pass.

Parameters

  • timeout — float | None

Return type: None

ready() — Return whether the call has completed.

Return type: bool

successful() — Return whether the call completed without raising an exception.

Heads up: if the result is not ready then raise ValueError.

Return type: bool

class mpi4py.util.pool.ApplyResult

Bases: AsyncResult

Result type of apply_async(). 💖

class mpi4py.util.pool.MapResult

Bases: AsyncResult

Result type of map_async() and starmap_async(). 💖

mpi4py.util.sync

Added in version 4.0.0.

The mpi4py.util.sync module provides parallel synchronization utilities. everybody on the same page, together, periodt 🫶

Sequential execution

class mpi4py.util.sync.Sequential — Sequential execution.

Context manager for sequential execution within a group of MPI processes. one at a time, in rank order, no cutting the line 🌸

The implementation is based in MPI-1 point-to-point communication. A process with rank i waits in a blocking receive until the previous process rank i-1 finish executing and signals the next rank i with a send.

__init__(comm, tag=0) — Initialize sequential execution.

Parameters

  • comm — Intracomm. Intracommunicator context.
  • tag — int. Tag for point-to-point communication.

Return type: None

__enter__() — Enter sequential execution.

Return type: Self

__exit__(*exc) — Exit sequential execution.

Parameters

  • exc — object

Return type: None

begin() — Begin sequential execution.

Return type: None

end() — End sequential execution.

Return type: None

Global counter

class mpi4py.util.sync.Counter — Global counter.

Produce consecutive values within a group of MPI processes. The counter interface is close to that of itertools.count. it's giving "everyone gets a number, nobody gets the same one" ✨

The implementation is based in MPI-3 one-sided operations. A root process (typically rank 0) holds the counter, and its value is queried and incremented with an atomic RMA fetch-and-add operation.

__init__(start=0, step=1, *, typecode='i', comm=COMM_SELF, info=INFO_NULL, root=0) — Initialize global counter.

Parameters

  • start — int. Start value.
  • step — int. Increment value.
  • typecode — str. Type code as defined in the array module.
  • comm — Intracomm. Intracommunicator context.
  • info — Info. Info object for RMA context creation.
  • root — int. Process rank holding the counter memory.

Return type: None

__iter__() — Implement iter(self).

Return type: Self

__next__() — Implement next(self).

Return type: int

next(incr=None) — Return current value and increment.

Parameters

  • incr — int | None. Increment value.

Returns: The counter value before incrementing.

Return type: int

free() — Free counter resources. clean up after yourself, bestie 🎀

Return type: None

Mutual exclusion

class mpi4py.util.sync.Mutex — Mutual exclusion.

Establish a critical section or mutual exclusion among MPI processes.

The mutex interface is close to that of threading.Lock and threading.RLock, allowing the use of either recursive or non-recursive mutual exclusion. However, a mutex should be used within a group of MPI processes, not threads. 👑

In non-recursive mode, the semantics of Mutex are somewhat different than these of threading.Lock:

  • Once acquired, a mutex is held and owned by a process until released.
  • Trying to acquire a mutex already held raises RuntimeError.
  • Trying to release a mutex not yet held raises RuntimeError.
fr fr, respect the lock: if it's already held and you try to grab it again, RuntimeError. If you try to release something you never held, RuntimeError. No cap. 💀

This mutex implementation uses the scalable and fair spinlock algorithm from [mcs-paper] and took inspiration from the MPI-3 RMA implementation of [uam-book]. Bestie, that's a whole academic glow-up for a lock. 💅

__init__(*, recursive=False, comm=COMM_SELF, info=INFO_NULL)

Initialize mutex object. Yes, constructor, we love a fresh start.

Parameters

  • comm (Intracomm) — Intracommunicator context.
  • recursive (bool) — Whether to allow recursive acquisition.
  • info (Info) — Info object for RMA context creation.

Return type: None

__enter__()

Acquire mutex. Context manager said "I gotchu". 🫶

Return type: Self

__exit__(*exc)

Release mutex.

Parameters

  • exc (object)

Return type: None

acquire(blocking=True)

Acquire mutex, blocking or non-blocking. Your choice, main character.

Parameters

  • blocking (bool) — If True, block until the mutex is held.

Returns: True if the mutex is held, False otherwise.

Return type: bool

release()

Release mutex. Let it gooo, let it gooo. 🦋

Return type: None

locked()

Return whether the mutex is held. Vibe check: is it locked or not?

Return type: bool

count()

Return the recursion count.

Return type: int

free()

Free mutex resources. Cleanup era — no leaks, periodt.

Return type: None

[mcs-paper]

John M. Mellor-Crummey and Michael L. Scott. Algorithms for scalable synchronization on shared-memory multiprocessors. ACM Transactions on Computer Systems, 9(1):21-65, February 1991. https://doi.org/10.1145/103727.103729

[uam-book]

William Gropp, Torsten Hoefler, Rajeev Thakur, Ewing Lusk. Using Advanced MPI - Modern Features of the Message-Passing Interface. Chapter 4, Section 4.7, Pages 130-131. The MIT Press, November 2014. https://mitpress.mit.edu/9780262527637/using-advanced-mpi/

🎀 Condition variable


class mpi4py.util.sync.Condition

Condition variable.

A condition variable allows one or more MPI processes to wait until they are notified by another processes. It's giving "don't text them first, wait for the notification". 💅

The condition variable interface is close to that of threading.Condition, allowing the use of either recursive or non-recursive mutual exclusion. However, the condition variable should be used within a group of MPI processes, not threads. Read that again, bestie — processes, not threads. Important.

This condition variable implementation uses a MPI-3 RMA-based scalable and fair circular queue algorithm to track the set of waiting processes. Circular queue, fair, scalable — she's an overachiever and we respect it. 👑

__init__(mutex=None, *, recursive=True, comm=COMM_SELF, info=INFO_NULL)

Initialize condition variable.

Parameters

  • mutex (Mutex | None) — Mutual exclusion object.
  • recursive (bool) — Whether to allow recursive acquisition.
  • comm (Intracomm) — Intracommunicator context.
  • info (Info) — Info object for RMA context creation.

Return type: None

__enter__()

Acquire the underlying mutex.

Return type: Self

__exit__(*exc)

Release the underlying mutex.

Parameters

  • exc (object)

Return type: None

acquire(blocking=True)

Acquire the underlying mutex.

Parameters

  • blocking (bool)

Return type: bool

release()

Release the underlying mutex.

Return type: None

locked()

Return whether the underlying mutex is held.

Return type: bool

wait()

Wait until notified by another process. Literally just sitting there, patiently, waiting for a sign. 🙈

Returns: Always True.

Return type: Literal[True]

wait_for(predicate)

Wait until a predicate evaluates to True. She waits for the condition to be true, not for a text back. Growth. 🌸

Parameters

  • predicate (Callable[[], T]) — callable returning a boolean.

Returns: The result of predicate once it evaluates to True.

Return type: T

notify(n=1)

Wake up one or more processes waiting on this condition.

Parameters

  • n (int) — Maximum number of processes to wake up.

Returns: The actual number of processes woken up.

Return type: int

notify_all()

Wake up all processes waiting on this condition. Group chat notification, everyone up. 🔔

Returns: The actual number of processes woken up.

Return type: int

free()

Free condition resources.

Return type: None

🍓 Semaphore object


class mpi4py.util.sync.Semaphore

Semaphore object.

A semaphore object manages an internal counter which is decremented by each acquire() call and incremented by each release() call. The internal counter never reaches a value below zero; when acquire() finds that it is zero, it blocks and waits until some other process calls release(). Counter go down, counter go up, counter never go negative — she has boundaries. 💅

The semaphore interface is close to that of threading.Semaphore and threading.BoundedSemaphore, allowing the use of either bounded (default) or unbounded semaphores. With a bounded semaphore, the internal counter never exceeds its initial value; otherwise release() raises ValueError. So yeah, unbounded means release() can throw ValueError at you. Not a drill.

This semaphore implementation uses a global Counter and a Condition variable to handle waiting and notification.

__init__(value=1, *, bounded=True, comm=COMM_SELF, info=INFO_NULL)

Initialize semaphore object.

Parameters

  • value (int) — Initial value for internal counter.
  • bounded (bool) — Bound internal counter to initial value.
  • comm (Intracomm) — Intracommunicator context.
  • info (Info) — Info object for RMA context creation.

Return type: None

__enter__()

Acquire semaphore.

Return type: Self — and yes bestie, it literally hands you back Self 💅 so you can keep the chain going

  • __exit__(*exc) — let go of the semaphore, we're done here 🫶
    • exc (object)
    • Return type: None
  • acquire(blocking=True) — grab the semaphore and knock the internal counter down by one ✨
    • blocking (bool) — if True, just sit there and wait patiently (no cap, it will block) until the semaphore is acquired.
    • Returns: True if the semaphore is acquired, False otherwise.
    • Return type: bool
  • release(n=1) — release the semaphore, bumping that internal counter up by one or more 🎀
    • n (int) — how much to increment the internal counter by.
    • Return type: None
  • free() — free semaphore resources, clean up your mess queen 🧹
    • Return type: None

🧪 Examples 🧪

test-sync-1.py

from mpi4py import MPI
from mpi4py.util.sync import Counter, Sequential

comm = MPI.COMM_WORLD

counter = Counter(comm)
with Sequential(comm):
   value = next(counter)
counter.free()

assert comm.rank == value

test-sync-2.py

from mpi4py import MPI
from mpi4py.util.sync import Counter, Mutex

comm = MPI.COMM_WORLD

mutex = Mutex(comm)
counter = Counter(comm)
with mutex:
   value = next(counter)
counter.free()
mutex.free()

assert (
   list(range(comm.size)) ==
   sorted(comm.allgather(value))
)

🌈 MPI4PY.RUN 🌈

Added in version 3.0.0. ⭐

okay so here's the whole vibe 👑 — at import time, mpi4py initializes the MPI execution environment by calling MPI_Init_thread(), and it installs an exit hook to automatically call MPI_Finalize() right before the Python process terminates. And also, mpi4py overrides the default ERRORS_ARE_FATAL error handler in favor of ERRORS_RETURN, which is what lets it translate MPI errors into Python exceptions 🦋

These departures from standard MPI behavior may be controversial, but honestly? they're quite convenient inside the highly dynamic Python programming environment, iykyk. Third-party code using mpi4py can just from mpi4py import MPI and do MPI calls without that tedious initialization/finalization handling 😭. And MPI errors, once they're automatically translated into Python exceptions, can be dealt with using the usual try…except…finally clauses — unhandled MPI exceptions will print a traceback, which helps you locate problems in your source code 🔍

Unfortunately — and this is the part where we get dramatic — the interplay of automatic MPI finalization and unhandled exceptions may lead to deadlocks 💀. And in unattended runs, these deadlocks will drain the battery of your laptop, or burn precious allocation hours in your supercomputing facility. Not the allocation hours bestie, NOT the allocation hours 😭

😭 Exceptions and deadlocks 😭

Consider the following snippet of Python code. Assume this code is stored in a standard Python script file and run with mpiexec in two or more processes.

deadlock.py

from mpi4py import MPI
assert MPI.COMM_WORLD.Get_size() > 1
rank = MPI.COMM_WORLD.Get_rank()
if rank == 0:
    1/0
    MPI.COMM_WORLD.send(None, dest=1, tag=42)
elif rank == 1:
    MPI.COMM_WORLD.recv(source=0, tag=42)

Process 0 raises a ZeroDivisionError exception before it ever performs a send call to process 1. And because that exception is not handled, the Python interpreter running in process 0 will proceed to exit with non-zero status. BUT — since mpi4py installed a finalizer hook to call MPI_Finalize() before exit, process 0 will block, waiting for the other processes to also enter the MPI_Finalize() call 😳

Meanwhile, process 1 is blocked waiting for a message to arrive from process 0, so it never reaches MPI_Finalize(). And the whole MPI execution environment is irremediably in a deadlock state 💀🔒

To alleviate this issue, mpi4py offers a simple, alternative command line execution mechanism based on using the -m flag and implemented with the runpy module. To use this feature, Python code should be run passing -m mpi4py in the command line invoking the Python interpreter. And in the case of unhandled exceptions, the finalizer hook will call MPI_Abort() on the MPI_COMM_WORLD communicator — thus effectively aborting the MPI execution environment 🔥

Warning: When a process is forced to abort, resources (e.g. open files) are not cleaned-up and any registered finalizers (either with the atexit module, the Python C/API function Py_AtExit(), or even the C standard library function atexit()) will not be executed. So like… aborting execution is an extremely impolite way of ensuring process termination 🙈. However, MPI provides no other mechanism to recover from a deadlock state. Periodt.

💻 Command line 💻

Using -m mpi4py to execute Python code on the command line resembles that of the Python interpreter ✨

mpiexec -n numprocs python -m mpi4py pyfile [arg] ...
mpiexec -n numprocs python -m mpi4py -m mod [arg] ...
mpiexec -n numprocs python -m mpi4py -c cmd [arg] ...
mpiexec -n numprocs python -m mpi4py - [arg] ...
  • <pyfile> — execute the Python code contained in pyfile, which must be a filesystem path referring to either a Python file, a directory containing a __main__.py file, or a zipfile containing a __main__.py file. 🍓
  • -m <mod> — search sys.path for the named module mod and execute its contents.
  • -c <cmd> — execute the Python code in the cmd string command.
  • - — read commands from standard input (sys.stdin).

See also:

🌸 MPI4PY.BENCH 🌸

Added in version 3.0.0. ⭐

👑 REFERENCE 👑

  • mpi4py.MPI — Message Passing Interface. 💌

💜 mpi4py.MPI 💜

Message Passing Interface.

✨ Classes ✨

okay bestie, here's the whole cast of characters 💖 every class chilling in mpi4py.MPI, lined up so you can meet them all:

  • mpi4py.MPI.BottomType — type of BOTTOM.
  • mpi4py.MPI.BufferAutomaticType — type of BUFFER_AUTOMATIC.
  • mpi4py.MPI.Cartcomm — Cartesian topology intracommunicator.
  • mpi4py.MPI.Comm — communication context.
  • mpi4py.MPI.Datatype — datatype object.
  • mpi4py.MPI.Distgraphcomm — distributed graph topology intracommunicator.
  • mpi4py.MPI.Errhandler — error handler.
  • mpi4py.MPI.File — file I/O context.
  • mpi4py.MPI.Graphcomm — general graph topology intracommunicator.
  • mpi4py.MPI.Grequest — generalized request handler.
  • mpi4py.MPI.Group — group of processes.
  • mpi4py.MPI.InPlaceType — type of IN_PLACE.
  • mpi4py.MPI.Info — info object.
  • mpi4py.MPI.Intercomm — intercommunicator.
  • mpi4py.MPI.Intracomm — intracommunicator.
  • mpi4py.MPI.Message — matched message.
  • mpi4py.MPI.Op — reduction operation.
  • mpi4py.MPI.Pickle — pickle/unpickle Python objects.
  • mpi4py.MPI.Prequest — persistent request handler.
  • mpi4py.MPI.Request — request handler.
  • mpi4py.MPI.Session — session context.
  • mpi4py.MPI.Status — status object.
  • mpi4py.MPI.Topocomm — topology intracommunicator.
  • mpi4py.MPI.Win — remote memory access context.
  • mpi4py.MPI.buffer — buffer.
  • mpi4py.MPI.memory — alias of mpi4py.MPI.buffer.

mpi4py.MPI.BottomType

class mpi4py.MPI.BottomType

Bases: object

It's literally just the type of BOTTOM 💅 that's the whole gig, no notes.

static __new__(cls)

Return type: Self

mpi4py.MPI.BufferAutomaticType

class mpi4py.MPI.BufferAutomaticType

Bases: object

The type of BUFFER_AUTOMATIC ✨ a whole vibe, and that vibe is automatic.

static __new__(cls)

Return type: Self

mpi4py.MPI.Cartcomm

class mpi4py.MPI.Cartcomm

Bases: Topocomm

Cartesian topology intracommunicator 🗺️ bestie this is the one where your processes live on a nice tidy grid, very organized, very demure.

static __new__(cls, comm=None)

Parameters:

  • comm (Cartcomm | None)

Return type: Self

✨ Methods Summary ✨

okay bestie, here's the whole roster of what you can do with your cartesian communicator, no cap:

  • Get_cart_rank(coords) — translate logical coordinates into ranks. glow-up from position to process ID 💅
  • Get_coords(rank) — the reverse, translating ranks back into logical coordinates
  • Get_dim() — hand you the number of dimensions
  • Get_topo() — spill all the info about the cartesian topology
  • Shift(direction, disp) — give you the process ranks you need for data shifting with Sendrecv <#mpi4py.MPI.Comm.Sendrecv>
  • Sub(remain_dims) — produce a lower-dimensional Cartesian topology. shrinking but make it iconic 🦋

🎀 Attributes Summary 🎀

  • coords — Coordinates.
  • dim — Number of dimensions.
  • dims — Dimensions.
  • ndim — Number of dimensions.
  • periods — Periodicity.
  • topo — Topology information.

📖 Methods Documentation 📖

Get_cart_rank(coords)

Translate logical coordinates to ranks. literally the coordinates-to-rank translator of your dreams ✨

Parameters

  • coords (Sequence[int])

Return type

int

Get_coords(rank)

Translate ranks to logical coordinates. going the other way, equally slay 💖

Parameters

  • rank (int)

Return type

list[int]

Get_dim()

Return number of dimensions.

Return type

int

Get_topo()

Return information on the cartesian topology.

Return type

tuple[list[int], list[int], list[int]]

Shift(direction, disp)

Return a process ranks for data shifting with Sendrecv <#mpi4py.MPI.Comm.Sendrecv>.

Parameters

  • direction (int)
  • disp (int)

Return type

tuple[int, int]

Sub(remain_dims)

Return a lower-dimensional Cartesian topology.

Parameters

  • remain_dims (Sequence[bool])

Return type

Cartcomm <#mpi4py.MPI.Cartcomm>

💫 Attributes Documentation 💫

coords

Coordinates.

dim

Number of dimensions.

dims

Dimensions.

ndim

Number of dimensions.

periods

Periodicity.

topo

Topology information.

🌈 mpi4py.MPI.Comm 🌈

class mpi4py.MPI.Comm

Bases: object <https://docs.python.org/3/library/functions.html#object>

Communication context. yeah, this is the moment, this is the main character 👑

static __new__(cls, comm=None)

Parameters

Return type

Self <https://docs.python.org/3/library/typing.html#typing.Self>

  • Abort([errorcode]) — Terminate the MPI execution environment. 😭 like, the whole thing. everyone out. pass an errorcode if you want to be specific about why you're nuking it from orbit 💀
  • Ack_failed([num_to_ack]) — Acknowledge failures on a communicator.</p> you're basically signing off on the mess 💅 num_to_ack tells it how many failures you're acknowledging.
  • Agree(flag) — Blocking agreement. everybody has to agree, and nobody moves until they do 🫶 the flag is your vote.
  • Allgather(sendbuf, recvbuf) — Gather to All. everyone sends, everyone receives the whole set. no secrets on this comm, bestie ✨
  • Allgather_init(sendbuf, recvbuf[, info]) — Persistent Gather to All. same energy as Allgather, but it sticks around so you can fire it off again and again 🔥 optional info for extra intel.
  • Allgatherv(sendbuf, recvbuf) — Gather to All Vector. the vector version — because sometimes everyone's bringing a different amount of stuff to the party 🎀
  • Allgatherv_init(sendbuf, recvbuf[, info]) — Persistent Gather to All Vector. vector edition, but persistent. info is optional, as always 🙈
  • Allreduce(sendbuf, recvbuf[, op]) — Reduce to All. crunch everyone's numbers down and hand the result to literally everyone 👑 drop an op in there to pick your reduction.
  • Allreduce_init(sendbuf, recvbuf[, op, info]) — Persistent Reduce to All.</persistent> persistent flavor — op and info are both optional here, fancy 💅
  • Alltoall(sendbuf, recvbuf) — All to All Scatter/Gather. everyone trades with everyone. it's giving group project where everyone actually participates for once 🌈
  • Alltoall_init(sendbuf, recvbuf[, info]) — Persistent All to All Scatter/Gather. same swap, but persistent so you can rerun it. info optional ✨
  • Alltoallv(sendbuf, recvbuf) — All to All Scatter/Gather Vector. the vector version — unequal amounts welcome, no judgement 🦋
  • Alltoallv_init(sendbuf, recvbuf[, info]) — Persistent All to All Scatter/Gather Vector. vector + persistent = the combo meal 🍓 info optional.
  • Alltoallw(sendbuf, recvbuf) — All to All Scatter/Gather General. the general one. maximum flexibility, maximum power, main character energy fr fr 👑
  • Alltoallw_init(sendbuf, recvbuf[, info]) — Persistent All to All Scatter/Gather General. general AND persistent. and yes, info is optional 💜
  • Attach_buffer(buf) — Attach a user-provided buffer for sending in buffered mode. you hand it buf, it uses it. that's the whole vibe 🫶
  • Barrier() — Barrier synchronization. everyone waits at the line until everyone's there. no cuts, no stragglers ⭐
  • Barrier_init([info]) — Persistent Barrier. the barrier you can reuse. info optional, obviously 💅
  • Bcast(buf[, root]) — Broadcast data from one process to all other processes. one source, everybody else listening. root says who's holding the mic 🎤
  • Bcast_init(buf[, root, info]) — Persistent Broadcast. the persistent remix — root and info both optional ✨
  • Bsend(buf, dest[, tag]) — Blocking send in buffered mode. buffered mode means it can return before the receiver is ready. dest is where it's headed, tag optional 🎀
  • Bsend_init(buf, dest[, tag]) — Persistent request for a send in buffered mode. same buffered send, but you get a persistent request back. dest required, tag optional 💖
  • Call_errhandler(errorcode) — Call the error handler installed on a communicator. you pass the errorcode, it invokes whatever handler is on deck 😭
  • Clone() — Clone an existing communicator. copy-paste but make it MPI. no args, no drama 🦋
  • Compare(comm) — Compare two communicators. you give it a comm, it tells you how they relate. iconique 🔍
  • Create(group) — Create communicator from group. hand it a group, get a communicator back. slay ✨
  • Create_errhandler(errhandler_fn) — Create a new error handler for communicators. pass your errhandler_fn and boom, custom error handling 👑
  • Create_keyval([copy_fn, delete_fn, nopython]) — Create a new attribute key for communicators. all three args are optional: copy_fn, delete_fn, and nopython 💅
  • Delete_attr(keyval) — Delete attribute value associated with a key. give it the keyval and that attribute is gone 🫶
  • Detach_buffer() — Remove an existing attached buffer. the undo button for Attach_buffer. no args needed 🎀
  • Disconnect() — Disconnect from a communicator. you and this communicator? it's over. no cap, it's just over 💀
  • Dup([info]) — Duplicate a communicator. 💫
  • Dup_with_info(info) — Duplicate a communicator with hints, bestie. ✨
  • Flush_buffer() — Block until all buffered messages have been transmitted. it's giving "wait for it…" energy 🫶
  • Free() — Free a communicator.
  • Free_keyval(keyval) — Free an attribute key for communicators. 🔑
  • Gather(sendbuf, recvbuf[, root]) — Gather data to one process from all other processes.
  • Gather_init(sendbuf, recvbuf[, root, info]) — Persistent Gather. 👑
  • Gatherv(sendbuf, recvbuf[, root]) — Gather Vector.
  • Gatherv_init(sendbuf, recvbuf[, root, info]) — Persistent Gather Vector.
  • Get_attr(keyval) — Retrieve attribute value by key.
  • Get_errhandler() — Get the error handler for a communicator.
  • Get_failed() — Extract the group of failed processes. 💀
  • Get_group() — Access the group associated with a communicator.
  • Get_info() — Return the current hints for a communicator.
  • Get_name() — Get the print name for this communicator. 🎀
  • Get_parent() — Return the parent intercommunicator for this process.
  • Get_rank() — Return the rank of this process in a communicator.
  • Get_size() — Return the number of processes in a communicator.
  • Get_topology() — Return the type of topology (if any) associated with a communicator.
  • Iagree(flag) — Nonblocking agreement.
  • Iallgather(sendbuf, recvbuf) — Nonblocking Gather to All.
  • Iallgatherv(sendbuf, recvbuf) — Nonblocking Gather to All Vector.
  • Iallreduce(sendbuf, recvbuf[, op]) — Nonblocking Reduce to All.
  • Ialltoall(sendbuf, recvbuf) — Nonblocking All to All Scatter/Gather.
  • Ialltoallv(sendbuf, recvbuf) — Nonblocking All to All Scatter/Gather Vector.
  • Ialltoallw(sendbuf, recvbuf) — Nonblocking All to All Scatter/Gather General.
  • Ibarrier() — Nonblocking Barrier.
  • Ibcast(buf[, root]) — Nonblocking Broadcast. 📣
  • Ibsend(buf, dest[, tag]) — Nonblocking send in buffered mode.
  • Idup([info]) — Nonblocking duplicate a communicator.
  • Idup_with_info(info) — Nonblocking duplicate a communicator with hints.

okay but notice how every single one of these that starts with a capital I is just the nonblocking version of its non-I bestie?? it's giving "same girl, different era" energy fr fr 💅 the I prefix literally just means "you get a request object back and you go live your life, we'll handle the waiting later" — no cap. 🦋

okay we're still deep in the communicator method lineup, alphabetically slaying, no skips, keep up bestie 💖

  • Iflush_buffer() — nonblocking flush for buffered messages. ✨
  • Igather(sendbuf, recvbuf[, root]) — nonblocking Gather.
  • Igatherv(sendbuf, recvbuf[, root]) — nonblocking Gather Vector. the v stands for very extra 💅
  • Improbe([source, tag, status]) — nonblocking test for a matched message. matched specifically, okay? iykyk.
  • Iprobe([source, tag, status]) — nonblocking test for a message. just any message fr fr.
  • Irecv(buf[, source, tag]) — nonblocking receive. she's not gonna wait around for you 🫶
  • Ireduce(sendbuf, recvbuf[, op, root]) — nonblocking Reduce to Root.
  • Ireduce_scatter(sendbuf, recvbuf[, ...]) — nonblocking Reduce-Scatter, the vector version.
  • Ireduce_scatter_block(sendbuf, recvbuf[, op]) — nonblocking Reduce-Scatter Block, and to be clear that's the regular, non-vector version. two different girls, don't confuse them 💀
  • Irsend(buf, dest[, tag]) — nonblocking send in ready mode. she assumes you're ready, do not disappoint her.
  • Is_inter() — tells you whether the communicator is an intercommunicator.
  • Is_intra() — tells you whether the communicator is an intracommunicator. yes bestie, they're different, that's the whole point.
  • Is_revoked() — indicates whether the communicator has been revoked. 😭
  • Iscatter(sendbuf, recvbuf[, root]) — nonblocking Scatter.
  • Iscatterv(sendbuf, recvbuf[, root]) — nonblocking Scatter Vector.
  • Isend(buf, dest[, tag]) — nonblocking send. iconic, the moment, no notes 👑
  • Isendrecv(sendbuf, dest[, sendtag, recvbuf, ...]) — nonblocking send and receive. doing both at once, multitasking queen 🌈
  • Isendrecv_replace(buf, dest[, sendtag, ...]) — send and receive a message, with the replace twist.
  • Ishrink() — nonblocking shrink of a communicator, removing all failed processes.
  • Issend(buf, dest[, tag]) — nonblocking send in synchronous mode. the s is doing so much work.
  • Join(fd) — interconnects two processes that are connected by a socket. 🦋
  • Mprobe([source, tag, status]) — blocking test for a matched message. yeah, blocking — she will sit there and wait, respectfully.
  • Precv_init(buf, partitions[, source, tag, info]) — creates a request for a partitioned recv operation.
  • Probe([source, tag, status]) — blocking test for a message.
  • Psend_init(buf, partitions, dest[, tag, info]) — creates a request for a partitioned send operation.
  • Recv(buf[, source, tag, status]) — blocking receive. she waits. patiently. for you. 🥺
  • Recv_init(buf[, source, tag]) — creates a persistent request for a receive. it's giving commitment 💜
  • Reduce(sendbuf, recvbuf[, op, root]) — Reduce to Root.
  • Reduce_init(sendbuf, recvbuf[, op, root, info]) — persistent Reduce to Root. she's back and she's forever.

and we're still not done, the list keeps going, stay with me 🎀

  • Reduce_scatter(sendbuf, recvbuf[, ...]) — Reduce-Scatter, but make it fancy — this is the vector version. 🦋
  • Reduce_scatter_block(sendbuf, recvbuf[, op]) — Reduce-Scatter Block, the regular non-vector one. No frills, just vibes. ✨
  • Reduce_scatter_block_init(sendbuf, recvbuf) — Persistent Reduce-Scatter Block (again: regular, non-vector, we keep it simple bestie). 🔁
  • Reduce_scatter_init(sendbuf, recvbuf[, ...]) — Persistent Reduce-Scatter, and yeah it's the vector flavor. 👑
  • Revoke() — Revoke a communicator. It's giving "you're on time out". 💀
  • Rsend(buf, dest[, tag]) — Blocking send, but in ready mode. 🏃♀️
  • Rsend_init(buf, dest[, tag]) — A persistent request for a send in ready mode. Set it once, reuse it forever, iconic behavior. 🎀
  • Scatter(sendbuf, recvbuf[, root]) — Scatter data from one process out to all the other processes. Sharing is caring fr fr. 🌸
  • Scatter_init(sendbuf, recvbuf[, root, info]) — Persistent Scatter. Same energy, reusable wrapper. 🔁
  • Scatterv(sendbuf, recvbuf[, root]) — Scatter Vector. Vector edition, obviously. 🌈
  • Scatterv_init(sendbuf, recvbuf[, root, info]) — Persistent Scatter Vector. Yeah bestie, the vector one but persistent. ✨
  • Send(buf, dest[, tag]) — Blocking send. Classic. The blueprint. 💅
  • Send_init(buf, dest[, tag]) — Creates a persistent request for a standard send. 🌟
  • Sendrecv(sendbuf, dest[, sendtag, recvbuf, ...]) — Send AND receive a message. Doing both at once is such main character energy. 👑
  • Sendrecv_replace(buf, dest[, sendtag, ...]) — Send and receive a message — the replace edition. 🔄
  • Set_attr(keyval, attrval) — Stores an attribute value that's associated with a key. 🗝️
  • Set_errhandler(errhandler) — Sets the error handler for a communicator. So when things go sideways, you already decided how it's handled. 😭
  • Set_info(info) — Sets new values for the hints associated with a communicator. 🧚
  • Set_name(name) — Sets the print name for this communicator. Naming things is self care. 💖
  • Shrink() — Shrinks a communicator to remove all the failed processes. Cleaning house, no cap. 🧹
  • Split([color, key]) — Splits a communicator by color and key. 💜
  • Split_type(split_type[, key, info]) — Splits a communicator by split type. 🦋
  • Ssend(buf, dest[, tag]) — Blocking send, but in synchronous mode. 🤝
  • Ssend_init(buf, dest[, tag]) — Persistent request for a send in synchronous mode. 🔁
  • allgather(sendobj) — Gather to All. Everybody gets everything, we love an equal distribution moment. 🌸
  • allreduce(sendobj[, op]) — Reduce to All. 📉
  • alltoall(sendobj) — All to All Scatter/Gather. The chaotic group chat of collectives, honestly. 💀
  • barrier() — Barrier synchronization. Everyone waits here until everyone's ready — literally the group chat "ok are we all here?" 🚧
  • bcast(obj[, root]) — Broadcast. One to everyone, no side conversations. 📢
  • bsend(obj, dest[, tag]) — Send in buffered mode. 🧺
  • f2py(arg) — no description given, she's mysterious like that. 🙈
  • free() — Calls Free if it's not null or predefined. ✨
  • fromhandle(handle) — Create object from MPI handle. 🫶
  • fromint(arg, /) — Translate integer handle to object.
  • gather(sendobj[, root]) — Gather.
  • ibsend(obj, dest[, tag]) — Nonblocking send in buffered mode.
  • improbe([source, tag, status]) — Nonblocking test for a matched message.
  • iprobe([source, tag, status]) — Nonblocking test for a message.
  • irecv([buf, source, tag]) — Nonblocking receive.
  • isend(obj, dest[, tag]) — Nonblocking send.
  • issend(obj, dest[, tag]) — Nonblocking send in synchronous mode.
  • mprobe([source, tag, status]) — Blocking test for a matched message.
  • probe([source, tag, status]) — Blocking test for a message.
  • py2f() — (no description, she's mysterious like that 💅)
  • recv([buf, source, tag, status]) — Receive.
  • reduce(sendobj[, op, root]) — Reduce to Root.
  • scatter(sendobj[, root]) — Scatter.
  • send(obj, dest[, tag]) — Send in standard mode.
  • sendrecv(sendobj, dest[, sendtag, recvbuf, ...]) — Send and Receive.
  • ssend(obj, dest[, tag]) — Send in synchronous mode.
  • toint() — Translate object to integer handle.

✨ Attributes Summary ✨

okay bestie, these are the lil vibes you can just read off a communicator, no method call needed 🎀

  • group — Group.
  • handle — MPI handle.
  • info — Info hints.
  • is_inter — Is intercommunicator.
  • is_intra — Is intracommunicator.
  • is_topo — Is a topology.
  • name — Print name.
  • rank — Rank of this process.
  • size — Number of processes.
  • topology — Topology type.

💅 Methods Documentation 💅

okay so now we get into the actual receipts, method by method. grab a snack, this is the good part 🍓

Abort(errorcode=0)

Terminate the MPI execution environment. 😭 like, it's over over.

Warning: The invocation of this method prevents the execution of various Python exit and cleanup mechanisms. Use this method as a last resort to prevent parallel deadlocks in case of unrecoverable errors. fr fr, this is the nuclear option — only reach for it when everything else is giving deadlock energy 💀

Parameters

  • errorcode (int)

Return type

  • NoReturn

Ack_failed(num_to_ack=None)

Acknowledge failures on a communicator.

Parameters

  • num_to_ack (int | None)

Return type

  • int

Agree(flag)

Blocking agreement. everyone has to agree before we move on, it's giving group project but make it ✨synchronized✨

Parameters

  • flag (int)

Return type

  • int

Allgather(sendbuf, recvbuf)

Gather to All. 🌈

Gather data from all processes and broadcast the combined data to all other processes. literally everyone gets everybody's tea, no FOMO allowed 🫶

Parameters

  • sendbuf (BufSpec | InPlace)
  • recvbuf (BufSpecB)

Return type

  • None

Allgather_init(sendbuf, recvbuf, info=INFO_NULL)

Persistent Gather to All.

Parameters

  • sendbuf (BufSpec | InPlace)
  • recvbuf (BufSpecB)
  • info (Info)

Return type

  • Prequest

Allgatherv(sendbuf, recvbuf)

Gather to All Vector.

and that's where we're leaving it for now bestie, more incoming 💖

Gathers data from every process and sends it back out to all the other processes — but here's the ✨spicy✨ part: each one can contribute a different amount of data and sit at a different displacement. Not all equal-sized chunks, bestie. Everyone brings their own lil' pile. 💅

Parameters

  • sendbuf (BufSpec | InPlace) 🫶
  • recvbuf (BufSpecV) 🌸

Return type — None

Allgatherv_init(sendbuf, recvbuf, info=INFO_NULL)

Persistent Gather to All Vector. 🦋 Same energy as Allgatherv, but it hands you back a persistent request instead of doing the thing right away. Set it up once, then fire it off whenever. Obsessed.

Parameters

  • sendbuf (BufSpec | InPlace)
  • recvbuf (BufSpecV)
  • info (Info)

Return type — Prequest 💖

Allreduce(sendbuf, recvbuf, op=SUM)

Reduce to All. 🔥 Everyone smashes their data together with op, and then everyone gets the answer. No one's left out, no main character hogging the result. Iconic behaviour fr fr.

Parameters

  • sendbuf (BufSpec | InPlace)
  • recvbuf (BufSpec)
  • op (Op)

Return type — None

Allreduce_init(sendbuf, recvbuf, op=SUM, info=INFO_NULL)

Persistent Reduce to All. ✨ The persistent-request version of Allreduce — set it up, get a Prequest, reuse it forever. So efficient. We love a repeat performer. 👑

Parameters

  • sendbuf (BufSpec | InPlace)
  • recvbuf (BufSpec)
  • op (Op)
  • info (Info)

Return type — Prequest 💜

Alltoall(sendbuf, recvbuf)

All to All Scatter/Gather. 🎀 Send data to all processes and recv data from all processes — like a group chat where literally everyone is @-ing everyone. The full send-and-receive glow-up.

Parameters

  • sendbuf (BufSpecB | InPlace)
  • recvbuf (BufSpecB)

Return type — None

Alltoall_init(sendbuf, recvbuf, info=INFO_NULL)

Persistent All to All Scatter/Gather. 💫 All the all-to-all energy, but persistent. Build the request once, vibe forever.

Parameters

  • sendbuf (BufSpecB | InPlace)
  • recvbuf (BufSpecB)
  • info (Info)

Return type — Prequest 🦋

Alltoallv(sendbuf, recvbuf)

All to All Scatter/Gather Vector. 🌈 Send data to all processes and recv data from all processes — and yes, everyone gets to specify different amounts of data and different displacements. No more pretending we're all the same size. Body positivity for buffers. 💅

Parameters

  • sendbuf (BufSpecV | InPlace)
  • recvbuf (BufSpecV)

Return type — None

Alltoallv_init(sendbuf, recvbuf, info=INFO_NULL)

Persistent All to All Scatter/Gather Vector. ✨ The vector all-to-all, but make it persistent. A Prequest you can keep in your pocket. 🫶

Parameters

  • sendbuf (BufSpecV | InPlace)
  • recvbuf (BufSpecV)
  • info (Info)

Return type — Prequest

Alltoallw(sendbuf, recvbuf)

All to All Scatter/Gather General. 👑 Send/recv data to/from all processes, and this one lets you specify different counts, displacements, and datatypes for every single dest/source. Maximum customisation, zero compromises. It's giving "I designed my own outfit for every party". 🎀

Parameters

  • sendbuf (BufSpecW | InPlace)
  • recvbuf (BufSpecW)

Return type — None

Alltoallw_init(sendbuf, recvbuf, info=INFO_NULL)

Persistent All to All Scatter/Gather General. 💜 Same fully-customisable general all-to-all, now in a persistent-request flavour. Chef's kiss. 😭

Parameters

  • sendbuf (BufSpecW | InPlace)
  • recvbuf (BufSpecW)
  • info (Info)

Return type — Prequest ⭐

Attach_buffer(buf)

Attach a user-provided buffer for sending in buffered mode. 🧺 You're handing MPI your own lil' basket so buffered sends have somewhere to stash things. Very demure, very mindful, very prepared. 🍓

Parameters

  • buf (Buffer | None)

Return type — None

Barrier()

Barrier synchronization. ⏳ The classic "okay everyone STOP and wait until we're all here" moment. Nobody moves until the whole squad arrives. It's the group photo pose. 📸

Return type — None

Barrier_init(info=INFO_NULL)

Persistent Barrier. 🦋 A barrier that you set up once and can reuse — no re-declaring, just vibes.

Parameters

  • info (Info)

Return type — Prequest 💖

Bcast(buf, root=0)

Broadcast data from one process to all other processes. 📣 One process gets the mic, everyone else listens and copies it down. root decides who's holding the aux. Default root is 0, so the usual suspect. 🎤

Parameters

  • buf (BufSpec)
  • root (int)

Return type — None

Bcast_init(buf, root=0, info=INFO_NULL)

Persistent Broadcast. ✨ Broadcast, but persistent — get your Prequest, reuse it on repeat. A hit single, basically. 🎶

Parameters

  • buf (BufSpec)
  • root (int)
  • info (Info)

Return type — Prequest

Bsend(buf, dest, tag=0)

Blocking send in buffered mode. 📦 It sends, it blocks, and it uses that buffered-mode setup you attached earlier. dest is who's getting it, tag is the lil' label (defaults to 0). 🏷️

Parameters

  • buf (BufSpec)
  • dest (int)
  • tag (int)

Return type — None

Bsend_init(buf, dest, tag=0)

Persistent request for a send in buffered mode. 🫶 The buffered send, but persistent — and this one hands you a Request (not a Prequest, bestie, watch the type 👀).

Parameters

  • buf (BufSpec)
  • dest (int)
  • tag (int)

Return type — Request 💜

Call_errhandler(errorcode)

Call the error handler installed on a communicator. 🚨 You're poking the handler that's currently attached to this communicator and telling it "hey, here's the errorcode, deal with it". Dramatic, but sometimes necessary. 😭

Parameters

  • errorcode (int)

Return type — None

Clone()

Clone an existing communicator. 👯 A copy of the communicator — same energy, whole new object. Dupe, but make it official.

Return type — Self 💖

Compare(comm)

Compare two communicators. 🔍 Ask it how this communicator stacks up against comm and it hands you back an int telling you the deal.

Parameters

  • comm (Comm)

Return type — int

Create(group)

Create communicator from group. 🛠️ Feed it a Group and it'll spin you up a fresh Comm. Build-a-bear, but for communicators.

Parameters

  • group (Group)

Return type — Comm ✨

classmethod Create_errhandler(errhandler_fn)

Create a new error handler for communicators. 🚨✨ Give it a callable and it makes you a brand-new Errhandler. The callable takes a Comm and an int, and returns None — that's the whole contract, no cap.

Parameters

  • errhandler_fn (Callable[[Comm, int], None])

Return type — Errhandler 🎀

classmethod Create_keyval(copy_fn=None, delete_fn=None, nopython=False)

Create a new attribute key for communicators. 🗝️ You're minting a brand-new attribute key so you can stash extra stuff on communicators. Both callback slots default to None, and nopython defaults to False. Very custom, very yours.

Parameters

  • copy_fn (Callable[[Comm, int, Any], Any] | None) 🦋
  • delete_fn (Callable[[Comm, int, Any], None] | None) — the callback that fires when an attribute gets deleted
  • nopython (bool) — whether to skip Python-level callback dispatch

Return type: int

Delete_attr(keyval)</p> 🗑️

okay so this one deletes the attribute value that's chilling with a particular key. bye bestie 👋

Parameters

  • keyval (int) — the key whose attribute you're yeeting

Return type: None

Detach_buffer()</p> 📦

Removes a buffer that was already attached. Un-glues it. simple as that.

Return type: Buffer | None

Disconnect()</p> 🔌

Disconnect from a communicator. it's giving "we need to talk" energy but for comms.

Return type: None

Dup(info=None)</p> 👯

Duplicate a communicator. one comm becomes two, iconic behaviour, no notes.

Parameters

  • info (Info | None) — hints for the new copy, or nothing at all

Return type: Self

Dup_with_info(info)</p> 👯‍♀️✨

Duplicate a communicator with hints. same dupe energy, but you're feeding it info for real this time.

Parameters

  • info (Info) — the hints, and this time they're not optional

Return type: Self

Flush_buffer()</p> 🚽💨

Block until every buffered message has actually been transmitted. like, sit there and wait, bestie, the messages are still in transit 🫶

Return type: None

Free()</p> 🕊️

Free a communicator. release it into the wild.

Return type: None

classmethod Free_keyval(keyval)</p> 🔑

Free an attribute key for communicators. it's a classmethod, so you call it on the class itself, not on an instance. iykyk.

Parameters

  • keyval (int) — the key you're freeing

Return type: int

Gather(sendbuf, recvbuf, root=0)</p> 🧺

Gather data to one process from all the other processes. everyone hands their stuff to root, root holds the whole pile. main character root energy fr fr 👑

Parameters

  • sendbuf (BufSpec | InPlace) — what you're sending
  • recvbuf (BufSpecB | None) — where it all lands (only meaningful on root)
  • root (int) — the process collecting everything, defaults to 0

Return type: None

Gather_init(sendbuf, recvbuf, root=0, info=INFO_NULL)</p> 🧺✨

Persistent Gather. same gathering vibe, but you set it up once and reuse it. lowkey efficient.

Parameters

  • sendbuf (BufSpec | InPlace) — what you're sending
  • recvbuf (BufSpecB | None) — where it lands
  • root (int) — the collector, defaults to 0
  • info (Info) — hints, defaults to INFO_NULL

Return type: Prequest

Gatherv(sendbuf, recvbuf, root=0)</p> 🧺🌈

Gather Vector. Gather data to one process from all the other processes — except everyone can send different amounts of data, at different displacements. no uniformity required, we love range 💅

Parameters

  • sendbuf (BufSpec | InPlace) — what you're sending
  • recvbuf (BufSpecV | None) — where it lands, vector-style
  • root (int) — the collector, defaults to 0

Return type: None

Gatherv_init(sendbuf, recvbuf, root=0, info=INFO_NULL)</p> 🧺🌈✨

Persistent Gather Vector. yes it's the persistent version of Gatherv, and yes it still does the different-amounts-different-displacements thing.

Parameters

  • sendbuf (BufSpec | InPlace) — what you're sending
  • recvbuf (BufSpecV | None) — where it lands
  • root (int) — the collector, defaults to 0
  • info (Info) — hints, defaults to INFO_NULL

Return type: Prequest

Get_attr(keyval)</p> 🔍

Retrieve an attribute value by key. the reverse of Delete_attr, if you will.

Parameters

  • keyval (int) — the key you're looking up

Return type: int | Any | None

Get_errhandler()</p> 🚨

Get the error handler for a communicator. who's on aux when things go wrong.

Return type: Errhandler

Get_failed()</p> 💀

Extract the group of failed processes. yeah. the ones that did not make it.

Return type: Group

Get_group()</p> 👥

Access the group associated with a communicator. the whole squad, in group form.

Return type: Group

Get_info()</p> 📋

Return the current hints for a communicator. receipts on what you told it.

Return type: Info

Get_name()</p> 🏷️

Get the print name for this communicator. its little nickname for display purposes.

Return type: str

classmethod Get_parent()</p> 👨‍👩‍👧

Return the parent intercommunicator for this process. it's a classmethod, so call it on the class. family reunion vibes.

Return type: Intercomm

Get_rank()</p> 🔢

Return the rank of this process in a communicator. who am i. classic.

Return type: int

Get_size()</p> 🔢✨

Return the number of processes in a communicator. how many of us are in the group chat.

Return type: int

Get_topology()</p> 🗺️

Return the type of topology (if any) associated with a communicator. if there's no topology, that's also an answer, bestie.

Return type: int

Iagree(flag)</p> 🤝

Nonblocking agreement. the I prefix means you get a Request back instead of just waiting around. very on the go.

Parameters

  • flag (Buffer) — the buffer for the agreement flag

Return type: Request

Iallgather(sendbuf, recvbuf)</p> 📣

Nonblocking Gather to All. everyone sends, everyone receives. equal-opportunity communication 🌈

Parameters

  • sendbuf (BufSpec | InPlace) — what you're sending
  • recvbuf (BufSpecB) — where it lands

Return type: Request

Iallgatherv(sendbuf, recvbuf)</p> 📣🌈

Nonblocking Gather to All Vector. same as above but with the vector flavour — different counts, different displacements.

Parameters

  • sendbuf (BufSpec | InPlace) — what you're sending
  • recvbuf (BufSpecV) — where it lands

Return type: Request

Iallreduce(sendbuf, recvbuf, op=SUM)</p> ➕✨

Nonblocking Reduce to All. everyone contributes, everyone gets the combined result. collective slay.

Parameters

  • sendbuf (BufSpec | InPlace) — what you're contributing
  • recvbuf (BufSpec) — where the result lands
  • op (Op) — the reduction operation, defaults to SUM

Return type: Request

Ialltoall(sendbuf, recvbuf)</p> 🔄

Nonblocking All to All Scatter/Gather. literally everyone trades with everyone. chaotic? maybe. iconic? absolutely.

Parameters

  • sendbuf (BufSpecB | InPlace) — what you're sending
  • recvbuf (BufSpecB) — what you're receiving

Return type: Request

Ialltoallv(sendbuf, recvbuf)</p> 🔄🌈

Nonblocking All to All Scatter/Gather Vector. the vector version — so the amounts and displacements can differ per partner.

Parameters

  • sendbuf (BufSpecV | InPlace) — what you're sending
  • recvbuf (BufSpecV) — what you're receiving

Return type: Request

Ialltoallw(sendbuf, recvbuf)</p> 🔄👑

Nonblocking All to All Scatter/Gather General. the general one. the most unhinged (affectionate) of the all-to-all family.

Parameters

  • sendbuf (BufSpecW | InPlace) — the thing you're sending, or the in-place flex if you're skipping the separate send buffer 🫶
  • recvbuf (BufSpecW) — where the goods land

Return type: Request

Ibarrier()

Nonblocking Barrier. Nobody moves till everybody's here, but make it async so you're not just standing there 💅

Return type: Request

Ibcast(buf, root=0)

Nonblocking Broadcast. One root yaps, everyone else receives the tea ✨

Parameters

  • buf (BufSpec) — the buffer getting broadcast
  • root (int) — who's the source of truth here

Return type: Request

Ibsend(buf, dest, tag=0)

Nonblocking send, but in buffered mode 🧺 — the message gets stashed locally so the send can finish without the receiver already waiting.

Parameters

  • buf (BufSpec) — what you're sending
  • dest (int) — who gets it
  • tag (int) — the little label that keeps your messages straight

Return type: Request

Idup(info=None)

Nonblocking duplicate a communicator 👯 — clone the whole vibe, no blocking.

Parameters

  • info (Info | None) — optional hints to hand over

Return type: tuple[Self, Request] — the new communicator and the request you gotta babysit, bestie

Idup_with_info(info)

Nonblocking duplicate a communicator with hints 🎀 — same clone energy, but you're required to pass the hints, no skipping.

Parameters

  • info (Info) — the hints, mandatory this time

Return type: tuple[Self, Request]

Iflush_buffer()

Nonblocking flush for buffered messages 🚽✨ — kicks out everything you shoved into the buffer with Bsend, asynchronously.

Return type: Request

Igather(sendbuf, recvbuf, root=0)

Nonblocking Gather — everybody sends their piece to the root, but nobody waits around for it 🌸

Parameters

  • sendbuf (BufSpec | InPlace) — your contribution
  • recvbuf (BufSpecB | None) — where the pile lands (root's business, so None elsewhere)
  • root (int) — the one collecting everything

Return type: Request

Igatherv(sendbuf, recvbuf, root=0)

Nonblocking Gather Vector — like gather, except everyone's allowed to bring a different amount 🍓. Nobody has to match.

Parameters

  • sendbuf (BufSpec | InPlace) — your piece, whatever size it is
  • recvbuf (BufSpecV | None) — the uneven pile at the root
  • root (int) — the collector

Return type: Request

Improbe(source=ANY_SOURCE, tag=ANY_TAG, status=None)

Nonblocking test for a matched message 🔍 — peeks and, if there's something there, actually matches it and hands you the Message.

Parameters

  • source (int) — who you're checking on
  • tag (int) — which tag you're checking for
  • status (Status | None) — where to stash the status info

Return type: Message | None — a message if there is one, None if there isn't 😭

Iprobe(source=ANY_SOURCE, tag=ANY_TAG, status=None)

Nonblocking test for a message 👀 — just checks if one's waiting, doesn't consume it.

Parameters

  • source (int) — the sender you're side-eyeing
  • tag (int) — the tag you're side-eyeing
  • status (Status | None) — optional status receptacle

Return type: bool

Irecv(buf, source=ANY_SOURCE, tag=ANY_TAG)

Nonblocking receive 📥 — you set it up, get a Request back, and go live your life until it's ready.

Parameters

  • buf (BufSpec) — where the incoming thing goes
  • source (int) — who you're expecting
  • tag (int) — which tag you're expecting

Return type: Request

Ireduce(sendbuf, recvbuf, op=SUM, root=0)

Nonblocking Reduce to Root 🔥 — everyone combines their stuff into one result, root gets it, nobody blocks.

Parameters

  • sendbuf (BufSpec | InPlace) — your input
  • recvbuf (BufSpec | None) — the final answer (root only)
  • op (Op) — how you're combining, defaults to SUM
  • root (int) — who receives the result

Return type: Request

Ireduce_scatter(sendbuf, recvbuf, recvcounts=None, op=SUM)

Nonblocking Reduce-Scatter, vector version 🌈 — reduce everything together, then scatter chunks of varying sizes back out.

Parameters

  • sendbuf (BufSpec | InPlace) — your input
  • recvbuf (BufSpec) — your share of the result
  • recvcounts (Sequence[int] | None) — how much each rank gets, uneven welcome
  • op (Op) — the reduction operator, defaults to SUM

Return type: Request

Ireduce_scatter_block(sendbuf, recvbuf, op=SUM)

Nonblocking Reduce-Scatter Block — the regular, non-vector version 💖. Everyone gets the same-sized chunk, no custom counts needed.

Parameters

  • sendbuf (BufSpecB | InPlace) — your input
  • recvbuf (BufSpec | BufSpecB) — your equal-sized slice
  • op (Op) — the operator, defaults to SUM

Return type: Request

Irsend(buf, dest, tag=0)

Nonblocking send in ready mode ⚡ — only legal if the matching receive is already posted. Do not play with this one casually, fr fr.

Parameters

  • buf (BufSpec) — what's going out
  • dest (int) — who it's going to
  • tag (int) — the message tag

Return type: Request

Is_inter()

Return whether the communicator is an intercommunicator 🦋 — i.e. it bridges two separate groups.

Return type: bool

Is_intra()

Return whether the communicator is an intracommunicator 🌸 — i.e. everyone's in one single group.

Return type: bool

Is_revoked()

Indicate whether the communicator has been revoked 💀 — you'd wanna know if it was.

Return type: bool

Iscatter(sendbuf, recvbuf, root=0)

Nonblocking Scatter — root splits the goods and flings them out, async edition 🎀

Parameters

  • sendbuf (BufSpecB | None) — the pile being split (root's job, None for everyone else)
  • recvbuf (BufSpec | InPlace) — your incoming share
  • root (int) — the one doing the splitting

Return type: Request

Iscatterv(sendbuf, recvbuf, root=0)

Nonblocking Scatter Vector — scattering, but each rank gets a different amount 🍓. Equal portions are so last season.

Parameters

  • sendbuf (BufSpecV | None) — the uneven pile (root only)
  • recvbuf (BufSpec | InPlace) — your custom-sized share
  • root (int) — the splitter

Return type: Request

Isend(buf, dest, tag=0)

Nonblocking send 📤 — the classic. Fire it off, grab your Request, deal with it later.

Parameters

  • buf (BufSpec) — what you're sending
  • dest (int) — the lucky recipient
  • tag (int) — the tag, keeping your messages from getting mixed up

Return type: Request

Isendrecv(sendbuf, dest, sendtag=0, recvbuf=None, source=ANY_SOURCE, recvtag=ANY_TAG)

Nonblocking send and receive, in one go 🔄 — no deadlock drama, no awkward waiting, just pure main character energy.

Parameters

  • sendbuf (BufSpec) — the thing you're shipping out
  • dest — (int) 💖 the rank you're aiming at
  • sendtag — (int) the tag you're stamping on the outgoing message
  • recvbuf — (BufSpec | None) where the incoming stuff lands, or None if you're not catching anything
  • source — (int) who you're listening for
  • recvtag — (int) the tag you're matching on the way in

Return type: Request

Isendrecv_replace(buf, dest, sendtag=0, source=ANY_SOURCE, recvtag=ANY_TAG)

Okay bestie, this one sends a message and receives one, and the tea is that the same buffer buf is used for both — send it out, get the replacement back in the same spot. Recycling queen 👑✨

Note: this function is guaranteed not to deadlock in situations where pairs of blocking sends and receives may deadlock. That's literally the whole point of it existing, no cap.
Caution: a common mistake when using this function is to mismatch the tags with the source and destination ranks, which can result in deadlock. So like… double-check your tags, bestie, I'm begging 🙏💀

Parameters

  • buf — (BufSpec) 🫶
  • dest — (int)
  • sendtag — (int)
  • source — (int)
  • recvtag — (int)

Return type: Request

Ishrink()

Nonblocking shrink a communicator to remove all failed processes. ✂️ bye felicia, you're not in this group chat anymore.

Return type: tuple[Comm, Request] — yes, a tuple, two things at once, it's giving multitasking 💅

Issend(buf, dest, tag=0)

Nonblocking send in synchronous mode. It's the same vibe as the normal send but ✨synchronous✨, and nonblocking, so your code keeps moving while it does its thing.

Parameters

  • buf — (BufSpec) 🌸
  • dest — (int) 🎯
  • tag — (int) 🏷️

Return type: Request

classmethod Join(fd)

Interconnect two processes connected by a socket. It's a classmethod, so call it on the class itself, not on an instance. 🔌

Parameters

  • fd — (int) the file descriptor, literally just a number bestie

Return type: Intercomm

Mprobe(source=ANY_SOURCE, tag=ANY_TAG, status=None)

Blocking test for a matched message. 👀 It sits there and waits (blocks!) until a message that actually matches shows up — matched, as in the source/tag actually line up. No match, no return.

Parameters

  • source — (int) 🌈
  • tag — (int)
  • status — (Status | None) 🎀

Return type: Message

Precv_init(buf, partitions, source=ANY_SOURCE, tag=ANY_TAG, info=INFO_NULL)

Create a request for a partitioned recv operation. Partitioned, as in partitions chunks of the buffer, and you get a Prequest back so you can fire it off whenever. 🧚

Parameters

  • buf — (BufSpec)
  • partitions — (int)
  • source — (int)
  • tag — (int)
  • info — (Info)

Return type: Prequest

Probe(source=ANY_SOURCE, tag=ANY_TAG, status=None)

Blocking test for a message. It just tells you if a message is there and gives you the status tea.

Note: this function blocks until the message arrives. So do not call it if you were hoping to do literally anything else in the meantime. 😭

Parameters

  • source — (int)
  • tag — (int)
  • status — (Status | None)

Return type: Literal[True] — that's it. True. Iconic, honestly. ✅

Psend_init(buf, partitions, dest, tag=0, info=INFO_NULL)

Create a request for a partitioned send operation. Same partitioned energy as Precv_init but going out instead of coming in. 💌

Parameters

  • buf — (BufSpec)
  • partitions — (int)
  • dest — (int)
  • tag — (int)
  • info — (Info)

Return type: Prequest

Recv(buf, source=ANY_SOURCE, tag=ANY_TAG, status=None)

Blocking receive. Classic. The bread and butter. 🍞🧈

Note: this function blocks until the message is received. It will simply sit there. Patiently. Forever if it has to.

Parameters

  • buf — (BufSpec) the landing zone 🛬
  • source — (int)
  • tag — (int)
  • status — (Status | None)

Return type: None

Recv_init(buf, source=ANY_SOURCE, tag=ANY_TAG)

Create a persistent request for a receive. Persistent, as in you set it up once and reuse it, which is a whole mood. 🔁

Parameters

  • buf — (BufSpec)
  • source — (int)
  • tag — (int)

Return type: Prequest

Reduce(sendbuf, recvbuf, op=SUM, root=0)

Reduce to Root. Everybody's sending their data in and it all gets squished together with op (default SUM, so we're adding 💅) and the result ends up at rank root.

Parameters

  • sendbuf — (BufSpec | InPlace)
  • recvbuf — (BufSpec | None)
  • op — (Op)
  • root — (int)

Return type: None

Reduce_init(sendbuf, recvbuf, op=SUM, root=0, info=INFO_NULL)

Persistent Reduce to Root. Same deal as above, but you get a Prequest you can launch over and over. 🦋

Parameters

  • sendbuf — (BufSpec | InPlace)
  • recvbuf — (BufSpec | None)
  • op — (Op)
  • root — (int)
  • info — (Info)

Return type: Prequest

Reduce_scatter(sendbuf, recvbuf, recvcounts=None, op=SUM)

Reduce-Scatter, vector version. Everybody reduces, then the result gets scattered out in uneven little pieces — recvcounts is how you say who gets how much. 🍓🍓🍓

Parameters

  • sendbuf — (BufSpec | InPlace)
  • recvbuf — (BufSpec)
  • recvcounts — (Sequence[int] | None)
  • op — (Op)

Return type: None

Reduce_scatter_block(sendbuf, recvbuf, op=SUM)

Reduce-Scatter Block — the regular, non-vector version. No recvcounts list here, everyone just gets the same amount, periodt. 👑

Parameters

  • sendbuf — (BufSpecB | InPlace)
  • recvbuf — (BufSpec | BufSpecB)
  • op — (Op)

Return type: None

Reduce_scatter_block_init(sendbuf, recvbuf, op=SUM, info=INFO_NULL)

Persistent Reduce-Scatter Block — again, the regular, non-vector version, but now you get a reusable Prequest out of it. 🎀✨

Parameters

  • sendbuf — (BufSpecB | InPlace)
  • recvbuf — (BufSpec | BufSpecB)
  • op — (Op)
  • info — (Info)

Return type: Prequest

Return type: Prequest

🫶 Reduce_scatter_init(sendbuf, recvbuf, recvcounts=None, op=SUM, info=INFO_NULL)

Persistent Reduce-Scatter, but make it the vector version ✨ (so every rank can get a different amount, no cap).

Parameters

  • sendbuf — BufSpec or InPlace
  • recvbuf — BufSpec
  • recvcounts — Sequence[int] or None
  • op — Op
  • info — Info

Return type: Prequest

💅 Revoke()

Revoke a communicator. Yeah bestie, it's exactly what it sounds like 🫠

Return type: None

🍓 Rsend(buf, dest, tag=0)

Blocking send, but in ready mode 🔥 (so the matching receive better already be posted, iykyk).

Parameters

  • buf — BufSpec
  • dest — int
  • tag — int

Return type: None

🧚 Rsend_init(buf, dest, tag=0)

A persistent request for a send in ready mode. Set it up once, fire it off forever, slay 💫

Parameters

  • buf — BufSpec
  • dest — int
  • tag — int

Return type: Request

🌈 Scatter(sendbuf, recvbuf, root=0)

Scatter data from one process out to all the other processes 🦋 one root, everybody gets a piece, we love a distribution moment.

Parameters

  • sendbuf — BufSpecB or None
  • recvbuf — BufSpec or InPlace
  • root — int

Return type: None

⭐ Scatter_init(sendbuf, recvbuf, root=0, info=INFO_NULL)

Persistent Scatter 💖 set it up one time, then just keep hitting it.

Parameters

  • sendbuf — BufSpecB or None
  • recvbuf — BufSpec or InPlace
  • root — int
  • info — Info

Return type: Prequest

🎀 Scatterv(sendbuf, recvbuf, root=0)

Scatter Vector 🌸

Scatter data from one process to all other processes, except here you get to hand out different amounts of data and displacements — everyone gets a custom-sized lil gift 🎁

Parameters

  • sendbuf — BufSpecV or None
  • recvbuf — BufSpec or InPlace
  • root — int

Return type: None

💜 Scatterv_init(sendbuf, recvbuf, root=0, info=INFO_NULL)

Persistent Scatter Vector 💅 the custom-sized-gift version, but make it reusable.

Parameters

  • sendbuf — BufSpecV or None
  • recvbuf — BufSpec or InPlace
  • root — int
  • info — Info

Return type: Prequest

👑 Send(buf, dest, tag=0)

Blocking send. The classic. The icon. The moment 🫶

Note: This function may block until the message is received. Whether Send blocks or not depends on several factors and is implementation dependent. So like… don't build your whole personality around it returning immediately, okay? 😭

Parameters

  • buf — BufSpec
  • dest — int
  • tag — int

Return type: None

✨ Send_init(buf, dest, tag=0)

Create a persistent request for a standard send 💖

Parameters

  • buf — BufSpec
  • dest — int
  • tag — int

Return type: Prequest

🦋 Sendrecv(sendbuf, dest, sendtag=0, recvbuf=None, source=ANY_SOURCE, recvtag=ANY_TAG, status=None)

Send and receive a message. One call, two jobs, main character energy fr fr 🔥

Note: This function is guaranteed not to deadlock in situations where pairs of blocking sends and receives may deadlock. So it's the safe bestie in a room full of risky ones 💚
Caution: A common mistake when using this function is to mismatch the tags with the source and destination ranks, which can result in deadlock. Do NOT do this. It's giving chaos and not the cute kind 💀

Parameters

  • sendbuf — BufSpec
  • dest — int
  • sendtag — int
  • recvbuf — BufSpec or None
  • source — int
  • recvtag — int
  • status — Status or None

Return type: None

💫 Sendrecv_replace(buf, dest, sendtag=0, source=ANY_SOURCE, recvtag=ANY_TAG, status=None)

Send and receive a message. Same vibe as above, but the buffer gets replaced in place 🌸

Note: This function is guaranteed not to deadlock in situations where pairs of blocking sends and receives may deadlock. Obsessed with the reliability honestly 💚
Caution: A common mistake when using this function is to mismatch the tags with the source and destination ranks, which can result in deadlock. Yeah bestie, same trap, don't fall in it 🙈

Parameters

  • buf — BufSpec
  • dest — int
  • sendtag — int
  • source — int
  • recvtag — int
  • status — Status or None

Return type: None

🎀 Set_attr(keyval, attrval)

Store an attribute value associated with a key 🗝️ lil key-value situation, keep it cute.

Parameters

  • keyval — int
  • attrval — Any

Return type: None

🌟 Set_errhandler(errhandler)

Set the error handler for a communicator 🚨 decide once and for all how you wanna be told things went wrong.

Parameters

  • errhandler — Errhandler

Return type: None

🫧 Set_info(info)

Set new values for the hints associated with a communicator 💭 updating the vibe notes.

Parameters

  • info — Info

Return type: None

💖 Set_name(name)

Set the print name for this communicator 🏷️ give it a little nickname so it shows up cute in debug output.

Parameters

  • name — str
  • Return type: None — yeah, nothing comes back out of this one, and that's the whole vibe 💅
  • Shrink() — shrinks a communicator, and by shrink I mean it removes all failed processes so the group can keep it moving. Collective glow-down. 🧚
    • Return type: Comm
  • Split(color=0, key=0) — splits the communicator up by color and key. Sorting-hat energy, fr fr. 🎀
    • Parameters:
      • color (int)
      • key (int)
    • Return type: Comm
  • Split_type(split_type, key=0, info=INFO_NULL) — same split energy but this time you're splitting by split type, and you can pass Info along for the ride. ✨
    • Parameters:
      • split_type (int)
      • key (int)
      • info (Info)
    • Return type: Comm
  • Ssend(buf, dest, tag=0) — a blocking send, but make it synchronous mode. It's giving "I'm not done until you've acknowledged me," no cap. 😤
    • Parameters:
      • buf (BufSpec)
      • dest (int)
      • tag (int)
    • Return type: None
  • Ssend_init(buf, dest, tag=0) — a persistent request for a send in synchronous mode. Set it up now, fire it whenever. So organized. 💅
    • Parameters:
      • buf (BufSpec)
      • dest (int)
      • tag (int)
    • Return type: Request
  • allgather(sendobj) — Gather to All. Everybody gets everybody's stuff. Sharing is caring, bestie. 🫶
    • Parameters:
      • sendobj (Any)
    • Return type: list[Any]
  • allreduce(sendobj, op=SUM) — Reduce to All. Everyone does the reduction, everyone gets the answer. The most democratic thing in this whole file. 👑
    • Parameters:
      • sendobj (Any)
      • op (Op | Callable[[Any, Any], Any])
    • Return type: Any
  • alltoall(sendobj) — All to All Scatter/Gather. Chaotic but make it organized. 🌈
    • Parameters:
      • sendobj (Sequence[Any])
    • Return type: list[Any]
  • barrier() — Barrier synchronization. Everyone waits right here together, no cutting the line, no exceptions. ✋
    • Note: This method is equivalent to Barrier.
    • Return type: None
  • bcast(obj, root=0) — Broadcast. root yells, everyone hears it. 📢
    • Parameters:
      • obj (Any)
      • root (int)
    • Return type: Any
  • bsend(obj, dest, tag=0) — send, but in buffered mode. The message chills in a buffer until it's ready to go. 🍓
    • Parameters:
      • obj (Any)
      • dest (int)
      • tag (int)
    • Return type: None
  • classmethod f2py(arg) — it's a classmethod, it takes arg, it hands back a Comm. No description given, it's just out here being mysterious. 🙈
    • Parameters:
      • arg (int)
    • Return type: Comm
  • free() — calls Free if it's not null and not predefined. Basically: if you're not nothing and you're not already special, you're free to go, bestie. 🦋
    • Return type: None
  • classmethod fromhandle(handle) — creates an object from an MPI handle. Full glow-up, handle to object, iconic. ✨
    • Parameters:
      • handle (int)
    • Return type: Comm
  • classmethod fromint(arg, /) — translates an integer handle into an object. Also note that lone / — arg is positional-only, so don't try to get cute with keywords. 💅
    • Parameters:
      • arg (int)
    • Return type: Comm
  • gather(sendobj, root=0) — Gather. Everything gets pulled in to root, and everyone else just vibes. 🔥
    • Parameters:
      • sendobj (Any)
      • root (int)
    • Return type: list[Any] | None
  • ibsend(obj, dest, tag=0) — nonblocking send in buffered mode. Same buffered energy, but you don't sit around waiting for it. 🏃‍♀️
    • Parameters:
      • obj (Any)
      • dest (int)
      • tag (int)
    • Return type: Request
  • improbe(source=ANY_SOURCE, tag=ANY_TAG, status=None) — nonblocking test for a matched message. Peeking to see if your message has arrived and is ready to be matched up. 👀
    • Parameters:
      • source (int)
      • tag (int)
      • status (Status | None)
    • Return type: Message | None
  • iprobe(source=ANY_SOURCE, tag=ANY_TAG, status=None) — nonblocking test for a message. Just checking, not committing. 🫣
    • Parameters:
      • source (int)
      • tag (int)
      • status (Status | None)
    • Return type: bool
  • irecv(buf=None, source=ANY_SOURCE, tag=ANY_TAG) — nonblocking receive. It comes back with a Request immediately and you deal with the rest later. Main character time management. ⏰
    • Parameters:
      • buf (Buffer | None)
      • source (int)
      • tag (int)
    • Return type: Request
  • isend(obj, dest, tag=0) — nonblocking send. Drop it and keep moving, bestie. 💨
    • Parameters:
      • obj (Any)
      • dest (int)
      • tag (int)
    • Return type: Request
  • issend(obj, dest, tag=0) — nonblocking send in synchronous mode. Both at once, obsessed with the range. 🌟
    • Parameters:
      • obj (Any)
      • dest (int)
      • tag (int)
    • Return type: Request
  • mprobe(source=ANY_SOURCE, tag=ANY_TAG, status=None) — blocking test for a matched message. 💅

So like, probe is the vibe-check version, but mprobe is the full matched message tea. It waits until a matching message actually lands, then hands you the whole thing. no cap.

Parameters

  • source — int
  • tag — int
  • status — Status or None

Return type: Message

  • probe(source=ANY_SOURCE, tag=ANY_TAG, status=None) — blocking test for a message. ✨

It literally just blocks until some message shows up, then tells you yes. It's giving "is anyone there??" energy, bestie.

Parameters

  • source — int
  • tag — int
  • status — Status or None

Return type: Literal[True]

  • py2f() — no description in the original, it's just out here doing its thing. 🦋

Return type: int

  • recv(buf=None, source=ANY_SOURCE, tag=ANY_TAG, status=None) — receive. 📥

The main character of message-passing ngl. You get a message, you get an answer, slay.

Parameters

  • buf — Buffer or None
  • source — int
  • tag — int
  • status — Status or None

Return type: Any

  • reduce(sendobj, op=SUM, root=0) — reduce to root. 🌀

Everyone sends their little contribution, everything gets smooshed together with op, and the result goes to the root. Iconic group-project behaviour, except this one actually works.

Parameters

  • sendobj — Any
  • op — Op or Callable[[Any, Any], Any]
  • root — int

Return type: Any or None

  • scatter(sendobj, root=0) — scatter. 🌈

The reverse of gather, fr fr. One big chunk gets split up and yeeted out to everyone from the root.

Parameters

  • sendobj — Sequence[Any] or None
  • root — int

Return type: Any

  • send(obj, dest, tag=0) — send in standard mode. 🚀

Parameters

  • obj — Any
  • dest — int
  • tag — int

Return type: None

  • sendrecv(sendobj, dest, sendtag=0, recvbuf=None, source=ANY_SOURCE, recvtag=ANY_TAG, status=None) — send and receive. 🔥

Sending and receiving at the same time?? multitasking queen behaviour, honestly.

Parameters

  • sendobj — Any
  • dest — int
  • sendtag — int
  • recvbuf — Buffer or None
  • source — int
  • recvtag — int
  • status — Status or None

Return type: Any

  • ssend(obj, dest, tag=0) — send in synchronous mode. ⏳

Parameters

  • obj — Any
  • dest — int
  • tag — int

Return type: None

  • toint() — translate object to integer handle. 🔢

Return type: int

🎀 Attributes Documentation 🎀

  • group — Group.
  • handle — MPI handle.
  • info — Info hints.
  • is_inter — is intercommunicator.
  • is_intra — is intracommunicator.
  • is_topo — is a topology.
  • name — print name.
  • rank — rank of this process.
  • size — number of processes.
  • topology — topology type.

🦋 mpi4py.MPI.Datatype 🦋

class mpi4py.MPI.Datatype

Bases: object

Datatype object. it's giving very "I am the blueprint" energy 💜

static __new__(cls, datatype=None)

Parameters

  • datatype — Datatype or None

Return type: Self

✨ Methods Summary ✨

okay bestie, here's the whole menu of Datatype methods, no skips, no cap 💅

  • Commit() — commit the datatype. it's giving "yes i'm ready now" 🫶
  • Create_contiguous(count) — create a contiguous datatype.
  • Create_darray(size, rank, gsizes, distribs, ...) — create a datatype for a distributed array on Cartesian process grids.
  • Create_f90_complex(p, r) — return a bounded complex datatype.
  • Create_f90_integer(r) — return a bounded integer datatype.
  • Create_f90_real(p, r) — return a bounded real datatype.
  • Create_hindexed(blocklengths, displacements) — create an indexed datatype.
  • Create_hindexed_block(blocklength, displacements) — create an indexed datatype with constant-sized blocks.
  • Create_hvector(count, blocklength, stride) — create a vector (strided) datatype with stride in bytes.
  • Create_indexed(blocklengths, displacements) — create an indexed datatype.
  • Create_indexed_block(blocklength, displacements) — create an indexed datatype with constant-sized blocks.
  • Create_keyval([copy_fn, delete_fn, nopython]) — create a new attribute key for datatypes.
  • Create_resized(lb, extent) — create a datatype with a new lower bound and extent.
  • Create_struct(blocklengths, displacements, ...) — create a general composite (struct) datatype.
  • Create_subarray(sizes, subsizes, starts[, order]) — create a datatype for a subarray of a multidimensional array.
  • Create_vector(count, blocklength, stride) — create a vector (strided) datatype.
  • Delete_attr(keyval) — delete attribute value associated with a key.
  • Dup() — duplicate a datatype.
  • Free() — free the datatype.
  • Free_keyval(keyval) — free an attribute key for datatypes.
  • Get_attr(keyval) — retrieve attribute value by key.
  • Get_contents() — return the input arguments used to create a datatype.
  • Get_envelope() — return the number of input arguments used to create a datatype.
  • Get_extent() — return lower bound and extent of datatype.
  • Get_name() — get the print name for this datatype.
  • Get_size() — return the number of bytes occupied by entries in the datatype.
  • Get_true_extent() — return the true lower bound and extent of a datatype.
  • Get_value_index(value, index) — return a predefined pair datatype.
  • Match_size(typeclass, size) — find a datatype matching a specified size in bytes.
  • Unpack(inbuf, position, outbuf, comm) — unpacks from contiguous memory according to datatype 📦
  • Unpack_external(datarep, inbuf, position, outbuf) — unpacks from contiguous memory according to datatype 📦
  • decode() — convenience method for decoding a datatype, so cute of her 💖
  • f2py(arg) — (bestie the docs really just left this one blank, no cap 💀)
  • free() — calls Free if not null or predefined 🧹
  • fromcode(code) — gets a predefined MPI datatype from a character code or type string 🔤
  • fromhandle(handle) — creates an object from an MPI handle ✨
  • fromint(arg, /) — translates an integer handle to an object 🔢
  • py2f() — (again, nothing here, the void stared back 🙈)
  • tocode() — gets a character code or type string from a predefined MPI datatype 🔤
  • toint() — translates an object to an integer handle 🔢

✨ Attributes Summary ✨

okay these are the lil properties you can just... read off a datatype, no method call needed, we love a low-effort slay 🎀

  • combiner — Combiner.
  • contents — Contents.
  • envelope — Envelope.
  • extent — Extent.
  • handle — MPI handle.
  • is_named — Is a named datatype.
  • is_predefined — Is a predefined datatype.
  • lb — Lower bound.
  • name — Print name.
  • size — Size (in bytes).
  • true_extent — True extent.
  • true_lb — True lower bound.
  • true_ub — True upper bound.
  • typechar — Character code.
  • typestr — Type string.
  • ub — Upper bound.

✨ Methods Documentation ✨

the actual receipts, one method at a time 💅

Commit()

commits the datatype. that's it, that's the whole vibe — she's committed now 💍

Return type

Create_contiguous(count)

creates a contiguous datatype 🧱

Parameters

Return type

  • Self — https://docs.python.org/3/library/typing.html#typing.Self
  • Create_darray(size, rank, gsizes, distribs, dargs, psizes, order=ORDER_C) — bestie this one literally builds you a datatype for a distributed array sitting on top of Cartesian process grids. very main character of it. 💫
    • size (int)
    • rank (int)
    • gsizes (Sequence[int])
    • distribs (Sequence[int])
    • dargs (Sequence[int])
    • psizes (Sequence[int])
    • order (int)
    • Returns: Self
  • Create_f90_complex(p, r) (classmethod) — hands you back a bounded complex datatype. that's it that's the whole vibe. ✨
    • p (int)
    • r (int)
    • Returns: Self
  • Create_f90_integer(r) (classmethod) — a bounded integer datatype, freshly served, no notes. 🧚
    • r (int)
    • Returns: Self
  • Create_f90_real(p, r) (classmethod) — yep you guessed it, a bounded real datatype. iconic, consistent, we love a trio. 💜
    • p (int)
    • r (int)
    • Returns: Self
  • Create_hindexed(blocklengths, displacements) — makes an indexed datatype for you. ngl it's giving structured-data energy.
🚨 heads up bestie: the displacements here are measured in bytes. do not come for me, that's just how it is.
  • blocklengths (Sequence[int])
  • displacements (Sequence[int])
  • Returns: Self
  • Create_hindexed_block(blocklength, displacements) — indexed datatype but every single block is the same size. uniform, tidy, lowkey obsessed. 🎀
🚨 same warning, same energy: displacements are measured in bytes.
  • blocklength (int)
  • displacements (Sequence[int])
  • Returns: Self
  • Create_hvector(count, blocklength, stride) — a vector (strided) datatype where the stride is in bytes. she's strutting fr fr. 🔥
    • count (int)
    • blocklength (int)
    • stride (int)
    • Returns: Self
  • Create_indexed(blocklengths, displacements) — an indexed datatype. the h-free sibling, still slaying. 💅
    • blocklengths (Sequence[int])
    • displacements (Sequence[int])
    • Returns: Self
  • Create_indexed_block(blocklength, displacements) — indexed datatype with constant-sized blocks. blocklength stays one single number, she doesn't do ranges. ✨
    • blocklength (int)
    • displacements (Sequence[int])
    • Returns: Self
  • Create_keyval(copy_fn=None, delete_fn=None, nopython=False) (classmethod) — creates a brand new attribute key for datatypes and returns the key as an int. giving registry energy, honestly. 👑
    • copy_fn (Callable[[Datatype, int, Any], Any] | None)
    • delete_fn (Callable[[Datatype, int, Any], None] | None)
    • nopython (bool)
    • Returns: int
  • Create_resized(lb, extent) — creates a datatype with a whole new lower bound and extent. glow-up but for byte layouts. 🦋
    • lb (int)
    • extent (int)
    • Returns: Self
  • Create_struct(blocklengths, displacements, datatypes) (classmethod) — the big one: a general composite (struct) datatype. this is the everything-everywhere-all-at-once of datatypes. 🌈
🚨 you know the drill by now: displacements are measured in bytes.
  • blocklengths (Sequence[int])
  • displacements (Sequence[int])
  • datatypes (Sequence[Datatype])
  • Returns: Self
  • Create_subarray(sizes, subsizes, starts, order=ORDER_C) — creates a datatype for a subarray carved out of a multidimensional array. tiny slice, big energy. 🍓
    • sizes (Sequence[int])
    • subsizes (Sequence[int])
    • starts (Sequence[int])
  • order (int) — an int bestie, that's the whole vibe 🫶

Return type — Self ✨

Create_vector(count, blocklength, stride) 🧚

Makes a vector (strided) datatype. literally the moment you needed structure with ✨gaps✨ in it, no cap 💅

Parameters

  • count (int)
  • blocklength (int)
  • stride (int)

Return type — Self 🌸

Delete_attr(keyval) 🎀

Yeets the attribute value that's hanging out with a key. bye boo 👋

Parameters

  • keyval (int)

Return type — None 💀

Dup() 🦋

Duplicates a datatype. it's giving copy-and-paste but make it MPI ✨

Return type — Self 💖

Free() 🫶

Frees the datatype. release it into the wild, bestie 🕊️

Return type — None 💀

classmethod Free_keyval(keyval) 👑

Frees an attribute key for datatypes. key said "my time has come" ✨

Parameters

  • keyval (int)

Return type — int 💅

Get_attr(keyval) 🔥

Retrieves an attribute value by key. like a lil lookup, but iconic 🌈

Parameters

  • keyval (int)

Return type — int | Any | None 💜

Get_contents() ⭐

Returns the input arguments you used to create a datatype. it's the receipts, bestie, the whole origin story 🧾✨

Return type

tuple[list[int], list[int], list[int], list[Datatype]]

Get_envelope() 🌸

Returns how many input arguments went into creating a datatype. the headcount of the situation 🎀

Return type

tuple[int, int, int, int, int]

Get_extent() 🦋

Returns the lower bound and the extent of the datatype. two numbers, one destiny 💫

Return type

tuple[int, int]

Get_name() 🏷️

Gets the print name for this datatype. what it calls itself 💅

Return type — str ✨

Get_size() 📏

Returns the number of bytes that the entries in the datatype occupy. size check but for memory, slay 💖

Return type — int 🔥

Get_true_extent() 💎

Returns the true lower bound and extent of a datatype. the honest version, no filter, periodt 🫶

Return type

tuple[int, int]

classmethod Get_value_index(value, index) 👑

Returns a predefined pair datatype. a lil matched set, iconic behavior 🎀

Parameters

  • value (Datatype)
  • index (Datatype)

Return type — Self ⭐

classmethod Match_size(typeclass, size) 🧚

Finds a datatype that matches a specified size in bytes. it's giving matchmaking but for types 💘

Parameters

  • typeclass (int)
  • size (int)

Return type — Self 🌈

Pack(inbuf, outbuf, position, comm) 🎒

Packs into contiguous memory according to the datatype. squish it in there bestie ✨

Parameters

  • inbuf (BufSpec)
  • outbuf (BufSpec)
  • position (int)
  • comm (Comm)

Return type — int 💜

Pack_external(datarep, inbuf, outbuf, position) 🌍

Packs into contiguous memory according to the datatype.

Uses the portable data representation external32. travel-ready, no cap 🧳✨

Parameters

  • datarep (str)
  • inbuf (BufSpec)
  • outbuf (BufSpec)
  • position (int)

Return type — int 🔥

Pack_external_size(datarep, count) 📦

Figures out how much space you need to pack a message.

Uses the portable data representation external32. same travel energy 💫

Note: returns an upper bound measured in bytes. so it's an estimate, bestie, don't come for it 🙈

Parameters

  • datarep (str)
  • count (int)

Return type — int 💅

Pack_size(count, comm) 📐

Figures out how much space you need to pack a message. the calculator moment 🧮✨

Note: returns an upper bound measured in bytes. again — upper bound, not the tea, just the ceiling 🫶

Parameters

  • count (int)
  • comm (Comm)

Return type — int 💖

Set_attr(keyval, attrval) 🎀

Stores an attribute value associated with a key. put it in the vault, bestie 🔐

Parameters

  • keyval (int)
  • attrval (Any)

Return type — None 💀

Set_name(name) 🏷️

Sets the print name for this datatype. rebrand szn ✨

Parameters

  • name (str)

Return type — None 💀

Unpack(inbuf, position, outbuf, comm) 🎁

Unpacks from contiguous memory according to the datatype. the un-squish, we love to see it 🌈

Parameters

  • inbuf (BufSpec)
  • position (int)
  • outbuf (BufSpec)
  • comm (Comm)

Return type — int 🔥

Unpack_external(datarep, inbuf, position, outbuf) 🌍

Unpacks from contiguous memory according to the datatype.

Uses the portable data representation external32. 🧳

Parameters

  • datarep (str)
  • inbuf (BufSpec)
  • position (int)
  • outbuf (BufSpec)

decode() — convenience method for decoding a datatype 💅

Return type: tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Datatype <#mpi4py.MPI.Datatype>, str <https://docs.python.org/3/library/stdtypes.html#str>, dict <https://docs.python.org/3/library/stdtypes.html#dict>[str <https://docs.python.org/3/library/stdtypes.html#str>, Any <https://docs.python.org/3/library/typing.html#typing.Any>]]

classmethod f2py(arg)

Return type: Datatype <#mpi4py.MPI.Datatype>

free() — Call Free if not null or predefined. bestie it literally just tidies up 💖

Return type: None <https://docs.python.org/3/library/constants.html#None>

classmethod fromcode(code) — Get a predefined MPI datatype from a character code or type string. iykyk ✨

Return type: Datatype <#mpi4py.MPI.Datatype>

classmethod fromhandle(handle) — Create an object from an MPI handle. giving very much "make me a real one from this int" 🪄

Return type: Datatype <#mpi4py.MPI.Datatype>

classmethod fromint(arg, /) — Translate an integer handle to an object.

Return type: Datatype <#mpi4py.MPI.Datatype>

py2f()

Return type: int <https://docs.python.org/3/library/functions.html#int>

tocode() — Get a character code or type string from a predefined MPI datatype.

Return type: str <https://docs.python.org/3/library/stdtypes.html#str>

toint() — Translate an object to an integer handle.

Return type: int <https://docs.python.org/3/library/functions.html#int>

✨ Attributes Documentation ✨

  • combiner — Combiner.
  • contents — Contents.
  • envelope — Envelope.
  • extent — Extent.
  • handle — MPI handle.
  • is_named — Is a named datatype.
  • is_predefined — Is a predefined datatype.
  • lb — Lower bound.
  • name — Print name.
  • size — Size (in bytes).
  • true_extent — True extent.
  • true_lb — True lower bound.
  • true_ub — True upper bound.
  • typechar — Character code.
  • typestr — Type string.
  • ub — Upper bound.

🦋 mpi4py.MPI.Distgraphcomm

class mpi4py.MPI.Distgraphcomm

Bases: Topocomm <#mpi4py.MPI.Topocomm>

Distributed graph topology intracommunicator. okay so this is the ✨fancy✨ communicator for distributed graphs, no cap 🌈

static __new__(cls, comm=None)

Return type: Self <https://docs.python.org/3/library/typing.html#typing.Self>

Methods Summary 📋

  • Get_dist_neighbors() — Return adjacency information for a distributed graph topology.
  • Get_dist_neighbors_count() — Return adjacency information for a distributed graph topology.

Methods Documentation 💖

Get_dist_neighbors() — Return adjacency information for a distributed graph topology.

Return type: tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[list <https://docs.python.org/3/library/stdtypes.html#list>[int <https://docs.python.org/3/library/functions.html#int>], list <https://docs.python.org/3/library/stdtypes.html#list>[int <https://docs.python.org/3/library/functions.html#int>], tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[list <https://docs.python.org/3/library/stdtypes.html#list>[int <https://docs.python.org/3/library/functions.html#int>], list <https://docs.python.org/3/library/stdtypes.html#list>[int <https://docs.python.org/3/library/functions.html#int>]] | None <https://docs.python.org/3/library/constants.html#None>]

Get_dist_neighbors_count() — Return adjacency information for a distributed graph topology.

Return type: int <https://docs.python.org/3/library/functions.html#int>

🎀 mpi4py.MPI.Errhandler

class mpi4py.MPI.Errhandler

Bases: object <https://docs.python.org/3/library/functions.html#object>

Error handler. the one who handles the drama when MPI throws a fit 💅😭

static __new__(cls, errhandler=None)

Return type: Self <https://docs.python.org/3/library/typing.html#typing.Self>

Methods Summary 📋

  • Free() — Free an error handler.
  • f2py(arg) — (no description, bestie, it just is)
  • free() — Call Free if not null.
  • fromhandle(handle) — Create object from MPI handle.
  • fromint(arg, /) — Translate integer handle to object.
  • py2f() — (again, no description, we vibe)
  • toint() — Translate object to integer handle.

Attributes Summary ✨

  • handle — MPI handle.

Methods Documentation 💖

Free() — Free an error handler.

Return type: None <https://docs.python.org/3/library/constants.html#None>

classmethod f2py(arg)

Return type: Errhandler <#mpi4py.MPI.Errhandler>

free() — Call Free if not null.

Return type: None <https://docs.python.org/3/library/constants.html#None>

classmethod fromhandle(handle) — Create object from MPI handle.

Return type: Errhandler <#mpi4py.MPI.Errhandler>

classmethod fromint(arg, /) — Translate integer handle to object.

Return type: Errhandler <#mpi4py.MPI.Errhandler>

py2f()

  • toint() — bestie this one takes the object and hands you back the integer handle for it. that's it, that's the whole job. so iconic of it 💅

Return type: int

✨ Attributes Documentation ✨

  • handle — the raw MPI handle, just vibing there as an attribute. this is the actual underlying thing, the real one, the main character 👑

🦋 mpi4py.MPI.File 🦋

class mpi4py.MPI.File

Bases: object

okay so this is the File I/O context, periodt. it's the whole vibe for doing file stuff in MPI — collective reads, collective writes, the works. lowkey one of the most useful little objects in the whole module 🫶

  • static __new__(cls, file=None)

the constructor situation. ngl it's static and it's __new__, so yes it's doing the fancy object-creation dance 🙈

Parameters:

  • file (File | None) — the file you're wrapping up in a fresh object, or None if you're not passing one. your call, bestie 💖

Return type: Self — it hands you back an instance of itself, as is only correct ✨

✨ Methods Summary ✨

okay bestie, here's the whole menu of what a File object can do for you — every single method, no skips, no gatekeeping 💅

  • Call_errhandler(errorcode) — rings up the error handler that's installed on a file. like, calling in backup for the drama 🫶
  • Close() — closes a file. bye babe, it was real 👋✨
  • Create_errhandler(errhandler_fn) — builds you a shiny new error handler, but for files specifically 🎀
  • Delete(filename[, info]) — deletes a file. gone, reduced to atoms 💀
  • Get_amode() — hands back the file access mode.
  • Get_atomicity() — hands back the atomicity mode.
  • Get_byte_offset(offset) — gives you the absolute byte position in the file 📍
  • Get_errhandler() — gets the error handler for a file.
  • Get_group() — lets you access the group of processes that opened the file. the whole squad, together 👑
  • Get_info() — returns the current hints for a file.
  • Get_position() — returns the current position of the individual file pointer.
  • Get_position_shared() — returns the current position of the shared file pointer.
  • Get_size() — returns the file size.
  • Get_type_extent(datatype) — returns the extent of datatype in the file.
  • Get_view() — returns the file view. main character reveal energy 🌈
  • Iread(buf) — nonblocking read using the individual file pointer.
  • Iread_all(buf) — nonblocking collective read using the individual file pointer.
  • Iread_at(offset, buf) — nonblocking read using an explicit offset.
  • Iread_at_all(offset, buf) — nonblocking collective read using an explicit offset.
  • Iread_shared(buf) — nonblocking read using the shared file pointer.
  • Iwrite(buf) — nonblocking write using the individual file pointer.
  • Iwrite_all(buf) — nonblocking collective write using the individual file pointer.
  • Iwrite_at(offset, buf) — nonblocking write using an explicit offset.
  • Iwrite_at_all(offset, buf) — nonblocking collective write using an explicit offset.
  • Iwrite_shared(buf) — nonblocking write using the shared file pointer.
  • Open(comm, filename[, amode, info]) — opens a file. the classic, the icon, the moment 🌟
  • Preallocate(size) — preallocates storage space for a file. manifesting that space before you even need it 🔮
  • Read(buf[, status]) — read using the individual file pointer.
  • Read_all(buf[, status]) — collective read using the individual file pointer.
  • Read_all_begin(buf) — starts a split collective read using the individual file pointer.
  • Read_all_end(buf[, status]) — wraps up a split collective read that was using the individual file pointer 💖
  • Read_at(offset, buf[, status]) — reads at an offset you literally hand it, no pointer drama ✨
  • Read_at_all(offset, buf[, status]) — the collective version of reading at an explicit offset 🎀
  • Read_at_all_begin(offset, buf) — kicks off a split collective read at an explicit offset (the "begin" half of the glow-up) 🦋
  • Read_at_all_end(buf[, status]) — and this is the "end" half, completing that split collective read at an explicit offset 🌸
  • Read_ordered(buf[, status]) — collective read that goes through the shared file pointer 💅
  • Read_ordered_begin(buf) — starts a split collective read using the shared file pointer 🫶
  • Read_ordered_end(buf[, status]) — completes a split collective read using the shared file pointer 😭
  • Read_shared(buf[, status]) — read using the shared file pointer, periodt 🔥
  • Seek(offset[, whence]) — moves the individual file pointer to wherever you want 👑
  • Seek_shared(offset[, whence]) — same energy, but for the shared file pointer 🌈
  • Set_atomicity(flag) — sets the atomicity mode ⭐
  • Set_errhandler(errhandler) — sets the error handler for a file 💀
  • Set_info(info) — sets new values for the hints tied to a file 🙈
  • Set_size(size) — sets the file size 🍓
  • Set_view([disp, etype, filetype, datarep, info]) — sets the file view 🧚
  • Sync() — makes all previous writes actually get transferred to the storage device 💜
  • Write(buf[, status]) — writes using the individual file pointer 💖
  • Write_all(buf[, status]) — collective write using the individual file pointer ✨
  • Write_all_begin(buf) — starts a split collective write using the individual file pointer 🎀
  • Write_all_end(buf[, status]) — completes a split collective write using the individual file pointer 🦋
  • Write_at(offset, buf[, status]) — write using an explicit offset 🌸
  • Write_at_all(offset, buf[, status]) — collective write using an explicit offset 💅
  • Write_at_all_begin(offset, buf) — starts a split collective write using an explicit offset 🫶
  • Write_at_all_end(buf[, status]) — completes a split collective write using an explicit offset 😭
  • Write_ordered(buf[, status]) — collective write using the shared file pointer 🔥
  • Write_ordered_begin(buf) — starts a split collective write using the shared file pointer 👑
  • Write_ordered_end(buf[, status]) — completes a split collective write using the shared file pointer 🌈
  • Write_shared(buf[, status]) — write using the shared file pointer ⭐
  • f2py(arg) — no description, the docs just left it here like an unsent text 🙈 not making anything up for it, bestie.
  • free() — Call Close if not null. that's it, that's the whole job 🫶
  • fromhandle(handle) — Create object from MPI handle.
  • fromint(arg, /) — Translate integer handle to object. (yes, that / means arg is positional-only, iykyk)
  • py2f() — also description-less 💀 the table just vibes.
  • toint() — Translate object to integer handle. the reverse glow-up ✨

🎀 Attributes Summary 🎀

the lil properties she carries around with her, periodt:

  • amode — Access mode.
  • atomicity — Atomicity mode.
  • group — Group.
  • group_rank — Group rank.
  • group_size — Group size.
  • handle — MPI handle.
  • info — Info hints.
  • size — Size (in bytes).

💅 Methods Documentation 💅

okay now the actual receipts, one method at a time, no skimming:

Call_errhandler(errorcode)

Call the error handler installed on a file. 📣

Parameters

  • errorcode — int

Return type — None

Close()

Close a file. 🚪 say bye bestie.

Return type — None

classmethod Create_errhandler(errhandler_fn)

Create a new error handler for files. custom handler, main character energy ✨

Parameters

  • errhandler_fn — Callable[[File, int], None]

Return type — Errhandler

classmethod Delete(filename, info=INFO_NULL)

Delete a file. 🗑️ note the default: info is INFO_NULL unless you say otherwise.

Parameters

  • filename — PathLike | str | bytes
  • info — Info

Return type — None

Get_amode()

Return the file access mode.

Return type — int

Get_atomicity()

Return the atomicity mode.

Return type — bool

Get_byte_offset(offset)

Return the absolute byte position in the file. 📍

Note: Input offset is measured in etype units relative to the current file view.

Parameters

  • offset — int

Return type — int

Get_errhandler()

Get the error handler for a file.

Return type — Errhandler

Get_group()

Access the group of processes that opened the file. 👯

Return type — Group

Get_info()

Return the current hints for a file.

Return type — Info

Get_position()

Return the current position of the individual file pointer.

Note: Position is measured in etype units relative to the current file view.

Return type — int

Get_position_shared()

Return the current position of the shared file pointer.

Note: Position is measured in etype units relative to the current view.

Return type — int

Get_size()

Return the file size.

Return type — int

Get_type_extent(datatype)

Return the extent of datatype in the file.

Parameters

  • datatype — Datatype

Return type — int

Get_view()

Return the file view. 👀

Return type — tuple[int, Datatype, Datatype, str]

✨ and now the I/O girlies, all of them returning a Request ✨

Iread(buf)

Nonblocking read using individual file pointer.

Parameters

  • buf — BufSpec

Return type — Request

Iread_all(buf)

Nonblocking collective read using individual file pointer.

Parameters

  • buf — BufSpec

Return type — Request

Iread_at(offset, buf)

Nonblocking read using explicit offset.

Parameters

  • offset — int
  • buf — BufSpec

Return type — Request

Iread_at_all(offset, buf)

Nonblocking collective read using explicit offset.

Parameters

  • offset — int
  • buf — BufSpec

Return type — Request

Iread_shared(buf)

Nonblocking read using shared file pointer.

Parameters

  • buf — BufSpec

Return type — Request

Iwrite(buf)

Nonblocking write using individual file pointer. ✍️

Parameters

  • buf — BufSpec

Return type — Request

Iwrite_all(buf)

Nonblocking collective write using individual file pointer.

Parameters

  • buf — BufSpec

Return type — Request

Iwrite_at(offset, buf)

Nonblocking write using explicit offset.

Parameters

  • offset (int)
  • buf (BufSpec)

Return type: Request

Iwrite_at_all(offset, buf)

Nonblocking collective write, but using an explicit offset instead of a file pointer. yes bestie, same energy as the others, just a different flavor of write 💅

Parameters

  • offset (int)
  • buf (BufSpec)

Return type: Request

Iwrite_shared(buf)

Nonblocking write using the shared file pointer. shared pointer moment ✨

Parameters

  • buf (BufSpec)

Return type: Request

classmethod Open(comm, filename, amode=MODE_RDONLY, info=INFO_NULL)

Open a file. the whole gateway drug to file I/O fr fr 🎀

Parameters

  • comm (Intracomm)
  • filename (PathLike | str | bytes)
  • amode (int)
  • info (Info)

Return type: Self

Preallocate(size)

Preallocate storage space for a file. reserve the vibes ahead of time, no cap

Parameters

  • size (int)

Return type: None

Read(buf, status=None)

Read using the individual file pointer.

Parameters

  • buf (BufSpec)
  • status (Status | None)

Return type: None

Read_all(buf, status=None)

Collective read using the individual file pointer. everyone reads together, main character ensemble energy 👑

Parameters

  • buf (BufSpec)
  • status (Status | None)

Return type: None

Read_all_begin(buf)

Start a split collective read using the individual file pointer. it's giving "we're doing this in two steps" 💖

Parameters

  • buf (BufSpec)

Return type: None

Read_all_end(buf, status=None)

Complete a split collective read using the individual file pointer. the second half of the two-step, slay 🦋

Parameters

  • buf (BufSpec)
  • status (Status | None)

Return type: None

Read_at(offset, buf, status=None)

Read using an explicit offset.

Parameters

  • offset (int)
  • buf (BufSpec)
  • status (Status | None)

Return type: None

Read_at_all(offset, buf, status=None)

Collective read using an explicit offset.

Parameters

  • offset (int)
  • buf (BufSpec)
  • status (Status | None)

Return type: None

Read_at_all_begin(offset, buf)

Start a split collective read using an explicit offset.

Parameters

  • offset (int)
  • buf (BufSpec)

Return type: None

Read_at_all_end(buf, status=None)

Complete a split collective read using an explicit offset.

Parameters

  • buf (BufSpec)
  • status (Status | None)

Return type: None

Read_ordered(buf, status=None)

Collective read using the shared file pointer.

Parameters

  • buf (BufSpec)
  • status (Status | None)

Return type: None

Read_ordered_begin(buf)

Start a split collective read using the shared file pointer.

Parameters

  • buf (BufSpec)

Return type: None

Read_ordered_end(buf, status=None)

Complete a split collective read using the shared file pointer.

Parameters

  • buf (BufSpec)
  • status (Status | None)

Return type: None

Read_shared(buf, status=None)

Read using the shared file pointer.

Parameters

  • buf (BufSpec)
  • status (Status | None)

Return type: None

Seek(offset, whence=SEEK_SET)

Update the individual file pointer. move that cursor bestie, we're going places 📍

Parameters

  • offset (int)
  • whence (int)

Return type: None

Seek_shared(offset, whence=SEEK_SET)

Update the shared file pointer. same cursor behavior but make it communal ✨

Parameters

  • offset (int)
  • whence (int)

Return type: None

Set_atomicity(flag)

Set the atomicity mode.

Parameters

  • flag (bool)

Return type: None

Set_errhandler(errhandler)

Set the error handler for a file.

Parameters

  • errhandler (Errhandler)

Return type: None

Set_info(info)

Set new values for the hints associated with a file.

Parameters

  • info (Info)

Return type: None

Set_size(size)

Set the file size.

Parameters

  • size (int)

Return type: None

Set_view(disp=0, etype=BYTE, filetype=None, datarep='native', info=INFO_NULL)

Set the file view. the glow-up of file configuration 🌈

Parameters

  • disp (int)
  • etype (Datatype)
  • filetype (Datatype or None) 💜
    • datarep (str)
    • info (Info)

Return type: None

Sync()

Causes all previous writes to be transferred to the storage device. Like, it's the "bestie I need you to actually commit" button. Push those writes all the way out, no cap. 💾✨

Return type: None

Write(buf, status=None)

Write using individual file pointer. Your own lil pointer, your own lil write. 🖊️

Parameters

  • buf (BufSpec)
  • status (Status or None)

Return type: None

Write_all(buf, status=None)

Collective write using individual file pointer. Everybody's writing, everybody's got their own pointer. Group project but make it functional. 🫶

Parameters

  • buf (BufSpec)
  • status (Status or None)

Return type: None

Write_all_begin(buf)

Start a split collective write using individual file pointer. This is the begin half of the split — the setup era. ✨

Parameters

  • buf (BufSpec)

Return type: None

Write_all_end(buf, status=None)

Complete a split collective write using individual file pointer. And this is the end half — closing the loop, we love a follow-through. 💅

Parameters

  • buf (BufSpec)
  • status (Status or None)

Return type: None

Write_at(offset, buf, status=None)

Write using explicit offset. You say exactly where, no guessing games. 📍

Parameters

  • offset (int)
  • buf (BufSpec)
  • status (Status or None)

Return type: None

Write_at_all(offset, buf, status=None)

Collective write using explicit offset. Everyone writes, everyone gets told the exact spot. Coordinated queen behaviour. 👑

Parameters

  • offset (int)
  • buf (BufSpec)
  • status (Status or None)

Return type: None

Write_at_all_begin(offset, buf)

Start a split collective write using explicit offset. The opening act of the explicit-offset split collective. 🎬

Parameters

  • offset (int)
  • buf (BufSpec)

Return type: None

Write_at_all_end(buf, status=None)

Complete a split collective write using explicit offset. And the finale. Curtain, applause, data written. 🌸

Parameters

  • buf (BufSpec)
  • status (Status or None)

Return type: None

Write_ordered(buf, status=None)

Collective write using shared file pointer. One shared pointer for the whole squad — orderly, no fighting over the spot. 🧚

Parameters

  • buf (BufSpec)
  • status (Status or None)

Return type: None

Write_ordered_begin(buf)

Start a split collective write using shared file pointer. Split collective, shared-pointer flavour, part one. 🍓

Parameters

  • buf (BufSpec)

Return type: None

Write_ordered_end(buf, status=None)

Complete a split collective write using shared file pointer. Shared-pointer split collective, part two, and we're done. 💖

Parameters

  • buf (BufSpec)
  • status (Status or None)

Return type: None

Write_shared(buf, status=None)

Write using shared file pointer. Non-split version, shared pointer, same energy. 🌈

Parameters

  • buf (BufSpec)
  • status (Status or None)

Return type: None

classmethod f2py(arg)

Yep, it's a classmethod, and yep, it takes one arg.

Parameters

  • arg (int)

Return type: File

free()

Call Close if not null. Tidy up, bestie. If it's not null, close it. No loose ends. 🧹

Return type: None

classmethod fromhandle(handle)

Create object from MPI handle. Hand it the handle, get an object back. Glow-up in one call. ✨

Parameters

  • handle (int)

Return type: File

classmethod fromint(arg, /)

Translate integer handle to object. Numbers in, object out. (Note the / — that arg is positional-only, iykyk.) 💅

Parameters

  • arg (int)

Return type: File

py2f()

Python to Fortran, babes.

Return type: int

toint()

Translate object to integer handle. The reverse glow-up: object in, integer out. 🔁

Return type: int

📋 Attributes Documentation 📋

  • amode — Access mode. 🔑
  • atomicity — Atomicity mode. ⚛️
  • group — Group. 👯
  • group_rank — Group rank. 🔢
  • group_size — Group size. 📏
  • handle — MPI handle. 🎀
  • info — Info hints. 💡
  • size — Size (in bytes). 📦

🦋 mpi4py.MPI.Graphcomm 🦋

class mpi4py.MPI.Graphcomm

Bases: Topocomm

General graph topology intracommunicator. Okay so this one isn't your basic line-up-in-a-row communicator — it's a whole graph, bestie. Nodes and edges, connections all over the place, it's giving "my social circle is not a straight line." 🕸️💖

static __new__(cls, comm=None)

The constructor moment. ✨

Parameters

  • comm (Graphcomm or None)

Return type: Self

📝 Methods Summary 📝

  • Get_dims() — Return the number of nodes and edges. 🌐
  • Get_neighbors(rank) — Return list of neighbors of a process. 🫂
  • Get_neighbors_count(rank) — Return number of neighbors of a process. 🔢
  • Get_topo() — Return index and edges. 🗺️

💅 Attributes Summary 💅

okay bestie these are the vibes this object is carrying around, all of them, no skips:

  • dims — Number of nodes and edges.
  • edges — Edges.
  • index — Index.
  • nedges — Number of edges.
  • neighbors — Neighbors.
  • nneighbors — Number of neighbors.
  • nnodes — Number of nodes.
  • topo — Topology information.

📖 Methods Documentation 📖

Get_dims()

Return the number of nodes and edges.

Return type: tuple[int, int]

Get_neighbors(rank)

Return list of neighbors of a process.

Parameters: rank (int)

Return type: list[int]

Get_neighbors_count(rank)

Return number of neighbors of a process.

Parameters: rank (int)

Return type: int

Get_topo()

Return index and edges.

Return type: tuple[list[int], list[int]]

🎀 Attributes Documentation 🎀

  • dims — Number of nodes and edges.
  • edges — Edges.
  • index — Index.
  • nedges — Number of edges.
  • neighbors — Neighbors.
  • nneighbors — Number of neighbors.
  • nnodes — Number of nodes.
  • topo — Topology information.

👑 mpi4py.MPI.Grequest 👑

class mpi4py.MPI.Grequest

Bases: Request

Generalized request handler. iconic behavior tbh

static __new__(cls, request=None)

Parameters: request (Grequest | None)

Return type: Self

💫 Methods Summary 💫

  • Complete() — Notify that a user-defined request is complete.
  • Start([query_fn, free_fn, cancel_fn, args, ...]) — Create and return a user-defined request.
  • complete([obj]) — Notify that a user-defined request is complete.

📖 Methods Documentation 📖

Complete()

Notify that a user-defined request is complete.

Return type: None

classmethod Start(query_fn=None, free_fn=None, cancel_fn=None, args=None, kwargs=None)

Create and return a user-defined request.

Parameters:

  • query_fn (Callable[[...], None] | None)
  • free_fn (Callable[[...], None] | None)
  • cancel_fn (Callable[[...], None] | None)
  • args (tuple[Any] | None)
  • kwargs (dict[str, Any] | None)

Return type: Grequest

complete(obj=None)

Notify that a user-defined request is complete.

Parameters: obj (Any)

Return type: None

🌸 mpi4py.MPI.Group 🌸

class mpi4py.MPI.Group

Bases: object

Group of processes. bestie this is literally your whole little squad 💖

static __new__(cls, group=None)

Parameters: group (Group | None)

Return type: Self

🎀 Methods Summary 🎀

Okay bestie, gather round 💖 here's the whole lineup of moves you can pull on a Group — one bullet per method, nothing skipped, no crumbs left behind:

  • Compare(group) — Compare two groups.
  • Create_from_session_pset(session, pset_name) — Create a new group from session and process set.
  • Difference(group1, group2) — Create a new group from the difference of two existing groups.
  • Dup() — Duplicate a group.
  • Excl(ranks) — Create a new group by excluding listed members.
  • Free() — Free a group.
  • Get_rank() — Return the rank of this process in a group.
  • Get_size() — Return the number of processes in a group.
  • Incl(ranks) — Create a new group by including listed members.
  • Intersection(group1, group2) — Create a new group from the intersection of two existing groups.
  • Range_excl(ranks) — Create a new group by excluding ranges of members.
  • Range_incl(ranks) — Create a new group by including ranges of members.
  • Translate_ranks([ranks, group]) — Translate ranks in a group to those in another group.
  • Union(group1, group2) — Create a new group from the union of two existing groups.
  • f2py(arg)
  • free() — Call Free if not null or predefined.
  • fromhandle(handle) — Create object from MPI handle.
  • fromint(arg, /) — Translate integer handle to object.
  • py2f()
  • toint() — Translate object to integer handle.

✨ Attributes Summary ✨

The lil properties you can peek at 👀:

  • handle — MPI handle.
  • rank — Rank of this process.
  • size — Number of processes.

💅 Methods Documentation 💅

Down into the receipts 📜 — every method, every parameter, every return type, exactly as it is.

Compare(group)

Compare two groups. Fr fr, it tells you how two groups relate 🫶

Parameters

  • group (Group — #mpi4py.MPI.Group)

Return type: int — https://docs.python.org/3/library/functions.html#int

classmethod Create_from_session_pset(session, pset_name)

Create a new group from session and process set. It's a classmethod, so it lives on the class itself 👑

Parameters

Return type: Self — https://docs.python.org/3/library/typing.html#typing.Self

classmethod Difference(group1, group2)

Create a new group from the difference of two existing groups. Subtraction but make it ✨groups✨

Parameters

  • group1 (Group — #mpi4py.MPI.Group)
  • group2 (Group — #mpi4py.MPI.Group)

Return type: Self — https://docs.python.org/3/library/typing.html#typing.Self

Dup()

Duplicate a group. A little copy of the whole vibe 🌸

Return type: Self — https://docs.python.org/3/library/typing.html#typing.Self

Excl(ranks)

Create a new group by excluding listed members. Bye bye to the ones you don't want 👋

Parameters

Return type: Self — https://docs.python.org/3/library/typing.html#typing.Self

Free()

Free a group. Let it go, release the memory, main character move 💅

Return type: None — https://docs.python.org/3/library/constants.html#None

Get_rank()

Return the rank of this process in a group.

Return type: int — https://docs.python.org/3/library/functions.html#int

Get_size()

Return the number of processes in a group.

Return type: int — https://docs.python.org/3/library/functions.html#int

Incl(ranks)

Create a new group by including listed members. Now this is the invite list 🎀

Parameters

Return type: Self — https://docs.python.org/3/library/typing.html#typing.Self

Intersection(group1, group2) <span style="color:hotpink">(classmethod)</span>

okay so bestie, you take two groups that already exist and you make a brand new group out of the intersection of them — like, only the members that are in BOTH. ✨

  • group1 — a Group 💜
  • group2 — another Group 💜

Return type: Self

Range_excl(ranks)

creates a fresh group by excluding ranges of members. bye bye to those ranges 👋

  • ranks — Sequence[tuple[int, int, int]]

Return type: Self

Range_incl(ranks)

same vibe but the opposite direction: makes a new group by including ranges of members. come on in, we saved you a seat 🫶

  • ranks — Sequence[tuple[int, int, int]]

Return type: Self

Translate_ranks(ranks=None, group=None)

this one translates ranks in a group into the ranks of another group. it's giving translator app but for process numbers 🌐

  • ranks — Sequence[int] | None
  • group — Group | None

Return type: list[int]

Union(group1, group2) <span style="color:purple">(classmethod)</span>

the glow-up version: build a new group from the union of two existing groups. everybody's invited, it's a party 🎉

  • group1 — a Group 💖
  • group2 — a Group 💖

Return type: Self

f2py(arg) <span style="color:purple">(classmethod)</span>

  • arg — int

Return type: Group

free()

calls Free — but only if it's not null and not predefined. like, don't go freeing something that was never yours to free, bestie 😭

Return type: None

fromhandle(handle) <span style="color:purple">(classmethod)</span>

creates an object straight from an MPI handle. handle in, object out ✨

  • handle — int

Return type: Group

fromint(arg, /) <span style="color:purple">(classmethod)</span>

translates an integer handle into an object. (note the / — that arg is positional-only, no keyword games 🔥)

  • arg — int

Return type: Group

py2f()

Return type: int

toint()

translates an object into an integer handle. the reverse glow-up 💅

Return type: int

Attributes Documentation ✨

  • handle — MPI handle.
  • rank — rank of this process.
  • size — number of processes.

mpi4py.MPI.InPlaceType 👑

class mpi4py.MPI.InPlaceType

Bases: object

type of IN_PLACE. that's it, that's the whole job 🎀

__new__(cls) <span style="color:cyan">(static)</span>

Return type: Self

mpi4py.MPI.Info 🌸

class mpi4py.MPI.Info

Bases: object

info object. it holds info. iconic behaviour honestly 💜

__new__(cls, info=None) <span style="color:cyan">(static)</span>

  • info — Info | None

Return type: Self

Methods Summary ✨

okay bestie, this is the whole vibe check on Info methods — every single one, no skips, no cap. 💅

  • Create([items]) — Create a new info object.
  • Create_env([args]) — Create a new environment info object.
  • Delete(key) — Remove a (key, value) pair from info.
  • Dup() — Duplicate an existing info object.
  • Free() — Free an info object.
  • Get(key) — Retrieve the value associated with a key.
  • Get_nkeys() — Return the number of currently defined keys in info.
  • Get_nthkey(n) — Return the n-th defined key in info.
  • Set(key, value) — Store a value associated with a key.
  • clear() — Clear contents.
  • copy() — Copy contents.
  • f2py(arg) —
  • free() — Call Free if not null or predefined.
  • fromhandle(handle) — Create object from MPI handle.
  • fromint(arg, /) — Translate integer handle to object.
  • get(key[, default]) — Retrieve value by key.
  • items() — Return list of items.
  • keys() — Return list of keys.
  • pop(key, *default) — Pop value by key.
  • popitem() — Pop first item.
  • py2f() —
  • toint() — Translate object to integer handle.
  • update([items]) — Update contents.
  • values() — Return list of values.

Attributes Summary 🌸

  • handle — MPI handle.

Methods Documentation 🫶

classmethod Create(items=None)

Create a new info object. ✨

Parameters

items (Info <#mpi4py.MPI.Info> | Mapping <https://docs.python.org/3/library/typing.html#typing.Mapping>[str <https://docs.python.org/3/library/stdtypes.html#str>, str <https://docs.python.org/3/library/stdtypes.html#str>] | Iterable <https://docs.python.org/3/library/typing.html#typing.Iterable>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[str <https://docs.python.org/3/library/stdtypes.html#str>, str <https://docs.python.org/3/library/stdtypes.html#str>]] | None <https://docs.python.org/3/library/constants.html#None>)

Return type

Self <https://docs.python.org/3/library/typing.html#typing.Self>

classmethod Create_env(args=None)

Create a new environment info object. 🦋

Parameters

args (Sequence <https://docs.python.org/3/library/typing.html#typing.Sequence>[str <https://docs.python.org/3/library/stdtypes.html#str>] | None <https://docs.python.org/3/library/constants.html#None>)

Return type

Self <https://docs.python.org/3/library/typing.html#typing.Self>

Delete(key)

Remove a (key, value) pair from info. 💅

Parameters

Return type

None <https://docs.python.org/3/library/constants.html#None>

Dup()

Duplicate an existing info object. 👑

Return type

Self <https://docs.python.org/3/library/typing.html#typing.Self>

Free()

Free an info object. 🧚

Return type

None <https://docs.python.org/3/library/constants.html#None>

Get(key)

Retrieve the value associated with a key. 🔑

Parameters

Return type

str <https://docs.python.org/3/library/stdtypes.html#str> | None <https://docs.python.org/3/library/constants.html#None>

Get_nkeys()

Return the number of currently defined keys in info. 🔢

Return type

int <https://docs.python.org/3/library/functions.html#int>

Get_nthkey(n)

Return the n-th defined key in info. 🗝️

Parameters

Return type

str <https://docs.python.org/3/library/stdtypes.html#str>

Set(key, value)

Store a value associated with a key. 🍓

Parameters

Return type

None <https://docs.python.org/3/library/constants.html#None>

clear()

Clear contents. ✨

okay bestie we're still in our Info era and honestly? it's giving organized little dictionary energy 🎀 no re-intro needed, let's just keep it rolling ✨

copy() Copy contents. A lil photocopy of your info object, no cap 🫶

classmethod f2py(arg)

free() Call Free if not null or predefined. Yeah it's literally called Free and it's doing exactly what it says on the tin 💅

classmethod fromhandle(handle) Create object from MPI handle.

classmethod fromint(arg, /) Translate integer handle to object.

get(key, default=None) Retrieve value by key. Standard main-character lookup behaviour, periodt 👑

items() Return list of items. Your whole little key-value lineup, served fresh 🌸

keys() Return list of keys.

pop(key, *default) Pop value by key. Yank it right outta there, iconic 💅

popitem() Pop first item. Not last — first. Read it twice bestie, it's not doing LIFO today 🙈

py2f()

toint() Translate object to integer handle.

update(items=(), **kwds) Update contents. Glow-up your info object in place ✨

values() Return list of values.

Attributes Documentation 🎀

handle MPI handle.

mpi4py.MPI.Intercomm 🦋

class mpi4py.MPI.Intercomm

Bases: Comm (#mpi4py.MPI.Comm)

Intercommunicator. That's the whole personality. Two groups, talking to each other, absolutely thriving 🌈

static __new__(cls, comm=None)

Methods Summary 💖

  • Create_from_groups(local_group, ...[, ...]) — Create communicator from group.
  • Get_remote_group() — Access the remote group associated with the inter-communicator.
  • Get_remote_size() — Intercommunicator remote size.
  • Merge([high]) — Merge intercommunicator into an intracommunicator.

Attributes Summary ⭐

  • remote_group — Remote group.
  • remote_size — Number of remote processes.

Methods Documentation 🫶

classmethod Create_from_groups(local_group, local_leader, remote_group, remote_leader, stringtag='org.mpi4py', info=INFO_NULL, errhandler=None) Create communicator from group.

Get_remote_group() Access the remote group associated with the inter-communicator.

  • Return type: Group (#mpi4py.MPI.Group)

Get_remote_size() Intercommunicator remote size.

Merge(high=False) Merge intercommunicator into an intracommunicator. Two become one, no cap 💖

Attributes Documentation 🌸

remote_group Remote group.

remote_size Number of remote processes.

mpi4py.MPI.Intracomm 👑

class mpi4py.MPI.Intracomm

Bases: Comm (#mpi4py.MPI.Comm)

Intracommunicator. The classic, the blueprint, the moment 🌟

static __new__(cls, comm=None)

✨ Methods Summary ✨

okay bestie, here's the whole method menu for this class, and it's lowkey a lot but we're gonna get through it together. no cap. 💖

  • Accept(port_name[, info, root]) — Accept a request to form a new intercommunicator. 💖
  • Cart_map(dims[, periods]) — Determine optimal process placement on a Cartesian topology. 🗺️
  • Connect(port_name[, info, root]) — Make a request to form a new intercommunicator. 🔗
  • Create_cart(dims[, periods, reorder]) — Create cartesian communicator. 🛒
  • Create_dist_graph(sources, degrees, destinations) — Create distributed graph communicator. 🕸️
  • Create_dist_graph_adjacent(sources, destinations) — Create distributed graph communicator. 🕸️
  • Create_from_group(group[, stringtag, info, ...]) — Create communicator from group. 👯
  • Create_graph(index, edges[, reorder]) — Create graph communicator. 📈
  • Create_group(group[, tag]) — Create communicator from group. 👯
  • Create_intercomm(local_leader, peer_comm, ...) — Create intercommunicator. 🌉
  • Exscan(sendbuf, recvbuf[, op]) — Exclusive Scan. 🔍
  • Exscan_init(sendbuf, recvbuf[, op, info]) — Persistent Exclusive Scan. 🔁
  • Graph_map(index, edges) — Determine optimal process placement on a graph topology. 🗺️
  • Iexscan(sendbuf, recvbuf[, op]) — Inclusive Scan. 🔍
  • Iscan(sendbuf, recvbuf[, op]) — Inclusive Scan. 🔍
  • Scan(sendbuf, recvbuf[, op]) — Inclusive Scan. 🔍
  • Scan_init(sendbuf, recvbuf[, op, info]) — Persistent Inclusive Scan. 🔁
  • Spawn(command[, args, maxprocs, info, root, ...]) — Spawn instances of a single MPI application. 🚀
  • Spawn_multiple(command[, args, maxprocs, ...]) — Spawn instances of multiple MPI applications. 🚀
  • exscan(sendobj[, op]) — Exclusive Scan. 🔍
  • scan(sendobj[, op]) — Inclusive Scan. 🔍

🛠️ Methods Documentation 🛠️

Accept(port_name, info=INFO_NULL, root=0)

Accept a request to form a new intercommunicator. it's literally the "hey bestie let's link up" of MPI. 💖

Parameters

Return type: Intercomm #mpi4py.MPI.Intercomm

Cart_map(dims, periods=None)

Determine optimal process placement on a Cartesian topology. it's giving "where should everyone sit" vibes. 🗺️

Parameters

Return type: int https://docs.python.org/3/library/functions.html#int

Connect(port_name, info=INFO_NULL, root=0)

Make a request to form a new intercommunicator. it's giving main character energy. 🔗

Parameters

Return type: Intercomm #mpi4py.MPI.Intercomm

Create_cart(dims, periods=None, reorder=False)

Create cartesian communicator. periodt. 🛒

Parameters

Return type: Cartcomm #mpi4py.MPI.Cartcomm

Create_dist_graph(sources, degrees, destinations, weights=None, info=INFO_NULL, reorder=False)

Create distributed graph communicator. lowkey iconic. 🕸️

Parameters

  • sources (Sequence[int] https://docs.python.org/3/library/typing.html#typing.Sequence https://docs.python.org/3/library/functions.html#int)
  • degrees (Sequence[int]) — the out-degree of every single node, one number per node, bestie 💫
  • destinations (Sequence[int]) — where all those edges actually point, flattened out into one big sequence 🫶
  • weights (Sequence[int] or None) — optional edge weights, or None if you're keeping it unweighted and unbothered
  • info (Info) — an Info object, obviously 🎀
  • reorder (bool) — do we let the implementation renumber the nodes? yes or no, no in-between

Return type

Distgraphcomm — a distributed graph communicator, iconic 👑

Create_dist_graph_adjacent(sources, destinations, sourceweights=None, destweights=None, info=INFO_NULL, reorder=False)

Create distributed graph communicator. Same energy as the one above, just in the adjacent (sparse) flavour 🦋

Parameters

  • sources (Sequence[int]) — where the edges come from 💫
  • destinations (Sequence[int]) — where the edges go 🫶
  • sourceweights (Sequence[int] or None) — weights on the source side, or None if you don't care
  • destweights (Sequence[int] or None) — weights on the destination side, or None for the unweighted vibe
  • info (Info) — an Info object, periodt
  • reorder (bool) — renumber the nodes or nah?

Return type

Distgraphcomm — same deal 🌸

classmethod Create_from_group(group, stringtag='org.mpi4py', info=INFO_NULL, errhandler=None)

Create communicator from group. It's a classmethod, so it knows things about itself 💅

Parameters

  • group (Group) — the Group you're building from 🌈
  • stringtag (str) — the string tag, defaulting to 'org.mpi4py' (yes, exactly that string, don't go changing it)
  • info (Info) — an Info object
  • errhandler (Errhandler or None) — your error handler, or None if you're rawdogging it 🙈

Return type

Intracomm — an intracommunicator, slay ✨

Create_graph(index, edges, reorder=False)

Create graph communicator. 🌸

Parameters

  • index (Sequence[int]) — the index array, it's giving "adjacency list boundaries" 💫
  • edges (Sequence[int]) — the edges themselves 🫶
  • reorder (bool) — let the implementation renumber the nodes?

Return type

Graphcomm — a graph communicator, bestie 🎀

Create_group(group, tag=0)

Create communicator from group. Different flavour, same dream ✨

Parameters

  • group (Group) — the Group in question 🌈
  • tag (int) — a tag, defaulting to 0 (zero, as in nothing, as in the default)

Return type

Intracomm — an intracommunicator 👑

Create_intercomm(local_leader, peer_comm, remote_leader, tag=0)

Create intercommunicator. For when you need two groups talking to each other, lowkey iconic 🦋

Parameters

  • local_leader (int) — the rank of the leader on your side 💫
  • peer_comm (Intracomm) — the Intracomm that connects to the other side 🌈
  • remote_leader (int) — the rank of the leader on the other side 🫶
  • tag (int) — a tag, defaulting to 0

Return type

Intercomm — an intercommunicator, periodt 🎀

Exscan(sendbuf, recvbuf, op=SUM)

Exclusive Scan. Everyone gets the combination of everybody before them 💅

Parameters

  • sendbuf (BufSpec or InPlace) — your input buffer, or InPlace if you're feeling spicy 🔥
  • recvbuf (BufSpec) — where the answer lands 🍓
  • op (Op) — the reduction operation, defaulting to SUM

Return type

None — nothing comes back, it all goes into recvbuf ✨

Exscan_init(sendbuf, recvbuf, op=SUM, info=INFO_NULL)

Persistent Exclusive Scan. Same exclusive scan energy, but persistent, so you can fire it off again and again 🧚

Parameters

  • sendbuf (BufSpec or InPlace) — input buffer, or InPlace 🔥
  • recvbuf (BufSpec) — output buffer 🍓
  • op (Op) — the operation, defaulting to SUM
  • info (Info) — an Info object, defaulting to INFO_NULL

Return type

Prequest — a persistent request, obsessed 🌸

Graph_map(index, edges)

Determine optimal process placement on a graph topology. Basically asking MPI "bestie, where should everybody sit?" 💫

Parameters

  • index (Sequence[int]) — the index array 🌈
  • edges (Sequence[int]) — the edges 🫶

Return type

int — an integer comes back, no cap ✨

Iexscan(sendbuf, recvbuf, op=SUM)

Inclusive Scan. Non-blocking edition 👑

Parameters

  • sendbuf (BufSpec or InPlace) — input buffer, or InPlace 🔥
  • recvbuf (BufSpec) — output buffer 🍓
  • op (Op) — the operation, defaulting to SUM

Return type

Request — a Request, go wait on it whenever 🎀

Iscan(sendbuf, recvbuf, op=SUM)

Inclusive Scan. Also non-blocking, also inclusive 💅

Parameters

  • sendbuf (BufSpec or InPlace) — input buffer, or InPlace 🔥
  • recvbuf (BufSpec) — output buffer 🍓
  • op (Op) — the operation, defaulting to SUM

Return type

Request — a Request 🌈

Scan(sendbuf, recvbuf, op=SUM)

Inclusive Scan. The blocking one, main character energy ⭐

Parameters

  • sendbuf (BufSpec or InPlace) — input buffer, or InPlace 🔥
  • recvbuf (BufSpec) — output buffer 🍓
  • op (Op) — the operation, defaulting to SUM

Return type

None — it all goes into recvbuf, nothing comes back ✨

Scan_init(sendbuf, recvbuf, op=SUM, info=INFO_NULL)

Persistent Inclusive Scan. Inclusive scan, but it sticks around 🧚

Parameters

  • sendbuf (BufSpec or InPlace) — input buffer, or InPlace 🔥
  • recvbuf (BufSpec) — output buffer 🍓
  • op (Op) — the operation, defaulting to SUM
  • info (Info) — an Info object, defaulting to INFO_NULL

Return type

Prequest — a persistent request, we love to see it 🌸

Spawn(command, args=None, maxprocs=1, info=INFO_NULL, root=0, errcodes=None)

Spawn instances of a single MPI application. You get to start up a whole new squad, and it's giving very much "go forth and compute" 💫

Parameters

  • command (PathLike or str or bytes) — the program to run — a path-like, a str, or bytes, all three are valid bestie 🫶
  • args (Sequence[str] or None) — the arguments to hand it, or None
  • maxprocs (int) — how many processes you want, defaulting to 1
  • info (Info) — an Info object, defaulting to INFO_NULL
  • root (int) — the root rank, defaulting to 0
  • errcodes (list[int] or None) — where error codes get written, or None if you don't want them 🍓

Return type

Intercomm — an intercommunicator to your shiny new processes 👑

Spawn_multiple(command, args=None, maxprocs=None, info=INFO_NULL, root=0, errcodes=None)

Spawn instances of multiple MPI applications. Multiple apps, one call, absolute chaos in the best way 🔥

Parameters

  • command (Sequence[PathLike | str | bytes]) — the thing to run, as a sequence of path-likes, strings, or bytes 🫶
  • args (Sequence[Sequence[str]] | None) — a sequence of argument sequences, or None
  • maxprocs (Sequence[int] | None) — how many procs per command, or None
  • info (Sequence[Info] | Info) — info objects, one or a whole sequence of them
  • root (int) — the root rank
  • errcodes (list[list[int]] | None) — the error codes you collect, or None

Return type: Intercomm

exscan(sendobj, op=SUM)

Exclusive Scan. you get the combination of everything that came before you, not including you bestie ✨

Parameters

  • sendobj (Any) — whatever you're sending in
  • op (Op | Callable[[Any, Any], Any]) — the operation, either an Op or a callable that takes two Anys and gives back an Any

Return type: Any

scan(sendobj, op=SUM)

Inclusive Scan. this one does include you, main character behavior fr fr 💅

Parameters

  • sendobj (Any) — the thing going in
  • op (Op | Callable[[Any, Any], Any]) — an Op, or a callable [[Any, Any], Any] situation

Return type: Any

🦋 mpi4py.MPI.Message 🦋

class mpi4py.MPI.Message

Bases: object

Matched message. it's giving "your message has been found" energy 💌

static __new__(cls, message=None)

Parameters

  • message (Message | None) — an existing message, or None

Return type: Self

📋 Methods Summary 📋

  • Iprobe(comm[, source, tag, status]) — Nonblocking test for a matched message.
  • Irecv(buf) — Nonblocking receive of matched message.
  • Probe(comm[, source, tag, status]) — Blocking test for a matched message.
  • Recv(buf[, status]) — Blocking receive of matched message.
  • f2py(arg) — (no description, it's just chillin' there)
  • free() — Do nothing.
  • fromhandle(handle) — Create object from MPI handle.
  • fromint(arg, /) — Translate integer handle to object.
  • iprobe(comm[, source, tag, status]) — Nonblocking test for a matched message.
  • irecv() — Nonblocking receive of matched message.
  • probe(comm[, source, tag, status]) — Blocking test for a matched message.
  • py2f() — (also no description, we respect the mystery)
  • recv([status]) — Blocking receive of matched message.
  • toint() — Translate object to integer handle.

🎀 Attributes Summary 🎀

  • handle — MPI handle. the little integer that runs the whole show iykyk

📖 Methods Documentation 📖

classmethod Iprobe(comm, source=ANY_SOURCE, tag=ANY_TAG, status=None)

Nonblocking test for a matched message. checks without committing, no strings attached 👑

Parameters

  • comm (Comm) — the communicator
  • source (int) — who you're listening for
  • tag (int) — the tag on the message
  • status (Status | None) — where the status lands, or None

Return type: Self | None

Irecv(buf)

Nonblocking receive of matched message. comes back instantly with a request, the data shows up later bestie 🌸

Parameters

  • buf (BufSpec) — the buffer receiving the goods

Return type: Request

classmethod Probe(comm, source=ANY_SOURCE, tag=ANY_TAG, status=None)

Blocking test for a matched message. it WILL sit there and wait until something shows up, no cap 💀

Parameters

  • comm (Comm) — the communicator in question
  • source (int) — the rank you're waiting on
  • tag (int) — the tag you're matching
  • status (Status | None) — status object slot, or None

Return type: Self

  • Recv(buf, status=None) — blocking receive of a matched message, bestie. You sit there and wait, patiently, like you're waiting for your iced coffee. 💅

Parameters:

  • buf (BufSpec)
  • status (Status | None)

Return type: None

  • classmethod f2py(arg)

Parameters: arg (int)

Return type: Message

  • free() — do nothing. Literally nothing. It's giving "no thoughts, head empty". 🙈

Return type: None

  • classmethod fromhandle(handle) — create object from MPI handle.

Parameters: handle (int)

Return type: Message

  • classmethod fromint(arg, /) — translate integer handle to object.

Parameters: arg (int)

Return type: Message

  • classmethod iprobe(comm, source=ANY_SOURCE, tag=ANY_TAG, status=None) — nonblocking test for a matched message. Just a lil peek, no commitment. 👀

Parameters:

  • comm (Comm)
  • source (int)
  • tag (int)
  • status (Status | None)

Return type: Self | None

  • irecv() — nonblocking receive of matched message.

Return type: Request

  • classmethod probe(comm, source=ANY_SOURCE, tag=ANY_TAG, status=None) — blocking test for a matched message.

Parameters:

  • comm (Comm)
  • source (int)
  • tag (int)
  • status (Status | None)

Return type: Self

  • py2f()

Return type: int

  • recv(status=None) — blocking receive of matched message.

Parameters: status (Status | None)

Return type: Any

  • toint() — translate object to integer handle.

Return type: int

Attributes Documentation ✨

  • handle — MPI handle. 🎀

mpi4py.MPI.Op 🦋

class mpi4py.MPI.Op

Bases: object

Reduction operation. Like, the operation that squishes a whole pile of values into one, and honestly? She's iconic for it. 🔥

static __new__(cls, op=None)

Parameters: op (Op | None)

Return type: Self

Methods Summary 🌸

  • Create(function[, commute]) — create a user-defined reduction operation.
  • Free() — free a user-defined reduction operation.
  • Is_commutative() — query reduction operations for their commutativity.
  • Reduce_local(inbuf, inoutbuf) — apply a reduction operation to local data.
  • f2py(arg)
  • free() — call Free if not null or predefined.
  • fromhandle(handle) — create object from MPI handle.
  • fromint(arg, /) — translate integer handle to object.
  • py2f()
  • toint() — translate object to integer handle.

Attributes Summary 💜

  • handle — MPI handle.
  • is_commutative — is a commutative operation.
  • is_predefined — is a predefined operation.

Methods Documentation 👑

  • classmethod Create(function, commute=False) — create a user-defined reduction operation, fr fr.

Parameters:

  • function (Callable[[Buffer, Buffer, Datatype], None])
  • commute (bool)

Return type: Self

  • Free() — free a user-defined reduction operation. Say bye bestie, we're releasing you. 😭

Return type: None

  • Is_commutative() — query reduction operations for their commutativity.

Return type: bool

  • Reduce_local(inbuf, inoutbuf) — apply a reduction operation to local data.

Parameters:

  • inbuf (BufSpec)
  • inoutbuf (BufSpec)

Return type: None

  • classmethod f2py(arg)

Parameters: arg (int)

Return type: Op

  • free() — call Free if not null or predefined. Responsible queen behavior, honestly. ✨

Return type: None

classmethod fromhandle(handle) 💅

Okay bestie, this one is literally the glow-up spell for an MPI handle: Create object from MPI handle.

Parameters

  • handle (int)

Return type Op

classmethod fromint(arg, /) ✨

Translate integer handle to object. No cap.

Parameters

  • arg (int)

Return type Op

py2f() 🦋

Return type int

toint() 🎀

Translate object to integer handle. Periodt.

Return type int

Attributes Documentation 👑

  • handle — MPI handle.
  • is_commutative — Is a commutative operation.
  • is_predefined — Is a predefined operation.

mpi4py.MPI.Pickle 🍓

class mpi4py.MPI.Pickle

Bases: object

Pickle/unpickle Python objects. It's giving serialization main character energy.

static __new__(cls, pickle=None)

Parameters

  • pickle (Pickle | None)

Return type Self

Methods Summary 💖

  • dumps(obj) — Serialize object to pickle data stream.
  • dumps_oob(obj) — Serialize object to pickle data stream and out-of-band buffers.
  • loads(data) — Deserialize object from pickle data stream.
  • loads_oob(data, buffers) — Deserialize object from pickle data stream and out-of-band buffers.

Attributes Summary 🌸

  • PROTOCOL — Protocol version.
  • THRESHOLD — Out-of-band threshold.

Methods Documentation 🔥

dumps(obj) 💅

Serialize object to pickle data stream.

Parameters

  • obj (Any)

Return type bytes

dumps_oob(obj) ✨

Serialize object to pickle data stream and out-of-band buffers.

Parameters

  • obj (Any)

Return type tuple[bytes, list[buffer]]

loads(data) 🦋

Deserialize object from pickle data stream.

Parameters

  • data (Buffer)

Return type Any

loads_oob(data, buffers) 🎀

Deserialize object from pickle data stream and out-of-band buffers.

Parameters

  • data (Buffer)
  • buffers (Iterable[Buffer])

Return type Any

Attributes Documentation 👑

  • PROTOCOL — Protocol version.
  • THRESHOLD — Out-of-band threshold.

mpi4py.MPI.Prequest 💜

class mpi4py.MPI.Prequest

Bases: Request

Persistent request handler. Lowkey iconic.

static __new__(cls, request=None)

Parameters

  • request (Prequest | None)

Return type Self

Methods Summary 🌈

  • Parrived(partition) — Test partial completion of a partitioned receive operation.
  • Pready(partition) — Mark a given partition as ready.
  • Pready_list(partitions) — Mark a sequence of partitions as ready.
  • Pready_range(partition_low, partition_high) — Mark a range of partitions as ready.
  • Start() — Initiate a communication with a persistent request.
  • Startall(requests) — Start a collection of persistent requests.

Methods Documentation 🔥

Parrived(partition) 💅

Test partial completion of a partitioned receive operation.

Parameters

  • partition (int)

Return type bool

Pready(partition) ✨

Mark a given partition as ready.

Parameters

  • partition (int)

Return type None

Pready_list(partitions) 🦋

Mark a sequence of partitions as ready.

Parameters

  • partitions (Sequence[int])

Return type None

Pready_range(partition_low, partition_high) 🎀

Mark a range of partitions as ready.

Parameters

  • partition_low (int)
  • partition_high (int)

Return type None

Start() 🔥

Initiate a communication with a persistent request.

Return type None

classmethod Startall(requests) 👑

Start a collection of persistent requests.

  • requests — a list of Prequest objects 💅 like, hand me the whole squad of pending requests at once, bestie

Return type: None — she does the thing and gives you nothing back, and that's the whole point, no cap 🫶

mpi4py.MPI.Request

class mpi4py.MPI.Request

Bases: object

Okay so this is the Request handler ✨ the little object that holds onto a nonblocking operation so you can check on it later. It's giving "I'll text you when it's done" energy, and honestly? Iconic. 👑

static __new__(cls, request=None)

Not me casually dropping a static constructor on you 🙈 yes, it's __new__, yes it's static, yes we're being fancy today.

Parameters:

  • request — a Request, or None if you're feeling mysterious 💀

Return type: Self — she hands back a brand new shiny Self, as one does 🌸

✨ Methods Summary ✨

okay bestie, here's the whole squad of methods, both the CamelCase version and the lowercase version, because this class said "why not both" and honestly? iconic of it 💅

  • Cancel() — cancel a request. bye bye request 🫶
  • Free() — free a communication request. let it go, bestie, release the memory
  • Get_status([status]) — a non-destructive test for the completion of a request (peeks, doesn't disturb 💖)
  • Get_status_all(requests[, statuses]) — non-destructive test for the completion of all the requests
  • Get_status_any(requests[, status]) — non-destructive test for the completion of any of the requests
  • Get_status_some(requests[, statuses]) — non-destructive test for completion of some requests
  • Test([status]) — test for the completion of a non-blocking operation
  • Testall(requests[, statuses]) — test for completion of all previously initiated requests
  • Testany(requests[, status]) — test for completion of any previously initiated request
  • Testsome(requests[, statuses]) — test for completion of some previously initiated requests
  • Wait([status]) — wait for a non-blocking operation to complete (this one actually blocks, no cap)
  • Waitall(requests[, statuses]) — wait for all previously initiated requests to complete
  • Waitany(requests[, status]) — wait for any previously initiated request to complete
  • Waitsome(requests[, statuses]) — wait for some previously initiated requests to complete
  • cancel() — cancel a request (the lowercase remix 🌈)
  • f2py(arg) — no description given, it's giving mystery ✨
  • free() — call Free if not null
  • fromhandle(handle) — create object from MPI handle
  • fromint(arg, /) — translate integer handle to object
  • get_status([status]) — non-destructive test for the completion of a request
  • get_status_all(requests[, statuses]) — non-destructive test for the completion of all requests
  • get_status_any(requests[, status]) — non-destructive test for the completion of any requests
  • get_status_some(requests[, statuses]) — non-destructive test for completion of some requests
  • py2f() — also no description, the manpage is keeping secrets 💀
  • test([status]) — test for the completion of a non-blocking operation
  • testall(requests[, statuses]) — test for completion of all previously initiated requests
  • testany(requests[, status]) — test for completion of any previously initiated request
  • testsome(requests[, statuses]) — test for completion of some previously initiated requests
  • toint() — translate object to integer handle
  • wait([status]) — wait for a non-blocking operation to complete
notice how Get_status/get_status and friends are literally the same vibe twice? yeah. pick whichever one matches your code's aesthetic, they're both here, we don't gatekeep 🎀
  • waitall(requests[, statuses]) — blocks until all the requests you already kicked off are done. every single one, bestie, no stragglers, no "almost there" 💅
  • waitany(requests[, status]) — blocks until any one of your previously initiated requests completes. first one home gets the crown 👑
  • waitsome(requests[, statuses]) — blocks until some of your previously initiated requests complete. not all, not one, just... some. iconic chaos 🦋

✨ Attributes Summary ✨

  • handle — the MPI handle. that's it, that's the whole vibe 🎀

💅 Methods Documentation 💅

Cancel()

Cancel a request. 🚫

Free()

Free a communication request. let it go, bestie, it's not yours anymore 🕊️

Get_status(status=None)

Non-destructive test for the completion of a request. peek at it, don't touch it 👀

classmethod Get_status_all(requests, statuses=None)

Non-destructive test for the completion of all requests.

classmethod Get_status_any(requests, status=None)

Non-destructive test for the completion of any requests.

classmethod Get_status_some(requests, statuses=None)

Non-destructive test for completion of some requests.

Test(status=None)

Test for the completion of a non-blocking operation. lowkey just checking in, no waiting around 🫶

classmethod Testall(requests, statuses=None)

Test for completion of all previously initiated requests.

classmethod Testany(requests, status=None)

Test for completion of any previously initiated request.

classmethod Testsome(requests, statuses=None)

Test for completion of some previously initiated requests.

Wait(status=None)

Wait for a non-blocking operation to complete. sit down, hydrate, it'll be done when it's done 💖

classmethod Waitall(requests, statuses=None)

Wait for all previously initiated requests to complete. all of them. every last one. periodt 🔥

classmethod Waitany(requests, status=None)

Wait for any previously initiated request to complete. first one to finish, you're the main character now ✨

classmethod Waitsome(requests, statuses=None)

Wait for some previously initiated requests to complete.

cancel()

Cancel a request. same energy as Cancel(), just lowercase and chill 🧊

classmethod f2py(arg)

Return type: Request 💖

free() 🎀

Calls Free if the thing isn't null. That's it, that's the whole job.

Return type: None

classmethod fromhandle(handle) 🪄

Builds you a whole object out of an MPI handle. Glow-up from raw number to real class, no cap.

Parameters:

  • handle (int)

Return type: Request

classmethod fromint(arg, /) 🌈

Takes an integer handle and translates it into the object. Same energy as fromhandle, different entry point.

Parameters:

  • arg (int)

Return type: Request

get_status(status=None) 👀

A non-destructive test for whether a request has finished. It peeks, it does not consume. Respectful king behavior.

Parameters:

  • status (Status | None)

Return type: bool

classmethod get_status_all(requests, statuses=None) 👑

Non-destructive test for the completion of all the requests. Everybody has to be done or it's a no from me.

Parameters:

  • requests (Sequence[Request])
  • statuses (list[Status] | None)

Return type: bool

classmethod get_status_any(requests, status=None) ✨

Non-destructive test for the completion of any of the requests. One single one finishing is enough to make it slay.

Parameters:

  • requests (Sequence[Request])
  • status (Status | None)

Return type: tuple[int, bool]

classmethod get_status_some(requests, statuses=None) 🌸

Non-destructive test for the completion of some of the requests. A little subset of finished vibes.

Parameters:

  • requests (Sequence[Request])
  • statuses (list[Status] | None)

Return type: list[int] | None

py2f() 🐍➡️🔢

No description in the docs, bestie — it just hands you back an int.

Return type: int

test(status=None) 🧪

Tests whether a non-blocking operation has completed. Note this one is not the "non-destructive" crew — it's the real test.

Parameters:

  • status (Status | None)

Return type: tuple[bool, Any | None]

classmethod testall(requests, statuses=None) 🔥

Tests for the completion of all the requests you previously initiated. Full house only.

Parameters:

  • requests (Sequence[Request])
  • statuses (list[Status] | None)

Return type: tuple[bool, list[Any] | None]

classmethod testany(requests, status=None) ⭐

Tests for the completion of any previously initiated request. First one to cross the finish line gets the attention.

Parameters:

  • requests (Sequence[Request])
  • status (Status | None)

Return type: tuple[int, bool, Any | None]

classmethod testsome(requests, statuses=None) 💅

Tests for the completion of some of the previously initiated requests. A lil group of overachievers, honestly iconic.

Parameters:

  • requests (Sequence[Request])
  • statuses (list[Status] | None)

Return type: tuple[list[int] | None, list[Any] | None]

toint() 🔢

Translates the object into an integer handle. The reverse glow-down, and I mean that with love.

Return type: int

wait(status=None) ⏳

Waits for a non-blocking operation to complete. Yes, it will sit there and hold your hand until it's done. Loyal.

Parameters:

  • status (Status | None)

Return type: Any

classmethod waitall(requests, statuses=None) 🫶

Waits for all previously initiated requests to complete. Every single one of them, no skipping, we are not leaving anybody behind.

Parameters:

  • requests (Sequence[Request])
  • statuses (list[Status] | None)

Return type: list[Any]

classmethod waitany(requests, status=None) 🦋

Waits for any previously initiated request to complete. Whichever one gets there first, that's the one we're celebrating.

Parameters:

  • requests (Sequence[Request])
  • status (Status | None)

Return type: tuple[int, Any]

classmethod waitsome(requests, statuses=None) 🍓

Waits for some of the previously initiated requests to complete. Not all of them — just however many show up to the party.

Parameters:

  • requests (Sequence[Request])
  • statuses (list[Status] | None)

Return type: tuple[list[int] | None, list[Any] | None]

Attributes Documentation 📌

  • handle — MPI handle.

🌸 mpi4py.MPI.Session 🌸

class mpi4py.MPI.Session

Bases: object

Okay bestie, this is the Session context ✨ — think of it as a whole vibe of MPI-ness that you can spin up, poke at, and shut down on its own terms.

static __new__(cls, session=None)
  • Parameters — session (Session | None)
  • Return type — Self

Methods Summary 💅

  • Attach_buffer(buf) — Attach a user-provided buffer for sending in buffered mode.
  • Call_errhandler(errorcode) — Call the error handler installed on a session.
  • Create_errhandler(errhandler_fn) — Create a new error handler for sessions.
  • Create_group(pset_name) — Create a new group from session and process set.
  • Detach_buffer() — Remove an existing attached buffer.
  • Finalize() — Finalize a session.
  • Flush_buffer() — Block until all buffered messages have been transmitted.
  • Get_errhandler() — Get the error handler for a session.
  • Get_info() — Return the current hints for a session.
  • Get_nth_pset(n[, info]) — Name of the n-th process set.
  • Get_num_psets([info]) — Number of available process sets.
  • Get_pset_info(pset_name) — Return the current hints for a session and process set.
  • Iflush_buffer() — Nonblocking flush for buffered messages.
  • Init([info, errhandler]) — Create a new session.
  • Set_errhandler(errhandler) — Set the error handler for a session.
  • f2py(arg)
  • free() — Call Finalize if not null.
  • fromhandle(handle) — Create object from MPI handle.
  • fromint(arg, /) — Translate integer handle to object.
  • py2f()
  • toint() — Translate object to integer handle.

Attributes Summary 🎀

  • handle — MPI handle.

Methods Documentation 📖

Attach_buffer(buf)

Attach a user-provided buffer for sending in buffered mode. 🫙✨

  • Parameters — buf (Buffer | None)
  • Return type — None

Call_errhandler(errorcode)

Call the error handler installed on a session. Like ringing the little alarm bell you set up earlier 📣

  • Parameters — errorcode (int)
  • Return type — None

classmethod Create_errhandler(errhandler_fn)

Create a new error handler for sessions. Custom alarm bell, made by you 💅

  • Parameters — errhandler_fn (Callable[[Session, int], None])
  • Return type — Errhandler

Create_group(pset_name)

Create a new group from session and process set. Squish a session + a process set together and boom, a group 🫶

  • Parameters — pset_name (str)

Return type: Group 🫶

Detach_buffer()

Say bye to a buffer you'd attached earlier — it just takes the attached buffer back off the shelf, that's it.

  • Return type: Buffer | None

Finalize()

Wrap up a session. That's the whole job. 👋

  • Return type: None

Flush_buffer()

Blocks (like, actually waits) until every single buffered message has been transmitted. Nothing sneaky gets left in the queue, bestie. ✨

  • Return type: None

Get_errhandler()

Hands you the error handler that's hooked up to a session.

  • Return type: Errhandler

Get_info()

Returns the current hints for a session. The tea, basically. 🍓

  • Return type: Info

Get_nth_pset(n, info=INFO_NULL)

Gives you the name of the n-th process set. No cap.

Parameters:

  • n (int)
  • info (Info)
  • Return type: str

Get_num_psets(info=INFO_NULL)

How many process sets are even available. The headcount. 👑

Parameters:

  • info (Info)
  • Return type: int

Get_pset_info(pset_name)

Returns the current hints for a session and a process set — both at once, iconic.

Parameters:

  • pset_name (str)
  • Return type: Info

Iflush_buffer()

Same energy as flushing buffered messages, but nonblocking — it does not sit there waiting. It hands you a request instead. 💅

  • Return type: Request

classmethod Init(info=INFO_NULL, errhandler=None)

Creates a brand new session. Main character origin story. ✨

Parameters:

  • info (Info)
  • errhandler (Errhandler | None)
  • Return type: Self

Set_errhandler(errhandler)

Sets the error handler for a session. Pick your handler, commit to it.

Parameters:

  • errhandler (Errhandler)
  • Return type: None

classmethod f2py(arg)

Parameters:

  • arg (int)
  • Return type: Session

free()

Calls Finalize if not null.

  • Return type: None

classmethod fromhandle(handle)

Builds an object straight from an MPI handle. 🎀

Parameters:

  • handle (int)
  • Return type: Session

classmethod fromint(arg, /)

Translates an integer handle into an object. Glow-up complete. 🌸

Parameters:

  • arg (int)
  • Return type: Session

py2f()

  • Return type: int

toint()

Translates an object into an integer handle.

  • Return type: int

Attributes Documentation 📌

handle

MPI handle.

mpi4py.MPI.Status 💜

class mpi4py.MPI.Status

Bases: object

Status object.

static __new__(cls, status=None)

Parameters:

  • status (Status | None)
  • Return type: Self

Methods Summary 🦋

  • Get_count([datatype]) — Get the number of top level elements.
  • Get_elements(datatype) — Get the number of basic elements in a datatype.
  • Get_error() — Get message error.
  • Get_source() — Get message source.
  • Get_tag() — Get message tag.
  • Is_cancelled() — Test to see if a request was cancelled.
  • Set_cancelled(flag) — Set the cancelled state associated with a status.
  • Set_elements(datatype, count) — Set the number of elements in a status.
  • Set_error(error) — Set message error.
  • Set_source(source) — Set message source.
  • Set_tag(tag) — Set message tag.
  • f2py(arg)
  • py2f()
  • tomemory() — Return status memory view.

Attributes Summary 🌈

  • cancelled — Cancelled state.
  • count — Byte count.
  • error — Message error.
  • source — Message source.
  • tag — Message tag.

Methods Documentation ✨

Get_count(datatype=BYTE)

Gives you the number of top level elements.

Parameters:

  • datatype (Datatype)
  • Return type: int

Get_elements(datatype)

Gives you the number of basic elements in a datatype.

Parameters:

  • datatype (Datatype)
  • Return type: int

✨ Get_error()

Gives you the message error. That's it, that's the whole thing 💅

  • Return type — int

✨ Get_source()

Gives you the message source. Yes queen, it's right there 🌸

  • Return type — int

✨ Get_tag()

Gives you the message tag. The little label on the message, iconic ✨

  • Return type — int

✨ Is_cancelled()

Checks whether a request got cancelled. Lowkey useful, no cap 🦋

  • Return type — bool

✨ Set_cancelled(flag)

Sets the cancelled state that's associated with a status.

⚠️ Heads up bestie: only reach for this one when you're implementing query callback functions for generalized requests. Not a casual-use situation, fr fr.
  • Parameters
    • flag — bool
  • Return type — None

✨ Set_elements(datatype, count)

Sets the number of elements in a status. Bestie, we're literally counting ✨

⚠️ Listen: this is only for when you're implementing query callback functions for generalized requests. Stay in your lane, it's giving specialized 💅
  • Parameters
    • datatype — Datatype
    • count — int
  • Return type — None

✨ Set_error(error)

Sets the message error.

  • Parameters
    • error — int
  • Return type — None

✨ Set_source(source)

Sets the message source.

  • Parameters
    • source — int
  • Return type — None

✨ Set_tag(tag)

Sets the message tag.

  • Parameters
    • tag — int
  • Return type — None

✨ classmethod f2py(arg)

A classmethod, so you're calling it on the class itself, not on an instance. Main character energy 🌟

  • Parameters
    • arg — list[int]
  • Return type — Self

✨ py2f()

  • Return type — list[int]

✨ tomemory()

Returns the status as a memory view. It's giving "here's the raw view" 👑

  • Return type — memoryview

🎀 Attributes Documentation

cancelled

Cancelled state.

count

Byte count.

error

Message error.

source

Message source.

tag

Message tag.

💜 mpi4py.MPI.Topocomm

class mpi4py.MPI.Topocomm

Bases: Intracomm

Topology intracommunicator. Bestie, this is the comm that actually knows who its neighbors are 🦋

static __new__(cls, comm=None)

  • Parameters
    • comm — Topocomm | None
  • Return type — Self

📋 Methods Summary

okay so here's the whole roster, and every single one of them is here, no skips, no cuts 💖

  • Ineighbor_allgather(sendbuf, recvbuf) — Nonblocking Neighbor Gather to All.
  • Ineighbor_allgatherv(sendbuf, recvbuf) — Nonblocking Neighbor Gather to All Vector.
  • Ineighbor_alltoall(sendbuf, recvbuf) — Nonblocking Neighbor All to All.
  • Ineighbor_alltoallv(sendbuf, recvbuf) — Nonblocking Neighbor All to All Vector.
  • Ineighbor_alltoallw(sendbuf, recvbuf) — Nonblocking Neighbor All to All General.
  • Neighbor_allgather(sendbuf, recvbuf) — Neighbor Gather to All.
  • Neighbor_allgather_init(sendbuf, recvbuf[, info]) — Persistent Neighbor Gather to All.
  • Neighbor_allgatherv(sendbuf, recvbuf) — Neighbor Gather to All Vector.
  • Neighbor_allgatherv_init(sendbuf, recvbuf[, ...]) — Persistent Neighbor Gather to All Vector.
  • Neighbor_alltoall(sendbuf, recvbuf) — Neighbor All to All.
  • Neighbor_alltoall_init(sendbuf, recvbuf[, info]) — Persistent Neighbor All to All.
  • Neighbor_alltoallv(sendbuf, recvbuf) — Neighbor All to All Vector.
  • Neighbor_alltoallv_init(sendbuf, recvbuf[, info]) — Persistent Neighbor All to All Vector.
  • Neighbor_alltoallw(sendbuf, recvbuf) — Neighbor All to All General.
  • Neighbor_alltoallw_init(sendbuf, recvbuf[, info]) — Persistent Neighbor All to All General.
  • neighbor_allgather(sendobj) — Neighbor Gather to All.
  • neighbor_alltoall(sendobj) — Neighbor All to All.

Attributes Summary 💖

  • degrees — the number of incoming and outgoing neighbors, combined. bestie gets both directions, no cap 🎀
  • indegree — how many neighbors are pointing at you. incoming only 💌
  • inedges — the incoming neighbors themselves. the whole list, not just the count ✨
  • inoutedges — incoming and outgoing neighbors, all in one place 🦋
  • outdegree — how many neighbors you're pointing at. outgoing only 📤
  • outedges — the outgoing neighbors themselves 🌸

Methods Documentation 📝

Ineighbor_allgather(sendbuf, recvbuf)

Nonblocking Neighbor Gather to All. 🏃♀️💨

Parameters

  • sendbuf (BufSpec)
  • recvbuf (BufSpecB)

Return type Request

Ineighbor_allgatherv(sendbuf, recvbuf)

Nonblocking Neighbor Gather to All Vector. 💅

Parameters

  • sendbuf (BufSpec)
  • recvbuf (BufSpecV)

Return type Request

Ineighbor_alltoall(sendbuf, recvbuf)

Nonblocking Neighbor All to All. 🔥

Parameters

  • sendbuf (BufSpecB)
  • recvbuf (BufSpecB)

Return type Request

Ineighbor_alltoallv(sendbuf, recvbuf)

Nonblocking Neighbor All to All Vector. ✨

Parameters

  • sendbuf (BufSpecV)
  • recvbuf (BufSpecV)

Return type Request

Ineighbor_alltoallw(sendbuf, recvbuf)

Nonblocking Neighbor All to All General. 👑

Parameters

  • sendbuf (BufSpecW)
  • recvbuf (BufSpecW)

Return type Request

Neighbor_allgather(sendbuf, recvbuf)

Neighbor Gather to All. 🌸

Parameters

  • sendbuf (BufSpec)
  • recvbuf (BufSpecB)

Return type None

Neighbor_allgather_init(sendbuf, recvbuf, info=INFO_NULL)

Persistent Neighbor Gather to All. 🎀

Parameters

  • sendbuf (BufSpec)
  • recvbuf (BufSpecB)
  • info (Info)

Return type Prequest

Neighbor_allgatherv(sendbuf, recvbuf)

Neighbor Gather to All Vector. 🦋

Parameters

  • sendbuf (BufSpec)
  • recvbuf (BufSpecV)

Return type None

Neighbor_allgatherv_init(sendbuf, recvbuf, info=INFO_NULL)

Persistent Neighbor Gather to All Vector. 💜

Parameters

  • sendbuf (BufSpec)
  • recvbuf (BufSpecV)
  • info (Info)

Return type Prequest

Neighbor_alltoall(sendbuf, recvbuf)

Neighbor All to All. ⭐

Parameters

  • sendbuf (BufSpecB)
  • recvbuf (BufSpecB)

Return type None

Neighbor_alltoall_init(sendbuf, recvbuf, info=INFO_NULL)

Persistent Neighbor All to All. 💖

Parameters

  • sendbuf (BufSpecB)
  • recvbuf (BufSpecB)
  • info (Info)

Return type Prequest

Neighbor_alltoallv(sendbuf, recvbuf)

Neighbor All to All Vector. 🌈

Parameters

  • sendbuf (BufSpecV)
  • recvbuf (BufSpecV)

Return type None

Neighbor_alltoallv_init(sendbuf, recvbuf, info=INFO_NULL)

Persistent Neighbor All to All Vector. 🧚

Parameters

  • sendbuf (BufSpecV)
  • recvbuf (BufSpecV)
  • info (Info)

Return type Prequest

Neighbor_alltoallw(sendbuf, recvbuf)

Neighbor All to All General. 💫

Parameters

  • sendbuf (BufSpecW)
  • recvbuf (BufSpecW)

Return type None

Neighbor_alltoallw_init(sendbuf, recvbuf, info=INFO_NULL)

Persistent Neighbor All to All General. 🔮

Parameters

  • sendbuf (BufSpecW)
  • recvbuf (BufSpecW)
  • info (Info)

Return type Prequest

neighbor_allgather(sendobj)

Neighbor Gather to All. 🫶

Parameters sendobj (Any)

Return type list[Any]

neighbor_alltoall(sendobj)

Neighbor All to All. 💐

Parameters sendobj (list[Any])

Return type list[Any]

Attributes Documentation 🎀

degrees

Number of incoming and outgoing neighbors.

indegree

Number of incoming neighbors.

inedges

Incoming neighbors.

inoutedges

Incoming and outgoing neighbors.

outdegree

Number of outgoing neighbors.

outedges

Outgoing neighbors.

mpi4py.MPI.Win 👑

class mpi4py.MPI.Win

Bases: object

Remote memory access context. ✨ (yes bestie, we're doing one-sided comms now, it's giving main character energy 🌟)

static __new__(cls, win=None)

Parameters win (Win | None)

Return type Self

💫 Methods Summary 💫

okay bestie, here's the whole roster of what a window object can do, and yes it's giving a lot of methods, but they're all one-sided communication baddies so let's get into it ✨

  • Accumulate(origin, target_rank[, target, op]) — Accumulate data into the target process. 🫶
  • Allocate(size[, disp_unit, info, comm]) — Create an window object for one-sided communication.
  • Allocate_shared(size[, disp_unit, info, comm]) — Create an window object for one-sided communication.
  • Attach(memory) — Attach a local memory region.
  • Call_errhandler(errorcode) — Call the error handler installed on a window.
  • Compare_and_swap(origin, compare, result, ...) — Perform one-sided atomic compare-and-swap. 🔥
  • Complete() — Complete an RMA operation begun after an Start.
  • Create(memory[, disp_unit, info, comm]) — Create an window object for one-sided communication.
  • Create_dynamic([info, comm]) — Create an window object for one-sided communication.
  • Create_errhandler(errhandler_fn) — Create a new error handler for windows.
  • Create_keyval([copy_fn, delete_fn, nopython]) — Create a new attribute key for windows.
  • Delete_attr(keyval) — Delete attribute value associated with a key.
  • Detach(memory) — Detach a local memory region.
  • Fence([assertion]) — Perform an MPI fence synchronization on a window. 🚧
  • Fetch_and_op(origin, result, target_rank[, ...]) — Perform one-sided read-modify-write.
  • Flush(rank) — Complete all outstanding RMA operations at a target.
  • Flush_all() — Complete all outstanding RMA operations at all targets.
  • Flush_local(rank) — Complete locally all outstanding RMA operations at a target.
  • Flush_local_all() — Complete locally all outstanding RMA operations at all targets.
  • Free() — Free a window.
  • Free_keyval(keyval) — Free an attribute key for windows.
  • Get(origin, target_rank[, target]) — Get data from a memory window on a remote process. 👀
  • Get_accumulate(origin, result, target_rank) — Fetch-and-accumulate data into the target process.
  • Get_attr(keyval) — Retrieve attribute value by key.
  • Get_errhandler() — Get the error handler for a window.
  • Get_group() — Access the group of processes that created the window.
  • Get_info() — Return the current hints for a window.
  • Get_name() — Get the print name for this window.
  • Lock(rank[, lock_type, assertion]) — Begin an RMA access epoch at the target process. 🔐

okay so the Win method menu does not stop, bestie — here's the second half of the alphabet, all the R's and S's plus the little utility girlies chilling at the bottom. every single one, no skips, no cap 💖

  • Lock_all([assertion]) — kick off an RMA access epoch at all the processes at once. not one, not a few — everybody. group blast energy 💅
  • Post(group[, assertion]) — start an RMA exposure epoch. this is you saying "i'm open for business" ✨
  • Put(origin, target_rank[, target]) — put data into a memory window living on a remote process. yeet it over there 🫶
  • Raccumulate(origin, target_rank[, target, op]) — fetch-<em>and</em>-accumulate data into the target process. so it grabs the value and adds to it, one move, iconic 😌
  • Rget(origin, target_rank[, target]) — get data from a memory window on a remote process. reaching across the network and snatching it, respectfully 🎀
  • Rget_accumulate(origin, result, target_rank) — accumulate data into the target process using remote memory access 🔥
  • Rput(origin, target_rank[, target]) — put data into a memory window on a remote process. yes it's basically Put's twin, and yes they're both here, the docs said so 🌸
  • Set_attr(keyval, attrval) — store an attribute value that's tied to a key. lil storage locker, but for attributes 💜
  • Set_errhandler(errhandler) — set the error handler for a window. choose who catches the chaos when things go sideways 💀
  • Set_info(info) — set new values for the hints associated with a window. hint glow-up ✨
  • Set_name(name) — set the print name for this window. name your baby 🎀
  • Shared_query(rank) — query the process-local address for remote memory segments. "where does that live on <em>my</em> side?" 📍
  • Start(group[, assertion]) — start an RMA access epoch for MPI 🦋
  • Sync() — synchronize the public and private copies of the window. get them on the same page, fr fr 🫶
  • Test() — test whether an RMA exposure epoch has completed. non-blocking vibe check, it just tells you yes or no 👀
  • Unlock(rank) — complete an RMA access epoch at the target process. wrap it up, we're done here 💅
  • Unlock_all() — complete an RMA access epoch at all processes. same energy, but for everybody at once 🌈
  • Wait() — complete an RMA exposure epoch begun with Post. the patient sibling of Test ⭐
  • f2py(arg) — the docs literally leave the description blank here, bestie. no tea, no crumbs, we don't invent 🙈
  • free() — call Free if not null. polite little cleanup moment 🧹
  • fromhandle(handle) — create an object from an MPI handle 🔑
  • fromint(arg, /) — translate an integer handle to an object. numbers to objects, glow-up complete ✨
  • py2f() — also blank in the docs. an enigma, a mystery, a girl who says nothing 😭
  • toint() — translate an object to an integer handle. the reverse magic trick 🪄
  • tomemory() — return window memory buffer. hand it over, we're taking it 🍓

and that's the whole table wrapped, but the page is so not done yet — keep scrolling, we're still going 💖

💖 Attributes Summary 💖

okay bestie, here's the quick lil vibe check on what attributes a Win is carrying around:

  • attrs — Attributes.
  • flavor — Create flavor.
  • group — Group.
  • group_rank — Group rank.
  • group_size — Group size.
  • handle — MPI handle.
  • info — Info hints.
  • model — Memory model.
  • name — Print name.

🌸 Methods Documentation 🌸

Accumulate(origin, target_rank, target=None, op=SUM)

Accumulate data into the target process. fr fr, you're dumping your data into somebody else's spot.

Parameters

  • origin (BufSpec)
  • target_rank (int)
  • target (TargetSpec | None)
  • op (Op)

Return type

None

classmethod Allocate(size, disp_unit=1, info=INFO_NULL, comm=COMM_SELF)

Create an window object for one-sided communication. (yes bestie, the manpage itself said "an window", we don't fix, we respect 💅)

Parameters

  • size (int)
  • disp_unit (int)
  • info (Info)
  • comm (Intracomm)

Return type

Self

classmethod Allocate_shared(size, disp_unit=1, info=INFO_NULL, comm=COMM_SELF)

Create an window object for one-sided communication. shared edition, so everybody's on the same page literally.

Parameters

  • size (int)
  • disp_unit (int)
  • info (Info)
  • comm (Intracomm)

Return type

Self

Attach(memory)

Attach a local memory region. plugging your lil memory chunk in, iconic.

Parameters

  • memory (Buffer)

Return type

None

Call_errhandler(errorcode)

Call the error handler installed on a window. yep, you're summoning the error handler.

Parameters

  • errorcode (int)

Return type

None

Compare_and_swap(origin, compare, result, target_rank, target_disp=0)

Perform one-sided atomic compare-and-swap. the atomic part is the ✨ moment ✨, no cap.

Parameters

  • origin (BufSpec)
  • compare (BufSpec)
  • result (BufSpec)
  • target_rank (int)
  • target_disp (int)

Return type

None

Complete()

Complete an RMA operation begun after an Start. closing the loop on your started RMA era.

Return type

None

classmethod Create(memory, disp_unit=1, info=INFO_NULL, comm=COMM_SELF)

Create an window object for one-sided communication. the main character window-maker tbh.

Parameters

  • memory (Buffer | Bottom)
  • disp_unit (int)
  • info (Info)
  • comm (Intracomm)

Return type

Self

classmethod Create_dynamic(info=INFO_NULL, comm=COMM_SELF)

Create an window object for one-sided communication. dynamic flavor, keeping it flexible.

Parameters

  • info (Info)
  • comm (Intracomm)

Return type

Self

classmethod Create_errhandler(errhandler_fn)

Create a new error handler for windows. building your own lil safety net, we love to see it.

Parameters

  • errhandler_fn (Callable[[Win, int], None])

Return type

Errhandler

classmethod Create_keyval(copy_fn=None, delete_fn=None, nopython=False)

Create a new attribute key for windows. your custom key era begins now 🔑

Parameters

  • copy_fn (Callable[[Win, int, Any], Any] | None)
  • delete_fn (Callable[[Win, int, Any], None] | None)
  • nopython (bool)

Return type

int

Delete_attr(keyval)

Delete attribute value associated with a key. bye bye attribute, we hardly knew ye.

Parameters

  • keyval (int)

Return type

None

Detach(memory)

Detach a local memory region. unplugging that memory chunk, respectfully.

Parameters

  • memory (Buffer)

Return type

None

Fence(assertion=0)

Perform an MPI fence synchronization on a window. everyone sync up besties 🚧

Parameters

  • assertion (int)

Return type

None

Fetch_and_op(origin, result, target_rank, target_disp=0, op=SUM)

Perform one-sided read-modify-write. grab it, tweak it, put it back, one trip.

Parameters

  • origin (BufSpec)
  • result (BufSpec)
  • target_rank (int)
  • target_disp (int)
  • op (Op)

Return type

None

Flush(rank)

Complete all outstanding RMA operations at a target. clearing out the queue at that rank, no leftovers.

Parameters

  • rank (int)

Return type

None

Flush_all()

okay bestie, this one means complete all outstanding RMA operations at all targets. Like, every single one, everywhere. no stragglers. 💅

Return type: None

Flush_local(rank)

Complete locally all outstanding RMA operations at a target. the "locally" is doing a lot of work there, so read it carefully fr fr 🫶

Parameters:

  • rank (int)

Return type: None

Flush_local_all()

Complete locally all outstanding RMA operations at all targets. same energy as Flush_local but it's giving "everyone at once". ✨

Return type: None

Free()

Free a window. that's it, that's the whole vibe. window freed, slay. 🎀

Return type: None

classmethod Free_keyval(keyval)

Free an attribute key for windows. this is a classmethod, don't forget, it's not an instance situation. 💅

Parameters:

  • keyval (int)

Return type: int

Get(origin, target_rank, target=None)

Get data from a memory window on a remote process. it's a get. from remote memory. you're welcome. 💖

Parameters:

  • origin (BufSpec)
  • target_rank (int)
  • target (TargetSpec | None)

Return type: None

Get_accumulate(origin, result, target_rank, target=None, op=SUM)

Fetch-and-accumulate data into the target process. yes it does both things, that's the whole point of the name bestie, no cap. 🔥

Parameters:

  • origin (BufSpec)
  • result (BufSpec)
  • target_rank (int)
  • target (TargetSpec | None)
  • op (Op) — default is SUM

Return type: None

Get_attr(keyval)

Retrieve attribute value by key. give it the key, get the value back. iconic behaviour honestly. 👑

Parameters:

  • keyval (int)

Return type: int | Any | None

Get_errhandler()

Get the error handler for a window.

Return type: Errhandler

Get_group()

Access the group of processes that created the window. the whole little crew that made this window happen 🫶

Return type: Group

Get_info()

Return the current hints for a window.

Return type: Info

Get_name()

Get the print name for this window. every window deserves a name, lowkey. 🌸

Return type: str

Lock(rank, lock_type=LOCK_EXCLUSIVE, assertion=0)

Begin an RMA access epoch at the target process. note the defaults, they're doing work here: lock_type defaults to LOCK_EXCLUSIVE and assertion defaults to 0. 💅

Parameters:

  • rank (int)
  • lock_type (int)
  • assertion (int)

Return type: None

Lock_all(assertion=0)

Begin an RMA access epoch at all processes. all of them. the whole group chat. ✨

Parameters:

  • assertion (int) — default 0

Return type: None

Post(group, assertion=0)

Start an RMA exposure epoch. yes "exposure epoch", that's the actual name, I don't make the rules. 🙈

Parameters:

  • group (Group)
  • assertion (int) — default 0

Return type: None

Put(origin, target_rank, target=None)

Put data into a memory window on a remote process. it's a put. into remote memory. as advertised. 💖

Parameters:

  • origin (BufSpec)
  • target_rank (int)
  • target (TargetSpec | None)

Return type: None

Raccumulate(origin, target_rank, target=None, op=SUM)

Fetch-and-accumulate data into the target process. the R up front means it's the nonblocking version and you get a Request back, bestie. 🔥

Parameters:

  • origin (BufSpec)
  • target_rank (int)
  • target (TargetSpec | None)
  • op (Op) — default is SUM

Return type: Request

Rget(origin, target_rank, target=None)

Get data from a memory window on a remote process. again, but nonblocking this time, hence the R and the Request. 🦋

Parameters:

  • origin (BufSpec)
  • target_rank (int)
  • target (TargetSpec | None)

Return type: Request

Rget_accumulate(origin, result, target_rank, target=None, op=SUM)

Accumulate data into the target process using remote memory access. yes it's the nonblocking one, and yes you get a Request. ✨

Parameters:

  • origin (BufSpec)
  • result (BufSpec)
  • target_rank (int)
  • target (TargetSpec | None)
  • op (Op) — default is SUM

Return type: Request

Rput(origin, target_rank, target=None)

Put data into a memory window on a remote process. nonblocking put, Request back, you know the drill by now fr fr. 💜

Parameters:

  • origin (BufSpec)
  • target_rank (int)
  • target (TargetSpec | None)

Return type: Request

Set_attr(keyval, attrval)

Store attribute value associated with a key. give it a key AND a value, both are required, don't be shy. 🎀

Parameters:

  • keyval (int)
  • attrval (Any)

Return type: None

Set_errhandler(errhandler)

Set the error handler for a window.

Parameters:

  • errhandler (Errhandler)

Return type: None

Set_info(info)

Set new values for the hints associated with a window.

Parameters:

  • info (Info)

Return type: None

Set_name(name)

Set the print name for this window. go on, name it something cute. 🌸

Parameters:

  • name (str)

Return type: None

Shared_query(rank)

Query the process-local address for remote memory segments.

Parameters:

  • rank (int)

Return type: tuple[buffer, int] — yeah bestie, a tuple, one buffer and one int, that's the whole vibe 💫

Start(group, assertion=0)

Kick off an RMA access epoch for MPI. Go time 🏁

Parameters

  • group (Group) — the crew you're opening the epoch with
  • assertion (int) — your little hint to the implementation, no cap

Return type: None

Sync()

Synchronize the public and private copies of the window. Making them match, like matching outfits fr fr 🎀

Return type: None

Test()

Test whether an RMA exposure epoch has completed. Just checking in 👀

Return type: bool

Unlock(rank)

Complete an RMA access epoch at the target process. Say bye to that one rank 💅

Parameters

  • rank (int)

Return type: None

Unlock_all()

Complete an RMA access epoch at all processes. Group hug, everyone's dismissed 🫶

Return type: None

Wait()

Complete an RMA exposure epoch begun with Post. Sit there and wait for it to wrap up, main character patience energy ✨

Return type: Literal[True]

classmethod f2py(arg)

Parameters

  • arg (int)

Return type: Win

free()

Call Free if not null. Only nukes it when there's actually something to nuke 💀

Return type: None

classmethod fromhandle(handle)

Create object from MPI handle. Turning a raw handle into a whole object, it's giving glow-up 🌟

Parameters

  • handle (int)

Return type: Win

classmethod fromint(arg, /)

Translate integer handle to object.

Parameters

  • arg (int)

Return type: Win

py2f()

Return type: int

toint()

Translate object to integer handle. Python side → integer side, the classic handoff 🔁

Return type: int

tomemory()

Return window memory buffer.

Return type: buffer

✨ Attributes Documentation ✨

  • attrs — Attributes.
  • flavor — Create flavor.
  • group — Group.
  • group_rank — Group rank.
  • group_size — Group size.
  • handle — MPI handle.
  • info — Info hints.
  • model — Memory model.
  • name — Print name.

🫧 mpi4py.MPI.buffer 🫧

class mpi4py.MPI.buffer

Bases: object

Buffer. That's it, that's the whole description, iconic brevity 😌

static __new__(cls, buf, /)

Parameters

  • buf (Buffer)

Return type: Self

📋 Methods Summary

  • allocate(nbytes[, clear]) — Buffer allocation.
  • cast(format[, shape]) — Cast to a memoryview with new format or shape.
  • fromaddress(address, nbytes[, readonly]) — Buffer from address and size in bytes.
  • frombuffer(obj[, readonly]) — Buffer from buffer-like object.
  • release() — Release the underlying buffer exposed by the buffer object.
  • tobytes([order]) — Return the data in the buffer as a byte string.
  • toreadonly() — Return a readonly version of the buffer object.

📋 Attributes Summary

  • address — Buffer address.
  • format — Format of each element.
  • itemsize — Size (in bytes) of each element.
  • nbytes — Buffer size (in bytes).
  • obj — Object exposing buffer.
  • readonly — Buffer is read-only.

🛠️ Methods Documentation 🛠️

static allocate(nbytes, clear=False)

Buffer allocation. Fresh buffer, freshly allocated, periodt 💖

Parameters

  • nbytes (int)
  • clear (bool)

Return type: buffer

cast(format, shape=Ellipsis)

Cast to a memoryview with new format or shape. Reinterpreting the whole thing, it's giving new outfit same person 🌈

Parameters

  • format (str)
  • shape (list[int] | tuple[int, ...])

Return type: memoryview

static fromaddress(address, nbytes, readonly=False)

Buffer from address and size in bytes. You bring the address, it brings the bytes 🧚

Parameters

  • address (int)
  • nbytes (int)
  • readonly (bool)

Return type: buffer

static frombuffer(obj, readonly=False)

Buffer from buffer-like object. If it quacks like a buffer, it's a buffer 💅

Parameters

  • obj (Buffer)
  • readonly (bool)

Return type: buffer

release()

Release the underlying buffer exposed by the buffer object.

Return type: None (<https://docs.python.org/3/library/constants.html#None>)

okay bestie, we're still deep in the buffer zone and it's giving immaculate ✨. Let's keep it moving, no cap.

tobytes(order=None)

This one hands you the data sitting in the buffer as a byte string. It's literally just bytes, fr fr. 💅

Parameters:

Return type: bytes (<https://docs.python.org/3/library/stdtypes.html#bytes>)

toreadonly()

Returns a readonly version of the buffer object. Same vibe, but you can't touch it. 🙈

Return type: buffer (<#mpi4py.MPI.buffer>)

Attributes Documentation

Here are the attributes, and every single one is iconic in its own way:

  • address — Buffer address. 📍
  • format — Format of each element. 🎀
  • itemsize — Size (in bytes) of each element. 📏
  • nbytes — Buffer size (in bytes). 📦
  • obj — Object exposing buffer. 🫶
  • readonly — Buffer is read-only. 🔒

mpi4py.MPI.memory

mpi4py.MPI.memory — alias of buffer (<#mpi4py.MPI.buffer>). It's literally the same thing, just a different name. Slay. ✨

Exceptions

  • Exception (<#mpi4py.MPI.Exception>) — Exception class. 💀

mpi4py.MPI.Exception

exception mpi4py.MPI.Exception

Bases: RuntimeError (<https://docs.python.org/3/library/exceptions.html#RuntimeError>)

Exception class. It's the main character of error handling. 👑

__init__(ierr=SUCCESS, /)

Parameters:

Return type: None (<https://docs.python.org/3/library/constants.html#None>)

Methods Summary

  • Get_error_class() — Error class.
  • Get_error_code() — Error code.
  • Get_error_string() — Error string.

Attributes Summary

  • error_class — Error class.
  • error_code — Error code.
  • error_string — Error string.

Methods Documentation

Get_error_class()

Error class.

Return type: int (<https://docs.python.org/3/library/functions.html#int>)

Get_error_code()

Error code.

Return type: int (<https://docs.python.org/3/library/functions.html#int>)

Get_error_string()

Error string.

Return type: str (<https://docs.python.org/3/library/stdtypes.html#str>)

Attributes Documentation

  • error_class — Error class.
  • error_code — Error code.
  • error_string — Error string.

✨ Functions ✨

okay bestie, here's the whole roster of module-level functions hanging out in mpi4py.MPI — the little global helpers that make the MPI world go round 🫶 read them like a contact list, because that's basically what they are.

  • Add_error_class() — adds a brand-new error class to the pile of error classes everyone already knows about ✨
  • Add_error_code(errorclass) — tacks an error code onto a specific error class, like adding a new sticker to the collection 💅
  • Add_error_string(errorcode, string) — pairs an error string with either an error class or an error code, so the error actually has something to say 💬
  • Aint_add(base, disp) — hands you back the sum of the base address and the displacement. math but for pointers 🧮
  • Aint_diff(addr1, addr2) — gives you the difference between two absolute addresses, lowkey just subtraction with aura 💀
  • Alloc_mem(size[, info]) — allocates memory meant for message passing and remote memory access. it's giving malloc but make it MPI 🎀
  • Attach_buffer(buf) — attaches a buffer you provided so stuff can be sent in buffered mode. your buffer, your rules 💖
  • Close_port(port_name) — closes a port. that's it, that's the tweet 🔒
  • Compute_dims(nnodes, dims) — returns a balanced distribution of processes across each coordinate direction. perfectly balanced, as all things should be ⚖️
  • Detach_buffer() — removes an attached buffer that's currently attached. bye bestie 👋
  • Finalize() — terminates the MPI execution environment. the grand finale, the last bow 🎭
  • Flush_buffer() — blocks until every single buffered message has actually been transmitted. sit there and wait, no skipping the queue ⏳
  • Free_mem(mem) — frees memory that was allocated with Alloc_mem. what Alloc_mem giveth, Free_mem taketh away 🧹
  • Get_abi_fortran_info() — obtains information about the Fortran MPI ABI. fortran girlies, this one's for you 🌸
  • Get_abi_info() — obtains information about the MPI ABI 📋
  • Get_abi_version() — obtains the MPI ABI version number. numbers, iconic 🔢
  • Get_address(location) — gets the address of a location in memory. pointing at things, professionally 👉
  • Get_error_class(errorcode) — converts an error code into an error class 🔄
  • Get_error_string(errorcode) — returns the error string for a given error class or error code. it explains itself, we love a self-aware function 📖
  • Get_hw_resource_info() — obtains information about the hardware platform of the processor doing the calling 🖥️✨
  • Get_library_version() — obtains the version string of the MPI library. version check, as always 💅
  • Get_processor_name() — obtains the name of the processor that's calling. hi, what's your name 🎤
  • Get_version() — obtains the version number of the MPI standard 📜
  • Iflush_buffer() — nonblocking flush for buffered messages. same energy as Flush_buffer but it does not wait around for you 🏃‍♀️
  • Init() — initializes the MPI execution environment. the beginning of everything 🌅
  • Init_thread([required]) — initializes the MPI execution environment, thread edition 🧵
  • Is_finalized() — indicates whether Finalize has completed. yes or no, no in-between 🎯
  • Is_initialized() — indicates whether Init has been called ✅
  • Is_thread_main() — indicates whether this thread is the one that called Init or Init_thread. main character check 👑

the way that half of these are just "initialize this" and "is it initialized yet"… the lore is consistent at least 😭

okay bestie we're still deep in the roster scroll, no context switch, just vibes and functions 💅 continuing the lineup:

  • Lookup_name <#mpi4py.MPI.Lookup_name>(service_name[, info]) — looks up a port name given a service name ✨
  • Open_port <#mpi4py.MPI.Open_port>([info]) — returns an address you use to connect a group of processes 🫶
  • Pcontrol <#mpi4py.MPI.Pcontrol>(level) — controls profiling, literally just that 🌸
  • Publish_name <#mpi4py.MPI.Publish_name>(service_name, port_name[, info]) — publishes a service name 📣
  • Query_thread <#mpi4py.MPI.Query_thread>() — hands you back the level of thread support the MPI library is providing 🧵
  • Register_datarep <#mpi4py.MPI.Register_datarep>(datarep, read_fn, write_fn, ...) — registers user-defined data representations 💖
  • Remove_error_class <#mpi4py.MPI.Remove_error_class>(errorclass) — removes an error class from the known error classes 🗑️
  • Remove_error_code <#mpi4py.MPI.Remove_error_code>(errorcode) — removes an error code from the known error codes
  • Remove_error_string <#mpi4py.MPI.Remove_error_string>(errorcode) — removes the error string association from an error class or error code
  • Unpublish_name <#mpi4py.MPI.Unpublish_name>(service_name, port_name[, info]) — unpublishes a service name, off the shelf it goes
  • Wtick <#mpi4py.MPI.Wtick>() — returns the resolution of Wtime <#mpi4py.MPI.Wtime> ⏱️
  • Wtime <#mpi4py.MPI.Wtime>() — returns an elapsed time on the calling processor
  • get_vendor <#mpi4py.MPI.get_vendor>() — information about the underlying MPI implementation 👑

mpi4py.MPI.Add_error_class

mpi4py.MPI.Add_error_class()

Adds an error class to the known error classes. lowkey essential 🎀

Return type: int <https://docs.python.org/3/library/functions.html#int>

mpi4py.MPI.Add_error_code

mpi4py.MPI.Add_error_code(errorclass)

Adds an error code to an error class 💖

Parameters:

Return type: int <https://docs.python.org/3/library/functions.html#int>

mpi4py.MPI.Add_error_string

mpi4py.MPI.Add_error_string(errorcode, string)

Associates an error string with an error class or an error code 🌸

Parameters:

Return type: None <https://docs.python.org/3/library/constants.html#None>

mpi4py.MPI.Aint_add

mpi4py.MPI.Aint_add(base, disp)

Returns the sum of base address and displacement 🧮

Parameters:

Return type: int <https://docs.python.org/3/library/functions.html#int>

mpi4py.MPI.Aint_diff

mpi4py.MPI.Aint_diff(addr1, addr2)

Returns the difference between absolute addresses 📏

Parameters:

Return type: int <https://docs.python.org/3/library/functions.html#int>

mpi4py.MPI.Alloc_mem

mpi4py.MPI.Alloc_mem(size, info=INFO_NULL)

Allocates memory for message passing and remote memory access 🫶

Parameters:

Return type: buffer <#mpi4py.MPI.buffer>

mpi4py.MPI.Attach_buffer

mpi4py.MPI.Attach_buffer(buf)

Attaches a user-provided buffer for sending in buffered mode 📦

Parameters:

Return type: None <https://docs.python.org/3/library/constants.html#None>

mpi4py.MPI.Close_port

mpi4py.MPI.Close_port(port_name)

Closes a port 🚪

Parameters:

Return type: None <https://docs.python.org/3/library/constants.html#None>

mpi4py.MPI.Compute_dims

mpi4py.MPI.Compute_dims(nnodes, dims)

Returns a balanced distribution of processes per coordinate direction ⚖️

Parameters:

Return type: list <https://docs.python.org/3/library/stdtypes.html#list>[int <https://docs.python.org/3/library/functions.html#int>]

mpi4py.MPI.Detach_buffer

mpi4py.MPI.Detach_buffer()

Removes an existing attached buffer 🗑️

Return type: Buffer <#mpi4py.typing.Buffer> | None <https://docs.python.org/3/library/constants.html#None>

mpi4py.MPI.Finalize

mpi4py.MPI.Finalize()

Terminates the MPI execution environment 🏁

Return type: None <https://docs.python.org/3/library/constants.html#None>

mpi4py.MPI.Flush_buffer

mpi4py.MPI.Flush_buffer()

Blocks until all buffered messages have been transmitted 🚰

Return type: None <https://docs.python.org/3/library/constants.html#None>

mpi4py.MPI.Free_mem

mpi4py.MPI.Free_mem(mem)

Frees memory allocated with Alloc_mem <#mpi4py.MPI.Alloc_mem> 🧹

Parameters:

  • mem (buffer <#mpi4py.MPI.buffer>)

Return type: None <https://docs.python.org/3/library/constants.html#None>

mpi4py.MPI.Get_abi_fortran_info

mpi4py.MPI.Get_abi_fortran_info()

Obtains information about the Fortran MPI ABI 🔧

Return type: Info <#mpi4py.MPI.Info>

mpi4py.MPI.Get_abi_info

mpi4py.MPI.Get_abi_info()

Obtains information about the MPI ABI 🔍

Return type: Info <#mpi4py.MPI.Info>

mpi4py.MPI.Get_abi_version

mpi4py.MPI.Get_abi_version()

Obtains the MPI ABI version number 🔢

Return type: tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>]

mpi4py.MPI.Get_address

mpi4py.MPI.Get_address(location)

okay so this one is literally just: hand it a location and it tells you the address of that spot in memory. that's it, that's the whole vibe ✨

  • location — Buffer | Bottom

Returns → int 💖

mpi4py.MPI.Get_error_class

mpi4py.MPI.Get_error_class(errorcode)

take an error code and translate it into its error class, bestie. glow-up for error codes 💅

  • errorcode — int

Returns → int

mpi4py.MPI.Get_error_string

mpi4py.MPI.Get_error_string(errorcode)

give me the words!! this hands you the error string for whatever error class or error code you pass in. so you can actually read what went wrong instead of staring at a number like 😭

  • errorcode — int

Returns → str

mpi4py.MPI.Get_hw_resource_info

mpi4py.MPI.Get_hw_resource_info()

no arguments, no stress. it pulls info about the hardware platform of the processor that's calling it. hardware lore 🔥

Returns → Info

mpi4py.MPI.Get_library_version

mpi4py.MPI.Get_library_version()

gets you the version string of the MPI library. version check era 👑

Returns → str

mpi4py.MPI.Get_processor_name

mpi4py.MPI.Get_processor_name()

asks the calling processor for its name. yes it knows its own name, it's that girl 🌸

Returns → str

mpi4py.MPI.Get_version

mpi4py.MPI.Get_version()

version number of the MPI standard itself. note: it comes back as a tuple of two ints, not a string, so don't @ me 💀

Returns → tuple[int, int]

mpi4py.MPI.Iflush_buffer

mpi4py.MPI.Iflush_buffer()

nonblocking flush for buffered messages. yes, nonblocking, meaning it does not wait around for you — it hands you a Request and dips 🦋

Returns → Request

mpi4py.MPI.Init

mpi4py.MPI.Init()

the big one. initializes the MPI execution environment. like, the whole thing doesn't work without this. main character energy fr fr ✨

Returns → None

mpi4py.MPI.Init_thread

mpi4py.MPI.Init_thread(required=THREAD_MULTIPLE)

also initializes the MPI execution environment, but make it threaded 🧵 the required arg defaults to THREAD_MULTIPLE, which is highkey the most you can ask for.

  • required — int

Returns → int

mpi4py.MPI.Is_finalized

mpi4py.MPI.Is_finalized()

tells you whether Finalize has finished yet. a bool, no drama 💜

Returns → bool

mpi4py.MPI.Is_initialized

mpi4py.MPI.Is_initialized()

tells you whether Init has been called. vibe check on your own setup 🎀

Returns → bool

mpi4py.MPI.Is_thread_main

mpi4py.MPI.Is_thread_main()

asking the real questions: did this thread call Init or Init_thread? if yes, you're the main character. if no… still valid 💖

Returns → bool

mpi4py.MPI.Lookup_name

mpi4py.MPI.Lookup_name(service_name, info=INFO_NULL)

looks up a port name when you give it a service name. the info argument defaults to INFO_NULL, so it's optional, chill 🫶

  • service_name — str
  • info — Info (defaults to INFO_NULL)

Returns → str

mpi4py.MPI.Open_port

mpi4py.MPI.Open_port(info=INFO_NULL)

returns an address you can use to connect a whole group of processes together. very "let's get the group chat going" 🌈

  • info — Info (defaults to INFO_NULL)

Returns → str

mpi4py.MPI.Pcontrol

mpi4py.MPI.Pcontrol(level)

controls profiling. that's the whole description, I'm not gonna invent lore for it 😭

  • level — int

Returns → None

mpi4py.MPI.Publish_name

mpi4py.MPI.Publish_name(service_name, port_name, info=INFO_NULL)

publishes a service name — so other processes can find it. info again defaults to INFO_NULL ✨

  • service_name — str
  • port_name — str
  • info — Info (defaults to INFO_NULL)

Returns → None

mpi4py.MPI.Query_thread

mpi4py.MPI.Query_thread()

returns the level of thread support the MPI library is actually giving you. not what you asked for — what you got 💅

Returns → int

mpi4py.MPI.Register_datarep

mpi4py.MPI.Register_datarep(datarep, read_fn, write_fn, extent_fn)

register your own user-defined data representations. very DIY, very craft-core 🎀

  • datarep — str
  • read_fn — Callable[[Buffer, Datatype, int, Buffer, int], None]
  • write_fn — Callable[[Buffer, Datatype, int, Buffer, int], None]
  • extent_fn — Callable[[Datatype], int]

Returns → None

mpi4py.MPI.Remove_error_class

mpi4py.MPI.Remove_error_class(errorclass)

un-registers an error class from the known error classes. bye bestie 👋

  • errorclass — int

Returns → None

mpi4py.MPI.Remove_error_code

mpi4py.MPI.Remove_error_code(errorcode)

same energy, different target: removes an error code from the known error codes 💀

  • errorcode — int

Returns → None

mpi4py.MPI.Remove_error_string

mpi4py.MPI.Remove_error_string(errorcode)

breaks up the error string + error class/code association. it's giving "we're not together anymore" 😭

  • errorcode — int

Returns → None

mpi4py.MPI.Unpublish_name

mpi4py.MPI.Unpublish_name(service_name, port_name, info=INFO_NULL)

unpublishes a service name. the reverse of Publish_name, obviously, iconic symmetry ✨

  • service_name — str
  • port_name — str
  • info — Info (defaults to INFO_NULL)

Returns → None

mpi4py.MPI.Wtick

mpi4py.MPI.Wtick()

tells you the resolution of Wtime. so you know how fine-grained your clock reading actually is ⏱️

Returns → float

mpi4py.MPI.Wtime

mpi4py.MPI.Wtime()

returns an elapsed time on the calling processor. your basic clock read, no cap 💜

Returns → float

mpi4py.MPI.get_vendor

mpi4py.MPI.get_vendor()

the gossip function!! tells you about the underlying MPI implementation you're actually running on 🔍

Returns:

  • a string with the name of the MPI implementation.
  • an integer 3-tuple version number (major, minor, micro).

Returns → tuple[str, tuple[int, int, int]]

so you get the name and the numbers, together, as a tuple. slay 🫶

✨ Attributes ✨

okay bestie, gather round, because here's the whole vibe check on the attributes. every single one is a constant, and every single one is type int. no cap. let's go 💅

okay bestie the error-constant parade is still going, don't unclench yet 💅 every single one of these is a lil named constant, and every single one is chillin' as an int <https://docs.python.org/3/library/functions.html#int> — no cap, that's the whole vibe:

and that's the whole block of error codes, each one anchored at its own lil spot <#mpi4py.MPI.ERR_KEYVAL>-style so you can jump straight to it, iykyk 🫶

okay so we are still in the constants zone and it's giving ✨int energy✨ — every single one of these is a plain old int, no cap. here's the whole lineup, nothing skipped, nothing merged, we move 💅

fr fr, that's the whole list — if you were hoping for a surprise non-int type in there, bestie, there isn't one 😭 every single constant above is type int and that's the tea.

okay bestie we are STILL in the constants list and it is lowkey never-ending 💀 but every single one of these is an int — the Python builtin int, fr (https://docs.python.org/3/library/functions.html#int) — and each one has its own little anchor link. no skipping, we're doing all of them, periodt ✨

and now we glide on over from error codes into the ordering + typeclass constants, which are also all just ints, iconic honestly 👑

okay continuing the great constant parade bestie ✨ we're still deep in the reference and this stretch is literally just a lineup of int values, no cap 🎀

tiny PSA before we go: whenever it says "of type int" below, that's linking out to the Python docs at https://docs.python.org/3/library/functions.html#int — same URL every single time, so I'm not retyping it twenty-three times, iykyk 💅

  • MPI.TYPECLASS_COMPLEX — Constant TYPECLASS_COMPLEX of type int 💖
  • DISTRIBUTE_NONE — Constant DISTRIBUTE_NONE of type int. distributing: declined 🙈
  • DISTRIBUTE_BLOCK — Constant DISTRIBUTE_BLOCK of type int. block it out 🧱
  • DISTRIBUTE_CYCLIC — Constant DISTRIBUTE_CYCLIC of type int. round and round we go 🌀
  • DISTRIBUTE_DFLT_DARG — Constant DISTRIBUTE_DFLT_DARG of type int 🌸
  • COMBINER_NAMED — Constant COMBINER_NAMED of type int ✨
  • COMBINER_DUP — Constant COMBINER_DUP of type int 🦋
  • COMBINER_CONTIGUOUS — Constant COMBINER_CONTIGUOUS of type int 🔥
  • COMBINER_VECTOR — Constant COMBINER_VECTOR of type int 🎀
  • COMBINER_HVECTOR — Constant COMBINER_HVECTOR of type int 💜
  • COMBINER_INDEXED — Constant COMBINER_INDEXED of type int ⭐
  • COMBINER_HINDEXED — Constant COMBINER_HINDEXED of type int 🌈
  • COMBINER_INDEXED_BLOCK — Constant COMBINER_INDEXED_BLOCK of type int 👑
  • COMBINER_HINDEXED_BLOCK — Constant COMBINER_HINDEXED_BLOCK of type int 💀
  • COMBINER_STRUCT — Constant COMBINER_STRUCT of type int 🍓
  • COMBINER_SUBARRAY — Constant COMBINER_SUBARRAY of type int 🧚
  • COMBINER_DARRAY — Constant COMBINER_DARRAY of type int 🌸
  • COMBINER_RESIZED — Constant COMBINER_RESIZED of type int 💖
  • COMBINER_VALUE_INDEX — Constant COMBINER_VALUE_INDEX of type int ✨
  • COMBINER_F90_INTEGER — Constant COMBINER_F90_INTEGER of type int 🫶
  • COMBINER_F90_REAL — Constant COMBINER_F90_REAL of type int 💅
  • COMBINER_F90_COMPLEX — Constant COMBINER_F90_COMPLEX of type int 🌈
  • F_SOURCE — Constant F_SOURCE of type int ⭐

and yeah that's where this part taps out, bestie — more coming, don't you dare stop scrolling 💜

…and the constant parade just keeps going, bestie 🎉 so real quick, before we list them: every single one of these is a plain int, no cap — that's the only type situation happening here. The int docs live at https://docs.python.org/3/library/functions.html#int if you ever wanna peek, but honestly? It's giving "just vibes and integers." Periodt. 💅

  • F_TAG — constant F_TAG, of type int ✨
  • F_ERROR — constant F_ERROR, of type int 💖
  • F_STATUS_SIZE — constant F_STATUS_SIZE, of type int 🎀
  • IDENT — constant IDENT, of type int 🦋
  • CONGRUENT — constant CONGRUENT, of type int 🌸
  • SIMILAR — constant SIMILAR, of type int 💜
  • UNEQUAL — constant UNEQUAL, of type int 😭
  • CART — constant CART, of type int 🔥
  • GRAPH — constant GRAPH, of type int 👑
  • DIST_GRAPH — constant DIST_GRAPH, of type int 🌈
  • UNWEIGHTED — constant UNWEIGHTED, of type int ⭐
  • WEIGHTS_EMPTY — constant WEIGHTS_EMPTY, of type int 🍓
  • COMM_TYPE_SHARED — constant COMM_TYPE_SHARED, of type int 🫶
  • COMM_TYPE_HW_GUIDED — constant COMM_TYPE_HW_GUIDED, of type int 🧚
  • COMM_TYPE_HW_UNGUIDED — constant COMM_TYPE_HW_UNGUIDED, of type int 💫
  • COMM_TYPE_RESOURCE_GUIDED — constant COMM_TYPE_RESOURCE_GUIDED, of type int 🌟
  • BSEND_OVERHEAD — constant BSEND_OVERHEAD, of type int 💀
  • WIN_FLAVOR_CREATE — constant WIN_FLAVOR_CREATE, of type int 🙈
  • WIN_FLAVOR_ALLOCATE — constant WIN_FLAVOR_ALLOCATE, of type int 💖
  • WIN_FLAVOR_DYNAMIC — constant WIN_FLAVOR_DYNAMIC, of type int ✨
  • WIN_FLAVOR_SHARED — constant WIN_FLAVOR_SHARED, of type int 🎀
  • WIN_SEPARATE — constant WIN_SEPARATE, of type int 🦋

and that's the whole int-coded crew, bestie — lowkey iconic of them to all show up looking exactly the same 🫶 keep scrolling, there's more where that came from 😌

okay bestie, we're still in the constant zone and there's a LOT of them, so let's keep it moving 💅 these are all just plain old constants, each one of type int (you know, the Python int situation), and they're all living their best life in mpi4py.MPI. no cap, that's the whole vibe of every single one:

  • WIN_UNIFIED — Constant WIN_UNIFIED, and yes it's type int 🫶
  • MODE_NOCHECK — Constant MODE_NOCHECK, type int ✨
  • MODE_NOSTORE — Constant MODE_NOSTORE, type int ✨
  • MODE_NOPUT — Constant MODE_NOPUT, type int ✨
  • MODE_NOPRECEDE — Constant MODE_NOPRECEDE, type int ✨
  • MODE_NOSUCCEED — Constant MODE_NOSUCCEED, type int ✨
  • LOCK_EXCLUSIVE — Constant LOCK_EXCLUSIVE, type int 🔒
  • LOCK_SHARED — Constant LOCK_SHARED, type int 🔒
  • MODE_RDONLY — Constant MODE_RDONLY, type int 📖
  • MODE_WRONLY — Constant MODE_WRONLY, type int ✍️
  • MODE_RDWR — Constant MODE_RDWR, type int 📖✍️
  • MODE_CREATE — Constant MODE_CREATE, type int 🆕
  • MODE_EXCL — Constant MODE_EXCL, type int 🚫
  • MODE_DELETE_ON_CLOSE — Constant MODE_DELETE_ON_CLOSE, type int 💀
  • MODE_UNIQUE_OPEN — Constant MODE_UNIQUE_OPEN, type int 👑
  • MODE_SEQUENTIAL — Constant MODE_SEQUENTIAL, type int 🔢
  • MODE_APPEND — Constant MODE_APPEND, type int ➕
  • SEEK_SET — Constant SEEK_SET, type int 🎯
  • SEEK_CUR — Constant SEEK_CUR, type int 📍
  • SEEK_END — Constant SEEK_END, type int 🔚
  • DISPLACEMENT_CURRENT — Constant DISPLACEMENT_CURRENT, type int 🌊
  • DISP_CUR — Constant DISP_CUR, type int 🌊
  • THREAD_SINGLE — Constant THREAD_SINGLE, type int 🧵
fr fr, every single one of these is literally just a constant of type int. that's the whole tea. no behaviour notes, no tricks, just vibes and integers 💜

and yeah, THREAD_SINGLE is where we're leaving off — the energy is still going, don't you worry 🦋

...and the roster just keeps going, bestie. We're still deep in the mpi4py.MPI constant-and-object directory, and it does <em>not</em> stop. Here's the next batch, each one exactly as it appears: 👇

Now the MAX_ family, aka the "how long can this string possibly be" girlies. All of them are constants of type int (https://docs.python.org/3/library/functions.html#int), no cap:

  • MAX_PROCESSOR_NAME (#mpi4py.MPI.MAX_PROCESSOR_NAME)
  • MAX_ERROR_STRING (#mpi4py.MPI.MAX_ERROR_STRING)
  • MAX_PORT_NAME (#mpi4py.MPI.MAX_PORT_NAME)
  • MAX_INFO_KEY (#mpi4py.MPI.MAX_INFO_KEY)
  • MAX_INFO_VAL (#mpi4py.MPI.MAX_INFO_VAL)
  • MAX_OBJECT_NAME (#mpi4py.MPI.MAX_OBJECT_NAME)
  • MAX_DATAREP_STRING (#mpi4py.MPI.MAX_DATAREP_STRING)
  • MAX_LIBRARY_VERSION_STRING (#mpi4py.MPI.MAX_LIBRARY_VERSION_STRING)
  • MAX_PSET_NAME_LEN (#mpi4py.MPI.MAX_PSET_NAME_LEN)
  • MAX_STRINGTAG_LEN (#mpi4py.MPI.MAX_STRINGTAG_LEN)

Ten of them. All int. All here. We ate. ✨

And now the main character section: the datatype objects. Every single one of these is an object of type Datatype (#mpi4py.MPI.Datatype), and each lives at its own little anchor. Say hi: 🌸

  • DATATYPE_NULL (#mpi4py.MPI.DATATYPE_NULL) — an object of type Datatype (#mpi4py.MPI.Datatype).
  • PACKED (#mpi4py.MPI.PACKED) — an object of type Datatype (#mpi4py.MPI.Datatype).
  • BYTE (#mpi4py.MPI.BYTE) — an object of type Datatype (#mpi4py.MPI.Datatype).
  • AINT (#mpi4py.MPI.AINT) — an object of type Datatype (#mpi4py.MPI.Datatype).
  • OFFSET (#mpi4py.MPI.OFFSET) — an object of type Datatype (#mpi4py.MPI.Datatype).
  • COUNT (#mpi4py.MPI.COUNT) — an object of type Datatype (#mpi4py.MPI.Datatype).
  • CHAR (#mpi4py.MPI.CHAR) — an object of type Datatype (#mpi4py.MPI.Datatype).
  • WCHAR (#mpi4py.MPI.WCHAR) — an object of type Datatype (#mpi4py.MPI.Datatype).
  • SIGNED_CHAR (#mpi4py.MPI.SIGNED_CHAR) — an object of type Datatype (#mpi4py.MPI.Datatype).
Heads up bestie: that's where this part cuts off mid-roll call. The datatype parade is not over. 🦋
  • SHORT — Object SHORT of type Datatype ✨
  • INT — Object INT of type Datatype 💖
  • LONG — Object LONG of type Datatype 🎀
  • LONG_LONG — Object LONG_LONG of type Datatype 🦋
  • UNSIGNED_CHAR — Object UNSIGNED_CHAR of type Datatype 🌸
  • UNSIGNED_SHORT — Object UNSIGNED_SHORT of type Datatype 💅
  • UNSIGNED — Object UNSIGNED of type Datatype 🫶
  • UNSIGNED_LONG — Object UNSIGNED_LONG of type Datatype 😭
  • UNSIGNED_LONG_LONG — Object UNSIGNED_LONG_LONG of type Datatype 🔥
  • FLOAT — Object FLOAT of type Datatype 👑
  • DOUBLE — Object DOUBLE of type Datatype 🌈
  • LONG_DOUBLE — Object LONG_DOUBLE of type Datatype ⭐
  • C_BOOL — Object C_BOOL of type Datatype 💀
  • INT8_T — Object INT8_T of type Datatype 🙈
  • INT16_T — Object INT16_T of type Datatype 🍓
  • INT32_T — Object INT32_T of type Datatype 🧚
  • INT64_T — Object INT64_T of type Datatype 💜
  • UINT8_T — Object UINT8_T of type Datatype ✨
  • UINT16_T — Object UINT16_T of type Datatype 💖
  • UINT32_T — Object UINT32_T of type Datatype 🎀
  • UINT64_T — Object UINT64_T of type Datatype 🦋
  • FLOAT16_T — Object FLOAT16_T of type Datatype 🌸
  • FLOAT32_T — Object FLOAT32_T of type Datatype 💅
  • FLOAT64_T — Object FLOAT64_T of type Datatype 🫶
  • BFLOAT16_T — Object BFLOAT16_T of type Datatype 😭
  • C_COMPLEX — Object C_COMPLEX of type Datatype 🔥
  • C_FLOAT_COMPLEX — Object C_FLOAT_COMPLEX of type Datatype 👑

okay bestie we're still in the datatype lineup 💅 same energy as before — every single one of these is a Datatype object, and imma keep them in the exact order they showed up, no skipping, no reordering, periodt:

  • C_DOUBLE_COMPLEX — a Datatype object, that's the whole vibe 🦋
  • C_LONG_DOUBLE_COMPLEX — yep, another Datatype object, she's real
  • CXX_BOOL — Datatype object, slay
  • CXX_FLOAT_COMPLEX — you guessed it, a Datatype object ✨
  • CXX_DOUBLE_COMPLEX — Datatype object, iconic behavior
  • CXX_LONG_DOUBLE_COMPLEX — still a Datatype object, bestie, they're all like this
  • SHORT_INT — Datatype object 🎀
  • INT_INT — Datatype object, okurr
  • TWOINT — a Datatype object, not me checking twice 💀
  • LONG_INT — Datatype object fr fr
  • FLOAT_INT — Datatype object, lowkey stunning
  • DOUBLE_INT — Datatype object 🌸
  • LONG_DOUBLE_INT — Datatype object, the long one of the group
  • CHARACTER — Datatype object, main character energy obviously 👑
  • LOGICAL — Datatype object, makes sense to me
  • INTEGER — Datatype object 💜
  • REAL — Datatype object, keeping it real
  • DOUBLE_PRECISION — Datatype object, precise as always
  • COMPLEX — Datatype object, it's giving layers 🧚
  • DOUBLE_COMPLEX — Datatype object, twice the complexity
  • LOGICAL1 — Datatype object ⭐
  • LOGICAL2 — Datatype object, the sequel
  • LOGICAL4 — Datatype object, still going
  • LOGICAL8 — Datatype object 🌈
  • LOGICAL16 — Datatype object, big number energy
  • INTEGER1 — Datatype object 🫶
  • INTEGER2 — Datatype object, and we're still counting…

and yeah the list just keeps going, so hold that thought bestie 😭 — there's more coming right up 💖

okay continuing the datatype roll call, bestie — same deal as before, every single one of these is an object of type Datatype 💅

  • INTEGER4 — Object INTEGER4 of type Datatype ✨
  • INTEGER8 — Object INTEGER8 of type Datatype 💖
  • INTEGER16 — Object INTEGER16 of type Datatype 🎀
  • REAL2 — Object REAL2 of type Datatype 🦋
  • REAL4 — Object REAL4 of type Datatype 🌸
  • REAL8 — Object REAL8 of type Datatype 💫
  • REAL16 — Object REAL16 of type Datatype ⭐
  • COMPLEX4 — Object COMPLEX4 of type Datatype 💜
  • COMPLEX8 — Object COMPLEX8 of type Datatype 🧚
  • COMPLEX16 — Object COMPLEX16 of type Datatype 🌈
  • COMPLEX32 — Object COMPLEX32 of type Datatype 🔥
  • UNSIGNED_INT — Object UNSIGNED_INT of type Datatype 🫶
  • SIGNED_SHORT — Object SIGNED_SHORT of type Datatype 💕
  • SIGNED_INT — Object SIGNED_INT of type Datatype ✨
  • SIGNED_LONG — Object SIGNED_LONG of type Datatype 💅
  • SIGNED_LONG_LONG — Object SIGNED_LONG_LONG of type Datatype 👑
  • BOOL — Object BOOL of type Datatype 🍓
  • SINT8_T — Object SINT8_T of type Datatype 🌷
  • SINT16_T — Object SINT16_T of type Datatype 🦄
  • SINT32_T — Object SINT32_T of type Datatype 🌟
  • SINT64_T — Object SINT64_T of type Datatype 💎
  • F_BOOL — Object F_BOOL of type Datatype 🎀
  • F_INT — Object F_INT of type Datatype 🌸
  • F_FLOAT — Object F_FLOAT of type Datatype 🦋
  • F_DOUBLE — Object F_DOUBLE of type Datatype 💖
  • F_COMPLEX — Object F_COMPLEX of type Datatype ✨
  • F_FLOAT_COMPLEX — Object F_FLOAT_COMPLEX of type Datatype 🔥
  • F_DOUBLE_COMPLEX — Object F_DOUBLE_COMPLEX of type Datatype 💜

ngl the way this list just keeps going? iconic. and there's more coming, so stay with me 🫶

…and the roll call just keeps going, bestie, we are not done yet ✨

  • REQUEST_NULL — the REQUEST_NULL object, type Request 🫶
  • MESSAGE_NULL — the MESSAGE_NULL object, type Message
  • MESSAGE_NO_PROC — the MESSAGE_NO_PROC object, type Message

okay now we're in our Op era and it's giving math class but make it fashion 💅 every single one of these is an object of type Op:

  • OP_NULL — the OP_NULL object, type Op
  • MAX — the MAX object, type Op
  • MIN — the MIN object, type Op
  • SUM — the SUM object, type Op
  • PROD — the PROD object, type Op
  • LAND — the LAND object, type Op
  • BAND — the BAND object, type Op
  • LOR — the LOR object, type Op
  • BOR — the BOR object, type Op
  • LXOR — the LXOR object, type Op
  • BXOR — the BXOR object, type Op
  • MAXLOC — the MAXLOC object, type Op
  • MINLOC — the MINLOC object, type Op
  • REPLACE — the REPLACE object, type Op
  • NO_OP — the NO_OP object, type Op

groups, bestie, groups 🌸

  • GROUP_NULL — the GROUP_NULL object, type Group
  • GROUP_EMPTY — the GROUP_EMPTY object, type Group

info time, no cap 🦋

  • INFO_NULL — the INFO_NULL object, type Info
  • INFO_ENV — the INFO_ENV object, type Info

error handlers, aka the "who's gonna tell them" squad 😭

  • ERRHANDLER_NULL — the ERRHANDLER_NULL object, type Errhandler
  • ERRORS_RETURN — the ERRORS_RETURN object, type Errhandler
  • ERRORS_ABORT — the ERRORS_ABORT object, type Errhandler
  • ERRORS_ARE_FATAL — the ERRORS_ARE_FATAL object, type Errhandler

comms, the main character energy of the whole module 👑

  • SESSION_NULL — the SESSION_NULL object, type Session
  • COMM_NULL — the COMM_NULL object, type Comm
  • COMM_SELF — the COMM_SELF object, type Intracomm
  • COMM_WORLD — the COMM_WORLD object, type Intracomm

and one last one for the window girlies 🪟

  • WIN_NULL — the WIN_NULL object, type Win

every name up there is literally spelled exactly like that, all caps, underscores and all — do not freestyle it, bestie, COMM_WORLD is not COMMWORLD and she will not forgive you 💀

okay bestie, last five rows of that table, hold on to your wig 💅

  • FILE_NULL — object FILE_NULL, and its type is File
  • BOTTOM — object BOTTOM, type BottomType
  • IN_PLACE — object IN_PLACE, type InPlaceType
  • BUFFER_AUTOMATIC — object BUFFER_AUTOMATIC, type BufferAutomaticType
  • pickle — object pickle, type Pickle

✨ and now… the CONSTANTS ✨

no cap, this is just a big ol' parade of int values. every single one of them is a plain Python int (you know, the int from the Python standard library docs), and every one is literally equal to its own name. iconic behaviour honestly 🎀

  • mpi4py.MPI.UNDEFINED — mpi4py.MPI.UNDEFINED: int = UNDEFINED. Constant UNDEFINED, type int 💜
  • mpi4py.MPI.ANY_SOURCE — mpi4py.MPI.ANY_SOURCE: int = ANY_SOURCE. Constant ANY_SOURCE, type int
  • mpi4py.MPI.ANY_TAG — mpi4py.MPI.ANY_TAG: int = ANY_TAG. Constant ANY_TAG, type int
  • mpi4py.MPI.PROC_NULL — mpi4py.MPI.PROC_NULL: int = PROC_NULL. Constant PROC_NULL, type int
  • mpi4py.MPI.ROOT — mpi4py.MPI.ROOT: int = ROOT. Constant ROOT, type int
  • mpi4py.MPI.KEYVAL_INVALID — mpi4py.MPI.KEYVAL_INVALID: int = KEYVAL_INVALID. Constant KEYVAL_INVALID, type int
  • mpi4py.MPI.TAG_UB — mpi4py.MPI.TAG_UB: int = TAG_UB. Constant TAG_UB, type int
  • mpi4py.MPI.IO — mpi4py.MPI.IO: int = IO. Constant IO, type int
  • mpi4py.MPI.WTIME_IS_GLOBAL — mpi4py.MPI.WTIME_IS_GLOBAL: int = WTIME_IS_GLOBAL. Constant WTIME_IS_GLOBAL, type int
  • mpi4py.MPI.UNIVERSE_SIZE — mpi4py.MPI.UNIVERSE_SIZE: int = UNIVERSE_SIZE. Constant UNIVERSE_SIZE, type int
  • mpi4py.MPI.APPNUM — mpi4py.MPI.APPNUM: int = APPNUM. Constant APPNUM, type int
  • mpi4py.MPI.LASTUSEDCODE — mpi4py.MPI.LASTUSEDCODE: int = LASTUSEDCODE. Constant LASTUSEDCODE, type int
  • mpi4py.MPI.WIN_BASE — mpi4py.MPI.WIN_BASE: int = WIN_BASE. Constant WIN_BASE, type int
  • mpi4py.MPI.WIN_SIZE — mpi4py.MPI.WIN_SIZE: int = WIN_SIZE. Constant WIN_SIZE, type int
  • mpi4py.MPI.WIN_DISP_UNIT — mpi4py.MPI.WIN_DISP_UNIT: int = WIN_DISP_UNIT. Constant WIN_DISP_UNIT, type int
  • mpi4py.MPI.WIN_CREATE_FLAVOR — mpi4py.MPI.WIN_CREATE_FLAVOR: int = WIN_CREATE_FLAVOR. Constant WIN_CREATE_FLAVOR, type int
  • mpi4py.MPI.WIN_FLAVOR — mpi4py.MPI.WIN_FLAVOR: int = WIN_FLAVOR. Constant WIN_FLAVOR, type int
  • mpi4py.MPI.WIN_MODEL — mpi4py.MPI.WIN_MODEL: int = WIN_MODEL. Constant WIN_MODEL, type int
  • mpi4py.MPI.SUCCESS — mpi4py.MPI.SUCCESS: int = SUCCESS. Constant SUCCESS, type int
  • mpi4py.MPI.ERR_LASTCODE — mpi4py.MPI.ERR_LASTCODE: int = ERR_LASTCODE. Constant ERR_LASTCODE, type int
  • mpi4py.MPI.ERR_ABI — mpi4py.MPI.ERR_ABI: int = ERR_ABI. Constant ERR_ABI, type int
  • mpi4py.MPI.ERR_TYPE — mpi4py.MPI.ERR_TYPE: int = ERR_TYPE. Constant ERR_TYPE, type int
  • mpi4py.MPI.ERR_REQUEST — mpi4py.MPI.ERR_REQUEST: int = ERR_REQUEST. Constant ERR_REQUEST, type int
  • mpi4py.MPI.ERR_OP — mpi4py.MPI.ERR_OP: int = ERR_OP. Constant ERR_OP, type int
  • mpi4py.MPI.ERR_GROUP — mpi4py.MPI.ERR_GROUP: int = ERR_GROUP. Constant ERR_GROUP, type int
  • mpi4py.MPI.ERR_INFO — mpi4py.MPI.ERR_INFO: int = ERR_INFO. Constant ERR_INFO, type int
  • mpi4py.MPI.ERR_ERRHANDLER — mpi4py.MPI.ERR_ERRHANDLER: int = ERR_ERRHANDLER. Constant ERR_ERRHANDLER, type int
  • mpi4py.MPI.ERR_SESSION — mpi4py.MPI.ERR_SESSION: int = ERR_SESSION. Constant ERR_SESSION, type int
  • mpi4py.MPI.ERR_COMM — mpi4py.MPI.ERR_COMM: int = ERR_COMM. Constant ERR_COMM, type int
  • mpi4py.MPI.ERR_WIN — mpi4py.MPI.ERR_WIN: int = ERR_WIN. Constant ERR_WIN, type int
  • mpi4py.MPI.ERR_FILE — mpi4py.MPI.ERR_FILE: int = ERR_FILE. Constant ERR_FILE, type int
  • mpi4py.MPI.ERR_BUFFER — mpi4py.MPI.ERR_BUFFER: int = ERR_BUFFER. Constant ERR_BUFFER, type int
  • mpi4py.MPI.ERR_COUNT — mpi4py.MPI.ERR_COUNT: int = ERR_COUNT. Constant ERR_COUNT, type int
  • mpi4py.MPI.ERR_TAG — mpi4py.MPI.ERR_TAG: int = ERR_TAG. Constant ERR_TAG, type int
  • mpi4py.MPI.ERR_RANK — mpi4py.MPI.ERR_RANK: int = ERR_RANK. Constant ERR_RANK, type int
  • mpi4py.MPI.ERR_ROOT — mpi4py.MPI.ERR_ROOT: int = ERR_ROOT. Constant ERR_ROOT, type int
  • mpi4py.MPI.ERR_TRUNCATE — mpi4py.MPI.ERR_TRUNCATE: int = ERR_TRUNCATE. Constant ERR_TRUNCATE, type int
  • mpi4py.MPI.ERR_IN_STATUS — mpi4py.MPI.ERR_IN_STATUS: int = ERR_IN_STATUS. Constant ERR_IN_STATUS, type int

that's the whole error-code squad right there, every last one, bestie 💖

okay bestie, we're deep in the error constant zone now 🌸 — every single one of these is a constant of type int (the regular Python int, the one that lives at https://docs.python.org/3/library/functions.html#int), and each one's value is literally its own name. No cap. Here we go, one by one, no skipping, we're finishing this list together 💅

mpi4py.MPI.ERR_PENDING

mpi4py.MPI.ERR_PENDING: int = ERR_PENDING

Constant ERR_PENDING of type int. The name is doing the absolute most and I respect it ✨

mpi4py.MPI.ERR_TOPOLOGY

mpi4py.MPI.ERR_TOPOLOGY: int = ERR_TOPOLOGY

Constant ERR_TOPOLOGY of type int. Say it with me: topology 💫

mpi4py.MPI.ERR_DIMS

mpi4py.MPI.ERR_DIMS: int = ERR_DIMS

Constant ERR_DIMS of type int. Short name, big energy 🎀

mpi4py.MPI.ERR_ARG

mpi4py.MPI.ERR_ARG: int = ERR_ARG

Constant ERR_ARG of type int. Three letters. Iconic minimalism 🦋

mpi4py.MPI.ERR_OTHER

mpi4py.MPI.ERR_OTHER: int = ERR_OTHER

Constant ERR_OTHER of type int. The "miscellaneous" of error constants and honestly? Relatable 🫶

mpi4py.MPI.ERR_UNKNOWN

mpi4py.MPI.ERR_UNKNOWN: int = ERR_UNKNOWN

Constant ERR_UNKNOWN of type int. Mysterious. Enigmatic. Main character 🔥

mpi4py.MPI.ERR_INTERN

mpi4py.MPI.ERR_INTERN: int = ERR_INTERN

Constant ERR_INTERN of type int. Internal business only, we don't ask questions 🙈

mpi4py.MPI.ERR_KEYVAL

mpi4py.MPI.ERR_KEYVAL: int = ERR_KEYVAL

Constant ERR_KEYVAL of type int. Key-value coded, literally 💜

mpi4py.MPI.ERR_NO_MEM

mpi4py.MPI.ERR_NO_MEM: int = ERR_NO_MEM

Constant ERR_NO_MEM of type int. Deep breaths, bestie 😭

mpi4py.MPI.ERR_INFO_KEY

mpi4py.MPI.ERR_INFO_KEY: int = ERR_INFO_KEY

Constant ERR_INFO_KEY of type int. The key half of the info duo 🔑

mpi4py.MPI.ERR_INFO_VALUE

mpi4py.MPI.ERR_INFO_VALUE: int = ERR_INFO_VALUE

Constant ERR_INFO_VALUE of type int. And here's the value half, they come as a set 💞

mpi4py.MPI.ERR_INFO_NOKEY

mpi4py.MPI.ERR_INFO_NOKEY: int = ERR_INFO_NOKEY

Constant ERR_INFO_NOKEY of type int. No key, no problem, we still list it 🎀

mpi4py.MPI.ERR_SPAWN

mpi4py.MPI.ERR_SPAWN: int = ERR_SPAWN

Constant ERR_SPAWN of type int. Spawn like a video game, obsessed 🎮

mpi4py.MPI.ERR_PORT

mpi4py.MPI.ERR_PORT: int = ERR_PORT

Constant ERR_PORT of type int. Four letters, maximum vibe 🌊

mpi4py.MPI.ERR_SERVICE

mpi4py.MPI.ERR_SERVICE: int = ERR_SERVICE

Constant ERR_SERVICE of type int. Customer service voice: activated 💅

mpi4py.MPI.ERR_NAME

mpi4py.MPI.ERR_NAME: int = ERR_NAME

Constant ERR_NAME of type int. What's in a name? This constant, apparently ✨

mpi4py.MPI.ERR_PROC_ABORTED

mpi4py.MPI.ERR_PROC_ABORTED: int = ERR_PROC_ABORTED

Constant ERR_PROC_ABORTED of type int. Long name, full drama, love that for it 🎭

mpi4py.MPI.ERR_BASE

mpi4py.MPI.ERR_BASE: int = ERR_BASE

Constant ERR_BASE of type int. The foundation, the blueprint, the base 💅

mpi4py.MPI.ERR_SIZE

mpi4py.MPI.ERR_SIZE: int = ERR_SIZE

Constant ERR_SIZE of type int. Size matters, and so does listing every constant 📏

mpi4py.MPI.ERR_DISP

mpi4py.MPI.ERR_DISP: int = ERR_DISP

Constant ERR_DISP of type int. Short for displacement and short in general 🦋

mpi4py.MPI.ERR_ASSERT

mpi4py.MPI.ERR_ASSERT: int = ERR_ASSERT

Constant ERR_ASSERT of type int. Asserting itself, as it should 👑

mpi4py.MPI.ERR_LOCKTYPE

mpi4py.MPI.ERR_LOCKTYPE: int = ERR_LOCKTYPE

Constant ERR_LOCKTYPE of type int. Locked in 🔒

mpi4py.MPI.ERR_RMA_CONFLICT

mpi4py.MPI.ERR_RMA_CONFLICT: int = ERR_RMA_CONFLICT

Constant ERR_RMA_CONFLICT of type int. The RMA era begins and the names get longer, we love a glow-up 🌈

mpi4py.MPI.ERR_RMA_SYNC

mpi4py.MPI.ERR_RMA_SYNC: int = ERR_RMA_SYNC

Constant ERR_RMA_SYNC of type int. Syncing up with the group chat 💬

mpi4py.MPI.ERR_RMA_RANGE

mpi4py.MPI.ERR_RMA_RANGE: int = ERR_RMA_RANGE

Constant ERR_RMA_RANGE of type int. Out of range but never out of style 💜

mpi4py.MPI.ERR_RMA_ATTACH

mpi4py.MPI.ERR_RMA_ATTACH: int = ERR_RMA_ATTACH

Constant ERR_RMA_ATTACH of type int. Attachment issues, but make it MPI 😭

mpi4py.MPI.ERR_RMA_SHARED

mpi4py.MPI.ERR_RMA_SHARED: int = ERR_RMA_SHARED

Constant ERR_RMA_SHARED of type int. Sharing is caring, bestie 🫶

mpi4py.MPI.ERR_RMA_FLAVOR

mpi4py.MPI.ERR_RMA_FLAVOR: int = ERR_RMA_FLAVOR

Constant ERR_RMA_FLAVOR of type int. Flavor?! In MY error constant list?! Yes, and it ate 🍓

mpi4py.MPI.ERR_BAD_FILE

mpi4py.MPI.ERR_BAD_FILE: int = ERR_BAD_FILE

Constant ERR_BAD_FILE of type int. Bad file, bad file, whatcha gonna do 📁

mpi4py.MPI.ERR_NO_SUCH_FILE

mpi4py.MPI.ERR_NO_SUCH_FILE: int = ERR_NO_SUCH_FILE

Constant ERR_NO_SUCH_FILE of type int. It's not there. It was never there. 💀

mpi4py.MPI.ERR_FILE_EXISTS

mpi4py.MPI.ERR_FILE_EXISTS: int = ERR_FILE_EXISTS

Constant ERR_FILE_EXISTS of type int. It IS there, actually, and it was there first 💅

mpi4py.MPI.ERR_FILE_IN_USE

mpi4py.MPI.ERR_FILE_IN_USE: int = ERR_FILE_IN_USE

Constant ERR_FILE_IN_USE of type int. Currently busy, do not perceive it 🙈

mpi4py.MPI.ERR_AMODE

mpi4py.MPI.ERR_AMODE: int = ERR_AMODE

Constant ERR_AMODE of type int. Access mode, abbreviated, efficient, slay ✨

mpi4py.MPI.ERR_ACCESS

mpi4py.MPI.ERR_ACCESS: int = ERR_ACCESS

Constant ERR_ACCESS of type int. Access denied, respectfully 🚫

mpi4py.MPI.ERR_READ_ONLY

mpi4py.MPI.ERR_READ_ONLY: int = ERR_READ_ONLY

Constant ERR_READ_ONLY of type int. Look but don't touch, fr fr 👀

mpi4py.MPI.ERR_NO_SPACE

mpi4py.MPI.ERR_NO_SPACE: int = ERR_NO_SPACE

Constant ERR_NO_SPACE of type int. No room at the inn 😭

mpi4py.MPI.ERR_QUOTA

mpi4py.MPI.ERR_QUOTA: int = ERR_QUOTA

Constant ERR_QUOTA of type int. You've hit your limit bestie, go touch grass 🌸

mpi4py.MPI.ERR_NOT_SAME

mpi4py.MPI.ERR_NOT_SAME: int = ERR_NOT_SAME

Constant ERR_NOT_SAME of type int. Not the same, and it's not even trying to be 🦋

mpi4py.MPI.ERR_IO

mpi4py.MPI.ERR_IO: int = ERR_IO

Constant ERR_IO of type int. Two letters, maximum chaos potential 🔥

mpi4py.MPI.ERR_UNSUPPORTED_OPERATION

mpi4py.MPI.ERR_UNSUPPORTED_OPERATION: int = ERR_UNSUPPORTED_OPERATION

Constant ERR_UNSUPPORTED_OPERATION of type int. We do not support that operation and we said what we said 💅

mpi4py.MPI.ERR_UNSUPPORTED_DATAREP

mpi4py.MPI.ERR_UNSUPPORTED_DATAREP: int = ERR_UNSUPPORTED_DATAREP

Constant ERR_UNSUPPORTED_DATAREP of type int. Same energy, different data representation, no cap 🎀

mpi4py.MPI.ERR_CONVERSION

mpi4py.MPI.ERR_CONVERSION: int = ERR_CONVERSION

Constant ERR_CONVERSION of type int. Glow-up attempt failed to convert 😭

mpi4py.MPI.ERR_DUP_DATAREP

mpi4py.MPI.ERR_DUP_DATAREP: int = ERR_DUP_DATAREP

Constant ERR_DUP_DATAREP of type int. Duplicate datarep, we've seen this one before 🫠

mpi4py.MPI.ERR_VALUE_TOO_LARGE

mpi4py.MPI.ERR_VALUE_TOO_LARGE: int = ERR_VALUE_TOO_LARGE

Constant ERR_VALUE_TOO_LARGE of type int. Too much. Too big. Too powerful. 👑

mpi4py.MPI.ERR_REVOKED

mpi4py.MPI.ERR_REVOKED: int = ERR_REVOKED

Constant ERR_REVOKED of type int. Revoked, like your group chat privileges 💀

mpi4py.MPI.ERR_PROC_FAILED

mpi4py.MPI.ERR_PROC_FAILED: int = ERR_PROC_FAILED

Constant ERR_PROC_FAILED of type int. And we close out this batch with the saddest name of the bunch, rest in pieces 😭🫶

🩷 mpi4py.MPI.ERR_PROC_FAILED_PENDING

mpi4py.MPI.ERR_PROC_FAILED_PENDING: int = ERR_PROC_FAILED_PENDING

Constant ERR_PROC_FAILED_PENDING, and she's of type int. that's the whole entry bestie, no crumbs left behind 💖

🧡 mpi4py.MPI.ORDER_C

mpi4py.MPI.ORDER_C: int = ORDER_C

Constant ORDER_C of type int. the C is right there in the name, slay 💅

🧡 mpi4py.MPI.ORDER_FORTRAN

mpi4py.MPI.ORDER_FORTRAN: int = ORDER_FORTRAN

Constant ORDER_FORTRAN of type int. her full legal name, no nicknames 🌸

🧡 mpi4py.MPI.ORDER_F

mpi4py.MPI.ORDER_F: int = ORDER_F

Constant ORDER_F of type int. the short version of the above, because she contains multitudes ✨

💜 mpi4py.MPI.TYPECLASS_LOGICAL

mpi4py.MPI.TYPECLASS_LOGICAL: int = TYPECLASS_LOGICAL

Constant TYPECLASS_LOGICAL of type int. typeclass girlies rise 🫶

💜 mpi4py.MPI.TYPECLASS_INTEGER

mpi4py.MPI.TYPECLASS_INTEGER: int = TYPECLASS_INTEGER

Constant TYPECLASS_INTEGER of type int. and yes she is herself an int, we love a self-consistent queen 💖

💜 mpi4py.MPI.TYPECLASS_REAL

mpi4py.MPI.TYPECLASS_REAL: int = TYPECLASS_REAL

Constant TYPECLASS_REAL of type int. keeping it real, literally ✨

💜 mpi4py.MPI.TYPECLASS_COMPLEX

mpi4py.MPI.TYPECLASS_COMPLEX: int = TYPECLASS_COMPLEX

Constant TYPECLASS_COMPLEX of type int. she's complicated and that's her brand 💅

🦋 mpi4py.MPI.DISTRIBUTE_NONE

mpi4py.MPI.DISTRIBUTE_NONE: int = DISTRIBUTE_NONE

Constant DISTRIBUTE_NONE of type int. distributing absolutely nothing, and doing it flawlessly 😌

🦋 mpi4py.MPI.DISTRIBUTE_BLOCK

mpi4py.MPI.DISTRIBUTE_BLOCK: int = DISTRIBUTE_BLOCK

Constant DISTRIBUTE_BLOCK of type int. block party, everyone invited 🎀

🦋 mpi4py.MPI.DISTRIBUTE_CYCLIC

mpi4py.MPI.DISTRIBUTE_CYCLIC: int = DISTRIBUTE_CYCLIC

Constant DISTRIBUTE_CYCLIC of type int. going in circles but make it fashion 🌀

🦋 mpi4py.MPI.DISTRIBUTE_DFLT_DARG

mpi4py.MPI.DISTRIBUTE_DFLT_DARG: int = DISTRIBUTE_DFLT_DARG

Constant DISTRIBUTE_DFLT_DARG of type int. the default one, the darg of it all, no cap 💖

👑 mpi4py.MPI.COMBINER_NAMED

mpi4py.MPI.COMBINER_NAMED: int = COMBINER_NAMED

Constant COMBINER_NAMED of type int. welcome to the COMBINER cinematic universe, we're here all day ✨

👑 mpi4py.MPI.COMBINER_DUP

mpi4py.MPI.COMBINER_DUP: int = COMBINER_DUP

Constant COMBINER_DUP of type int. duplicating the vibe fr fr 💅

👑 mpi4py.MPI.COMBINER_CONTIGUOUS

mpi4py.MPI.COMBINER_CONTIGUOUS: int = COMBINER_CONTIGUOUS

Constant COMBINER_CONTIGUOUS of type int. all in a row, no gaps, iconic behavior 🎀

👑 mpi4py.MPI.COMBINER_VECTOR

mpi4py.MPI.COMBINER_VECTOR: int = COMBINER_VECTOR

Constant COMBINER_VECTOR of type int. she has direction and she has magnitude, periodt 🌈

👑 mpi4py.MPI.COMBINER_HVECTOR

mpi4py.MPI.COMBINER_HVECTOR: int = COMBINER_HVECTOR

Constant COMBINER_HVECTOR of type int. the H stands for her, obviously 💜

👑 mpi4py.MPI.COMBINER_INDEXED

mpi4py.MPI.COMBINER_INDEXED: int = COMBINER_INDEXED

Constant COMBINER_INDEXED of type int. indexed and unbothered 🫶

👑 mpi4py.MPI.COMBINER_HINDEXED

mpi4py.MPI.COMBINER_HINDEXED: int = COMBINER_HINDEXED

Constant COMBINER_HINDEXED of type int. the H returns, she's booked and busy 💅

👑 mpi4py.MPI.COMBINER_INDEXED_BLOCK

mpi4py.MPI.COMBINER_INDEXED_BLOCK: int = COMBINER_INDEXED_BLOCK

Constant COMBINER_INDEXED_BLOCK of type int. indexed AND blocked, a crossover event 🔥

👑 mpi4py.MPI.COMBINER_HINDEXED_BLOCK

mpi4py.MPI.COMBINER_HINDEXED_BLOCK: int = COMBINER_HINDEXED_BLOCK

Constant COMBINER_HINDEXED_BLOCK of type int. the sequel to the crossover, and honestly it ate 😭

👑 mpi4py.MPI.COMBINER_STRUCT

mpi4py.MPI.COMBINER_STRUCT: int = COMBINER_STRUCT

Constant COMBINER_STRUCT of type int. structured, organized, thriving 🌸

👑 mpi4py.MPI.COMBINER_SUBARRAY

mpi4py.MPI.COMBINER_SUBARRAY: int = COMBINER_SUBARRAY

Constant COMBINER_SUBARRAY of type int. a whole array but like, a sub one 💖

👑 mpi4py.MPI.COMBINER_DARRAY

mpi4py.MPI.COMBINER_DARRAY: int = COMBINER_DARRAY

Constant COMBINER_DARRAY of type int. the D is doing a lot of heavy lifting here and we respect it 🎀

👑 mpi4py.MPI.COMBINER_RESIZED

mpi4py.MPI.COMBINER_RESIZED: int = COMBINER_RESIZED

Constant COMBINER_RESIZED of type int. glow-up arc, resized and reborn ✨

👑 mpi4py.MPI.COMBINER_VALUE_INDEX

mpi4py.MPI.COMBINER_VALUE_INDEX: int = COMBINER_VALUE_INDEX

Constant COMBINER_VALUE_INDEX of type int. values AND index, she's doing both jobs 💅

👑 mpi4py.MPI.COMBINER_F90_INTEGER

mpi4py.MPI.COMBINER_F90_INTEGER: int = COMBINER_F90_INTEGER

Constant COMBINER_F90_INTEGER of type int. Fortran 90 said hello and we said hi back 🫶

👑 mpi4py.MPI.COMBINER_F90_REAL

mpi4py.MPI.COMBINER_F90_REAL: int = COMBINER_F90_REAL

Constant COMBINER_F90_REAL of type int. still Fortran 90, still real 💜

👑 mpi4py.MPI.COMBINER_F90_COMPLEX

mpi4py.MPI.COMBINER_F90_COMPLEX: int = COMBINER_F90_COMPLEX

Constant COMBINER_F90_COMPLEX of type int. the last of the F90 trio, and she understood the assignment 🌈

🌟 mpi4py.MPI.F_SOURCE

mpi4py.MPI.F_SOURCE: int = F_SOURCE

Constant F_SOURCE of type int. we're in the F_ era now, buckle up bestie 🎀

🌟 mpi4py.MPI.F_TAG

mpi4py.MPI.F_TAG: int = F_TAG

Constant F_TAG of type int. she's tagged, she's iconic, she's an int 💖

🌟 mpi4py.MPI.F_ERROR

mpi4py.MPI.F_ERROR: int = F_ERROR

Constant F_ERROR of type int. error by name, not by nature 😌

🌟 mpi4py.MPI.F_STATUS_SIZE

mpi4py.MPI.F_STATUS_SIZE: int = F_STATUS_SIZE

Constant F_STATUS_SIZE of type int. size queen behavior but for statuses 🫶

🔥 mpi4py.MPI.IDENT

mpi4py.MPI.IDENT: int = IDENT

Constant IDENT of type int. identical to nothing, she's one of a kind ✨

🔥 mpi4py.MPI.CONGRUENT

mpi4py.MPI.CONGRUENT: int = CONGRUENT

Constant CONGRUENT of type int. she matches the energy, she's congruent with it 💅

🔥 mpi4py.MPI.SIMILAR

mpi4py.MPI.SIMILAR: int = SIMILAR

Constant SIMILAR of type int. not identical but like, the same vibe 🌸

🔥 mpi4py.MPI.UNEQUAL

mpi4py.MPI.UNEQUAL: int = UNEQUAL

Constant UNEQUAL of type int. she said we are NOT the same and honestly? valid 😭

🗺️ mpi4py.MPI.CART

mpi4py.MPI.CART: int = CART

Constant CART of type int. topology arc begins, we're going cartesian 🧭

🗺️ mpi4py.MPI.GRAPH

mpi4py.MPI.GRAPH: int = GRAPH

Constant GRAPH of type int. graph girlies, your moment has arrived 📈

🗺️ mpi4py.MPI.DIST_GRAPH

mpi4py.MPI.DIST_GRAPH: int = DIST_GRAPH

Constant DIST_GRAPH of type int. the distributed sequel, and she devoured 💅

🗺️ mpi4py.MPI.UNWEIGHTED

mpi4py.MPI.UNWEIGHTED: int = UNWEIGHTED

Constant UNWEIGHTED of type int. no weights, no baggage, she travels light 🦋

🗺️ mpi4py.MPI.WEIGHTS_EMPTY

mpi4py.MPI.WEIGHTS_EMPTY: int = WEIGHTS_EMPTY

Constant WEIGHTS_EMPTY of type int. the weights are empty bestie, the container is empty, that's the whole thing 🫙

🌈 mpi4py.MPI.COMM_TYPE_SHARED

mpi4py.MPI.COMM_TYPE_SHARED: int = COMM_TYPE_SHARED

Constant COMM_TYPE_SHARED of type int. sharing is caring, and she cares 🌸

🌈 mpi4py.MPI.COMM_TYPE_HW_GUIDED

mpi4py.MPI.COMM_TYPE_HW_GUIDED: int = COMM_TYPE_HW_GUIDED

Constant COMM_TYPE_HW_GUIDED of type int. hardware-guided, main character energy, and that's the last one in this batch so let's keep scrolling 👑💖

💅 mpi4py.MPI.COMM_TYPE_HW_UNGUIDED

mpi4py.MPI.COMM_TYPE_HW_UNGUIDED: int = COMM_TYPE_HW_UNGUIDED

okay so this is the constant COMM_TYPE_HW_UNGUIDED, and its whole deal is that it's an int <https://docs.python.org/3/library/functions.html#int>. that's it, that's the vibe. ✨

💅 mpi4py.MPI.COMM_TYPE_RESOURCE_GUIDED

mpi4py.MPI.COMM_TYPE_RESOURCE_GUIDED: int = COMM_TYPE_RESOURCE_GUIDED

constant COMM_TYPE_RESOURCE_GUIDED, type int <https://docs.python.org/3/library/functions.html#int>. she's giving resource-guided energy and she's an integer, periodt. 🎀

🫶 mpi4py.MPI.BSEND_OVERHEAD

mpi4py.MPI.BSEND_OVERHEAD: int = BSEND_OVERHEAD

the constant BSEND_OVERHEAD, and bestie, it is of type int <https://docs.python.org/3/library/functions.html#int>. lowkey iconic. 💖

🦋 mpi4py.MPI.WIN_FLAVOR_CREATE

mpi4py.MPI.WIN_FLAVOR_CREATE: int = WIN_FLAVOR_CREATE

constant WIN_FLAVOR_CREATE — an int <https://docs.python.org/3/library/functions.html#int>. window flavor number one, and she is an integer fr fr. ✨

🦋 mpi4py.MPI.WIN_FLAVOR_ALLOCATE

mpi4py.MPI.WIN_FLAVOR_ALLOCATE: int = WIN_FLAVOR_ALLOCATE

constant WIN_FLAVOR_ALLOCATE, type int <https://docs.python.org/3/library/functions.html#int>. allocate-flavored, int-shaped, obsessed. 💜

🦋 mpi4py.MPI.WIN_FLAVOR_DYNAMIC

mpi4py.MPI.WIN_FLAVOR_DYNAMIC: int = WIN_FLAVOR_DYNAMIC

constant WIN_FLAVOR_DYNAMIC, of type int <https://docs.python.org/3/library/functions.html#int>. dynamic queen, still an int, no cap. 🌈

🦋 mpi4py.MPI.WIN_FLAVOR_SHARED

mpi4py.MPI.WIN_FLAVOR_SHARED: int = WIN_FLAVOR_SHARED

constant WIN_FLAVOR_SHARED — int <https://docs.python.org/3/library/functions.html#int>. sharing is caring and it's an integer. 🫶

🌸 mpi4py.MPI.WIN_SEPARATE

mpi4py.MPI.WIN_SEPARATE: int = WIN_SEPARATE

constant WIN_SEPARATE, type int <https://docs.python.org/3/library/functions.html#int>. separate but still an int, she's doing her own thing. 💅

🌸 mpi4py.MPI.WIN_UNIFIED

mpi4py.MPI.WIN_UNIFIED: int = WIN_UNIFIED

constant WIN_UNIFIED, of type int <https://docs.python.org/3/library/functions.html#int>. unified and unbothered, and yes, an integer. 👑

⭐ mpi4py.MPI.MODE_NOCHECK

mpi4py.MPI.MODE_NOCHECK: int = MODE_NOCHECK

constant MODE_NOCHECK, and she's an int <https://docs.python.org/3/library/functions.html#int>. no check, no stress, all int. ✨

⭐ mpi4py.MPI.MODE_NOSTORE

mpi4py.MPI.MODE_NOSTORE: int = MODE_NOSTORE

constant MODE_NOSTORE — type int <https://docs.python.org/3/library/functions.html#int>. nothing stored except the fact that she's an integer. 🎀

⭐ mpi4py.MPI.MODE_NOPUT

mpi4py.MPI.MODE_NOPUT: int = MODE_NOPUT

constant MODE_NOPUT, of type int <https://docs.python.org/3/library/functions.html#int>. no putting, but definitely an int. 💖

⭐ mpi4py.MPI.MODE_NOPRECEDE

mpi4py.MPI.MODE_NOPRECEDE: int = MODE_NOPRECEDE

constant MODE_NOPRECEDE, type int <https://docs.python.org/3/library/functions.html#int>. nothing precedes her except being an integer. 🦋

⭐ mpi4py.MPI.MODE_NOSUCCEED

mpi4py.MPI.MODE_NOSUCCEED: int = MODE_NOSUCCEED

constant MODE_NOSUCCEED — int <https://docs.python.org/3/library/functions.html#int>. nothing succeeds her except… more integers. 🌈

🔥 mpi4py.MPI.LOCK_EXCLUSIVE

mpi4py.MPI.LOCK_EXCLUSIVE: int = LOCK_EXCLUSIVE

constant LOCK_EXCLUSIVE, of type int <https://docs.python.org/3/library/functions.html#int>. exclusive lock energy, main character, still an int. 👑

🔥 mpi4py.MPI.LOCK_SHARED

mpi4py.MPI.LOCK_SHARED: int = LOCK_SHARED

constant LOCK_SHARED, type int <https://docs.python.org/3/library/functions.html#int>. shared lock, shared vibes, shared int-ness. 🫶

🎀 mpi4py.MPI.MODE_RDONLY

mpi4py.MPI.MODE_RDONLY: int = MODE_RDONLY

constant MODE_RDONLY, and it's an int <https://docs.python.org/3/library/functions.html#int>. read-only mode, but read this: she's an integer. ✨

🎀 mpi4py.MPI.MODE_WRONLY

mpi4py.MPI.MODE_WRONLY: int = MODE_WRONLY

constant MODE_WRONLY — type int <https://docs.python.org/3/library/functions.html#int>. write-only, but I'm writing this down: int. 💜

🎀 mpi4py.MPI.MODE_RDWR

mpi4py.MPI.MODE_RDWR: int = MODE_RDWR

constant MODE_RDWR, of type int <https://docs.python.org/3/library/functions.html#int>. read AND write, she does both, and she's an integer. 💅

🌸 mpi4py.MPI.MODE_CREATE

mpi4py.MPI.MODE_CREATE: int = MODE_CREATE

constant MODE_CREATE, type int <https://docs.python.org/3/library/functions.html#int>. creating a whole vibe, and also an int. 🌟

🌸 mpi4py.MPI.MODE_EXCL

mpi4py.MPI.MODE_EXCL: int = MODE_EXCL

constant MODE_EXCL — int <https://docs.python.org/3/library/functions.html#int>. exclusive behavior, inclusive heart, integer soul. 🦋

🌸 mpi4py.MPI.MODE_DELETE_ON_CLOSE

mpi4py.MPI.MODE_DELETE_ON_CLOSE: int = MODE_DELETE_ON_CLOSE

constant MODE_DELETE_ON_CLOSE, of type int <https://docs.python.org/3/library/functions.html#int>. delete on close bestie, and yes she's an int. 💖

🌸 mpi4py.MPI.MODE_UNIQUE_OPEN

mpi4py.MPI.MODE_UNIQUE_OPEN: int = MODE_UNIQUE_OPEN

constant MODE_UNIQUE_OPEN, type int <https://docs.python.org/3/library/functions.html#int>. unique open, unique int, we love to see it. 🎀

🌸 mpi4py.MPI.MODE_SEQUENTIAL

mpi4py.MPI.MODE_SEQUENTIAL: int = MODE_SEQUENTIAL

constant MODE_SEQUENTIAL, and she is an int <https://docs.python.org/3/library/functions.html#int>. one thing after another, sequentially, as an integer. ⭐

🌸 mpi4py.MPI.MODE_APPEND

mpi4py.MPI.MODE_APPEND: int = MODE_APPEND

constant MODE_APPEND — type int <https://docs.python.org/3/library/functions.html#int>. append energy, integer reality. 🔥

🧚 mpi4py.MPI.SEEK_SET

mpi4py.MPI.SEEK_SET: int = SEEK_SET

constant SEEK_SET, of type int <https://docs.python.org/3/library/functions.html#int>. set your position, set your standards, stay an int. 💅

🧚 mpi4py.MPI.SEEK_CUR

mpi4py.MPI.SEEK_CUR: int = SEEK_CUR

constant SEEK_CUR, type int <https://docs.python.org/3/library/functions.html#int>. current position, current mood, current int. 🌈

🧚 mpi4py.MPI.SEEK_END

mpi4py.MPI.SEEK_END: int = SEEK_END

constant SEEK_END — int <https://docs.python.org/3/library/functions.html#int>. seek to the end, but never the end of the int pipeline. 👑

🍓 mpi4py.MPI.DISPLACEMENT_CURRENT

mpi4py.MPI.DISPLACEMENT_CURRENT: int = DISPLACEMENT_CURRENT

constant DISPLACEMENT_CURRENT, and bestie, she's an int <https://docs.python.org/3/library/functions.html#int>. displaced? never. an int? always. ✨

🍓 mpi4py.MPI.DISP_CUR

mpi4py.MPI.DISP_CUR: int = DISP_CUR

constant DISP_CUR, of type int <https://docs.python.org/3/library/functions.html#int>. the short-king version of the name above, equally an int. 🎀

💜 mpi4py.MPI.THREAD_SINGLE

mpi4py.MPI.THREAD_SINGLE: int = THREAD_SINGLE

constant THREAD_SINGLE, type int <https://docs.python.org/3/library/functions.html#int>. single-threaded and single, but never alone — she has int <https://docs.python.org/3/library/functions.html#int> energy. 🫶

💜 mpi4py.MPI.THREAD_FUNNELED

mpi4py.MPI.THREAD_FUNNELED: int = THREAD_FUNNELED

constant THREAD_FUNNELED — int <https://docs.python.org/3/library/functions.html#int>. funneled right into the integer pipeline. 🌟

💜 mpi4py.MPI.THREAD_SERIALIZED

mpi4py.MPI.THREAD_SERIALIZED: int = THREAD_SERIALIZED

constant THREAD_SERIALIZED, of type int <https://docs.python.org/3/library/functions.html#int>. serialized, sanitized, still an integer. 💖

💜 mpi4py.MPI.THREAD_MULTIPLE

mpi4py.MPI.THREAD_MULTIPLE: int = THREAD_MULTIPLE

constant THREAD_MULTIPLE, type int <https://docs.python.org/3/library/functions.html#int>. multiple threads, multiple vibes, one int. 🔥

👑 mpi4py.MPI.VERSION

mpi4py.MPI.VERSION: int = VERSION

constant VERSION, and she is an int <https://docs.python.org/3/library/functions.html#int>. the version constant, doing version constant things, as an integer. ✨

👑 mpi4py.MPI.SUBVERSION

mpi4py.MPI.SUBVERSION: int = SUBVERSION

constant SUBVERSION — int <https://docs.python.org/3/library/functions.html#int>. subversion here means "the sub-part of the version," not the other thing, bestie. 🌸

📏 mpi4py.MPI.MAX_PROCESSOR_NAME

mpi4py.MPI.MAX_PROCESSOR_NAME: int = MAX_PROCESSOR_NAME

constant MAX_PROCESSOR_NAME, of type int <https://docs.python.org/3/library/functions.html#int>. a MAX constant, and yes it's an integer. 🎀

📏 mpi4py.MPI.MAX_ERROR_STRING

mpi4py.MPI.MAX_ERROR_STRING: int = MAX_ERROR_STRING

constant MAX_ERROR_STRING, type int <https://docs.python.org/3/library/functions.html#int>. max error string length vibes, integer body. 🦋

📏 mpi4py.MPI.MAX_PORT_NAME

mpi4py.MPI.MAX_PORT_NAME: int = MAX_PORT_NAME

constant MAX_PORT_NAME — int <https://docs.python.org/3/library/functions.html#int>. a max, a name, a port, an int. the whole package. 🌈

📏 mpi4py.MPI.MAX_INFO_KEY

mpi4py.MPI.MAX_INFO_KEY: int = MAX_INFO_KEY

constant MAX_INFO_KEY, of type int <https://docs.python.org/3/library/functions.html#int>. the key to the max info, and the key is an integer. 💅

📏 mpi4py.MPI.MAX_INFO_VAL

mpi4py.MPI.MAX_INFO_VAL: int = MAX_INFO_VAL

constant MAX_INFO_VAL, type int <https://docs.python.org/3/library/functions.html#int>. the value half of the pair above, equally an int. 💜

📏 mpi4py.MPI.MAX_OBJECT_NAME

mpi4py.MPI.MAX_OBJECT_NAME: int = MAX_OBJECT_NAME

constant MAX_OBJECT_NAME — int <https://docs.python.org/3/library/functions.html#int>. max object name, main character name, integer type. 👑

📏 mpi4py.MPI.MAX_DATAREP_STRING

mpi4py.MPI.MAX_DATAREP_STRING: int = MAX_DATAREP_STRING

constant MAX_DATAREP_STRING, of type int <https://docs.python.org/3/library/functions.html#int>. datarep string max, integer always. 🍓

📏 mpi4py.MPI.MAX_LIBRARY_VERSION_STRING

mpi4py.MPI.MAX_LIBRARY_VERSION_STRING: int = MAX_LIBRARY_VERSION_STRING

constant MAX_LIBRARY_VERSION_STRING, type int <https://docs.python.org/3/library/functions.html#int>. the longest-named MAX in this batch and, you guessed it, an integer. not me being obsessed with how consistent she is 💀

okay bestie we're still in the constants zone and honestly? the datatype roster is iconic — every single one of these is a module-level name living in mpi4py.MPI, and you're getting all of them, no skips, no edits, periodt 💅

  • mpi4py.MPI.MAX_PSET_NAME_LEN — declared as mpi4py.MPI.MAX_PSET_NAME_LEN: int = MAX_PSET_NAME_LEN. It's a constant named MAX_PSET_NAME_LEN whose type is int. 🎀
  • mpi4py.MPI.MAX_STRINGTAG_LEN — declared as mpi4py.MPI.MAX_STRINGTAG_LEN: int = MAX_STRINGTAG_LEN. A constant named MAX_STRINGTAG_LEN, type int. ✨

and now the datatype girlies — every one of these is an object of type <code>Datatype</code>, fr fr 🦋

  • mpi4py.MPI.DATATYPE_NULL — mpi4py.MPI.DATATYPE_NULL: Datatype = DATATYPE_NULL. Object DATATYPE_NULL, type Datatype.
  • mpi4py.MPI.PACKED — mpi4py.MPI.PACKED: Datatype = PACKED. Object PACKED, type Datatype.
  • mpi4py.MPI.BYTE — mpi4py.MPI.BYTE: Datatype = BYTE. Object BYTE, type Datatype.
  • mpi4py.MPI.AINT — mpi4py.MPI.AINT: Datatype = AINT. Object AINT, type Datatype.
  • mpi4py.MPI.OFFSET — mpi4py.MPI.OFFSET: Datatype = OFFSET. Object OFFSET, type Datatype.
  • mpi4py.MPI.COUNT — mpi4py.MPI.COUNT: Datatype = COUNT. Object COUNT, type Datatype.

the classic C-flavoured crew, showing up one by one like it's a group photo 🌸

  • mpi4py.MPI.CHAR — mpi4py.MPI.CHAR: Datatype = CHAR. Object CHAR, type Datatype.
  • mpi4py.MPI.WCHAR — mpi4py.MPI.WCHAR: Datatype = WCHAR. Object WCHAR, type Datatype.
  • mpi4py.MPI.SIGNED_CHAR — mpi4py.MPI.SIGNED_CHAR: Datatype = SIGNED_CHAR. Object SIGNED_CHAR, type Datatype.
  • mpi4py.MPI.SHORT — mpi4py.MPI.SHORT: Datatype = SHORT. Object SHORT, type Datatype.
  • mpi4py.MPI.INT — mpi4py.MPI.INT: Datatype = INT. Object INT, type Datatype.
  • mpi4py.MPI.LONG — mpi4py.MPI.LONG: Datatype = LONG. Object LONG, type Datatype.
  • mpi4py.MPI.LONG_LONG — mpi4py.MPI.LONG_LONG: Datatype = LONG_LONG. Object LONG_LONG, type Datatype.
  • mpi4py.MPI.UNSIGNED_CHAR — mpi4py.MPI.UNSIGNED_CHAR: Datatype = UNSIGNED_CHAR. Object UNSIGNED_CHAR, type Datatype.
  • mpi4py.MPI.UNSIGNED_SHORT — mpi4py.MPI.UNSIGNED_SHORT: Datatype = UNSIGNED_SHORT. Object UNSIGNED_SHORT, type Datatype.
  • mpi4py.MPI.UNSIGNED — mpi4py.MPI.UNSIGNED: Datatype = UNSIGNED. Object UNSIGNED, type Datatype.
  • mpi4py.MPI.UNSIGNED_LONG — mpi4py.MPI.UNSIGNED_LONG: Datatype = UNSIGNED_LONG. Object UNSIGNED_LONG, type Datatype.
  • mpi4py.MPI.UNSIGNED_LONG_LONG — mpi4py.MPI.UNSIGNED_LONG_LONG: Datatype = UNSIGNED_LONG_LONG. Object UNSIGNED_LONG_LONG, type Datatype.

floating point era 😭 they're all so pretty and so specific

  • mpi4py.MPI.FLOAT — mpi4py.MPI.FLOAT: Datatype = FLOAT. Object FLOAT, type Datatype.
  • mpi4py.MPI.DOUBLE — mpi4py.MPI.DOUBLE: Datatype = DOUBLE. Object DOUBLE, type Datatype.
  • mpi4py.MPI.LONG_DOUBLE — mpi4py.MPI.LONG_DOUBLE: Datatype = LONG_DOUBLE. Object LONG_DOUBLE, type Datatype.

now the <code>_t</code> family — fixed-width besties, lowkey the ones you actually reach for 👑

  • mpi4py.MPI.C_BOOL — mpi4py.MPI.C_BOOL: Datatype = C_BOOL. Object C_BOOL, type Datatype.
  • mpi4py.MPI.INT8_T — mpi4py.MPI.INT8_T: Datatype = INT8_T. Object INT8_T, type Datatype.
  • mpi4py.MPI.INT16_T — mpi4py.MPI.INT16_T: Datatype = INT16_T. Object INT16_T, type Datatype.
  • mpi4py.MPI.INT32_T — mpi4py.MPI.INT32_T: Datatype = INT32_T. Object INT32_T, type Datatype.
  • mpi4py.MPI.INT64_T — mpi4py.MPI.INT64_T: Datatype = INT64_T. Object INT64_T, type Datatype.
  • mpi4py.MPI.UINT8_T — mpi4py.MPI.UINT8_T: Datatype = UINT8_T. Object UINT8_T, type Datatype.
  • mpi4py.MPI.UINT16_T — mpi4py.MPI.UINT16_T: Datatype = UINT16_T. Object UINT16_T, type Datatype.
  • mpi4py.MPI.UINT32_T — mpi4py.MPI.UINT32_T: Datatype = UINT32_T. Object UINT32_T, type Datatype.
  • mpi4py.MPI.UINT64_T — mpi4py.MPI.UINT64_T: Datatype = UINT64_T. Object UINT64_T, type Datatype.
  • mpi4py.MPI.FLOAT16_T — mpi4py.MPI.FLOAT16_T: Datatype = FLOAT16_T. Object FLOAT16_T, type Datatype.
  • mpi4py.MPI.FLOAT32_T — mpi4py.MPI.FLOAT32_T: Datatype = FLOAT32_T. Object FLOAT32_T, type Datatype.
  • mpi4py.MPI.FLOAT64_T — mpi4py.MPI.FLOAT64_T: Datatype = FLOAT64_T. Object FLOAT64_T, type Datatype.
  • mpi4py.MPI.BFLOAT16_T — mpi4py.MPI.BFLOAT16_T: Datatype = BFLOAT16_T. Object BFLOAT16_T, type Datatype.

complex number moment 🧚 stay with me, we're not even halfway through the list

  • mpi4py.MPI.C_COMPLEX — mpi4py.MPI.C_COMPLEX: Datatype = C_COMPLEX. Object C_COMPLEX, type Datatype.
  • mpi4py.MPI.C_FLOAT_COMPLEX — mpi4py.MPI.C_FLOAT_COMPLEX: Datatype = C_FLOAT_COMPLEX. Object C_FLOAT_COMPLEX, type Datatype.
  • mpi4py.MPI.C_DOUBLE_COMPLEX — mpi4py.MPI.C_DOUBLE_COMPLEX: Datatype = C_DOUBLE_COMPLEX. Object C_DOUBLE_COMPLEX, type Datatype.
  • mpi4py.MPI.C_LONG_DOUBLE_COMPLEX — mpi4py.MPI.C_LONG_DOUBLE_COMPLEX: Datatype = C_LONG_DOUBLE_COMPLEX. Object C_LONG_DOUBLE_COMPLEX, type Datatype.

and the C++ remix, same energy, different name 💜

  • mpi4py.MPI.CXX_BOOL — mpi4py.MPI.CXX_BOOL: Datatype = CXX_BOOL. Object CXX_BOOL, type Datatype.
  • mpi4py.MPI.CXX_FLOAT_COMPLEX — mpi4py.MPI.CXX_FLOAT_COMPLEX: Datatype = CXX_FLOAT_COMPLEX. Object CXX_FLOAT_COMPLEX, type Datatype.
  • mpi4py.MPI.CXX_DOUBLE_COMPLEX — mpi4py.MPI.CXX_DOUBLE_COMPLEX: Datatype = CXX_DOUBLE_COMPLEX. Object CXX_DOUBLE_COMPLEX, type Datatype.
  • mpi4py.MPI.CXX_LONG_DOUBLE_COMPLEX — mpi4py.MPI.CXX_LONG_DOUBLE_COMPLEX: Datatype = CXX_LONG_DOUBLE_COMPLEX. Object CXX_LONG_DOUBLE_COMPLEX, type Datatype.

the two-for-one bundles 🫶 pairs, but make them a datatype

  • mpi4py.MPI.SHORT_INT — mpi4py.MPI.SHORT_INT: Datatype = SHORT_INT. Object SHORT_INT, type Datatype.
  • mpi4py.MPI.INT_INT — mpi4py.MPI.INT_INT: Datatype = INT_INT. Object INT_INT, type Datatype.
  • mpi4py.MPI.TWOINT — mpi4py.MPI.TWOINT: Datatype = TWOINT. Object TWOINT, type Datatype.
  • mpi4py.MPI.LONG_INT — mpi4py.MPI.LONG_INT: Datatype = LONG_INT. Object LONG_INT, type Datatype.
  • mpi4py.MPI.FLOAT_INT — mpi4py.MPI.FLOAT_INT: Datatype = FLOAT_INT. Object FLOAT_INT, type Datatype.
  • mpi4py.MPI.DOUBLE_INT — mpi4py.MPI.DOUBLE_INT: Datatype = DOUBLE_INT. Object DOUBLE_INT, type Datatype.
  • mpi4py.MPI.LONG_DOUBLE_INT — mpi4py.MPI.LONG_DOUBLE_INT: Datatype = LONG_DOUBLE_INT. Object LONG_DOUBLE_INT, type Datatype.

Fortran girlies, this is your section, we love you 🌈

  • mpi4py.MPI.CHARACTER — mpi4py.MPI.CHARACTER: Datatype = CHARACTER. Object CHARACTER, type Datatype.
  • mpi4py.MPI.LOGICAL — mpi4py.MPI.LOGICAL: Datatype = LOGICAL. Object LOGICAL, type Datatype.
  • mpi4py.MPI.INTEGER — mpi4py.MPI.INTEGER: Datatype = INTEGER. Object INTEGER, type Datatype.
  • mpi4py.MPI.REAL — mpi4py.MPI.REAL: Datatype = REAL. Object REAL, type Datatype.
  • mpi4py.MPI.DOUBLE_PRECISION — mpi4py.MPI.DOUBLE_PRECISION: Datatype = DOUBLE_PRECISION. Object DOUBLE_PRECISION, type Datatype.
  • mpi4py.MPI.COMPLEX — mpi4py.MPI.COMPLEX: Datatype = COMPLEX. Object COMPLEX, type Datatype.
  • mpi4py.MPI.DOUBLE_COMPLEX — mpi4py.MPI.DOUBLE_COMPLEX: Datatype = DOUBLE_COMPLEX. Object DOUBLE_COMPLEX, type Datatype.

and the sized Fortran variants, numbered like they're in a lineup ✨

  • mpi4py.MPI.LOGICAL1 — mpi4py.MPI.LOGICAL1: Datatype = LOGICAL1. Object LOGICAL1, type Datatype.
  • mpi4py.MPI.LOGICAL2 — mpi4py.MPI.LOGICAL2: Datatype = LOGICAL2. Object LOGICAL2, type Datatype.
  • mpi4py.MPI.LOGICAL4 — mpi4py.MPI.LOGICAL4: Datatype = LOGICAL4. Object LOGICAL4, type Datatype.
  • mpi4py.MPI.LOGICAL8 — mpi4py.MPI.LOGICAL8: Datatype = LOGICAL8. Object LOGICAL8, type Datatype.
  • mpi4py.MPI.LOGICAL16 — mpi4py.MPI.LOGICAL16: Datatype = LOGICAL16. Object LOGICAL16, type Datatype.
  • mpi4py.MPI.INTEGER1 — mpi4py.MPI.INTEGER1: Datatype = INTEGER1. Object INTEGER1, type Datatype.
  • mpi4py.MPI.INTEGER2 — mpi4py.MPI.INTEGER2: Datatype = INTEGER2. Object INTEGER2, type Datatype.
  • mpi4py.MPI.INTEGER4 — mpi4py.MPI.INTEGER4: Datatype = INTEGER4. Object INTEGER4, type Datatype.
  • mpi4py.MPI.INTEGER8 — mpi4py.MPI.INTEGER8: Datatype = INTEGER8. Object INTEGER8, type Datatype.
  • mpi4py.MPI.INTEGER16 — mpi4py.MPI.INTEGER16: Datatype = INTEGER16. Object INTEGER16, type Datatype.

and that's the whole datatype lineup bestie, every name exactly where it belongs, no notes 💅

💖 mpi4py.MPI.REAL2 💖

  • mpi4py.MPI.REAL2: Datatype = REAL2
  • Object REAL2 of type Datatype (mpi4py.MPI.Datatype)

✨ mpi4py.MPI.REAL4 ✨

  • mpi4py.MPI.REAL4: Datatype = REAL4
  • Object REAL4 of type Datatype (mpi4py.MPI.Datatype)

🌸 mpi4py.MPI.REAL8 🌸

  • mpi4py.MPI.REAL8: Datatype = REAL8
  • Object REAL8 of type Datatype (mpi4py.MPI.Datatype)

🦋 mpi4py.MPI.REAL16 🦋

  • mpi4py.MPI.REAL16: Datatype = REAL16
  • Object REAL16 of type Datatype (mpi4py.MPI.Datatype)

💜 mpi4py.MPI.COMPLEX4 💜

  • mpi4py.MPI.COMPLEX4: Datatype = COMPLEX4
  • Object COMPLEX4 of type Datatype (mpi4py.MPI.Datatype)

🍓 mpi4py.MPI.COMPLEX8 🍓

  • mpi4py.MPI.COMPLEX8: Datatype = COMPLEX8
  • Object COMPLEX8 of type Datatype (mpi4py.MPI.Datatype)

⭐ mpi4py.MPI.COMPLEX16 ⭐

  • mpi4py.MPI.COMPLEX16: Datatype = COMPLEX16
  • Object COMPLEX16 of type Datatype (mpi4py.MPI.Datatype)

🌊 mpi4py.MPI.COMPLEX32 🌊

  • mpi4py.MPI.COMPLEX32: Datatype = COMPLEX32
  • Object COMPLEX32 of type Datatype (mpi4py.MPI.Datatype)

🌿 mpi4py.MPI.UNSIGNED_INT 🌿

  • mpi4py.MPI.UNSIGNED_INT: Datatype = UNSIGNED_INT
  • Object UNSIGNED_INT of type Datatype (mpi4py.MPI.Datatype)

💅 mpi4py.MPI.SIGNED_SHORT 💅

  • mpi4py.MPI.SIGNED_SHORT: Datatype = SIGNED_SHORT
  • Object SIGNED_SHORT of type Datatype (mpi4py.MPI.Datatype)

🔮 mpi4py.MPI.SIGNED_INT 🔮

  • mpi4py.MPI.SIGNED_INT: Datatype = SIGNED_INT
  • Object SIGNED_INT of type Datatype (mpi4py.MPI.Datatype)

💎 mpi4py.MPI.SIGNED_LONG 💎

  • mpi4py.MPI.SIGNED_LONG: Datatype = SIGNED_LONG
  • Object SIGNED_LONG of type Datatype (mpi4py.MPI.Datatype)

🧚 mpi4py.MPI.SIGNED_LONG_LONG 🧚

  • mpi4py.MPI.SIGNED_LONG_LONG: Datatype = SIGNED_LONG_LONG
  • Object SIGNED_LONG_LONG of type Datatype (mpi4py.MPI.Datatype)

🌈 mpi4py.MPI.BOOL 🌈

  • mpi4py.MPI.BOOL: Datatype = BOOL
  • Object BOOL of type Datatype (mpi4py.MPI.Datatype)

🎀 mpi4py.MPI.SINT8_T 🎀

  • mpi4py.MPI.SINT8_T: Datatype = SINT8_T
  • Object SINT8_T of type Datatype (mpi4py.MPI.Datatype)

🪩 mpi4py.MPI.SINT16_T 🪩

  • mpi4py.MPI.SINT16_T: Datatype = SINT16_T
  • Object SINT16_T of type Datatype (mpi4py.MPI.Datatype)

💠 mpi4py.MPI.SINT32_T 💠

  • mpi4py.MPI.SINT32_T: Datatype = SINT32_T
  • Object SINT32_T of type Datatype (mpi4py.MPI.Datatype)

🌙 mpi4py.MPI.SINT64_T 🌙

  • mpi4py.MPI.SINT64_T: Datatype = SINT64_T
  • Object SINT64_T of type Datatype (mpi4py.MPI.Datatype)

🍑 mpi4py.MPI.F_BOOL 🍑

  • mpi4py.MPI.F_BOOL: Datatype = F_BOOL
  • Object F_BOOL of type Datatype (mpi4py.MPI.Datatype)

🌱 mpi4py.MPI.F_INT 🌱

  • mpi4py.MPI.F_INT: Datatype = F_INT
  • Object F_INT of type Datatype (mpi4py.MPI.Datatype)

💧 mpi4py.MPI.F_FLOAT 💧

  • mpi4py.MPI.F_FLOAT: Datatype = F_FLOAT
  • Object F_FLOAT of type Datatype (mpi4py.MPI.Datatype)

👑 mpi4py.MPI.F_DOUBLE 👑

  • mpi4py.MPI.F_DOUBLE: Datatype = F_DOUBLE
  • Object F_DOUBLE of type Datatype (mpi4py.MPI.Datatype)

🍀 mpi4py.MPI.F_COMPLEX 🍀

  • mpi4py.MPI.F_COMPLEX: Datatype = F_COMPLEX
  • Object F_COMPLEX of type Datatype (mpi4py.MPI.Datatype)

🫧 mpi4py.MPI.F_FLOAT_COMPLEX 🫧

  • mpi4py.MPI.F_FLOAT_COMPLEX: Datatype = F_FLOAT_COMPLEX
  • Object F_FLOAT_COMPLEX of type Datatype (mpi4py.MPI.Datatype)

🌌 mpi4py.MPI.F_DOUBLE_COMPLEX 🌌

  • mpi4py.MPI.F_DOUBLE_COMPLEX: Datatype = F_DOUBLE_COMPLEX
  • Object F_DOUBLE_COMPLEX of type Datatype (mpi4py.MPI.Datatype)

❄️ mpi4py.MPI.REQUEST_NULL ❄️

  • mpi4py.MPI.REQUEST_NULL: Request = REQUEST_NULL
  • Object REQUEST_NULL of type Request (mpi4py.MPI.Request)

🔔 mpi4py.MPI.MESSAGE_NULL 🔔

  • mpi4py.MPI.MESSAGE_NULL: Message = MESSAGE_NULL
  • Object MESSAGE_NULL of type Message (mpi4py.MPI.Message)

📭 mpi4py.MPI.MESSAGE_NO_PROC 📭

  • mpi4py.MPI.MESSAGE_NO_PROC: Message = MESSAGE_NO_PROC
  • Object MESSAGE_NO_PROC of type Message (mpi4py.MPI.Message)

🌀 mpi4py.MPI.OP_NULL 🌀

  • mpi4py.MPI.OP_NULL: Op = OP_NULL
  • Object OP_NULL of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

🔥 mpi4py.MPI.MAX 🔥

  • mpi4py.MPI.MAX: Op = MAX
  • Object MAX of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

💙 mpi4py.MPI.MIN 💙

  • mpi4py.MPI.MIN: Op = MIN
  • Object MIN of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

➕ mpi4py.MPI.SUM ➕

  • mpi4py.MPI.SUM: Op = SUM
  • Object SUM of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

✖️ mpi4py.MPI.PROD ✖️

  • mpi4py.MPI.PROD: Op = PROD
  • Object PROD of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

🔗 mpi4py.MPI.LAND 🔗

  • mpi4py.MPI.LAND: Op = LAND
  • Object LAND of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

🧩 mpi4py.MPI.BAND 🧩

  • mpi4py.MPI.BAND: Op = BAND
  • Object BAND of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

🌿 mpi4py.MPI.LOR 🌿

  • mpi4py.MPI.LOR: Op = LOR
  • Object LOR of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

☀️ mpi4py.MPI.BOR ☀️

  • mpi4py.MPI.BOR: Op = BOR
  • Object BOR of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

💖 mpi4py.MPI.LXOR 💖

  • mpi4py.MPI.LXOR: Op = LXOR
  • Object LXOR of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

🔷 mpi4py.MPI.BXOR 🔷

  • mpi4py.MPI.BXOR: Op = BXOR
  • Object BXOR of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

📍 mpi4py.MPI.MAXLOC 📍

  • mpi4py.MPI.MAXLOC: Op = MAXLOC
  • Object MAXLOC of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

📌 mpi4py.MPI.MINLOC 📌

  • mpi4py.MPI.MINLOC: Op = MINLOC
  • Object MINLOC of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

🔄 mpi4py.MPI.REPLACE 🔄

  • mpi4py.MPI.REPLACE: Op = REPLACE
  • Object REPLACE of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

🚫 mpi4py.MPI.NO_OP 🚫

  • mpi4py.MPI.NO_OP: Op = NO_OP
  • Object NO_OP of type Op (mpi4py.MPI.Op)

Parameters

  • x (Any)
  • y (Any)

Return type: Any

🕳️ mpi4py.MPI.GROUP_NULL 🕳️

  • mpi4py.MPI.GROUP_NULL: Group = GROUP_NULL
  • Object GROUP_NULL of type Group (mpi4py.MPI.Group)

🫥 mpi4py.MPI.GROUP_EMPTY 🫥

  • mpi4py.MPI.GROUP_EMPTY: Group = GROUP_EMPTY
  • Object GROUP_EMPTY of type Group (mpi4py.MPI.Group)

📭 mpi4py.MPI.INFO_NULL 📭

  • mpi4py.MPI.INFO_NULL: Info = INFO_NULL
  • Object INFO_NULL of type Info (mpi4py.MPI.Info)

🌍 mpi4py.MPI.INFO_ENV 🌍

  • mpi4py.MPI.INFO_ENV: Info = INFO_ENV
  • Object INFO_ENV of type Info (mpi4py.MPI.Info)

🧯 mpi4py.MPI.ERRHANDLER_NULL 🧯

  • mpi4py.MPI.ERRHANDLER_NULL: Errhandler = ERRHANDLER_NULL
  • Object ERRHANDLER_NULL of type Errhandler (mpi4py.MPI.Errhandler)

↩️ mpi4py.MPI.ERRORS_RETURN ↩️

  • mpi4py.MPI.ERRORS_RETURN: Errhandler = ERRORS_RETURN
  • Object ERRORS_RETURN of type Errhandler (mpi4py.MPI.Errhandler)

🛑 mpi4py.MPI.ERRORS_ABORT 🛑

  • mpi4py.MPI.ERRORS_ABORT: Errhandler = ERRORS_ABORT
  • Object ERRORS_ABORT of type Errhandler (mpi4py.MPI.Errhandler)

💀 mpi4py.MPI.ERRORS_ARE_FATAL 💀

  • mpi4py.MPI.ERRORS_ARE_FATAL: Errhandler = ERRORS_ARE_FATAL
  • Object ERRORS_ARE_FATAL of type Errhandler (mpi4py.MPI.Errhandler)

🌱 mpi4py.MPI.SESSION_NULL 🌱

  • mpi4py.MPI.SESSION_NULL: Session = SESSION_NULL
  • Object SESSION_NULL of type Session (mpi4py.MPI.Session)

🫧 mpi4py.MPI.COMM_NULL 🫧

  • mpi4py.MPI.COMM_NULL: Comm = COMM_NULL
  • Object COMM_NULL of type Comm (mpi4py.MPI.Comm)

🪞 mpi4py.MPI.COMM_SELF 🪞

  • mpi4py.MPI.COMM_SELF: Intracomm = COMM_SELF
  • Object COMM_SELF of type Intracomm (mpi4py.MPI.Intracomm)

🌎 mpi4py.MPI.COMM_WORLD 🌎

  • mpi4py.MPI.COMM_WORLD: Intracomm = COMM_WORLD
  • Object COMM_WORLD of type Intracomm (mpi4py.MPI.Intracomm)

🪟 mpi4py.MPI.WIN_NULL 🪟

  • mpi4py.MPI.WIN_NULL: Win = WIN_NULL
  • Object WIN_NULL of type Win (mpi4py.MPI.Win)

📄 mpi4py.MPI.FILE_NULL 📄

  • mpi4py.MPI.FILE_NULL: File = FILE_NULL
  • Object FILE_NULL of type File (mpi4py.MPI.File)

⬇️ mpi4py.MPI.BOTTOM ⬇️

  • mpi4py.MPI.BOTTOM: BottomType = BOTTOM
  • Object BOTTOM of type BottomType (mpi4py.MPI.BottomType)

🔁 mpi4py.MPI.IN_PLACE 🔁

  • mpi4py.MPI.IN_PLACE: InPlaceType = IN_PLACE
  • Object IN_PLACE of type InPlaceType (mpi4py.MPI.InPlaceType)

✨ mpi4py.MPI.BUFFER_AUTOMATIC ✨

  • mpi4py.MPI.BUFFER_AUTOMATIC: BufferAutomaticType = BUFFER_AUTOMATIC
  • Object BUFFER_AUTOMATIC of type BufferAutomaticType (mpi4py.MPI.BufferAutomaticType)
  • mpi4py.MPI.pickle — okay bestie, this is literally the module-level thing: mpi4py.MPI.pickle 💅 it's typed as Pickle (as in the mpi4py.MPI.Pickle object type, iykyk), and it's an instance of the Pickle object class. That's it. That's the whole vibe. ✨

💖 CITATION 💖

okay so if MPI for Python has been a whole significant moment for a project of yours that ends up in an academic publication?? please please please acknowledge it, bestie, it's giving respect-the-queens energy 🙏 here's the receipts:

🌈 INSTALLATION 🌈

✨ Wheel packages ✨

The mpi4py project builds and publishes binary wheels that can run across a whole buffet of things, no cap:

  • operating systems: Linux, macOS, Windows;
  • processor architectures: AMD64, ARM64;
  • MPI implementations: MPICH, Open MPI, MVAPICH, Intel MPI, HPE Cray MPICH, Microsoft MPI;
  • Python implementations: CPython, PyPy.

These mpi4py wheels are distributed via the Python Package Index (PyPI <https://pypi.org/project/mpi4py/>) and honestly you can just install them with Python package managers like pip <https://pip.pypa.io>, like:

python -m pip install mpi4py

The mpi4py wheels can be installed in standard Python virtual environments, fr fr. And plot twist: the MPI runtime can be provided by other wheels installed in that same virtual environment. 💅

Tip: Intel publishes production-grade Intel MPI wheels <https://pypi.org/project/impi-rt/#files> for Linux (x86_64) and Windows (AMD64). mpi4py and MPI wheels can be installed side by side to get a ready-to-use Python+MPI environment, bestie:
python -m pip install mpi4py impi-rt
Tip: The mpi4py project publishes MPICH wheels <https://pypi.org/project/mpich/#files> and Open MPI wheels <https://pypi.org/project/openmpi/#files> for Linux (x86_64/aarch64) and macOS (arm64/x86_64). mpi4py and MPI wheels can be installed side by side to get a ready-to-use Python+MPI environment:
python -m pip install mpi4py mpich    # for MPICH
python -m pip install mpi4py openmpi  # for Open MPI
Warning: ⚠️ The MPI wheels are distributed with special focus on ease of use, convenience, compatibility, and interoperability. The Linux wheels are built in somewhat constrained environments with relatively dated Linux distributions (manylinux <https://github.com/pypa/manylinux> container images). So like, they may lack support for features like GPU awareness (CUDA/ROCm) and C++/Fortran bindings. In production scenarios, it is recommended to use external (either custom-built or system-provided) MPI installations. Periodt. 💀

The mpi4py wheels can also be installed (with pip <https://pip.pypa.io>) in conda <https://docs.conda.io> environments and they should work out of the box, without any special tweak to environment variables, for any of the MPI packages provided by conda-forge <https://conda-forge.org/>. Iconic. ✨

Externally-provided MPI implementations may come from a system package manager, sysadmin-maintained builds accessible via module files, or customized user builds. Such usage is supported and encouraged, lowkey. However, there are a few platform-specific considerations to take into account. 🙈

🌸 Linux 🌸

The Linux (x86_64/aarch64) wheels require one of:

Users may need to set the LD_LIBRARY_PATH environment variable such that the dynamic linker is able to find at runtime the MPI shared library file (libmpi.so.*). iykyk 💅

💜 Fedora/RHEL 💜

On Fedora/RHEL systems, both MPICH and Open MPI are available for installation. There is no default or preferred MPI implementation, bestie — instead, users must select their favorite MPI implementation by loading the proper MPI module:

module load mpi/mpich-$(arch)    # for MPICH
module load mpi/openmpi-$(arch)  # for Open MPI

After loading the requested MPI module, the LD_LIBRARY_PATH environment variable should be properly setup. slay ✨

🦋 Debian/Ubuntu 🦋

On Debian/Ubuntu systems, Open MPI is the default MPI implementation and most of the MPI-based applications and libraries provided by the distribution depend on Open MPI. Nonetheless, MPICH is also available to users for installation.

In Ubuntu 22.04 and older, due to legacy reasons, the MPICH ABI is slightly broken: the MPI shared library file is named libmpich.so.12 instead of libmpi.so.12 as required by the MPICH ABI Compatibility Initiative <https://www.mpich.org/abi/>. not me crying over ABI drama 😭

Users without sudo access can workaround this issue creating a symbolic link anywhere in their home directory and appending to LD_LIBRARY_PATH:

mkdir -p ~/.local/lib
libdir=/usr/lib/$(arch)-linux-gnu
ln -s $libdir/libmpich.so.12 ~/.local/lib/libmpi.so.12
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:~/.local/lib

A system-wide fix for all users requires sudo access:

libdir=/usr/lib/$(arch)-linux-gnu
sudo ln -sr $libdir/libmpi{ch,}.so.12

🎀 HPE Cray OS 🎀

On HPE Cray systems, users must load the cray-mpich-abi module. For further details, refer to man intro_mpi <https://cpe.ext.hpe.com/docs/latest/mpt/mpich/intro_mpi.html#using-mpich-abi-compatibility>. 👑

⭐ macOS ⭐

The macOS (arm64/x86_64) wheels require:

🫶 Windows 🫶

The Windows (AMD64) wheels require one of:

User may need to set the I_MPI_ROOT or MSMPI_BIN environment variables such that the MPI dynamic link library (DLL) (impi.dll or msmpi.dll) can be found at runtime. 💅

Intel MPI is under active development and supports recent versions of the MPI standard. Intel MPI can be installed with pip (see the impi-rt <https://pypi.org/project/impi-rt/> package on PyPI), being therefore straightforward to get it up and running within a Python environment. Intel MPI can also be installed system-wide as part of the Intel oneAPI HPC Toolkit for Windows or via standalone online/offline installers. ate, no crumbs ✨

💖 Conda packages 💖

The conda-forge <https://conda-forge.org/> community provides ready-to-use binary packages from an ever growing collection of software libraries built around the multi-platform conda package manager. Four MPI implementations are available on conda-forge: Open MPI (Linux and macOS), MPICH (Linux and macOS), Intel MPI (Linux and Windows), and Microsoft MPI (Windows). You can install mpi4py and your preferred MPI implementation using the conda <https://docs.conda.io> package manager:

  • to use MPICH do:
conda install -c conda-forge mpi4py mpich
  • to use Open MPI do:
conda install -c conda-forge mpi4py openmpi
  • to use Intel MPI do:
conda install -c conda-forge mpi4py impi_rt
  • to use Microsoft MPI do:
conda install -c conda-forge mpi4py msmpi

MPICH and many of its derivatives are ABI-compatible. You can provide the package specification mpich=X.Y.*=external_* (where X and Y are the major and minor version numbers) to request the conda package manager to use system-provided MPICH (or derivative) libraries. Similarly, you can provide the package specification openmpi=X.Y.*=external_* to use system-provided Open MPI libraries. bestie that's the whole game 🔥

The openmpi package on conda-forge has built-in CUDA support, but it is disabled by default. To enable it, follow the instruction outlined during conda install. Additionally, UCX support is also available once the ucx package is installed.

Warning: ⚠️ The MPI conda-forge packages are built with special focus on compatibility. The MPICH and Open MPI packages are built in a constrained environment with relatively dated OS images. Therefore, they may lack support for high-performance features like cross-memory attach (XPMEM/CMA). In production scenarios, it is recommended to use external (either custom-built or system-provided) MPI installations. See the relevant conda-forge documentation about using external MPI libraries <https://conda-forge.org/docs/user/tipsandtricks/#using-external-message-passing-interface-mpi-libraries> . 💀

🧚 System packages 🧚

mpi4py is readily available through system package managers of most Linux distributions and the most popular community package managers for macOS. iconic ✨

🌸 Linux 🌸

On Fedora Linux systems (as well as RHEL and their derivatives using the EPEL software repository), you can install binary packages with the system package manager:

  • using dnf and the mpich package:
sudo dnf install python3-mpi4py-mpich
  • using dnf and the openmpi package:
sudo dnf install python3-mpi4py-openmpi

Please remember to load the correct MPI module for your chosen MPI implementation:

  • for the mpich package do:
module load mpi/mpich-$(arch)
python -c "from mpi4py import MPI"
  • for the openmpi package do:
module load mpi/openmpi-$(arch)
python -c "from mpi4py import MPI"

On Ubuntu Linux and Debian Linux systems, binary packages are available for installation using the system package manager:

sudo apt install python3-mpi4py

🌈 On Arch Linux, bestie

Binary packages? Already there, and you can grab them with the system package manager, like:

sudo pacman -S python-mpi4py

Slay. That's it. That's the whole thing. 💅

🍎 macOS girlies, this one's for you

macOS users can install mpi4py using the Homebrew <https://brew.sh/> package manager:

brew install mpi4py

Heads up though — the Homebrew mpi4py package uses Open MPI. Alternatively, install the mpich package and next install mpi4py from sources using pip.

Also, alternatively (so many alternatives, we love options), mpi4py can be installed from MacPorts <https://www.macports.org/>:

sudo port install py-mpi4py

🔨 Building from sources (the DIY era)

Okay so installing mpi4py from pre-built binary wheels, conda packages, or system packages is not always desired or appropriate. Like, for example, the mpi4py wheels published on PyPI may not be interoperable with non-mainstream, vendor-specific MPI implementations. Or a system mpi4py package may be built with an alternative, non-default MPI implementation. Awkward.

In such scenarios, mpi4py can still be installed from its source distribution (sdist) using pip:

python -m pip install --no-binary=mpi4py mpi4py

You can also install the in-development version with:

python -m pip install git+https://github.com/mpi4py/mpi4py

or:

python -m pip install https://github.com/mpi4py/mpi4py/tarball/master
Note: 💖 Installing mpi4py from its source distribution (available on PyPI) or Git source code repository (available on GitHub) requires a C compiler and a working MPI implementation with development headers and libraries. No compiler, no vibes, no mpi4py. Periodt.
Warning: 😭 pip keeps previously built wheel files in its cache for future reuse. So if you want to reinstall the mpi4py package from its source distribution using a different or updated MPI implementation, you have to either first remove the cached wheel file:
python -m pip cache remove mpi4py
python -m pip install --no-binary=mpi4py mpi4py

or ask pip to disable the cache:

python -m pip install --no-cache-dir --no-binary=mpi4py mpi4py

Pick your fighter. Both work. 🫶

🧚 Build backends (yes, there are three)

mpi4py supports three different build backends, and honestly? iconic:

  1. setuptools <https://setuptools.pypa.io/> — the default ✨
  2. scikit-build-core <https://scikit-build-core.readthedocs.io/> — CMake <https://cmake.org/>-based
  3. meson-python <https://meson-python.readthedocs.io/> — Meson <https://mesonbuild.com/>-based

The build backend can be selected by setting the MPI4PY_BUILD_BACKEND environment variable. That's the vibe check right there.

MPI4PY_BUILD_BACKEND

  • Choices — "setuptools", "scikit-build-core", "meson-python"
  • Default — "setuptools"
  • Request a build backend for building mpi4py from sources.

🌸 Using setuptools

Tip: Set the MPI4PY_BUILD_BACKEND environment variable to "setuptools" to use the setuptools <https://setuptools.pypa.io/> build backend.

When using the default setuptools <https://setuptools.pypa.io/> build backend, mpi4py relies on the legacy Python distutils framework to build C extension modules. Legacy, yes. Still doing the job, also yes. The following environment variables affect the build configuration — memorize these, bestie, they're the whole plot:

  • MPI4PY_BUILD_MPICC — The mpicc compiler wrapper command is searched for in the executable search path (the PATH environment variable) and used to compile the mpi4py.MPI <#module-mpi4py.MPI> C extension module. Alternatively, use the MPI4PY_BUILD_MPICC environment variable to the full path or command corresponding to the MPI-aware C compiler.
  • MPI4PY_BUILD_MPILD — The mpicc compiler wrapper command is also used for linking the mpi4py.MPI <#module-mpi4py.MPI> C extension module. Alternatively, use the MPI4PY_BUILD_MPILD environment variable to specify the full path or command corresponding to the MPI-aware C linker.
  • MPI4PY_BUILD_MPICFG — If the MPI implementation does not provide a compiler wrapper, or it is not installed in a default system location, all relevant build information like include/library locations and library lists can be provided in an ini-style configuration file under a [mpi] section. mpi4py can then be asked to use the custom build information by setting the MPI4PY_BUILD_MPICFG environment variable to the full path of the configuration file. As an example, see the mpi.cfg file located in the top level mpi4py source directory. 🎀
  • MPI4PY_BUILD_CONFIGURE — Some vendor MPI implementations may not provide complete coverage of the MPI standard, or may provide partial features of newer MPI standard versions while advertising support for an older version. Setting the MPI4PY_BUILD_CONFIGURE environment variable to a non-empty string will trigger the run of exhaustive checks for the availability of all MPI constants, predefined handles, and routines. Thorough queen behavior.
  • MPI4PY_BUILD_MPIABI — Setting the MPI4PY_BUILD_MPIABI environment variable to "1" enables enhanced support for the MPI 5.0 standard ABI and the MPICH or Open MPI legacy ABIs. The mpi4py.MPI <#module-mpi4py.MPI> extension module is then able to dynamically link at runtime with older versions (down to the MPI 3.0 standard) of the corresponding MPI implementation used at compile time. This feature is only available on Linux, macOS, and Windows. POSIX-like systems other than Linux and macOS are not currently supported, although they could easily be: all what is needed is for the platform to either support weak symbols in shared modules/libraries, or support the standard POSIX dlopen()/dlsym() APIs.
  • MPI4PY_BUILD_PYSABI — Build with the CPython 3.10+ Stable ABI <https://docs.python.org/3/c-api/stable.html#stable-abi>. Setting the MPI4PY_BUILD_PYSABI environment variable to a string "{major}.{minor}" defines the Py_LIMITED_API <https://docs.python.org/3/c-api/stable.html#c.Py_LIMITED_API> value to use for building extension modules.

The following environment variables are aliases for the ones described above. Having shorter names, they are convenient for occasional use in the command line. Its usage is not recommended in automation scenarios like packaging recipes, deployment scripts, and container image creation. (Cute for a one-off, not for the group project, iykyk.)

  • MPICC — Convenience alias for MPI4PY_BUILD_MPICC.
  • MPILD — Convenience alias for MPI4PY_BUILD_MPILD.
  • MPICFG — Convenience alias for MPI4PY_BUILD_MPICFG.

⭐ Using scikit-build-core

Tip: Set the MPI4PY_BUILD_BACKEND environment variable to "scikit-build-core" to use the scikit-build-core <https://scikit-build-core.readthedocs.io/> build backend.

When using the scikit-build-core <https://scikit-build-core.readthedocs.io/> build backend, mpi4py delegates all of MPI build configuration to CMake <https://cmake.org/>'s FindMPI <https://cmake.org/cmake/help/latest/module/FindMPI.html> module. Besides the obvious advantage of cross-platform support, this delegation to CMake may be convenient in build environments exposing vendor software stacks via intricate module systems. 🦋

Note however that mpi4py will not be able to look for MPI routines available beyond the MPI standard version the MPI implementation advertises to support (via the MPI_VERSION and MPI_SUBVERSION macro constants in the mpi.h header file), and any missing MPI constant or symbol will prevent a successful build. 💀

💜 Using meson-python

Tip: Set the MPI4PY_BUILD_BACKEND environment variable to "meson-python" to use the meson-python <https://meson-python.readthedocs.io/> build backend.

When using the meson-python <https://meson-python.readthedocs.io/> build backend, mpi4py delegates build tasks to the Meson <https://mesonbuild.com/> build system.

Warning: 🚨 mpi4py support for the meson-python <https://meson-python.readthedocs.io/> build backend is experimental. For the time being, users must set the CC <https://docs.python.org/3/using/configure.html#envvar-CC> environment variable to the command or path corresponding to the mpicc C compiler wrapper. Don't skip this step, bestie, the build will simply not cooperate. 😭

🌸 DEVELOPMENT 🌸

✨ Prerequisites ✨

okay bestie, before you can develop MPI for Python you need to have the following software properly installed, no skipping:

Optionally, consider installing the following packages:

Tip: Most routine development tasks like building, installing in editable mode, testing, and generating documentation can be performed with the spin (<https://github.com/scientific-python/spin>) developer tool. Run spin at the top level source directory for a list of available subcommands. 🧚

🛠️ Building 🛠️

MPI for Python uses a setuptools-based build system that relies on the setup.py file. Some setuptools commands (e.g., build) accept additional options:

  • --mpi= — Lets you pass a section with MPI configuration within a special configuration file. Alternatively, you can use the MPICFG environment variable.
  • --mpicc= — Specify the path or name of the mpicc C compiler wrapper. Alternatively, use the MPICC environment variable.
  • --mpild= — Specify the full path or name for the MPI-aware C linker. Alternatively, use the MPILD environment variable. If not set, the mpicc C compiler wrapper is used for linking.
  • --configure — Runs exhaustive tests for checking about missing MPI types, constants, and functions. This option should be passed in order to build MPI for Python against old MPI-1, MPI-2, or MPI-3 implementations, possibly providing a subset of MPI-4.

If you use a MPI implementation providing a mpicc C compiler wrapper (e.g., MPICH or Open MPI), it will be used for compilation and linking. This is the preferred and easiest way to build MPI for Python. 👑

If mpicc is found in the executable search path (PATH environment variable), simply run the build command:

$ python setup.py build

If mpicc is not in your search path or the compiler wrapper has a different name, you can run the build command specifying its location, either via the --mpicc command option or using the MPICC environment variable:

$ python setup.py build --mpicc=/path/to/mpicc
$ env MPICC=/path/to/mpicc python setup.py build

Alternatively, you can provide all the relevant information about your MPI implementation by editing the mpi.cfg file located in the top level source directory. You can use the default section [mpi] or add a new custom section, for example [vendor_mpi] (see the examples provided in the mpi.cfg file as a starting point to write your own section):

[mpi]
include_dirs         = /usr/local/mpi/include
libraries            = mpi
library_dirs         = /usr/local/mpi/lib
runtime_library_dirs = /usr/local/mpi/lib

[vendor_mpi]
include_dirs         = /opt/mpi/include ...
libraries            = mpi ...
library_dirs         = /opt/mpi/lib ...
runtime_library_dirs = /opt/mpi/lib ...

...

and then run the build command specifying you custom configuration section:

$ python setup.py build --mpi=vendor_mpi
$ env MPICFG=vendor_mpi python setup.py build

📦 Installing 📦

MPI for Python can be installed in editable mode:

$ python -m pip install --editable .

After modifying Cython sources, an in-place rebuild is needed:

$ python setup.py build --inplace

🧪 Testing 🧪

To quickly test the installation:

$ mpiexec -n 5 python -m mpi4py.bench helloworld
Hello, World! I am process 0 of 5 on localhost.
Hello, World! I am process 1 of 5 on localhost.
Hello, World! I am process 2 of 5 on localhost.
Hello, World! I am process 3 of 5 on localhost.
Hello, World! I am process 4 of 5 on localhost.

$ mpiexec -n 5 python -m mpi4py.bench ringtest -l 10 -n 1048576
time for 10 loops = 0.00361614 seconds (5 processes, 1048576 bytes)

If you installed from a git clone or the source distribution, issuing at the command line:

$ mpiexec -n 5 python demo/helloworld.py

will launch a five-process run of the Python interpreter and run the demo script demo/helloworld.py from the source distribution. slay. 💅

You can also run all the unittest scripts:

$ mpiexec -n 5 python test/main.py

or, if you have the pytest (<https://docs.pytest.org/>) unit testing framework installed:

$ mpiexec -n 5 pytest

💅 GUIDELINES 💅

🎀 Fair play 🎀

Summary

This section defines Rules of Play for companies and outside developers that engage with the mpi4py project. It covers:

  • Restrictions on use of the mpi4py name.
  • How and whether to publish a modified distribution.
  • How to make us aware of patched versions.

After reading this section, companies and developers will know what kinds of behavior the mpi4py developers and contributors would like to see, and which we consider troublesome, bothersome, and unacceptable.

This document is a close adaptation of NumPy NEP 36 (<https://numpy.org/neps/nep-0036-fair-play.html>).

Motivation

Occasionally, we learn of modified mpi4py versions and binary distributions circulated by outsiders. These patched versions can cause problems to mpi4py users (see, e.g., mpi4py/mpi4py#508 — <https://github.com/mpi4py/mpi4py/issues/508>). When issues like these arise, our developers waste time identifying the problematic release, locating alterations, and determining an appropriate course of action. 😭

In addition, packages on the Python Packaging Index are sometimes named such that users assume they are sanctioned or maintained by the mpi4py developers. We wish to reduce the number of such incidents.

Scope

This document aims to define a minimal set of rules that, when followed, will be considered good-faith efforts in line with the expectations of the mpi4py developers and contributors.

Our hope is that companies and outside developers who feel they need to modify mpi4py will first consider contributing to the project, or use alternative mechanisms for patching and extending mpi4py.

When in doubt, please talk to us first (<https://github.com/mpi4py/mpi4py/discussions/>). We may suggest an alternative; at minimum, we'll be informed and we may even grant an exception if deemed appropriate. 🫶

✨ Fair play rules ✨

  1. Do not reuse the mpi4py name for projects not affiliated with the mpi4py project.

At time of writing, there are only a handful of mpi4py-named packages developed by the mpi4py project, including mpi4py and mpi4py-fft. We ask that outside packages not include the phrase mpi4py, i.e., avoid names such as mycompany-mpi4py or mpi4py-mycompany.

To be clear, this rule only applies to modules (package names); it is perfectly acceptable to have a submodule of your own package named mycompany.mpi4py.

  1. Do not publish binary mpi4py wheels on PyPI (<https://pypi.org/>).

We ask companies and outside developers to not publish binary mpi4py wheels in the main Python Package Index (<https://pypi.org/>) under names such mpi4py-mpich, mpi4py-openmpi, or mpi4py-vendor_mpi.

The usual approaches to build binary Python wheels involve the embedding of dependent shared libraries. While such an approach may seem convenient and often is, in the particular case of MPI and mpi4py it is ultimately harmful to end users. Embedding the MPI shared libraries would prevent the use of external, system-provided MPI installations with hardware-specific optimizations and site-specific tweaks. 💀

The MPI 5.0 standard features an Application Binary Interface (ABI) for MPI, see [mpi-abi-paper] and [mpi-abi-issue]. Such standardization allows for any binary dependent on the MPI library to be used with multiple MPI backends. Once MPI implementations provide support for the new MPI ABI, the mpi4py project will follow and add support to the binary wheels published on PyPI. 🌈

[mpi-abi-paper] : J. Hammond, L. Dalcin, E. Schnetter, M. Pérache, J. B. Besnard, J. Brown, G. Brito Gadeschi, S. Byrne, J. Schuchart, and H. Zhou. MPI Application Binary Interface Standardization. EuroMPI 2023, Bristol, UK, September 2023. <https://doi.org/10.1145/3615318.3615319>

[mpi-abi-issue] : MPI Forum GitHub Issue: MPI needs a standard ABI. <https://github.com/mpi-forum/mpi-issues/issues/751>

  1. Do not republish modified versions of mpi4py.

Modified versions of mpi4py make it very difficult for the developers to address bug reports, since we typically do not know which parts of mpi4py have been modified.

If you have to break this rule (and we implore you not to!), then make it clear in the __version__ tag that you have modified mpi4py, e.g.:

>>> print(mpi4py.__version__)
'4.0.0+mycompany.13`

We understand that minor patches are often required to make a library work inside of a package ecosystem. This is totally acceptable, but we ask that no substantive changes are made.

  1. Do not extend or modify mpi4py's API.

If you absolutely have to break the previous rule, please do not add additional functions to the namespace, or modify the API of existing functions. Having additional functions exposed in distributed versions is confusing for users and developers alike. 🙈

💖 LICENSE 💖

okay so before anyone panics, here's the whole legal situation, and yes it's giving ✨official✨ but it's also very chill, don't worry 🫶

Copyright (c) 2025, Lisandro Dalcin — that's the whole copyright line, bestie, keep it sacred 👑

Here's the actual license text, verbatim, because legal stuff is the one thing you do NOT paraphrase, fr fr:

Copyright (c) 2025, Lisandro Dalcin

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its
   contributors may be used to endorse or promote products derived from
   this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS
IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

so what does all that actually mean in human words? let me translate 💅

  1. if you hand out the source code, you have to keep the copyright notice, the conditions list, and the disclaimer in there. no deleting receipts.
  2. if you hand out a compiled binary, same deal — the copyright notice, conditions, and disclaimer gotta show up in the docs and/or other materials that ship with it.
  3. you cannot use the copyright holder's name or the contributors' names to endorse or promote stuff built from this software without asking first. no clout-leeching, periodt.

and the big all-caps bit? that's the classic "no warranties" scream 🗣️ — the software comes “AS IS”, no express or implied warranty of any kind (including merchantability or fitness for a particular purpose), and nobody's liable for any direct, indirect, incidental, special, exemplary, or consequential damages — including procurement of substitute goods or services, loss of use, data, or profits, or business interruption — no matter the theory of liability (contract, strict liability, or tort, including negligence or otherwise) that arises out of using this software, even if they were told it might happen. it's giving standard open-source protective energy, lowkey iconic 🌈

📜 CHANGES 📜

the lore. the timeline. the glow-up history. buckle up bestie, we're going chronologically backwards 💖

Release 4.1.1 [2025-10-10]

  • Add MPIABI-aware import hook support. ✨
  • Support MPI.ERR_ERRHANDLER <#mpi4py.MPI.ERR_ERRHANDLER> with Open MPI.
  • Fix Windows build issues with Intel MPI 2021.16. 🪟
  • Minor fixes and improvements to typing stubs.
  • Minor fixes to documentation.
  • Publish Python 3.8-3.14 and PyPy 3.11 wheels. 🛞
  • PyPy 3.10 (EOL) wheels are no longer published. rest in peace 💀

Release 4.1.0 [2025-06-25]

New features

  • Publish binary wheel packages on PyPI <https://pypi.org/project/mpi4py/#files> with support for multiple operating systems (Linux, macOS, Windows), processor architectures (AMD64, ARM64), MPI implementations (MPICH, Open MPI, and their ABI-compatible derivatives), and Python implementations (CPython, PyPy). like… the sheer coverage?? obsessed 👑
  • Add support for the MPI 5.0 standard.
    • MPI handle serialization with integral values.
    • Fixed-size Fortran LOGICAL datatypes.
    • Query ABI version/info and Fortran ABI info.
  • MPI.Datatype.Create_contiguous <#mpi4py.MPI.Datatype.Create_contiguous> now uses BigMPI <https://doi.org/10.1109/ExaMPI.2014.5>'s approach when using MPI implementations that do not yet support the MPI 4.0 large-count APIs.
  • Add support for MPI.FLOAT16_T <#mpi4py.MPI.FLOAT16_T> and MPI.BFLOAT16_T <#mpi4py.MPI.BFLOAT16_T> datatypes. These datatypes are not yet standard but available as extensions in MPI implementations. 🧚
  • Add MPI.Status.tomemory <#mpi4py.MPI.Status.tomemory> to expose the status contents as a memoryview <https://docs.python.org/3/library/stdtypes.html#memoryview> object.

Enhancements

  • Support (opt-in via MPI4PY_BUILD_PYSABI <#envvar-MPI4PY_BUILD_PYSABI>) for building with Py_LIMITED_API <https://docs.python.org/3/c-api/stable.html#c.Py_LIMITED_API> under Python 3.10+ (requires Cython 3.1+).
  • Support (opt-in via MPI4PY_BUILD_MPIABI <#envvar-MPI4PY_BUILD_MPIABI>) for building with the MPI 5.0 standard ABI and the MPICH or Open MPI legacy ABIs. The MPI <#module-mpi4py.MPI> extension module will be able to dynamically link at runtime with older versions (down to the MPI 3.0 standard) of the MPI implementation used at compile time. Only available on Linux, macOS, and Windows. 🔥
  • Support a buffersize parameter in the MPIPoolExecutor.map() <#mpi4py.futures.MPIPoolExecutor.map> and MPIPoolExecutor.starmap() <#mpi4py.futures.MPIPoolExecutor.starmap> methods to limit the number of pending tasks.
  • Improve ownership management of DLPack capsules.
  • Reimplement MPI DLL search path on Windows.
  • Minor fixes to typing stubs and documentation.

Backward-incompatible changes

⚠️ heads up bestie, these will absolutely bite your old code, read carefully
  • Python 3.8+ is required. 📈
  • The MPI.Exception <#mpi4py.MPI.Exception> class is now a heap type.
  • The types of the MPI.BOTTOM <#mpi4py.MPI.BOTTOM>, MPI.IN_PLACE <#mpi4py.MPI.IN_PLACE>, and MPI.BUFFER_AUTOMATIC <#mpi4py.MPI.BUFFER_AUTOMATIC> are no longer subclasses of int <https://docs.python.org/3/library/functions.html#int>. yeah. that one. 😭

Release 4.0.3 [2025-02-13]

  • Fix DLPack v1.0 support. 🩹

Release 4.0.2 [2025-02-01]

  • Support MPI-4 features within Intel MPI 2021.14.
  • Various fixes and updates to tests.
  • Minor fixes to typing support.
  • Minor fix to documentation.

Release 4.0.1 [2024-10-11]

  • Update support for Python 3.13:
    • Enable Cython 3.1 support for free-threaded CPython. 🧵
    • Allow compiling Cython-generated C sources with the full Python C-API.
    • Fix MPI DLL path workarounds on Windows after changes to locals().
  • Enhancements to test suite:
    • Support XML reports via unittest-xml-reporting.
    • Add command line options to exclude tests by patterns and files.
    • Refactor Python 2 code to use Python 3 constructs using pyupgrade.
  • Miscellaneous:
    • Minor and mostly inconsequential subclass fix in mpi4py.util.pkl5.
    • Update compatibility workarounds for legacy MPICH 3.0 release.

Release 4.0.0 [2024-07-28]

New features

  • Add support for the MPI-4.0 standard.
    • Use large count MPI-4 routines.
    • Add persistent collective communication.
    • Add partitioned point-to-point communication.
    • Add new communicator constructors.
    • Add the Session class and its methods.
  • Add support for the MPI-4.1 standard.
    • Add non-destructive completion test for multiple requests.
    • Add value-index datatype constructor.
    • Add communicator/session buffer attach/detach/flush.
    • Support for removal of error classes/codes/strings.
    • Support for querying hardware resource information.
  • Add preliminary support for the upcoming MPI-5.0 standard.
    • User-level failure mitigation (ULFM). 💀➡️✨
  • mpi4py.util.pool: New drop-in replacement for multiprocessing.pool.
  • mpi4py.util.sync: New synchronization utilities.
  • Add runtime check for mismatch between mpiexec and MPI library. 🕵️
  • Support scikit-build-core <https://scikit-build.readthedocs.io/> as an alternative build backend.
  • Support meson-python <https://meson-python.readthedocs.io/> as an alternative build backend.

Enhancements

  • mpi4py.futures: Support for parallel tasks.
  • mpi4py.futures: Report exception tracebacks in workers.
  • mpi4py.util.pkl5: Add support for collective communication.
  • Add methods Datatype.fromcode(), Datatype.tocode() and attributes Datatype.typestr, Datatype.typechar to simplify NumPy interoperability for simple cases.
  • Add methods Comm.Create_errhandler(), Win.Create_errhandler(), and File.Create_errhandler() to create custom error handlers.
  • Add support for pickle serialization of instances of MPI types. All instances of Datatype, Info, and Status can be serialized. Instances of Op can be serialized only if created through mpi4py by calling Op.Create(). Instances of other MPI types can be serialized only if they reference predefined handles.
  • Add handle attribute and fromhandle() class method to MPI classes to ease interoperability with external code. The handle value is an unsigned integer guaranteed to fit on the platform's uintptr_t C type.
  • Add lowercase free() method to MPI classes to ease MPI object deallocation and cleanup. This method eventually attempts to call Free(), but only if the object's MPI handle is not a null or predefined handle, and such call is allowed within the World Model init/finalize. 🧹

Backward-incompatible changes

⚠️ this is the big one, the era shift, the before-and-after
  • Python 2 is no longer supported, Python 3.6+ is required, but typing stubs are supported for Python 3.8+. 👋 bye python 2
  • The Intracomm.Create_group() method is no longer defined in the base Comm class.
  • Group.Compare() and Comm.Compare() are no longer class methods but instance methods. Existing codes using the former class methods are expected to continue working.
  • Group.Translate_ranks() is no longer a class method but an instance method. Existing codes using the former class method are expected to continue working.
  • The LB and UB datatypes are no longer available, use Datatype.Create_resized() instead.
  • The HOST predefined attribute key is no longer available.
  • The MPI.memory class has been renamed to MPI.buffer. The old name is still available as an alias to the new name. 💅
  • The mpi4py.dl module is no longer available.
  • The mpi4py.get_config function returns an empty dictionary.

Miscellaneous

  • The project is now licensed under the BSD-3-Clause license. This change is fairly inconsequential for users and distributors. It simply adds an additional clause against using contributor names for promotional purposes without their consent.
  • Add a new guidelines section to documentation laying out new fair play rules. These rules ask companies and outside developers to refrain from reusing the mpi4py name in unaffiliated projects, publishing binary mpi4py wheels on the main Python Package Index (PyPI), and distributing modified versions with incompatible or extended API changes. The primary motivation of these rules is to avoid fragmentation and end-user confusion. 🫶

Release 3.1.6 [2024-04-14]

⚠️ This is the last release supporting Python 2.
  • Fix various build issues. 🔧

Release 3.1.5 [2023-10-04]

⚠️ This is the last release supporting Python 2.
  • Rebuild C sources with Cython 0.29.36 to support Python 3.12.

Release 3.1.4 [2022-11-02]

⚠️ This is the last release supporting Python 2.
  • Rebuild C sources with Cython 0.29.32 to support Python 3.11.
  • Fix contiguity check for DLPack and CAI buffers.
  • Workaround build failures with setuptools v60.

Release 3.1.3 [2021-11-25]

⚠️ This is the last release supporting Python 2.
  • Add missing support for MPI.BOTTOM to generalized all-to-all collectives.

Release 3.1.2 [2021-11-04]

⚠️ This is the last release supporting Python 2.
  • mpi4py.futures: add a _max_workers property to MPIPoolExecutor. yes bestie, you can finally peek at it 💅
  • mpi4py.util.dtlib: fix the computation of alignment for predefined datatypes.
  • mpi4py.util.pkl5: fix a deadlock when using ssend() + mprobe(). (not the fun kind of deadlock, there is no fun kind of deadlock 😭)
  • mpi4py.util.pkl5: add environment variable MPI4PY_PICKLE_THRESHOLD.
  • mpi4py.rc: interpret "y" and "n" strings as boolean values. slay, lowercase rights 🫶
  • Fix/add typemap/typestr for MPI.WCHAR/MPI.COUNT datatypes.
  • Minor fixes and additions to documentation.
  • Minor fixes to typing support.
  • Support for local version identifier (PEP-440).

🎀 Release 3.1.1 [2021-08-14]

Warning: This is the last release supporting Python 2. 🫡 pour one out
  • Fix typo in Requires-Python package metadata.
  • Regenerate C sources with Cython 0.29.24.

🌸 Release 3.1.0 [2021-08-12]

Warning: This is the last release supporting Python 2. (yes, again, it's giving final-season energy 💀)
  • New features:
    • mpi4py.util: a whole new package collecting miscellaneous utilities. it's giving ✨utility drawer✨
  • Enhancements:
    • Add pickle-based Request.waitsome() and Request.testsome().
    • Add lowercase methods Request.get_status() and Request.cancel().
    • Support for passing Python GPU arrays compliant with the DLPack <https://github.com/dmlc/dlpack> data interchange mechanism (link <https://data-apis.org/array-api/latest/design_topics/data_interchange.html>) and the __cuda_array_interface__ (CAI) standard (link <https://numba.readthedocs.io/en/stable/cuda/cuda_array_interface.html>) to uppercase methods. This support requires that mpi4py is built against CUDA-aware MPI <https://developer.nvidia.com/blog/introduction-cuda-aware-mpi/> implementations. This feature is currently experimental and subject to future changes. ⚠️ experimental means experimental, bestie, don't build your whole thesis on it
    • mpi4py.futures: add support for initializers and canceling futures at shutdown. Environment variables names now follow the pattern MPI4PY_FUTURES_*, the previous MPI4PY_* names are deprecated. (deprecated = still works, still judging you 💅)
    • Add type annotations to Cython code. The first line of the docstring of functions and methods displays a signature including type annotations.
    • Add companion stub files to support type checkers. your IDE is gonna be so normal about this fr fr
    • Support for weak references.
  • Miscellaneous:

🦋 Release 3.0.3 [2019-11-04]

  • Regenerate Cython wrappers to support Python 3.8.

⭐ Release 3.0.2 [2019-06-11]

  • Bug fixes:
    • Fix handling of readonly buffers in support for Python 2 legacy buffer interface. The issue triggers only when using a buffer-like object that is readonly and does not export the new Python 3 buffer interface.
    • Fix build issues with Open MPI 4.0.x series related to removal of many MPI-1 symbols deprecated in MPI-2 and removed in MPI-3.
    • Minor documentation fixes.

💜 Release 3.0.1 [2019-02-15]

  • Bug fixes:
    • Fix Comm.scatter() and other collectives corrupting input send list. Add safety measures to prevent related issues in global reduction operations. (your input list said not today 🙈)
    • Fix error-checking code for counts in Op.Reduce_local().
  • Enhancements:
    • Map size-specific Python/NumPy typecodes to MPI datatypes.
    • Allow partial specification of target list/tuple arguments in the various Win RMA methods.
    • Workaround for removal of MPI_{LB|UB} in Open MPI 4.0.
    • Support for Microsoft MPI v10.0.

🍓 Release 3.0.0 [2017-11-08]

  • New features:
    • mpi4py.futures: execute computations asynchronously using a pool of MPI processes. This package is based on concurrent.futures from the Python standard library.
    • mpi4py.run: run Python code and abort execution in case of unhandled exceptions to prevent deadlocks.
    • mpi4py.bench: run basic MPI benchmarks and tests.
  • Enhancements:
    • Lowercase, pickle-based collective communication calls are now thread-safe through the use of fine-grained locking. 🔒
    • The MPI module now exposes a memory type which is a lightweight variant of the builtin memoryview type, but exposes both the legacy Python 2 and the modern Python 3 buffer interface under a Python 2 runtime.
    • The MPI.Comm.Alltoallw() method now uses count=1 and displ=0 as defaults, assuming that messages are specified through user-defined datatypes.
    • The Request.Wait[all]() methods now return True to match the interface of Request.Test[all]().
    • The Win class now implements the Python buffer interface.
  • Backward-incompatible changes:
    • The buf argument of the MPI.Comm.recv() method is deprecated, passing anything but None emits a warning.
    • The MPI.Win.memory property was removed, use the MPI.Win.tomemory() method instead.
    • Executing python -m mpi4py in the command line is now equivalent to python -m mpi4py.run. For the former behavior, use python -m mpi4py.bench.
    • Python 2.6 and 3.2 are no longer supported. The mpi4py.MPI module may still build and partially work, but other pure-Python modules under the mpi4py namespace will not.
    • Windows: remove support for legacy MPICH2, Open MPI, and DeinoMPI.

🧚 Release 2.0.0 [2015-10-18]

  • Support for MPI-3 features.
    • Matched probes and receives.
    • Nonblocking collectives.
    • Neighborhood collectives.
    • New communicator constructors.
    • Request-based RMA operations.
    • New RMA communication and synchronisation calls.
    • New window constructors.
    • New datatype constructor.
    • New C++ boolean and floating complex datatypes.
  • Support for MPI-2 features not included in previous releases.
    • Generalized All-to-All collective (Comm.Alltoallw())
    • User-defined data representations (Register_datarep())
  • New scalable implementation of reduction operations for Python objects. This code is based on binomial tree algorithms using point-to-point communication and duplicated communicator contexts. To disable this feature, use mpi4py.rc.fast_reduce = False.
  • Backward-incompatible changes:
    • Python 2.4, 2.5, 3.0 and 3.1 are no longer supported.
    • Default MPI error handling policies are overridden. After import, mpi4py sets the ERRORS_RETURN error handler in COMM_SELF and COMM_WORLD, as well as any new Comm, Win, or File instance created through mpi4py, thus effectively ignoring the MPI rules about error handler inheritance. This way, MPI errors translate to Python exceptions. To disable this behavior and use the standard MPI error handling rules, use mpi4py.rc.errors = 'default'.
    • Change signature of all send methods, dest is a required argument.
    • Change signature of all receive and probe methods, source defaults to ANY_SOURCE, tag defaults to ANY_TAG.
    • Change signature of send lowercase-spelling methods, obj arguments are not mandatory.
    • Change signature of recv lowercase-spelling methods, renamed 'obj' arguments to 'buf'.
    • Change Request.Waitsome() and Request.Testsome() to return None or list.
    • Change signature of all lowercase-spelling collectives, sendobj arguments are now mandatory, recvobj arguments were removed.
    • Reduction operations MAXLOC and MINLOC are no longer special-cased in lowercase-spelling methods Comm.[all]reduce() and Comm.[ex]scan(), the input object must be specified as a tuple (obj, location).
    • Change signature of name publishing functions. The new signatures are Publish_name(service_name, port_name, info=INFO_NULL) and Unpublish_name(service_name, port_name, info=INFO_NULL).
    • Win instances now cache Python objects exposing memory by keeping references instead of using MPI attribute caching.
    • Change signature of Win.Lock(). The new signature is Win.Lock(rank, lock_type=LOCK_EXCLUSIVE, assertion=0).
    • Move Cartcomm.Map() to Intracomm.Cart_map().
    • Move Graphcomm.Map() to Intracomm.Graph_map().
    • Remove the mpi4py.MPE module.
    • Rename the Cython definition file for use with cimport statement from mpi_c.pxd to libmpi.pxd.

🌈 Release 1.3.1 [2013-08-07]

  • Regenerate C wrappers with Cython 0.19.1 to support Python 3.3.
  • Install *.pxd files in <site-packages>/mpi4py to ease the support for Cython's cimport statement in code requiring to access mpi4py internals.
  • As a side-effect of using Cython 0.19.1, ancient Python 2.3 is no longer supported. If you really need it, you can install an older Cython and run python setup.py build_src --force.

💖 Release 1.3 [2012-01-20]

  • Now Comm.recv() accept a buffer to receive the message.
  • Add Comm.irecv() and Request.{wait|test}[any|all]().
  • Add Intracomm.Spawn_multiple().
  • Better buffer handling for PEP 3118 and legacy buffer interfaces.
  • Add support for attribute attribute caching on communicators, datatypes and windows.
  • Install MPI-enabled Python interpreter as <path>/mpi4py/bin/python-mpi.
  • Windows: support for building with Open MPI.

🎀 Release 1.2.2 [2010-09-13]

  • Add mpi4py.get_config() to retrieve information (compiler wrappers, includes, libraries, etc) about the MPI implementation employed to build mpi4py.
  • Workaround Python libraries with missing GILState-related API calls in case of non-threaded Python builds.
  • Windows: look for MPICH2, DeinoMPI, Microsoft HPC Pack at their default install locations under %ProgramFiles.
  • MPE: fix hacks related to old API's, these hacks are broken when MPE is built with a MPI implementations other than MPICH2.
  • HP-MPI: fix for missing Fortran datatypes, use dlopen() to load the MPI shared library before MPI_Init()
  • Many distutils-related fixes, cleanup, and enhancements, better logics to find MPI compiler wrappers.
  • Support for pip install mpi4py.

🫶 Release 1.2.1 [2010-02-26]

  • Fix declaration in Cython include file. This declaration, while valid for Cython, broke the simple-minded parsing used in conf/mpidistutils.py to implement configure-tests for availability of MPI symbols.
  • Update SWIG support and make it compatible with Python 3. Also generate an warning for SWIG < 1.3.28.
  • Fix distutils-related issues in Mac OS X. Now ARCHFLAGS environment variable is honored of all Python's config/Makefile variables.
  • Fix issues with Open MPI < 1.4.2 related to error checking and MPI_XXX_NULL handles.

Release 1.2 [2009-12-29] 🎀

  • Automatic MPI datatype discovery for NumPy arrays and PEP-3118 buffers. So now buffer-like objects can be messaged directly — you don't have to spell out a 2/3-list/tuple like [data, MPI.DOUBLE] or [data, count, MPI.DOUBLE] anymore. Only basic types get this treatment tho: all C/C99-native signed/unsigned integral types, plus single/double precision real/complex floating types. Massive thanks to Eilif Muller for the initial feedback 💖
  • Nonblocking send of pickled Python objects. Huge thanks to Andreas Kloeckner for the initial patch and the genuinely enlightening discussion about this glow-up 🙌
  • Request instances now hold a reference to the Python object exposing the buffer involved in point-to-point communication or parallel I/O. Again, ty Andreas Kloeckner for the initial feedback ✨
  • Support for logging of user-defined states and events using MPE <https://www.mcs.anl.gov/research/projects/perfvis/>. Runtime (like, without requiring a recompile!) activation of logging of all MPI calls is supported on POSIX platforms implementing dlopen(). Obsessed 🫶
  • Support for all the new features in MPI-2.2: new C99 and F90 datatypes, distributed graph topology, local reduction operation, and other minor enhancements. Periodt 💅
  • Fix for the annoying issues related to Open MPI and Python dynamic loading of extension modules on platforms supporting dlopen(). finally 😭
  • Fix for SLURM dynamic loading issues on SiCortex. Many thanks to Ian Langmore for providing me shell access 🐚

Release 1.1.0 [2009-06-06] 🦋

  • Fix bug in Comm.Iprobe() that caused segfaults, because Python C-API calls were being issued with the GIL released (issue #2). not the segfault bestie 💀
  • Add Comm.bsend() and Comm.ssend() for buffered and synchronous send semantics when communicating general Python objects.
  • Now the call Info.Get(key) returns a single value (like, instead of a 2-tuple). That value is None if key is not in the Info object, or a string otherwise. Previously the call redundantly returned (None, False) for missing key-value pairs — None is enough to signal a missing entry, we don't need the extra drama.
  • Add support for parametrized Fortran datatypes ✨
  • Add support for decoding user-defined datatypes.
  • Add support for user-defined reduction operations on memory buffers. However, at most 16 user-defined reduction operations can be created. Ask the author for more room if you need it 👀

Release 1.0.0 [2009-03-20] 👑

This is the first release of the all-new, Cython-based implementation of MPI for Python. Unfortunately, this implementation is not backward-compatible with the previous one 😭. The list below summarizes the more important changes that can impact user codes.

  • Some communication calls had overloaded functionality. Now there's a clear distinction between communication of general Python objects with pickle, and (fast, near C-speed) communication of buffer-like objects (e.g., NumPy arrays).
    • for communicating general Python objects, you have to use all-lowercase methods, like send(), recv(), bcast(), etc.
    • for communicating array data, you have to use Send(), Recv(), Bcast(), etc. methods. Buffer arguments to these calls must be explicitly specified by using a 2/3-list/tuple like [data, MPI.DOUBLE], or [data, count, MPI.DOUBLE] (the former one uses the byte-size of data and the extent of the MPI datatype to define the count).
  • Indexing a communicator with an integer returned a special object associating the communication with a target rank, alleviating you from specifying source/destination/root arguments in point-to-point and collective communications. This functionality is no longer available, so expressions like:
MPI.COMM_WORLD[0].Send(...)
MPI.COMM_WORLD[0].Recv(...)
MPI.COMM_WORLD[0].Bcast(...)

have to be replaced by:

MPI.COMM_WORLD.Send(..., dest=0)
MPI.COMM_WORLD.Recv(..., source=0)
MPI.COMM_WORLD.Bcast(..., root=0)
  • Automatic MPI initialization (i.e., at import time) requests the maximum level of MPI thread support (i.e., it is done by calling MPI_Init_thread() and passing MPI_THREAD_MULTIPLE). In case you need to change this behavior, you can tweak the contents of the mpi4py.rc module.
  • In order to obtain the values of predefined attributes attached to the world communicator, now you have to use the Get_attr() method on the MPI.COMM_WORLD instance:
tag_ub = MPI.COMM_WORLD.Get_attr(MPI.TAG_UB)
  • In the previous implementation, MPI.COMM_WORLD and MPI.COMM_SELF were associated to duplicates of the (C-level) MPI_COMM_WORLD and MPI_COMM_SELF predefined communicator handles. Now this is no longer the case — MPI.COMM_WORLD and MPI.COMM_SELF proxy the actual MPI_COMM_WORLD and MPI_COMM_SELF handles. glow-up fr fr ✨
  • Convenience aliases MPI.WORLD and MPI.SELF were removed. Use instead MPI.COMM_WORLD and MPI.COMM_SELF.
  • Convenience constants MPI.WORLD_SIZE and MPI.WORLD_RANK were removed. Use instead MPI.COMM_WORLD.Get_size() and MPI.COMM_WORLD.Get_rank().

Author 🌈

Lisandro Dalcin

2026, Lisandro Dalcin

and that's a wrap on the whole page bestie!! 🎉 this was Release 4.1, dated March 20, 2026 — that's the version and date stamped at the bottom of the manual page (MPI4PY(3)), and yes I'm putting it in the sign-off instead of copying the footer line, because we're cute like that 💅🌸 go forth and parallelize, you absolute icon 🫶✨

📦 where this page comes from