Update docs (#169)

Author: thesues

README.md

@@ -30,7 +30,7 @@ Integration with SGLang and other inference engines are in progress.
 Most users just need to deploy and run InfiniStore, and they don't need to understand how InfiniStore works internally. For these users, PIP is the recommended way to install:
 
 ```
-pip install InfiniStore
+pip install infinistore
 ```
 
 ## Install from Source Code
@@ -53,7 +53,7 @@ pre-commit install
 After installation, either from PIP or from source code, run the following command to verify your installation is successful:
 
 ```
-InfiniStore --manage-port 8088
+infinistore --manage-port 8088
 curl http://127.0.0.1:8088/selftest
 ```
 
@@ -70,28 +70,28 @@ Your server machine may be equipped with TCP network or RDMA network. The comman
 For TCP/IP Network:
 
 ```
-InfiniStore --service-port 12345
+infinistore --service-port 12345
 ```
 
 For RDMA(RoCE):
 
 ```
-InfiniStore --service-port 12345 --dev-name mlx5_0 --link-type Ethernet
+infinistore --service-port 12345 --dev-name mlx5_0 --link-type Ethernet
 ```
 
 For RDMA(Infiniband):
 
 ```
-InfiniStore --service-port 12345 --dev-name mlx5_0 --link-type IB
+infinistore --service-port 12345 --dev-name mlx5_0 --link-type IB
 ```
 
 2. **Run InfiniStore Client**
 
 Check the following example code to run an InfiniStore client:
 
-* ```InfiniStore/example/client.py```
-* ```InfiniStore/example/client_async.py```
-* ```InfiniStore/example/client_async_single.py```
+* ```infinistore/example/client.py```
+* ```infinistore/example/client_async.py```
+* ```infinistore/example/client_async_single.py```
 
 ## Run Within a vLLM Cluster
 
@@ -120,7 +120,7 @@ If you are submitting a code change, run the following unit test and pre-commit
 2. **Run Unit Tests**
 
 ```
-pytest InfiniStore/test_InfiniStore.py
+pytest infinistore/test_infinistore.py
 ```
 
 3. **Run Pre-commit Checks**

infinistore/lib.py

@@ -361,7 +361,7 @@ def tcp_read_cache(self, key: str, **kwargs) -> np.ndarray:
 
         Parameters:
         key (str): The key associated with the cached item.
-        **kwargs: Additional keyword arguments.
+        ``**kwargs``: Additional keyword arguments.
 
         Returns:
         np.ndarray: The cached item retrieved from the TCP connection.
@@ -397,6 +397,31 @@ def tcp_write_cache(self, key: str, ptr: int, size: int, **kwargs):
     async def rdma_write_cache_async(
         self, blocks: List[Tuple[str, int]], block_size: int, ptr: int
     ):
+        """
+        Asynchronously writes data to the infinistore cache using RDMA.
+
+        This function performs an RDMA write operation to the infinistore cache.
+        It requires an active RDMA connection and uses a semaphore to limit
+        concurrent writes. The operation is completed asynchronously.
+
+        Args:
+            blocks (List[Tuple[str, int]]): A list of tuples where each tuple
+                contains a key (str) and an offset (int) representing the data
+                blocks to be written.
+            block_size (int): The size of each block to be written, in bytes.
+            ptr (int): A pointer to the memory location containing the data to
+                be written.
+
+        Raises:
+            Exception: If RDMA is not connected or if the write operation fails.
+        Returns:
+            int: The result code of the write operation if successful.
+
+        Notes:
+            - If the RDMA connection is not established, an exception is raised.
+            - The semaphore ensures that the number of concurrent writes is
+              limited.
+        """
         if not self.rdma_connected:
             raise Exception("this function is only valid for connected rdma")
 
@@ -430,6 +455,30 @@ def _callback(code):
     async def rdma_read_cache_async(
         self, blocks: List[Tuple[str, int]], block_size: int, ptr: int
     ):
+        """
+        Asynchronously reads data from the RDMA cache.
+
+        This function performs an asynchronous RDMA read operation for the specified
+        blocks of data. It requires an active RDMA connection and uses a semaphore
+        to limit concurrent operations.
+
+        Args:
+            blocks (List[Tuple[str, int]]): A list of tuples where each tuple contains
+                a key (str) and an offset (int) specifying the data to be read.
+            block_size (int): The size of each block to be read.
+            ptr (int): A pointer to the memory location where the data will be stored.
+
+        Raises:
+            Exception: If RDMA is not connected or if the RDMA read operation fails.
+            InfiniStoreKeyNotFound: If some keys are not found in the RDMA cache.
+
+        Returns:
+            int: The result code of the RDMA read operation (e.g., 200 for success).
+
+        Note:
+            This function uses a callback mechanism to handle the result of the RDMA
+            read operation. The semaphore is released after the operation completes.
+        """
         if not self.rdma_connected:
             raise Exception("this function is only valid for connected rdma")
         pass