Read bm from zip (#846)

* Added support in zip bm

* Change to 1M

* install rocksdb in the ci

* Change to apt get

* stop service

* Added unzip

* Change the temp folder name

* PR review

Author: dor-forer

.github/workflows/benchmark-runner.yml

@@ -61,7 +61,8 @@ jobs:
       - name: Install benchmark dependencies
         run: |
           sudo .install/install_script.sh
-          sudo apt install python3-pip -y
+          ./install_rocksdb_simple.sh
+          sudo apt-get install -y python3-pip
           pip3 install --upgrade pip PyYAML setuptools redisbench-admin
           pip3 install -r requirements.txt
       - name: Download pre-generated indices

install_rocksdb_simple.sh

@@ -51,10 +51,11 @@ while [[ $# -gt 0 ]]; do
 done
 
 echo "Installing RocksDB 10.5.1..."
-
+sudo systemctl stop unattended-upgrades || true
+sudo pkill -9 unattended-upgr || true
 # Install dependencies
-sudo apt update
-sudo apt install -y build-essential cmake git wget \
+sudo apt-get update
+sudo apt-get install -y build-essential cmake git wget unzip \
     libgflags-dev libsnappy-dev zlib1g-dev libbz2-dev \
     liblz4-dev libzstd-dev libgtest-dev pkg-config
 

src/VecSim/index_factories/hnsw_disk_factory.cpp

@@ -16,38 +16,177 @@
 #include <fstream>
 #include <filesystem>
 #include <unistd.h>
+#include <sys/wait.h>
 #include <ctime>
 #include <cstdlib>
+#include <array>
+#include <memory>
+#include <random>
 
 namespace HNSWDiskFactory {
 
 #ifdef BUILD_TESTS
 
+/**
+ * @brief Generate a random alphanumeric string of the specified length
+ * @param length The length of the string to generate
+ * @return A random string containing only alphanumeric characters
+ */
+static std::string generate_random_string(size_t length) {
+    static const char charset[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    static const size_t charset_size = sizeof(charset) - 1;
+
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<size_t> dist(0, charset_size - 1);
+
+    std::string result;
+    result.reserve(length);
+    for (size_t i = 0; i < length; ++i) {
+        result += charset[dist(gen)];
+    }
+    return result;
+}
+
+/**
+ * @brief Check if a file is a zip archive by examining its magic bytes
+ * @param file_path Path to the file to check
+ * @return true if the file starts with zip magic bytes (PK\x03\x04)
+ */
+static bool isZipFile(const std::string &file_path) {
+    std::ifstream file(file_path, std::ios::binary);
+    if (!file.is_open()) {
+        return false;
+    }
+    // ZIP files start with "PK\x03\x04" (0x504B0304)
+    std::array<char, 4> magic{};
+    file.read(magic.data(), 4);
+    return file.gcount() == 4 && magic[0] == 'P' && magic[1] == 'K' &&
+           magic[2] == '\x03' && magic[3] == '\x04';
+}
+
+/**
+ * @brief Extract a zip file to a target directory using the system unzip command
+ * @param zip_path Path to the zip file
+ * @param target_dir Directory where the zip contents will be extracted
+ * @throws std::runtime_error if extraction fails
+ */
+static void extractZipToDirectory(const std::string &zip_path, const std::string &target_dir) {
+    // Create the target directory if it doesn't exist
+    std::filesystem::create_directories(target_dir);
+
+    // Build the unzip command
+    // -o: overwrite files without prompting
+    // -q: quiet mode
+    // -d: extract to specified directory
+    std::string command = "unzip -o -q \"" + zip_path + "\" -d \"" + target_dir + "\"";
+
+    // Execute the command
+    int status = std::system(command.c_str());
+    if (status != 0) {
+        throw std::runtime_error("Failed to extract zip file: " + zip_path +
+                                 " (exit code: " + std::to_string(status) + ")");
+    }
+}
+
 // RAII wrapper to manage RocksDB database and temporary directory cleanup
 class ManagedRocksDB {
 private:
     std::unique_ptr<rocksdb::DB> db;
     rocksdb::ColumnFamilyHandle *cf = nullptr;
     std::string temp_dir;
+    std::string extracted_folder_path;  // Path to the extracted index folder within temp_dir
     bool cleanup_temp_dir;  // Whether to delete temp_dir on destruction
 
+    // Private constructor - use static factory methods
+    ManagedRocksDB() : cleanup_temp_dir(false) {}
+
 public:
-    // Constructor for loading from checkpoint (with temp directory for writes)
-    // Copies the entire checkpoint to a temp location to ensure the original is never modified
-    ManagedRocksDB(const std::string &checkpoint_dir, const std::string &temp_path)
-        : temp_dir(temp_path), cleanup_temp_dir(true) {
+    // Factory method for loading from a zip file (extracts to temp directory)
+    static std::unique_ptr<ManagedRocksDB> fromZipFile(const std::string &zip_path,
+                                                        const std::string &temp_path) {
+        auto instance = std::unique_ptr<ManagedRocksDB>(new ManagedRocksDB());
+        instance->temp_dir = temp_path;
+        instance->extracted_folder_path = temp_path;
+        instance->cleanup_temp_dir = true;
 
         // Create temp directory
-        std::filesystem::create_directories(temp_dir);
+        std::filesystem::create_directories(instance->temp_dir);
+
+        // Extract the zip file to temp directory
+        try {
+            extractZipToDirectory(zip_path, instance->temp_dir);
+        } catch (const std::exception &e) {
+            std::filesystem::remove_all(instance->temp_dir);
+            throw std::runtime_error("Failed to extract zip file: " + std::string(e.what()));
+        }
+
+        // Find the extracted folder - it should contain index.hnsw_disk_v1 and rocksdb/
+        // The zip might contain the folder at root level or directly contain the files
+        std::string index_file = instance->temp_dir + "/index.hnsw_disk_v1";
+        std::string rocksdb_dir = instance->temp_dir + "/rocksdb";
+
+        if (!std::filesystem::exists(index_file) || !std::filesystem::exists(rocksdb_dir)) {
+            // Check if there's a single subdirectory containing the files
+            for (const auto &entry : std::filesystem::directory_iterator(instance->temp_dir)) {
+                if (entry.is_directory()) {
+                    std::string sub_index = entry.path().string() + "/index.hnsw_disk_v1";
+                    std::string sub_rocksdb = entry.path().string() + "/rocksdb";
+                    if (std::filesystem::exists(sub_index) &&
+                        std::filesystem::exists(sub_rocksdb)) {
+                        instance->extracted_folder_path = entry.path().string();
+                        break;
+                    }
+                }
+            }
+        }
+
+        // Verify the structure exists
+        if (!std::filesystem::exists(instance->extracted_folder_path + "/index.hnsw_disk_v1") ||
+            !std::filesystem::exists(instance->extracted_folder_path + "/rocksdb")) {
+            std::filesystem::remove_all(instance->temp_dir);
+            throw std::runtime_error(
+                "Invalid zip structure: expected index.hnsw_disk_v1 and rocksdb/ directory");
+        }
+
+        // Open RocksDB from the extracted checkpoint
+        std::string checkpoint_dir = instance->extracted_folder_path + "/rocksdb";
+        rocksdb::Options options;
+        options.create_if_missing = false;
+        options.error_if_exists = false;
+        options.statistics = rocksdb::CreateDBStatistics();
+
+        rocksdb::DB *db_ptr = nullptr;
+        rocksdb::Status status = rocksdb::DB::Open(options, checkpoint_dir, &db_ptr);
+        if (!status.ok()) {
+            std::filesystem::remove_all(instance->temp_dir);
+            throw std::runtime_error("Failed to open RocksDB from extracted checkpoint: " +
+                                     status.ToString());
+        }
+
+        instance->db.reset(db_ptr);
+        instance->cf = instance->db->DefaultColumnFamily();
+        return instance;
+    }
+
+    // Factory method for loading from checkpoint directory (copies to temp location)
+    static std::unique_ptr<ManagedRocksDB> fromCheckpointDir(const std::string &checkpoint_dir,
+                                                              const std::string &temp_path) {
+        auto instance = std::unique_ptr<ManagedRocksDB>(new ManagedRocksDB());
+        instance->temp_dir = temp_path;
+        instance->cleanup_temp_dir = true;
+
+        // Create temp directory
+        std::filesystem::create_directories(instance->temp_dir);
 
         // Copy the entire checkpoint to temp location to preserve the original
-        std::string temp_checkpoint = temp_dir + "/checkpoint_copy";
+        std::string temp_checkpoint = instance->temp_dir + "/checkpoint_copy";
         try {
             std::filesystem::copy(checkpoint_dir, temp_checkpoint,
                                 std::filesystem::copy_options::recursive);
         } catch (const std::filesystem::filesystem_error &e) {
             // Clean up temp dir if copy failed
-            std::filesystem::remove_all(temp_dir);
+            std::filesystem::remove_all(instance->temp_dir);
             throw std::runtime_error("Failed to copy checkpoint to temp location: " +
                                    std::string(e.what()));
         }
@@ -63,20 +202,25 @@ class ManagedRocksDB {
         rocksdb::Status status = rocksdb::DB::Open(options, temp_checkpoint, &db_ptr);
         if (!status.ok()) {
             // Clean up temp dir if DB open failed
-            std::filesystem::remove_all(temp_dir);
+            std::filesystem::remove_all(instance->temp_dir);
             throw std::runtime_error("Failed to open RocksDB from temp checkpoint: " +
                                    status.ToString());
         }
 
-        db.reset(db_ptr);
-        cf = db->DefaultColumnFamily();
+        instance->db.reset(db_ptr);
+        instance->cf = instance->db->DefaultColumnFamily();
+        return instance;
     }
 
-    // Constructor for creating new index (permanent location, no cleanup)
-    ManagedRocksDB(rocksdb::DB *db_ptr, const std::string &db_path)
-        : temp_dir(db_path), cleanup_temp_dir(false) {
-        db.reset(db_ptr);
-        cf = db->DefaultColumnFamily();
+    // Factory method for creating new index (permanent location, no cleanup)
+    static std::unique_ptr<ManagedRocksDB> fromExistingDB(rocksdb::DB *db_ptr,
+                                                          const std::string &db_path) {
+        auto instance = std::unique_ptr<ManagedRocksDB>(new ManagedRocksDB());
+        instance->temp_dir = db_path;
+        instance->cleanup_temp_dir = false;
+        instance->db.reset(db_ptr);
+        instance->cf = instance->db->DefaultColumnFamily();
+        return instance;
     }
 
     // Destructor: closes DB and optionally cleans up temp directory
@@ -100,6 +244,7 @@ class ManagedRocksDB {
     rocksdb::DB* getDB() const { return db.get(); }
     rocksdb::ColumnFamilyHandle* getCF() const { return cf; }
     const std::string& getTempDir() const { return temp_dir; }
+    const std::string& getExtractedFolderPath() const { return extracted_folder_path; }
 };
 
 // Static managed RocksDB instance for benchmark convenience wrapper
@@ -180,7 +325,7 @@ VecSimIndex *NewIndex(const VecSimParams *params) {
     }
 
     // Store in RAII wrapper (will close DB on exit, but won't delete directory)
-    managed_rocksdb = std::make_unique<ManagedRocksDB>(db_ptr, dbPath);
+    managed_rocksdb = ManagedRocksDB::fromExistingDB(db_ptr, dbPath);
 
     // Create AbstractIndexInitParams
     AbstractIndexInitParams abstractInitParams = NewAbstractInitParams(params);
@@ -278,7 +423,24 @@ VecSimIndex *NewIndex(const std::string &folder_path, rocksdb::DB *db,
 }
 
 VecSimIndex *NewIndex(const std::string &folder_path, bool is_normalized) {
-    // Get the checkpoint directory path
+    // Create a temporary directory
+    // Using PID and timestamp to ensure uniqueness across multiple benchmark runs
+    std::string temp_dir = (std::filesystem::temp_directory_path() /
+        ("hnsw_disk_benchmark_" + std::to_string(getpid()) + "_" +
+        std::to_string(std::time(nullptr)) + "_" + generate_random_string(8))).string();
+
+    // Check if the input is a zip file
+    if (isZipFile(folder_path)) {
+        // Load from zip file - extract and open RocksDB from extracted location
+        managed_rocksdb = ManagedRocksDB::fromZipFile(folder_path, temp_dir);
+
+        // Use the extracted folder path for loading the index
+        std::string extracted_path = managed_rocksdb->getExtractedFolderPath();
+        return NewIndex(extracted_path, managed_rocksdb->getDB(), managed_rocksdb->getCF(),
+                        is_normalized);
+    }
+
+    // Not a zip file - treat as folder path (original behavior)
     std::string checkpoint_dir = GetCheckpointDir(folder_path);
 
     if (!std::filesystem::exists(checkpoint_dir)) {
@@ -287,12 +449,7 @@ VecSimIndex *NewIndex(const std::string &folder_path, bool is_normalized) {
             "\nMake sure the index was saved with the checkpoint-based format.");
     }
 
-    // Create a temporary directory for the checkpoint copy
-    // Using PID and timestamp to ensure uniqueness across multiple benchmark runs
-    std::string temp_dir = "/tmp/hnsw_disk_benchmark_" + std::to_string(getpid()) +
-                          "_" + std::to_string(std::time(nullptr));
-
-    managed_rocksdb = std::make_unique<ManagedRocksDB>(checkpoint_dir, temp_dir);
+    managed_rocksdb = ManagedRocksDB::fromCheckpointDir(checkpoint_dir, temp_dir);
 
     return NewIndex(folder_path, managed_rocksdb->getDB(), managed_rocksdb->getCF(), is_normalized);
 }

src/VecSim/index_factories/hnsw_disk_factory.h

@@ -70,18 +70,28 @@ VecSimIndex *NewIndex(const std::string &folder_path, rocksdb::DB *db,
 
 /**
  * Convenience wrapper to load a disk-based HNSW index with automatic database management.
- * Opens the checkpoint database and loads the index from the specified folder.
+ * Opens the checkpoint database and loads the index from the specified folder or zip file.
  * The original checkpoint is NEVER modified - all operations use a temporary copy.
  *
- * @param folder_path Path to the folder containing the index
+ * @param folder_path Path to the folder containing the index, OR path to a zip file
+ *                    containing the index folder structure
  * @param is_normalized Whether vectors are already normalized (for Cosine metric optimization)
  * @return VecSimIndex* Pointer to the loaded HNSWDiskIndex, or throws on error
  *
+ * @note ZIP FILE SUPPORT:
+ *       - If folder_path points to a zip file (detected by magic bytes), it will be
+ *         extracted to a temporary directory before loading
+ *       - The zip file should contain:
+ *           - index.hnsw_disk_v1 (index metadata file)
+ *           - rocksdb/ (RocksDB checkpoint directory)
+ *         Either at root level or inside a single subdirectory
+ *
  * @note CHECKPOINT PRESERVATION:
- *       - The entire checkpoint is copied to /tmp/hnsw_disk_benchmark_<pid>_<timestamp>/checkpoint_copy
- *       - All RocksDB operations (reads and writes) use the temporary copy
- *       - The original checkpoint remains completely unchanged across all benchmark runs
- *       - This ensures consistent benchmark results when running the same benchmark multiple times
+ *       - For folder input: The checkpoint is copied to <temp_dir>/hnsw_disk_benchmark_<pid>_<timestamp>_<random>/
+ *       - For zip input: The zip is extracted to <temp_dir>/hnsw_disk_benchmark_<pid>_<timestamp>_<random>/
+ *       - <temp_dir> is the system temporary directory (std::filesystem::temp_directory_path())
+ *       - All RocksDB operations use the temporary copy
+ *       - The original files remain completely unchanged
  *
  * @note CLEANUP GUARANTEES:
  *       - Temporary directory is automatically cleaned up via RAII (ManagedRocksDB destructor)

tests/benchmark/data/hnsw_indices/hnsw_indices_bm-hnsw-disk-fp32-single.txt

@@ -1,3 +1,3 @@
-https://dev.cto.redis.s3.amazonaws.com/VectorSimilarity/deep1b/deep-1M-cosine-dim96-M32-efc200-disk-vectors.zip
+https://dev.cto.redis.s3.amazonaws.com/VectorSimilarity/deep1b/deep-1M-L2-dim96-M32-efc200-disk-vectors.zip
 https://dev.cto.redis.s3.amazonaws.com/VectorSimilarity/deep1b/deep.query.public.10K.fbin
 https://dev.cto.redis.s3.amazonaws.com/VectorSimilarity/deep1b/deep.groundtruth.1M.10K.ibin

tests/benchmark/run_files/bm_hnsw_disk_single_fp32.cpp

@@ -12,19 +12,19 @@ bool BM_VecSimGeneral::is_multi = false;
 // Only enable HNSW_DISK for this benchmark
 uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_MASK_HNSW_DISK;
 
-// Configure using deep dataset (1M vectors, 96 dimensions)
+// Configure using deep dataset (100K vectors, 96 dimensions)
 size_t BM_VecSimGeneral::n_queries = 100;
-size_t BM_VecSimGeneral::n_vectors = 1000000;
+size_t BM_VecSimGeneral::n_vectors = 100000;
 size_t BM_VecSimGeneral::dim = 96;
 size_t BM_VecSimGeneral::M = 32;
 size_t BM_VecSimGeneral::EF_C = 256;
 
 // Dataset file paths - using deep dataset
 // For HNSW disk, hnsw_index_file points to the folder containing index.hnsw_disk_v1 and rocksdb/
 const char *BM_VecSimGeneral::hnsw_index_file =
-    "tests/benchmark/data/deep-1M-cosine-dim96-M32-efc200-disk-vectors";
+    "tests/benchmark/data/deep-100K-L2-dim96-M32-efc200-disk-vectors";
 const char *BM_VecSimGeneral::test_queries_file = "tests/benchmark/data/deep.query.public.10K.fbin";
-const char *BM_VecSimGeneral::ground_truth_file = "tests/benchmark/data/deep.groundtruth.1M.10K.ibin"; // defined only for this benchmark
+const char *BM_VecSimGeneral::ground_truth_file = "tests/benchmark/data/deep.groundtruth.100K.10K.ibin"; // defined only for this benchmark
 
 #define BM_FUNC_NAME(bm_func, algo) CONCAT_WITH_UNDERSCORE_ARCH(bm_func, algo, Single)
 #define BM_ADD_LABEL                CONCAT_WITH_UNDERSCORE_ARCH(AddLabel, Single)