diff --git a/.codeboarding/Benchmarking_Analysis.md b/.codeboarding/Benchmarking_Analysis.md
new file mode 100644
index 000000000000..077166d73c63
--- /dev/null
+++ b/.codeboarding/Benchmarking_Analysis.md
@@ -0,0 +1,187 @@
+```mermaid
+
+graph LR
+
+ API_Benchmarking["API Benchmarking"]
+
+ Kernel_Benchmarking["Kernel Benchmarking"]
+
+ Model_Accuracy_Benchmarking["Model Accuracy Benchmarking"]
+
+ Model_Speed_Benchmarking["Model Speed Benchmarking"]
+
+ Multi_GPU_Benchmarking["Multi-GPU Benchmarking"]
+
+ Utilities["Utilities"]
+
+ API_Benchmarking -- "uses" --> Utilities
+
+ Kernel_Benchmarking -- "uses" --> Utilities
+
+ Model_Accuracy_Benchmarking -- "interacts with" --> API_Benchmarking
+
+ Model_Accuracy_Benchmarking -- "uses" --> Utilities
+
+ Model_Speed_Benchmarking -- "interacts with" --> API_Benchmarking
+
+ Model_Speed_Benchmarking -- "uses" --> Utilities
+
+ Multi_GPU_Benchmarking -- "interacts with" --> Model_Speed_Benchmarking
+
+ Multi_GPU_Benchmarking -- "uses" --> Utilities
+
+ click Utilities href "https://github.com/dmlc/dgl/blob/master/.codeboarding//Utilities.md" "Details"
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+The `dgl.benchmarks` component is designed for evaluating the performance, accuracy, and speed of DGL's API and GNN models. It is organized into several sub-components, each focusing on a specific aspect of benchmarking. These components collectively provide a comprehensive framework for assessing the quality and performance of the DGL library, covering different levels of abstraction from low-level kernel operations to end-to-end model training, and addressing critical aspects like accuracy, speed, and scalability. This allows DGL developers to identify areas for improvement and users to make informed decisions about model and API usage.
+
+
+
+### API Benchmarking
+
+This sub-component contains a collection of scripts and utilities specifically designed to benchmark the performance of various DGL API calls. This includes operations like graph construction, edge/node manipulation, and message passing primitives.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.benchmarks.benchmarks.api.bench_add_self_loop` (0:0)
+
+- `dgl.benchmarks.benchmarks.api.bench_batch` (0:0)
+
+- `dgl.benchmarks.benchmarks.api.bench_builtin_update_all_coo` (0:0)
+
+- `dgl.benchmarks.benchmarks.api.bench_sample_neighbors` (0:0)
+
+
+
+
+
+### Kernel Benchmarking
+
+This component focuses on benchmarking the performance of DGL's low-level kernel operations, such as `edgesoftmax`, `gsddmm`, and `gspmm`. These are fundamental building blocks for many GNN operations.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.benchmarks.benchmarks.kernel.bench_edgesoftmax` (0:0)
+
+- `dgl.benchmarks.benchmarks.kernel.bench_gsddmm_u_dot_v` (0:0)
+
+- `dgl.benchmarks.benchmarks.kernel.bench_gspmm_u_mul_e_sum` (0:0)
+
+
+
+
+
+### Model Accuracy Benchmarking
+
+This sub-component provides scripts to evaluate the accuracy of various common GNN models implemented in DGL, such as GAT, GCN, RGCN, and SAGE. It helps in verifying the correctness of model implementations and comparing their performance on standard datasets.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.benchmarks.benchmarks.model_acc.bench_gat` (0:0)
+
+- `dgl.benchmarks.benchmarks.model_acc.bench_gcn` (0:0)
+
+- `dgl.benchmarks.benchmarks.model_acc.bench_rgcn_base` (0:0)
+
+- `dgl.benchmarks.benchmarks.model_acc.bench_sage` (0:0)
+
+
+
+
+
+### Model Speed Benchmarking
+
+This component is dedicated to measuring the training and inference speed of different GNN models within DGL. It includes benchmarks for models like GAT, GCN, PinSAGE, and RGCN, often with variations for different sampling strategies (e.g., neighbor sampling).
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.benchmarks.benchmarks.model_speed.bench_gat` (0:0)
+
+- `dgl.benchmarks.benchmarks.model_speed.bench_pinsage` (0:0)
+
+- `dgl.benchmarks.benchmarks.model_speed.bench_rgcn_base` (0:0)
+
+- `dgl.benchmarks.benchmarks.model_speed.bench_sage_ns` (0:0)
+
+
+
+
+
+### Multi-GPU Benchmarking
+
+This sub-component focuses on evaluating the performance of DGL when utilizing multiple GPUs for training GNN models, specifically for models like RGCN and SAGE. It helps assess the scalability and efficiency of distributed training.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.benchmarks.benchmarks.multigpu.bench_multigpu_rgcn` (0:0)
+
+- `dgl.benchmarks.benchmarks.multigpu.bench_multigpu_sage` (0:0)
+
+- `dgl.benchmarks.benchmarks.multigpu.rgcn_model` (0:0)
+
+
+
+
+
+### Utilities
+
+This module likely contains helper functions, common configurations, data loading utilities, and other shared code used across the various benchmarking scripts.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.benchmarks.benchmarks.utils` (0:0)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Core_Graph_Engine.md b/.codeboarding/Core_Graph_Engine.md
new file mode 100644
index 000000000000..77e397acb887
--- /dev/null
+++ b/.codeboarding/Core_Graph_Engine.md
@@ -0,0 +1,325 @@
+```mermaid
+
+graph LR
+
+ Core_Graph_Engine["Core Graph Engine"]
+
+ Graph_Data_Structures["Graph Data Structures"]
+
+ Foreign_Function_Interface_FFI_["Foreign Function Interface (FFI)"]
+
+ Message_Passing_Primitives["Message Passing Primitives"]
+
+ Sparse_Tensor_Operations["Sparse Tensor Operations"]
+
+ Graph_Convolutional_Layers_Base_["Graph Convolutional Layers (Base)"]
+
+ Global_Pooling_Modules["Global Pooling Modules"]
+
+ HeteroGraphConv["HeteroGraphConv"]
+
+ GNN_Explainability_Modules["GNN Explainability Modules"]
+
+ Reset_Parameters_Functions["Reset Parameters Functions"]
+
+ Core_Graph_Engine -- "uses" --> Foreign_Function_Interface_FFI_
+
+ Core_Graph_Engine -- "provides primitives for" --> Graph_Data_Structures
+
+ Core_Graph_Engine -- "provides primitives for" --> Message_Passing_Primitives
+
+ Core_Graph_Engine -- "provides primitives for" --> Sparse_Tensor_Operations
+
+ Graph_Data_Structures -- "are built upon" --> Core_Graph_Engine
+
+ Message_Passing_Primitives -- "are used by" --> Graph_Convolutional_Layers_Base_
+
+ Sparse_Tensor_Operations -- "are used by" --> Graph_Data_Structures
+
+ Graph_Convolutional_Layers_Base_ -- "rely on" --> Core_Graph_Engine
+
+ Graph_Convolutional_Layers_Base_ -- "are used by" --> GNN_Explainability_Modules
+
+ Global_Pooling_Modules -- "rely on" --> Core_Graph_Engine
+
+ HeteroGraphConv -- "rely on" --> Core_Graph_Engine
+
+ HeteroGraphConv -- "extends" --> Graph_Convolutional_Layers_Base_
+
+ Reset_Parameters_Functions -- "are used by" --> Graph_Convolutional_Layers_Base_
+
+ Reset_Parameters_Functions -- "are used by" --> Global_Pooling_Modules
+
+ Reset_Parameters_Functions -- "are used by" --> GNN_Explainability_Modules
+
+ click Core_Graph_Engine href "https://github.com/dmlc/dgl/blob/master/.codeboarding//Core_Graph_Engine.md" "Details"
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+The `Core Graph Engine` is the fundamental layer of DGL, providing the basic building blocks for graph operations and serving as the interface to the optimized C/C++ backend. It is crucial for performance and defines the core data structures and primitives for Graph Neural Networks.
+
+
+
+### Core Graph Engine
+
+The foundational layer of DGL, responsible for managing fundamental graph data structures (nodes, edges, attributes), providing low-level graph manipulation, and serving as the Foreign Function Interface (FFI) to the optimized C/C++ backend for high-performance operations. It also defines the core message passing primitives and sparse tensor operations essential for Graph Neural Networks.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl/heterograph.py` (1:1)
+
+- `dgl/graph_index.py` (1:1)
+
+- `dgl/frame.py` (1:1)
+
+- `dgl/core.py` (1:1)
+
+- `dgl/_ffi/__init__.py` (1:1)
+
+- `dgl/ndarray.py` (1:1)
+
+- `dgl/sparse.py` (1:1)
+
+- `dgl/function/message.py` (1:1)
+
+- `dgl/function/reducer.py` (1:1)
+
+- `dgl/ops/__init__.py` (1:1)
+
+
+
+
+
+### Graph Data Structures
+
+This component encompasses the core data structures used to represent graphs in DGL, including `DGLGraph` for general graphs and `DGLBlock` for representing computation graphs in mini-batch training. It also includes `GraphIndex` and `HeteroGraphIndex` for efficient indexing and manipulation of graph elements.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl/heterograph.py` (1:1)
+
+- `dgl/graph_index.py` (1:1)
+
+- `dgl/heterograph_index.py` (1:1)
+
+
+
+
+
+### Foreign Function Interface (FFI)
+
+This component provides the mechanism for Python to interact with the highly optimized C/C++ backend of DGL. It includes classes like `Function`, `NDArrayBase`, and `ObjectBase` that bridge the gap between Python objects and their C/C++ counterparts, enabling efficient data transfer and computation.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl/_ffi/function.py` (1:1)
+
+- `dgl/_ffi/ndarray.py` (1:1)
+
+- `dgl/_ffi/object.py` (1:1)
+
+
+
+
+
+### Message Passing Primitives
+
+This component defines the fundamental operations for message passing in Graph Neural Networks, including `MessageFunction` for defining how messages are generated and `ReduceFunction` for defining how messages are aggregated at nodes. These primitives are essential for building any GNN layer.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl/function/message.py` (1:1)
+
+- `dgl/function/reducer.py` (1:1)
+
+
+
+
+
+### Sparse Tensor Operations
+
+This component provides functionalities for handling sparse tensors, which are common in graph data (e.g., adjacency matrices). It includes classes like `SparseMatrix` and `NDArray` for efficient storage and manipulation of sparse data, crucial for memory and computational efficiency in large graphs.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl/ndarray.py` (1:1)
+
+- `dgl/sparse.py` (1:1)
+
+
+
+
+
+### Graph Convolutional Layers (Base)
+
+A broad category encompassing various graph neural network layers that perform message passing and aggregation on graph structures. These layers are the building blocks for most GNN models.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl/nn/pytorch/conv/atomicconv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/cfconv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/chebconv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/gatconv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/graphconv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/sageconv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/gcn2conv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/tagconv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/gatedgraphconv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/nnconv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/pnaconv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/cugraph_gatconv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/cugraph_relgraphconv.py` (1:1)
+
+- `dgl/nn/pytorch/conv/cugraph_sageconv.py` (1:1)
+
+
+
+
+
+### Global Pooling Modules
+
+A collection of modules designed to aggregate node and edge features into a single graph-level representation. They are crucial for graph classification and regression tasks.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl/nn/pytorch/glob/set2set.py` (1:1)
+
+- `dgl/nn/pytorch/glob/set_transformer.py` (1:1)
+
+
+
+
+
+### HeteroGraphConv
+
+A versatile module for performing convolutions on heterogeneous graphs. It allows defining different message-passing functions for each type of edge, enabling flexible modeling of complex graph structures.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl/nn/pytorch/hetero/heterographconv.py` (1:1)
+
+
+
+
+
+### GNN Explainability Modules
+
+This category includes modules like `GNNExplainer`, `PGExplainer`, and `SubgraphX`, which provide methods to interpret and explain the predictions of Graph Neural Networks by identifying important nodes and edges.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl/nn/pytorch/explain/gnnexplainer.py` (1:1)
+
+- `dgl/nn/pytorch/explain/pgexplainer.py` (1:1)
+
+- `dgl/nn/pytorch/explain/subgraphx.py` (1:1)
+
+
+
+
+
+### Reset Parameters Functions
+
+A common pattern across many `dgl.nn.pytorch` modules, these functions are responsible for initializing the weights and biases of the neural network layers within a module. This ensures proper starting conditions for training.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl/nn/pytorch/glob/set2set.py` (1:1)
+
+- `dgl/nn/pytorch/glob/set_transformer.py` (1:1)
+
+- `dgl/nn/pytorch/conv/graphconv.py` (1:1)
+
+- `dgl/nn/pytorch/explain/gnnexplainer.py` (1:1)
+
+- `dgl/nn/pytorch/conv/twirlsconv.py` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Data_Pipeline_Utilities.md b/.codeboarding/Data_Pipeline_Utilities.md
new file mode 100644
index 000000000000..72312621f3e0
--- /dev/null
+++ b/.codeboarding/Data_Pipeline_Utilities.md
@@ -0,0 +1,233 @@
+```mermaid
+
+graph LR
+
+ Dataset_Management["Dataset Management"]
+
+ Data_Loading["Data Loading"]
+
+ Graph_Sampling["Graph Sampling"]
+
+ Graph_Transformations["Graph Transformations"]
+
+ Graph_Utilities["Graph Utilities"]
+
+ GraphBolt_Framework["GraphBolt Framework"]
+
+ Feature_Storage["Feature Storage"]
+
+ Dataset_Management -- "interacts with" --> GraphBolt_Framework
+
+ Dataset_Management -- "can be transformed by" --> Graph_Transformations
+
+ Data_Loading -- "uses" --> Graph_Sampling
+
+ Data_Loading -- "provides data to" --> GraphBolt_Framework
+
+ Graph_Sampling -- "used by" --> Data_Loading
+
+ Graph_Sampling -- "interacts with" --> GraphBolt_Framework
+
+ Graph_Transformations -- "transforms output of" --> Dataset_Management
+
+ Graph_Transformations -- "uses" --> Graph_Utilities
+
+ Graph_Utilities -- "supports" --> Dataset_Management
+
+ Graph_Utilities -- "supports" --> Graph_Transformations
+
+ GraphBolt_Framework -- "integrates with" --> Dataset_Management
+
+ GraphBolt_Framework -- "enhances" --> Data_Loading
+
+ GraphBolt_Framework -- "enhances" --> Graph_Sampling
+
+ GraphBolt_Framework -- "utilizes" --> Feature_Storage
+
+ Feature_Storage -- "is core to" --> GraphBolt_Framework
+
+ Feature_Storage -- "used by" --> Data_Loading
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+Manages and processes graph-related data, including datasets and data loading utilities.
+
+
+
+### Dataset Management
+
+Handles the loading, storage, and access of various graph datasets, including built-in datasets and custom CSV-based datasets. It provides a unified interface for different graph data sources.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.data.dgl_dataset.DGLDataset` (1:1)
+
+- `dgl.data.dgl_dataset.DGLBuiltinDataset` (1:1)
+
+- `dgl.data.csv_dataset.CSVDataset` (10:213)
+
+
+
+
+
+### Data Loading
+
+Provides efficient data loading mechanisms for GNN training, including batching and various sampling strategies to create mini-batches of graph data.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.dataloading.dataloader.DataLoader` (787:1259)
+
+- `dgl.dataloading.base.Sampler` (163:191)
+
+- `dgl.dataloading.base.BlockSampler` (194:260)
+
+- `dgl.dataloading.neighbor_sampler.NeighborSampler` (10:205)
+
+
+
+
+
+### Graph Sampling
+
+Implements various graph sampling algorithms (e.g., neighbor sampling, PinSAGE sampling) crucial for training GNNs on large graphs by creating subgraphs or mini-batches.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.sampling.pinsage.PinSAGESampler` (165:271)
+
+- `dgl.dataloading.neighbor_sampler.NeighborSampler` (10:205)
+
+
+
+
+
+### Graph Transformations
+
+Offers a collection of functions and modules to transform graphs, such as adding/removing edges, self-loops, and applying normalization or positional encodings.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.transforms.module.BaseTransform` (100:107)
+
+- `dgl.transforms.module.AddSelfLoop` (509:649)
+
+- `dgl.transforms.module.DropEdge` (1587:1634)
+
+- `dgl.transforms.module.GCNNorm` (1118:1201)
+
+- `dgl.transforms.module.Compose` (1083:1115)
+
+
+
+
+
+### Graph Utilities
+
+Provides general utility functions and helper classes that support various graph operations across the DGL library, including internal error handling and data type consistency checks.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.utils.internal.InconsistentDtypeException` (21:27)
+
+
+
+
+
+### GraphBolt Framework
+
+A high-performance framework designed for efficient graph data loading and sampling, particularly for large-scale GNN training. It introduces concepts like FeatureStore, SamplingGraph, and a dedicated DataLoader.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.graphbolt.dataloader.DataLoader` (77:190)
+
+- `dgl.graphbolt.feature_store.FeatureStore` (138:296)
+
+- `dgl.graphbolt.sampling_graph.SamplingGraph` (10:85)
+
+- `dgl.graphbolt.dataset.Dataset` (50:94)
+
+- `dgl.graphbolt.minibatch_transformer.MiniBatchTransformer` (14:45)
+
+- `dgl.graphbolt.impl.neighbor_sampler.NeighborSamplerImpl` (639:778)
+
+
+
+
+
+### Feature Storage
+
+Manages the storage and retrieval of node and edge features, with implementations for CPU and GPU caching to optimize feature access during training.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.graphbolt.feature_store.FeatureStore` (138:296)
+
+- `dgl.graphbolt.feature_store.Feature` (25:135)
+
+- `dgl.graphbolt.impl.cpu_cached_feature.CPUCachedFeature` (18:461)
+
+- `dgl.graphbolt.impl.gpu_cached_feature.GPUCachedFeature` (17:257)
+
+- `dgl.graphbolt.impl.torch_based_feature_store.TorchBasedFeatureStore` (570:664)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Distributed_Processing.md b/.codeboarding/Distributed_Processing.md
new file mode 100644
index 000000000000..b9b15aa6ba31
--- /dev/null
+++ b/.codeboarding/Distributed_Processing.md
@@ -0,0 +1,325 @@
+```mermaid
+
+graph LR
+
+ dist_context["dist_context"]
+
+ rpc["rpc"]
+
+ kvstore["kvstore"]
+
+ dist_graph["dist_graph"]
+
+ graph_partition_book["graph_partition_book"]
+
+ dist_dataloader["dist_dataloader"]
+
+ partition["partition"]
+
+ graph_services["graph_services"]
+
+ sparse_optim["sparse_optim"]
+
+ role["role"]
+
+ dist_context -- "initializes" --> rpc
+
+ rpc -- "facilitates communication for" --> kvstore
+
+ rpc -- "facilitates communication for" --> dist_graph
+
+ kvstore -- "stores parameters for" --> sparse_optim
+
+ dist_graph -- "depends on" --> graph_partition_book
+
+ dist_graph -- "delegates operations to" --> graph_services
+
+ dist_dataloader -- "loads data from" --> dist_graph
+
+ partition -- "generates partitioning scheme for" --> graph_partition_book
+
+ rpc -- "facilitates communication for" --> role
+
+ dist_context -- "manages resources for" --> dist_dataloader
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+The `dgl.distributed` subsystem is crucial for enabling scalable graph processing in DGL by distributing graph data and computations across multiple machines. It provides the foundational infrastructure for building distributed graph neural networks (GNNs) and other graph-based applications.
+
+
+
+### dist_context
+
+Manages the distributed environment's lifecycle. It handles the initialization and finalization of the RPC (Remote Procedure Call) system and other distributed services. This component ensures that all processes in the distributed setup are properly configured and synchronized, providing a robust communication backbone. It also manages resource pooling for efficient operation.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.distributed.dist_context.initialize` (207:318)
+
+- `dgl.distributed.dist_context.finalize` (1:1)
+
+- `dgl.distributed.dist_context.set_rank` (1:1)
+
+- `dgl.distributed.dist_context.set_role` (1:1)
+
+- `dgl.distributed.dist_context.set_group_id` (1:1)
+
+- `dgl.distributed.dist_context.CustomPool` (113:204)
+
+
+
+
+
+### rpc
+
+Implements the core Remote Procedure Call (RPC) mechanism for inter-process communication. It provides functionalities for sending and receiving messages, registering services, and managing remote function execution. This includes handling message serialization, network communication, and ensuring reliable data exchange between distributed nodes.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.distributed.rpc.send_request` (1:1)
+
+- `dgl.distributed.rpc.recv_response` (1:1)
+
+- `dgl.distributed.rpc.register_service` (1:1)
+
+- `dgl.distributed.rpc.set_rpc_worker_pool` (1:1)
+
+- `dgl.distributed.rpc.connect_to_server` (1:1)
+
+- `dgl.distributed.rpc.shutdown_workers` (1:1)
+
+- `dgl.distributed.rpc.RPCMessage` (1:1)
+
+
+
+
+
+### kvstore
+
+Provides a distributed key-value store, essential for managing and sharing large-scale data (e.g., node/edge embeddings, model parameters) across the cluster. It supports operations like `pull` (retrieving data from servers), `push` (updating data on servers), data initialization, and deletion. It also manages distributed tensors (`DistTensor`) for efficient parameter storage.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.distributed.kvstore.KVClient` (961:1579)
+
+- `dgl.distributed.kvstore.KVServer` (731:955)
+
+- `dgl.distributed.kvstore.pull` (1:1)
+
+- `dgl.distributed.kvstore.push` (1:1)
+
+- `dgl.distributed.kvstore.init_data` (1:1)
+
+- `dgl.distributed.kvstore.delete_data` (1:1)
+
+- `dgl.distributed.kvstore.DistTensor` (1:1)
+
+
+
+
+
+### dist_graph
+
+Represents a graph that is partitioned and distributed across multiple servers. It allows users to interact with this distributed graph as if it were a single entity, abstracting away the complexities of data distribution. It provides methods for accessing graph properties and performing graph operations in a distributed manner, with `DistGraphServer` handling server-side requests.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.distributed.dist_graph.DistGraph` (647:1679)
+
+- `dgl.distributed.dist_graph.DistGraphServer` (487:644)
+
+- `dgl.distributed.dist_graph.partition_graph` (1:1)
+
+- `dgl.distributed.dist_graph.set_partition_book` (1:1)
+
+
+
+
+
+### graph_partition_book
+
+Manages the metadata required for graph partitioning. It maps global node and edge IDs to their respective partitions and local IDs, enabling efficient data localization. It defines partition policies (e.g., `NodePartitionPolicy`, `EdgePartitionPolicy`) and provides mechanisms like `RangePartitionBook` for looking up where specific graph elements reside.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.distributed.graph_partition_book.GraphPartitionBook` (266:537)
+
+- `dgl.distributed.graph_partition_book.RangePartitionBook` (540:964)
+
+- `dgl.distributed.graph_partition_book.NodePartitionPolicy` (1139:1145)
+
+- `dgl.distributed.graph_partition_book.EdgePartitionPolicy` (1148:1158)
+
+
+
+
+
+### dist_dataloader
+
+Provides distributed data loading capabilities, allowing training jobs to efficiently load mini-batches of graph data (nodes or edges) from the distributed graph. It includes specialized data loaders (`DistNodeDataLoader`, `DistEdgeDataLoader`) and collators for batching, ensuring that data is fetched and prepared for training in a distributed setting.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.distributed.dist_dataloader.DistDataLoader` (22:183)
+
+- `dgl.distributed.dist_dataloader.DistNodeDataLoader` (791:839)
+
+- `dgl.distributed.dist_dataloader.DistEdgeDataLoader` (842:893)
+
+- `dgl.distributed.dist_dataloader.Collator` (275:333)
+
+- `dgl.distributed.dist_dataloader.NodeCollator` (336:430)
+
+- `dgl.distributed.dist_dataloader.EdgeCollator` (433:779)
+
+
+
+
+
+### partition
+
+Contains utilities and functions for partitioning a large graph into smaller subgraphs suitable for distribution across multiple machines. It handles the creation and loading of partition configurations, which are then utilized by the `graph_partition_book` to manage the distributed graph's structure.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.distributed.partition.partition_graph` (816:1553)
+
+- `dgl.distributed.partition.load_partition` (285:404)
+
+
+
+
+
+### graph_services
+
+Offers distributed graph query services, such as sampling neighbors, finding edges, and computing degrees. It coordinates these requests across different graph partitions, leveraging the RPC mechanism to gather information from relevant servers and aggregate results.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.distributed.graph_services.sample_neighbors` (1036:1161)
+
+- `dgl.distributed.graph_services.find_edges` (1235:1262)
+
+- `dgl.distributed.graph_services.in_degree` (1:1)
+
+- `dgl.distributed.graph_services.out_degree` (1:1)
+
+- `dgl.distributed.graph_services.in_subgraph` (1265:1304)
+
+- `dgl.distributed.graph_services.Request` (1:1)
+
+- `dgl.distributed.graph_services.Response` (1:1)
+
+
+
+
+
+### sparse_optim
+
+Implements distributed sparse optimizers for PyTorch, specifically designed to efficiently update sparse parameters (e.g., node embeddings) that are stored in the distributed KVStore. This includes optimizers like `SparseAdagrad` and `SparseAdam`, which are optimized for sparse gradient updates in a distributed setting.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.distributed.optim.pytorch.sparse_optim.DistSparseGradOptimizer` (23:447)
+
+- `dgl.distributed.optim.pytorch.sparse_optim.SparseAdagrad` (464:575)
+
+- `dgl.distributed.optim.pytorch.sparse_optim.SparseAdam` (578:746)
+
+
+
+
+
+### role
+
+Manages the roles (e.g., server, client, trainer) of different processes within the distributed DGL system. It facilitates coordinated behavior by providing mechanisms for role registration and querying, ensuring that each process understands its responsibilities and can interact appropriately with others.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.distributed.role.set_role` (1:1)
+
+- `dgl.distributed.role.get_role` (1:1)
+
+- `dgl.distributed.role.register_role` (1:1)
+
+- `dgl.distributed.role.RegisterRoleRequest` (1:1)
+
+- `dgl.distributed.role.GetRoleRequest` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Graph_Neural_Network_Framework.md b/.codeboarding/Graph_Neural_Network_Framework.md
new file mode 100644
index 000000000000..1ef00df85705
--- /dev/null
+++ b/.codeboarding/Graph_Neural_Network_Framework.md
@@ -0,0 +1,141 @@
+```mermaid
+
+graph LR
+
+ dgl_nn_pytorch_conv["dgl.nn.pytorch.conv"]
+
+ dgl_nn_pytorch_hetero["dgl.nn.pytorch.hetero"]
+
+ dgl_nn_pytorch_glob["dgl.nn.pytorch.glob"]
+
+ dgl_nn_pytorch_network_emb["dgl.nn.pytorch.network_emb"]
+
+ dgl_nn_pytorch_explain["dgl.nn.pytorch.explain"]
+
+ dgl_nn_pytorch_hetero -- "wraps and applies" --> dgl_nn_pytorch_conv
+
+ dgl_nn_pytorch_conv -- "provides core operations for" --> dgl_nn_pytorch_hetero
+
+ dgl_nn_pytorch_glob -- "takes input from" --> dgl_nn_pytorch_conv
+
+ dgl_nn_pytorch_conv -- "generates features for" --> dgl_nn_pytorch_glob
+
+ dgl_nn_pytorch_explain -- "works with models built using" --> dgl_nn_pytorch_conv
+
+ dgl_nn_pytorch_explain -- "interprets outputs of" --> dgl_nn_pytorch_conv
+
+ dgl_nn_pytorch_network_emb -- "provides initial features for" --> dgl_nn_pytorch_conv
+
+ dgl_nn_pytorch_conv -- "can refine/process outputs of" --> dgl_nn_pytorch_network_emb
+
+ dgl_nn_pytorch_glob -- "can aggregate features from processed graphs by" --> dgl_nn_pytorch_hetero
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+This subsystem, Graph Neural Network Framework, provides a comprehensive set of tools for building, training, and interpreting Graph Neural Networks (GNNs) within the DGL (Deep Graph Library) ecosystem, specifically tailored for PyTorch. It encompasses fundamental GNN layers, mechanisms for handling complex graph structures, pooling strategies for graph-level predictions, and modules for model interpretability.
+
+
+
+### dgl.nn.pytorch.conv
+
+This module is the cornerstone of the GNN framework, offering a diverse collection of graph convolutional layers (e.g., GATConv, SAGEConv, GraphConv, RelGraphConv, HGTConv, GINConv, GCN2Conv, APPNPConv, TAGConv, ChebConv, AGNNConv, TWIRLSConv, DGNConv). These layers implement the core message-passing mechanisms, defining how node features are aggregated from their neighbors and transformed to learn new, richer representations. They are fundamental for capturing local graph structure and propagating information across the graph.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.nn.pytorch.conv` (1:1)
+
+
+
+
+
+### dgl.nn.pytorch.hetero
+
+This module provides specialized layers and wrappers, such as HeteroGraphConv and HeteroLinear, designed to effectively process heterogeneous graphs—graphs that contain multiple types of nodes and edges. It enables the application of different GNN operations and transformations based on the specific node and edge types, which is crucial for modeling real-world complex relational data.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.nn.pytorch.hetero` (1:1)
+
+
+
+
+
+### dgl.nn.pytorch.glob
+
+This module implements various global pooling mechanisms (e.g., GlobalAttentionPooling, Set2Set, AvgPooling, MaxPooling, SumPooling, SortPooling, SetAttentionBlock, PMALayer, SetTransformerEncoder, SetTransformerDecoder). These layers aggregate node representations from an entire graph (or a subgraph) into a single, fixed-size graph-level representation. This aggregation is vital for tasks that require a single output for the entire graph, such as graph classification or regression.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.nn.pytorch.glob` (1:1)
+
+
+
+
+
+### dgl.nn.pytorch.network_emb
+
+This module offers layers for learning low-dimensional, dense vector representations (embeddings) of nodes or edges, including NodeEmbedding and EdgeEmbedding. These embeddings are designed to capture the structural properties and relationships of entities within the graph, often serving as initial feature inputs for GNN models or for tasks like link prediction.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.nn.pytorch.network_emb` (1:1)
+
+
+
+
+
+### dgl.nn.pytorch.explain
+
+This module provides tools and methods, such as PGExplainer and HeteroPGExplainer, for interpreting the predictions made by GNN models. It helps users understand which specific parts of the input graph (nodes, edges, or subgraphs) are most influential in a model's decision, thereby enhancing model transparency and trustworthiness.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.nn.pytorch.explain` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/on_boarding.md b/.codeboarding/on_boarding.md
new file mode 100644
index 000000000000..c9f545fdde22
--- /dev/null
+++ b/.codeboarding/on_boarding.md
@@ -0,0 +1,201 @@
+```mermaid
+
+graph LR
+
+ Core_Graph_Engine["Core Graph Engine"]
+
+ Graph_Neural_Network_Framework["Graph Neural Network Framework"]
+
+ Data_Pipeline_Utilities["Data Pipeline & Utilities"]
+
+ Distributed_Processing["Distributed Processing"]
+
+ Benchmarking_Analysis["Benchmarking & Analysis"]
+
+ Core_Graph_Engine -- "provides primitives for" --> Graph_Neural_Network_Framework
+
+ Core_Graph_Engine -- "provides data structures for" --> Data_Pipeline_Utilities
+
+ Core_Graph_Engine -- "supports" --> Distributed_Processing
+
+ Graph_Neural_Network_Framework -- "utilizes" --> Core_Graph_Engine
+
+ Graph_Neural_Network_Framework -- "consumes data from" --> Data_Pipeline_Utilities
+
+ Data_Pipeline_Utilities -- "provides data to" --> Graph_Neural_Network_Framework
+
+ Data_Pipeline_Utilities -- "operates on" --> Core_Graph_Engine
+
+ Distributed_Processing -- "leverages" --> Core_Graph_Engine
+
+ Distributed_Processing -- "integrates with" --> Data_Pipeline_Utilities
+
+ Benchmarking_Analysis -- "evaluates" --> Graph_Neural_Network_Framework
+
+ Benchmarking_Analysis -- "measures performance of" --> Core_Graph_Engine
+
+ click Core_Graph_Engine href "https://github.com/dmlc/dgl/blob/master/.codeboarding//Core_Graph_Engine.md" "Details"
+
+ click Graph_Neural_Network_Framework href "https://github.com/dmlc/dgl/blob/master/.codeboarding//Graph_Neural_Network_Framework.md" "Details"
+
+ click Data_Pipeline_Utilities href "https://github.com/dmlc/dgl/blob/master/.codeboarding//Data_Pipeline_Utilities.md" "Details"
+
+ click Distributed_Processing href "https://github.com/dmlc/dgl/blob/master/.codeboarding//Distributed_Processing.md" "Details"
+
+ click Benchmarking_Analysis href "https://github.com/dmlc/dgl/blob/master/.codeboarding//Benchmarking_Analysis.md" "Details"
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+This analysis consolidates the DGL architecture into five high-level components, highlighting their responsibilities, key source files, and interrelationships.
+
+
+
+### Core Graph Engine
+
+The foundational layer of DGL, responsible for managing fundamental graph data structures (nodes, edges, attributes), providing low-level graph manipulation, and serving as the Foreign Function Interface (FFI) to the optimized C/C++ backend for high-performance operations. It also defines the core message passing primitives and sparse tensor operations essential for Graph Neural Networks.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.heterograph` (0:0)
+
+- `dgl.graph_index` (0:0)
+
+- `dgl.frame` (0:0)
+
+- `dgl.core` (0:0)
+
+- `dgl._ffi` (0:0)
+
+- `dgl.ndarray` (0:0)
+
+- `dgl.sparse` (0:0)
+
+- `dgl.function.message` (0:0)
+
+- `dgl.function.reducer` (0:0)
+
+- `dgl.ops` (0:0)
+
+
+
+
+
+### Graph Neural Network Framework
+
+Implements a comprehensive suite of Graph Neural Network (GNN) layers, attention mechanisms, and pooling layers compatible with various deep learning frameworks. It also includes modules for interpreting GNN model predictions to understand influential graph parts.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.nn.pytorch.conv` (0:0)
+
+- `dgl.nn.pytorch.hetero` (0:0)
+
+- `dgl.nn.pytorch.glob` (0:0)
+
+- `dgl.nn.pytorch.network_emb` (0:0)
+
+- `dgl.nn.pytorch.explain` (0:0)
+
+
+
+
+
+### Data Pipeline & Utilities
+
+Manages all aspects of graph data, including built-in datasets, loading/saving graphs, and efficient data loading for GNN training (batching, lazy feature loading). It also provides various graph sampling algorithms, conversion utilities between graph representations, and general graph transformation functions. The high-performance GraphBolt framework is a key part of this component.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.data` (0:0)
+
+- `dgl.dataloading` (0:0)
+
+- `dgl.sampling` (0:0)
+
+- `dgl.convert` (0:0)
+
+- `dgl.transforms.functional` (0:0)
+
+- `dgl.transforms.module` (0:0)
+
+- `dgl.utils` (0:0)
+
+- `dgl.homophily` (0:0)
+
+- `dgl.merge` (10:123)
+
+- `dgl.readout` (0:0)
+
+- `dgl.graphbolt` (0:0)
+
+
+
+
+
+### Distributed Processing
+
+Enables scalable training and inference on large-scale graphs by providing distributed graph data structures, distributed data loaders, RPC mechanisms, and graph partitioning tools. It extends the core DGL functionalities for distributed environments.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.distributed` (0:0)
+
+
+
+
+
+### Benchmarking & Analysis
+
+Contains utilities for evaluating DGL's API performance, model accuracy, and speed. It includes implementations of common GNN models for testing and provides tools for analyzing model behavior.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `dgl.benchmarks` (0:0)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file