|
| procedure, pass(this) | init (this, send_pe, recv_pe) |
| | Initialise the uTofu communication method. See gs_comm.f90 for details.
|
| |
| procedure, pass(this) | free (this) |
| | Deallocate the uTofu communication method.
|
| |
| procedure, pass(this) | nbsend (this, u, n, tag, deps, strm) |
| | Pack the send slabs and fire all one-sided puts (non-blocking).
|
| |
| procedure, pass(this) | nbrecv (this, tag) |
| | No-op: the one-sided receive buffer is registered once at init, so there is nothing to post per round.
|
| |
| procedure, pass(this) | nbwait (this, u, n, op, strm) |
| | Poll for incoming puts, reducing each slab into u as it lands, then wait for our own sends to drain and flip the double-buffer parity.
|
| |
| procedure, pass(this) | nbsend_vec (this, u, n, nc, tag, deps, strm) |
| | Pack the fused nc-component send slabs and fire the puts (non-blocking).
|
| |
| procedure, pass(this) | nbrecv_vec (this, tag, nc) |
| | No-op: the vector receive buffer is registered once at init, so there is nothing to post per round.
|
| |
| procedure, pass(this) | nbwait_vec (this, u, n, nc, op, strm) |
| | Poll for incoming vector puts, reducing each nc-component slab into u as it lands, then flip the vector double-buffer parity. Same protocol as gs_nbwait_utofu, on the vector context and parity.
|
| |
| procedure(gs_comm_init), deferred, pass | init gs_comm_init |
| |
| procedure(gs_comm_free), deferred, pass | free gs_comm_free |
| |
| procedure(gs_nbsend), deferred, pass | nbsend gs_nbsend |
| |
| procedure(gs_nbrecv), deferred, pass | nbrecv gs_nbrecv |
| |
| procedure(gs_nbwait), deferred, pass | nbwait gs_nbwait |
| |
| procedure, pass(this) | init_dofs (this) |
| |
| procedure, pass(this) | free_dofs (this) |
| |
| procedure, pass(this) | init_order (this, send_pe, recv_pe) |
| | Obtains which ranks to send and receive data from.
|
| |
| procedure, pass(this) | free_order (this) |
| |
| procedure, pass(this) | take_schedule (this, src) |
| | Take over the gather-scatter schedule (dof lists and peer order) of src, avoiding a second (expensive) pass over the connectivity. The data is moved rather than copied, so src is left without a schedule and must not be used for communication afterwards (it can still be freed). No communication resources are set up here; complete the handover with init_schedule once src has been freed, so that the two backends never hold their resources at the same time.
|
| |
| procedure, pass(this) | init_schedule (this) |
| | Set up this communication method for the schedule taken over by take_schedule. Collective, as init is.
|
| |
| procedure, pass(this) | nbsend_vec (this, u, n, nc, tag, deps, strm) |
| | Fused vector halo exchange. Default implementations abort; backends that set vec_supported = .true. override them.
|
| |
| procedure, pass(this) | nbrecv_vec (this, tag, nc) |
| | Default fused vector receive. Abort unless a backend overrides it.
|
| |
| procedure, pass(this) | nbwait_vec (this, u, n, nc, op, strm) |
| | Default fused vector wait/reduce. Abort unless a backend overrides it.
|
| |
|
| real(kind=rp), dimension(:), pointer | send_buf => null() |
| | Concatenated send slabs, one per peer (the put sources). Registered with uTofu; a pointer (not allocatable) so c_loc can take its address – the standard forbids the target attribute on a type component.
|
| |
| real(kind=rp), dimension(:), pointer | recv_buf => null() |
| | Double-buffered receive slabs: two halves of buf_size elements each, selected by parity. Registered with uTofu; pointer for the same reason as send_buf.
|
| |
| integer, dimension(:), allocatable | send_len |
| | Per-peer slab lengths and 0-based offsets into send_buf / recv_buf.
|
| |
| integer, dimension(:), allocatable | recv_len |
| |
| integer, dimension(:), allocatable | send_offset |
| |
| integer, dimension(:), allocatable | recv_offset |
| |
| integer(c_int64_t), dimension(:), allocatable | send_off64 |
| | Int64 views of the send layout, passed to the C transport.
|
| |
| integer(c_int64_t), dimension(:), allocatable | send_len64 |
| |
| integer(c_int64_t), dimension(:), allocatable | rmt_vcq_id |
| | Per send-peer remote put targets, learned from each receiver at init: its receive VCQ id, buffer STADD, the byte-offsets of our slab in its two parity halves, and the edata tag it wants us to stamp.
|
| |
| integer(c_int64_t), dimension(:), allocatable | rmt_stadd |
| |
| integer(c_int64_t), dimension(:), allocatable | dst_off0 |
| |
| integer(c_int64_t), dimension(:), allocatable | dst_off1 |
| |
| integer(c_int), dimension(:), allocatable | dst_tag |
| |
| integer(c_int), dimension(:), allocatable | recv_indices |
| | Scratch for the unpack-as-ready loop: receive-peer indices completed by the latest poll and how many (c_int to match the C transport).
|
| |
| integer(c_int) | ncompleted = 0 |
| |
| integer | buf_size = 0 |
| | Size in elements of one receive half (= total receive count).
|
| |
| integer | send_size = 0 |
| | Size in elements of one send half (= total send count); send_buf is double-buffered (2 * send_size) so a round can pack while the previous round's puts are still draining.
|
| |
| integer | elem_size = 0 |
| | Storage size of one element in bytes.
|
| |
| integer | parity = 0 |
| | Active double-buffer half for the next round.
|
| |
| type(c_ptr) | ctx = c_null_ptr |
| | Opaque per-instance uTofu context (registrations + notice stash).
|
| |
| real(kind=rp), dimension(:), pointer | send_buf_v => null() |
| | Fused vector (multi-component) path: double-buffered send/recv slabs sized for GS_VEC_NC components. Each peer slab holds nc consecutive component blocks, so the scalar layout is reused scaled by nc. The path has its OWN uTofu context (registrations, receive VCQ and thus private MRQ, completion counters) and its own parity: a neighbour racing from a vector round into a scalar round (or vice versa) must not land notices in the other path's queue.
|
| |
| real(kind=rp), dimension(:), pointer | recv_buf_v => null() |
| |
| integer(c_int64_t), dimension(:), allocatable | rmt_vcq_id_v |
| | Per send-peer vector-path put targets: the receiver's vector recv VCQ id and buffer STADD, our slab's scalar element offset within one of its halves, and its scalar half size (both unscaled; the sender scales by nc and folds the parity in at round time).
|
| |
| integer(c_int64_t), dimension(:), allocatable | rmt_stadd_v |
| |
| integer(c_int64_t), dimension(:), allocatable | rmt_off_v |
| |
| integer(c_int64_t), dimension(:), allocatable | rmt_bufsz_v |
| |
| integer(c_int64_t), dimension(:), allocatable | send_off64_v |
| | Per-round scratch, computed by the master each nbsend_vec: the send layout scaled by nc and the absolute destination element offsets (vector parity already folded in).
|
| |
| integer(c_int64_t), dimension(:), allocatable | send_len64_v |
| |
| integer(c_int64_t), dimension(:), allocatable | dst_off_v |
| |
| integer | parity_v = 0 |
| | Active vector double-buffer half for the next vector round.
|
| |
| type(c_ptr) | ctx_v = c_null_ptr |
| | Opaque uTofu context of the vector path.
|
| |
| type(stack_i4_t), dimension(:), allocatable | send_dof |
| | A list of stacks of dof indices local to this process to send to rank_i.
|
| |
| type(stack_i4_t), dimension(:), allocatable | recv_dof |
| | recv_dof(rank_i) is a stack of dof indices local to this process to receive from rank_i. size(recv_dof) == pe_size
|
| |
| integer, dimension(:), allocatable | send_pe |
| | Array of ranks that this process should send to.
|
| |
| integer, dimension(:), allocatable | recv_pe |
| | array of ranks that this process will receive messages from
|
| |
| logical | vec_supported = .false. |
| | Whether this backend implements the fused vector (multi-component) halo exchange (nbsend_vec/nbrecv_vec/nbwait_vec). When .false., the gs_op_r3 caller falls back to nc independent scalar exchanges.
|
| |
Definition at line 76 of file gs_utofu.F90.