https://github.com/llnl/lwgrp

The Light-weight Group Library provides methods for MPI codes to quickly create and destroy process groups
https://github.com/llnl/lwgrp

mpi shell

Last synced: 7 days ago
JSON representation

The Light-weight Group Library provides methods for MPI codes to quickly create and destroy process groups

• Host: GitHub
• URL: https://github.com/llnl/lwgrp
• Owner: LLNL
• License: other
• Created: 2012-08-06T20:57:39.000Z (over 12 years ago)
• Default Branch: main
• Last Pushed: 2024-06-28T18:00:56.000Z (5 months ago)
• Last Synced: 2024-06-29T19:03:20.730Z (5 months ago)
• Topics: mpi, shell
• Language: C
• Homepage:
• Size: 1.25 MB
• Stars: 5
• Watchers: 18
• Forks: 7
• Open Issues: 1
• Metadata Files:
  • Readme: README
  • Contributing: CONTRIBUTING.md
  • License: LICENSE.TXT
  • Code of conduct: CODE_OF_CONDUCT.md

Awesome Lists containing this project

README

        
The light-weight group library defines data structures and collective

operations to group MPI processes as an ordered set.  Such groups are

useful as substitutes for MPI communicators when the overhead of

communicator creation is too costly.  For example, certain sorting

algorithms recursively divide processes into subgroups as the sort

algorithm progresses.  These groups may be different with each

invocation, so that it is inefficient to create and destroy

communicators during the sort routine.

Data structures:

  chain    - each member records addresses of left and right members

             first and last rank set boundary to MPI_PROC_NULL

  ring     - like the chain, except first and last rank wrap around 

  logchain - each member records addresses of each member 2^d hops

             to left and right d=0..log(N)-1 (MPI_PROC_NULL at ends)

  logring  - each member records addresses of each member 2^d hops

             to left and right with wrap at ends

We represent groups of processes using a doubly-linked list called

a "chain".  This is a very simple struct that records the number

of processes in the group, the rank of the local process within the

group, the address of the local process, and the addresses of the

processes having ranks one less (left) and one more (right) than the

local process.  We implement the LWGRP library on top of MPI, so for

addresses we record a parent communicator and ranks within that

communicator.  To be light-weight, the reference to the communicator

is a literal copy of the handle value, not a full dup.

Since each member only stores the addresses for a few other group

members, it is the responsibility of higher level software to exchange

address information for more general point-to-point communication.

Additionally, the caller is responsible for choosing tag values as a

group context.

There is also a "ring", which is like a chain, but it wraps around

at the ends.

There are two structures, called a logchain and logring, used to cache

adddresses of more group members.  These structures must be used in

conjunction with either a chain or ring, respectively.  They cache

addresses for processes that are 2^d hops to the left and right sides

where d ranges from 0 to log(N)-1 inclusive.  This pattern enables

one to construct trees, and so it's useful to cache this information

for use in collective operations.