Add CI workflow for Java projects using Maven

.github/workflows/ci.yml

@@ -0,0 +1,35 @@
+name: Java CI with Maven
+
+on:
+  push:
+    branches:
+      - master  # Trigger only on push to master branch (e.g., after merging a PR)
+  pull_request:
+    branches: 
+      - master
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v3
+
+    - name: Set up JDK
+      uses: actions/setup-java@v3
+      with:
+        java-version: '21'        # Or 11, 21, etc.
+        distribution: 'temurin'   # Recommended distribution
+
+    - name: Cache Maven packages
+      uses: actions/cache@v3
+      with:
+        path: ~/.m2
+        key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+        restore-keys: |
+          ${{ runner.os }}-maven-
+
+
+    - name: Build and test with Maven
+      run: mvn test -Dtest=BtreeBenchmark

.gitignore

@@ -1,5 +1,5 @@
 .vscode
 bin
-storage
+storage/*.btree
 target
 lib

src/test/btree/BtreeBenchmark.java

@@ -41,6 +41,18 @@ public void setUp() {
     btree = new Btree(keyType, valueType, btreeFilePath, Globals.INVALID_PAGE_ID, bufferPool);
   }
 
+  public void setUp2() {
+    CleanUp();
+    // Initialize the DiskManager
+    diskManager = new BasicDiskManager();
+    // Initialize the buffer pool with a size of 10 pages
+    bufferPool = new BufferPool(MAX_PAGES, K, diskManager);
+    keyType = new Template(Integer.class);
+    valueType = new Template(Integer.class);
+    // Initialize the B-tree
+    btree = new Btree(keyType, valueType, btreeFilePath, Globals.INVALID_PAGE_ID, bufferPool);
+  }
+
   @After
   public void CleanUp() {
     // monitor.interrupt();
@@ -60,6 +72,7 @@ private Compositekey makeCompositekey(int age, int salary, Template type) {
     return key;
   }
 
+
   private Compositekey makeCompositekey(int val, Template type) {
     Compositekey key = new Compositekey(type);
     key.set(0, val, Integer.class);
@@ -554,4 +567,156 @@ public void testBtreeBenchmark3() throws Exception {
         Arrays.stream(overallThroughputs).average().getAsDouble());
     System.out.println("└───────────────────────────────────────────────────────────");
   }
+
+
+  @Test
+  public void testBtreeBenchmark4() throws Exception {
+    int keysnumber = 2_000_000;
+    double[] totalExecutionTimes = new double[ITERATIONS];
+    double[] totalInsertTimes = new double[ITERATIONS];
+    double[] avgInsertTimes = new double[ITERATIONS];
+    double[] insertThroughputs = new double[ITERATIONS];
+    double[] totalSearchTimes = new double[ITERATIONS];
+    double[] avgSearchTimes = new double[ITERATIONS];
+    double[] searchThroughputs = new double[ITERATIONS];
+    double[] overallThroughputs = new double[ITERATIONS];
+
+    for (int iteration = 0; iteration < ITERATIONS; iteration++) {
+      setUp2(); // Reset the environment for each iteration
+      int writersCnt = 200;
+      int readersCnt = 200;
+      List<Thread> threads = new ArrayList<>();
+      int op = 10000;
+
+
+      double[] insertTimes = new double[2 * keysnumber];
+      double[] searchTimes = new double[keysnumber];
+
+      threads = new ArrayList<>();
+      double startTime = (double) System.currentTimeMillis();
+      double startTimeW = (double) System.currentTimeMillis();
+      // Insert operations
+      for (int i = 0; i < writersCnt; i++) {
+        final int end = op * (i + 1);
+        Thread writer =
+            new Thread(
+                () -> {
+                  for (int key = end - op; key < end; key++) {
+                    try {
+                      long insertStartTime = System.currentTimeMillis();
+                      btree.insert(
+                          makeCompositekey(key, keyType),
+                          makeCompositekey(key, valueType));
+                      long insertEndTime = System.currentTimeMillis();
+                      insertTimes[key] = (insertEndTime - insertStartTime);
+                    } catch (Exception e) {
+                      e.printStackTrace();
+                      fail();
+                    }
+                  }
+                });
+        threads.add(writer);
+      }
+
+      Collections.shuffle(threads);
+      for (Thread thread : threads) {
+        thread.start();
+      }
+
+      for (Thread thread : threads) {
+        thread.join();
+      }
+
+      double insertTotalTime = System.currentTimeMillis() - startTimeW;
+      totalInsertTimes[iteration] = insertTotalTime;
+      avgInsertTimes[iteration] = Arrays.stream(insertTimes).average().getAsDouble();
+      insertThroughputs[iteration] = 2 * keysnumber / insertTotalTime * 1000;
+
+      // Search operations
+      threads = new ArrayList<>();
+      double startTime2 = System.currentTimeMillis();
+
+      for (int i = 0; i < readersCnt; i++) {
+        final int end = op * (i + 1);
+        Thread reader =
+            new Thread(
+                () -> {
+                  for (int key = end - op; key < end; key++) {
+                    try {
+                      long searchStartTime = System.currentTimeMillis();
+                      Compositekey val =
+                          btree.get(makeCompositekey(key, keyType));
+                      long searchEndTime = System.currentTimeMillis();
+                      searchTimes[key] = (searchEndTime - searchStartTime);
+                      // assertEquals(0, val.compareTo(makeCompositekey(key, valueType)));
+                    } catch (Exception e) {
+                      System.out.println("thread " + end / op + ": expected ->" + key);
+                      e.printStackTrace();
+                      fail();
+                    }
+                  }
+                });
+        threads.add(reader);
+      }
+
+      Collections.shuffle(threads);
+      for (Thread thread : threads) {
+        thread.start();
+      }
+
+      for (Thread thread : threads) {
+        thread.join();
+      }
+
+      double searchTotalTime = System.currentTimeMillis() - startTime2;
+      totalSearchTimes[iteration] = searchTotalTime;
+      avgSearchTimes[iteration] = Arrays.stream(searchTimes).average().getAsDouble();
+      searchThroughputs[iteration] = keysnumber / searchTotalTime * 1000;
+
+      double endTime = System.currentTimeMillis();
+      totalExecutionTimes[iteration] = (endTime - startTime) / 1000.0;
+      overallThroughputs[iteration] = (keysnumber * 3) / (insertTotalTime + searchTotalTime) * 1000;
+
+      CleanUp(); // Clean up after each iteration
+      System.out.println("Iteration " + (iteration + 1) + " completed");
+    }
+
+    // Calculate and display averages
+    System.out.println("┌───────────────────────────────────────────────────────────");
+    System.out.printf(
+        "\033[1;36m              B-TREE BENCHMARK RESULTS (%d ITERATIONS)           \033[0m\n",
+        ITERATIONS);
+    System.out.println("┬───────────────────────────────────────────────────────────");
+    System.out.printf(
+        " \033[1mAverage total execution time:\033[0m %8.2f seconds\n",
+        Arrays.stream(totalExecutionTimes).average().getAsDouble());
+    System.out.println("┼───────────────────────────────────────────────────────────");
+    System.out.printf(" \033[1;32mInsert+Delete operations:\033[0m\n");
+    System.out.printf(
+        "   - Average total time:     %8.2f seconds\n",
+        Arrays.stream(totalInsertTimes).average().getAsDouble() / 1000);
+    System.out.printf(
+        "   - Average operation time: %8.2f ms per operation\n",
+        Arrays.stream(avgInsertTimes).average().getAsDouble());
+    System.out.printf(
+        "   - Average throughput:     %8.2f operations per second\n",
+        Arrays.stream(insertThroughputs).average().getAsDouble());
+    System.out.println("┼───────────────────────────────────────────────────────────");
+    System.out.printf(" \033[1;33mSearch operations:\033[0m\n");
+    System.out.printf(
+        "   - Average total time:     %8.2f seconds\n",
+        Arrays.stream(totalSearchTimes).average().getAsDouble() / 1000);
+    System.out.printf(
+        "   - Average operation time: %8.2f ms per operation\n",
+        Arrays.stream(avgSearchTimes).average().getAsDouble());
+    System.out.printf(
+        "   - Average throughput:     %8.2f operations per second\n",
+        Arrays.stream(searchThroughputs).average().getAsDouble());
+    System.out.println("┼───────────────────────────────────────────────────────────");
+    System.out.printf(
+        " \033[1;35mAverage overall throughput:\033[0m %8.2f operations per second\n",
+        Arrays.stream(overallThroughputs).average().getAsDouble());
+    System.out.println("└───────────────────────────────────────────────────────────");
+  }
+
 }

storage/README.md

@@ -0,0 +1 @@
+place holder