[Refactor] Remove data loader to simplify api (#33)

* Feat: Make data load internal

* Update docs for data loading

* Ruff format

* Update examples and remove not used import

Author: haochengxia

README.md

@@ -54,33 +54,37 @@ With libcachesim installed, you can start cache simulation for some eviction alg
 ```python
 import libcachesim as lcs
 
-# Step 1: Get one trace from S3 bucket
-URI = "cache_dataset_oracleGeneral/2007_msr/msr_hm_0.oracleGeneral.zst"
-dl = lcs.DataLoader()
-dl.load(URI)
-
-# Step 2: Open trace and process efficiently
+# Step 1: Open a trace hosted on S3 (find more via https://github.com/cacheMon/cache_dataset)
+URI = "s3://cache-datasets/cache_dataset_oracleGeneral/2007_msr/msr_hm_0.oracleGeneral.zst"
 reader = lcs.TraceReader(
-    trace = dl.get_cache_path(URI),
+    trace = URI,
     trace_type = lcs.TraceType.ORACLE_GENERAL_TRACE,
     reader_init_params = lcs.ReaderInitParam(ignore_obj_size=False)
 )
 
-# Step 3: Initialize cache
-cache = lcs.S3FIFO(cache_size=1024*1024)
-
-# Step 4: Process entire trace efficiently (C++ backend)
-obj_miss_ratio, byte_miss_ratio = cache.process_trace(reader)
-print(f"Object miss ratio: {obj_miss_ratio:.4f}, Byte miss ratio: {byte_miss_ratio:.4f}")
+# Step 2: Initialize cache
+cache = lcs.S3FIFO(
+    cache_size=1024*1024,
+    # Cache specific parameters
+    small_size_ratio=0.2,
+    ghost_size_ratio=0.8,
+    move_to_main_threshold=2,
+)
 
-# Step 4.1: Process with limited number of requests
-cache = lcs.S3FIFO(cache_size=1024*1024)
-obj_miss_ratio, byte_miss_ratio = cache.process_trace(
-    reader,
-    start_req=0,
-    max_req=1000
+# Step 3: Process entire trace efficiently (C++ backend)
+req_miss_ratio, byte_miss_ratio = cache.process_trace(reader)
+print(f"Request miss ratio: {req_miss_ratio:.4f}, Byte miss ratio: {byte_miss_ratio:.4f}")
+
+# Step 3.1: Further process the first 1000 requests again
+cache = lcs.S3FIFO(
+    cache_size=1024 * 1024,
+    # Cache specific parameters
+    small_size_ratio=0.2,
+    ghost_size_ratio=0.8,
+    move_to_main_threshold=2,
 )
-print(f"Object miss ratio: {obj_miss_ratio:.4f}, Byte miss ratio: {byte_miss_ratio:.4f}")
+req_miss_ratio, byte_miss_ratio = cache.process_trace(reader, start_req=0, max_req=1000)
+print(f"Request miss ratio: {req_miss_ratio:.4f}, Byte miss ratio: {byte_miss_ratio:.4f}")
 ```
 
 ## Plugin System

docs/src/en/getting_started/quickstart.md

@@ -56,33 +56,37 @@ With libcachesim installed, you can start cache simulation for some eviction alg
     ```python
     import libcachesim as lcs
 
-    # Step 1: Get one trace from S3 bucket
-    URI = "cache_dataset_oracleGeneral/2007_msr/msr_hm_0.oracleGeneral.zst"
-    dl = lcs.DataLoader()
-    dl.load(URI)
-
-    # Step 2: Open trace and process efficiently
+    # Step 1: Open a trace hosted on S3 (find more via https://github.com/cacheMon/cache_dataset)
+    URI = "s3://cache-datasets/cache_dataset_oracleGeneral/2007_msr/msr_hm_0.oracleGeneral.zst"
     reader = lcs.TraceReader(
-        trace = dl.get_cache_path(URI),
+        trace = URI,
         trace_type = lcs.TraceType.ORACLE_GENERAL_TRACE,
         reader_init_params = lcs.ReaderInitParam(ignore_obj_size=False)
     )
 
-    # Step 3: Initialize cache
-    cache = lcs.S3FIFO(cache_size=1024*1024)
-
-    # Step 4: Process entire trace efficiently (C++ backend)
-    obj_miss_ratio, byte_miss_ratio = cache.process_trace(reader)
-    print(f"Object miss ratio: {obj_miss_ratio:.4f}, Byte miss ratio: {byte_miss_ratio:.4f}")
+    # Step 2: Initialize cache
+    cache = lcs.S3FIFO(
+        cache_size=1024*1024,
+        # Cache specific parameters
+        small_size_ratio=0.2,
+        ghost_size_ratio=0.8,
+        move_to_main_threshold=2,
+    )
 
-    # Step 4.1: Process with limited number of requests
-    cache = lcs.S3FIFO(cache_size=1024*1024)
-    obj_miss_ratio, byte_miss_ratio = cache.process_trace(
-        reader,
-        start_req=0,
-        max_req=1000
+    # Step 3: Process entire trace efficiently (C++ backend)
+    req_miss_ratio, byte_miss_ratio = cache.process_trace(reader)
+    print(f"Request miss ratio: {req_miss_ratio:.4f}, Byte miss ratio: {byte_miss_ratio:.4f}")
+
+    # Step 3.1: Further process the first 1000 requests again
+    cache = lcs.S3FIFO(
+        cache_size=1024 * 1024,
+        # Cache specific parameters
+        small_size_ratio=0.2,
+        ghost_size_ratio=0.8,
+        move_to_main_threshold=2,
     )
-    print(f"Object miss ratio: {obj_miss_ratio:.4f}, Byte miss ratio: {byte_miss_ratio:.4f}")
+    req_miss_ratio, byte_miss_ratio = cache.process_trace(reader, start_req=0, max_req=1000)
+    print(f"Request miss ratio: {req_miss_ratio:.4f}, Byte miss ratio: {byte_miss_ratio:.4f}")
     ```
 
 The above example demonstrates the basic workflow of using `libcachesim` for cache simulation:

examples/basic_usage.py

@@ -1,25 +1,26 @@
 import libcachesim as lcs
 
-# Step 1: Get one trace from S3 bucket
-URI = "cache_dataset_oracleGeneral/2007_msr/msr_hm_0.oracleGeneral.zst"
-dl = lcs.DataLoader()
-dl.load(URI)
-
-# Step 2: Open trace and process efficiently
+# Step 1: Open a trace hosted on S3 (find more via https://github.com/cacheMon/cache_dataset)
+URI = "s3://cache-datasets/cache_dataset_oracleGeneral/2007_msr/msr_hm_0.oracleGeneral.zst"
 reader = lcs.TraceReader(
-    trace=dl.get_cache_path(URI),
+    trace=URI,
     trace_type=lcs.TraceType.ORACLE_GENERAL_TRACE,
     reader_init_params=lcs.ReaderInitParam(ignore_obj_size=False),
 )
 
-# Step 3: Initialize cache
-cache = lcs.S3FIFO(cache_size=1024 * 1024)
+# Step 2: Initialize cache
+cache = lcs.S3FIFO(
+    cache_size=1024 * 1024,
+    # Cache specific parameters
+    small_size_ratio=0.2,
+    ghost_size_ratio=0.8,
+    move_to_main_threshold=2,
+)
 
-# Step 4: Process entire trace efficiently (C++ backend)
-obj_miss_ratio, byte_miss_ratio = cache.process_trace(reader)
-print(f"Object miss ratio: {obj_miss_ratio:.4f}, Byte miss ratio: {byte_miss_ratio:.4f}")
+# Step 3: Process entire trace efficiently (C++ backend)
+req_miss_ratio, byte_miss_ratio = cache.process_trace(reader)
+print(f"Request miss ratio: {req_miss_ratio:.4f}, Byte miss ratio: {byte_miss_ratio:.4f}")
 
-# Step 4.1: Process with limited number of requests
-cache = lcs.S3FIFO(cache_size=1024 * 1024)
-obj_miss_ratio, byte_miss_ratio = cache.process_trace(reader, start_req=0, max_req=1000)
-print(f"Object miss ratio: {obj_miss_ratio:.4f}, Byte miss ratio: {byte_miss_ratio:.4f}")
+# Step 3.1: Further process the first 1000 requests again
+req_miss_ratio, byte_miss_ratio = cache.process_trace(reader, start_req=0, max_req=1000)
+print(f"Request miss ratio: {req_miss_ratio:.4f}, Byte miss ratio: {byte_miss_ratio:.4f}")

libcachesim/__init__.py

@@ -59,7 +59,6 @@
 from .trace_analyzer import TraceAnalyzer
 from .synthetic_reader import SyntheticReader, create_zipf_requests, create_uniform_requests
 from .util import Util
-from .data_loader import DataLoader
 
 __all__ = [
     # Core classes
@@ -118,8 +117,6 @@
     "create_uniform_requests",
     # Utilities
     "Util",
-    # Data loader
-    "DataLoader",
     # Metadata
     "__doc__",
     "__version__",