cuddl::shared_tile_counter Class Reference

A tile counter shared by every rank of a communicator, for replica_search::next_tile. More...

Public Member Functions
__host__	shared_tile_counter (shared_tile_counter &&other) noexcept
__host__ shared_tile_counter &	operator= (shared_tile_counter &&other) noexcept
__host__	~shared_tile_counter ()
uint64_t	operator() ()
	The next tile number of the search, counting from 0 across every rank.
Result< void >	reset ()
	Starts the count again at 0 once every rank has finished the previous search.

Static Public Member Functions
static Result< shared_tile_counter >	make (MPI_Comm comm)

Detailed Description

A tile counter shared by every rank of a communicator, for replica_search::next_tile.

Making, resetting and destroying it are collective.

Rank 0 holds the count in an MPI window, and each claim is one remote fetch-and-add: about 20 microseconds across nodes, against tiles that take milliseconds to search. Open MPI completes a claim from another node only while rank 0 is inside MPI, even with hardware atomics: while rank 0 waited on its GPU, claims from the other node took 70-130 ms. Rank 0 therefore runs a thread that drives MPI progress for as long as the counter lives, so MPI must provide MPI_THREAD_MULTIPLE. The thread polls without sleeping, because Open MPI drives one-sided operations only on some progress calls: with a 20 us sleep between polls, claims took 10-21 ms. It yields, so it occupies a core only while no other thread wants one. A counter serves one search; call reset on every rank before the next. A failed claim aborts the communicator, because a lost tile would silently drop pairs from the results.

Definition at line 325 of file distributed.cuh.

Constructor & Destructor Documentation

shared_tile_counter()

__host__ cuddl::shared_tile_counter::shared_tile_counter ( shared_tile_counter &&  other )

inlinenoexcept

Definition at line 327 of file distributed.cuh.

        : state_(std::move(other.state_)) {}

~shared_tile_counter()

__host__ cuddl::shared_tile_counter::~shared_tile_counter ( )

inline

Definition at line 333 of file distributed.cuh.

{}  // NOLINT(modernize-use-equals-default)

Member Function Documentation

make()

static Result< shared_tile_counter > cuddl::shared_tile_counter::make ( MPI_Comm  comm )

inlinestatic

Definition at line 335 of file distributed.cuh.

                                                                         {
        int provided = MPI_THREAD_SINGLE;
        CUDDL_TRY(detail::mpi_try(MPI_Query_thread(&provided), "MPI_Query_thread"));
        if (provided < MPI_THREAD_MULTIPLE) {
            return Err(
                Error::invalid_argument(
                    "shared_tile_counter needs MPI initialised with MPI_THREAD_MULTIPLE"
                )
            );
        }
        auto state = std::make_unique<shared_state>();
        state->comm = comm;
        CUDDL_TRY(detail::mpi_try(MPI_Comm_rank(comm, &state->rank), "MPI_Comm_rank"));
        auto const bytes = state->rank == 0 ? static_cast<MPI_Aint>(sizeof(uint64_t)) : 0;
        CUDDL_TRY(
            detail::mpi_try(
                MPI_Win_allocate(
                    bytes, sizeof(uint64_t), MPI_INFO_NULL, comm, &state->count, &state->window
                ),
                "MPI_Win_allocate"
            )
        );
        CUDDL_TRY(detail::mpi_try(MPI_Win_lock_all(0, state->window), "MPI_Win_lock_all"));
        state->locked = true;
        if (state->rank == 0) {
            *state->count = 0;
            CUDDL_TRY(detail::mpi_try(MPI_Win_sync(state->window), "MPI_Win_sync"));
            CUDDL_TRY(
                detail::mpi_try(MPI_Comm_dup(MPI_COMM_SELF, &state->progress_comm), "MPI_Comm_dup")
            );
            // Probing a communicator nobody sends on runs MPI's progress engine, which
            // completes the claims other ranks have in flight.
            if (!detail::ablated("progress-thread")) {
                state->progress =
                    std::jthread([comm = state->progress_comm](const std::stop_token& stop) {
                        while (!stop.stop_requested()) {
                            int flag = 0;
                            MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, comm, &flag, MPI_STATUS_IGNORE);
                            std::this_thread::yield();
                        }
                    });
            }
        }
        CUDDL_TRY(detail::mpi_try(MPI_Barrier(comm), "MPI_Barrier"));
        shared_tile_counter counter;
        counter.state_ = std::move(state);
        return Result<shared_tile_counter>::ok(std::move(counter));
    }

Here is the call graph for this function:

operator()()

uint64_t cuddl::shared_tile_counter::operator() ( )

inline

The next tile number of the search, counting from 0 across every rank.

Definition at line 385 of file distributed.cuh.

                                        {
        std::lock_guard const lock(state_->update);
        uint64_t const one = 1;
        uint64_t previous = 0;
        if (MPI_Fetch_and_op(&one, &previous, MPI_UINT64_T, 0, 0, MPI_SUM, state_->window) !=
                MPI_SUCCESS ||
            MPI_Win_flush(0, state_->window) != MPI_SUCCESS) {
            MPI_Abort(state_->comm, 1);
        }
        return previous;
    }

operator=()

__host__ shared_tile_counter & cuddl::shared_tile_counter::operator= ( shared_tile_counter &&  other )

inlinenoexcept

Definition at line 329 of file distributed.cuh.

                                                                                  {
        state_ = std::move(other.state_);
        return *this;
    }

reset()

Result< void > cuddl::shared_tile_counter::reset ( )

inline

Starts the count again at 0 once every rank has finished the previous search.

Definition at line 398 of file distributed.cuh.

                                       {
        CUDDL_TRY(detail::mpi_try(MPI_Barrier(state_->comm), "MPI_Barrier"));
        if (state_->rank == 0) {
            uint64_t const zero = 0;
            CUDDL_TRY(
                detail::mpi_try(
                    MPI_Accumulate(
                        &zero, 1, MPI_UINT64_T, 0, 0, 1, MPI_UINT64_T, MPI_REPLACE, state_->window
                    ),
                    "MPI_Accumulate"
                )
            );
            CUDDL_TRY(detail::mpi_try(MPI_Win_flush(0, state_->window), "MPI_Win_flush"));
        }
        return detail::mpi_try(MPI_Barrier(state_->comm), "MPI_Barrier");
    }

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• distributed.cuh