Sylvain Jeaugey
6aae379278
Network user buffer support for collectives * Leverage user buffer registration to achieve zero-copy inter-node communications for Ring, NVLS and Collnet Add RAS subsystem * Create a RAS thread keeping track of all NCCL communicators. * Add a ncclras tool contacting the RAS thread and getting a report. Add fp8 support * Add support for e5m2 and e4m3 8-bit floating point operations. * Use Tree/PAT algorithms when possible for better numerical stability. Add NIC fusion * Add a NET API to ask the network plugin to fuse a set of interfaces together. * Fuse multiple NICs under the same PCI switch as a single, larger NIC. Socket connection failure retry * Retry in case of socket connection failure (unreachable host) * Avoid "Software caused connection abort" errors on retries QP connection failure retry * Retry in case of IB QP connection failure during ibv_modify_qp. NET API improvements * Allow plugins to force a flush in case data and completion ordering is not guaranteed. * Indicate when completion is not needed (e.g. for the LL128 protocol), allowing plugins to skip generating a completion. * Allow for full offload of allgather operations when using one GPU per node. NCCL_ALGO/NCCL_PROTO strict enforcement * Extend NCCL_ALGO/NCCL_PROTO syntax to be able to specify ALGO/PROTO filters for each collective operation. * Strictly enforce the ALGO/PROTO filters, no longer fall back on the ring algorithm when the filtering leaves no option and error out instead. Enable CUMEM host allocations * Use cumem functions for host memory allocation by default. Improved profiler plugin API * Avoid dependencies with NCCL includes. * Add information on whether the buffer is registered or not Adjust PAT tuning * Improve transition between PAT and ring at scale. Fix hangs when running with different CPU architectures * Detect when we use a mix of GPU architectures * Ensure Algo/Proto decisions are made based on that unified state. Fix FD leak in UDS * Fix a leak when mapping buffers intra-node with cumem IPCs. Fix crash when mixing buffer registration and graph buffer registration. * Separate local and graph registration to avoid crashes when we free buffers. Fix user buffer registration with dmabuf * Make ncclSend/ncclRecv communication with buffer registration functional on network plugins relying on dmabuf for buffer registration. Fix crash in IB code caused by uninitialized fields. Fix non-blocking ncclSend/ncclRecv * Fix case where ncclSend/ncclRecv would return ncclSuccess in non-blocking mode even though the operation was not enqueued onto the stream. * Issue #1495 Various compiler tweaks and fixes * PR #758 Fix typo in ncclTopoPrintGraph * Issue #1468
82 lines
4.4 KiB
C
82 lines
4.4 KiB
C
/*
|
|
* Copyright (c) 2017-2022, NVIDIA CORPORATION. All rights reserved.
|
|
*/
|
|
|
|
#ifndef NCCL_NET_V8_H_
|
|
#define NCCL_NET_V8_H_
|
|
|
|
#include "net_device.h"
|
|
|
|
typedef struct {
|
|
char* name; // Used mostly for logging.
|
|
char* pciPath; // Path to the PCI device in /sys.
|
|
uint64_t guid; // Unique identifier for the NIC chip. Important for
|
|
// cards with multiple PCI functions (Physical or virtual).
|
|
int ptrSupport; // [NCCL_PTR_HOST|NCCL_PTR_CUDA|NCCL_PTR_DMABUF]
|
|
int regIsGlobal; // regMr is not tied to a particular comm
|
|
int speed; // Port speed in Mbps.
|
|
int port; // Port number.
|
|
float latency; // Network latency
|
|
int maxComms; // Maximum number of comms we can create
|
|
int maxRecvs; // Maximum number of grouped receives.
|
|
ncclNetDeviceType netDeviceType; // Network offload type
|
|
int netDeviceVersion; // Version number for network offload
|
|
} ncclNetProperties_v8_t;
|
|
|
|
typedef struct {
|
|
// Name of the network (mainly for logs)
|
|
const char* name;
|
|
// Initialize the network.
|
|
ncclResult_t (*init)(ncclDebugLogger_t logFunction);
|
|
// Return the number of adapters.
|
|
ncclResult_t (*devices)(int* ndev);
|
|
// Get various device properties.
|
|
ncclResult_t (*getProperties)(int dev, ncclNetProperties_v8_t* props);
|
|
// Create a receiving object and provide a handle to connect to it. The
|
|
// handle can be up to NCCL_NET_HANDLE_MAXSIZE bytes and will be exchanged
|
|
// between ranks to create a connection.
|
|
ncclResult_t (*listen)(int dev, void* handle, void** listenComm);
|
|
// Connect to a handle and return a sending comm object for that peer.
|
|
// This call must not block for the connection to be established, and instead
|
|
// should return successfully with sendComm == NULL with the expectation that
|
|
// it will be called again until sendComm != NULL.
|
|
// If *sendDevComm points to a valid object, then NCCL is requesting device offload for this connection
|
|
ncclResult_t (*connect)(int dev, void* handle, void** sendComm, ncclNetDeviceHandle_v8_t** sendDevComm);
|
|
// Finalize connection establishment after remote peer has called connect.
|
|
// This call must not block for the connection to be established, and instead
|
|
// should return successfully with recvComm == NULL with the expectation that
|
|
// it will be called again until recvComm != NULL.
|
|
// If *recvDevComm points to a valid object, then NCCL is requesting device offload for this connection
|
|
ncclResult_t (*accept)(void* listenComm, void** recvComm, ncclNetDeviceHandle_v8_t** recvDevComm);
|
|
// Register/Deregister memory. Comm can be either a sendComm or a recvComm.
|
|
// Type is either NCCL_PTR_HOST or NCCL_PTR_CUDA.
|
|
ncclResult_t (*regMr)(void* comm, void* data, size_t size, int type, void** mhandle);
|
|
/* DMA-BUF support */
|
|
ncclResult_t (*regMrDmaBuf)(void* comm, void* data, size_t size, int type, uint64_t offset, int fd, void** mhandle);
|
|
ncclResult_t (*deregMr)(void* comm, void* mhandle);
|
|
// Asynchronous send to a peer.
|
|
// May return request == NULL if the call cannot be performed (or would block)
|
|
ncclResult_t (*isend)(void* sendComm, void* data, int size, int tag, void* mhandle, void** request);
|
|
// Asynchronous recv from a peer.
|
|
// May return request == NULL if the call cannot be performed (or would block)
|
|
ncclResult_t (*irecv)(void* recvComm, int n, void** data, int* sizes, int* tags, void** mhandles, void** request);
|
|
// Perform a flush/fence to make sure all data received with NCCL_PTR_CUDA is
|
|
// visible to the GPU
|
|
ncclResult_t (*iflush)(void* recvComm, int n, void** data, int* sizes, void** mhandles, void** request);
|
|
// Test whether a request is complete. If size is not NULL, it returns the
|
|
// number of bytes sent/received.
|
|
ncclResult_t (*test)(void* request, int* done, int* sizes);
|
|
// Close and free send/recv comm objects
|
|
ncclResult_t (*closeSend)(void* sendComm);
|
|
ncclResult_t (*closeRecv)(void* recvComm);
|
|
ncclResult_t (*closeListen)(void* listenComm);
|
|
|
|
// Copy the given mhandle to a dptr in a format usable by this plugin's device code
|
|
ncclResult_t (*getDeviceMr)(void* comm, void* mhandle, void** dptr_mhandle);
|
|
|
|
// Notify the plugin that a recv has completed by the device
|
|
ncclResult_t (*irecvConsumed)(void* recvComm, int n, void* request);
|
|
} ncclNet_v8_t;
|
|
|
|
#endif // end include guard
|