CMakeLists.txt

@@ -1,19 +1,6 @@
 cmake_minimum_required(VERSION 3.13.4)
 project(RTSA-lab01-CacheAnalysis)
 
-#===============================================================================
-# 0. Add GoogleTest
-#===============================================================================
-include(FetchContent)
-FetchContent_Declare(
-  googletest
-  URL 
-  URL https://github.com/google/googletest/archive/05CC6081FCBD0071053DE78238E136B3.zip
-)
-# For Windows: Prevent overriding the parent project's compiler/linker settings
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-FetchContent_MakeAvailable(googletest)
-
 #===============================================================================
 # 1. VERIFY LLVM INSTALLATION DIR
 # This is just a bit of a sanity checking.
@@ -121,5 +108,4 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
 # available for the sub-projects.
 #===============================================================================
 add_subdirectory(CacheAnalysisPass)  # Use your pass name here.
-add_subdirectory(UnitTest)
 #add_subdirectory(lib)

README.md

@@ -88,7 +88,6 @@ This is my personally preferred IDE setup for C/C++ and by no means needed to ac
 clangd,
 Clang-Format,
 CodeLLDB,
-C++ TestMate,
 Docker and
 Remote Development
 
@@ -152,12 +151,6 @@ You can also set the following variables in the CacheAnalysisPass/CacheAnalysisP
 
 Helpful to understand what the program does but not very so much for the actual exercise.
 
-## UnitTest
-
-The best way to see what your function does is to use the UnitTest.cpp.
-With "C++ TestMate" install you can simply run or debug the test from the side panel in VS Code (Flask Icon).
-The "C++ TestMate" is not installed in the VM as I just added this feature now.
-Please feel free to add more test cases to your liking in UnitTest.cpp.
 ## Use the Helper script
 
 Again if you work on a Pool PC use poolhelper.sh insted of the helper.sh script.

UnitTest/CMakeLists.txt

@@ -1,52 +0,0 @@
-cmake_minimum_required(VERSION 3.13.4)
-project(UnitTest)
-
-#===============================================================================
-# 1. LOAD LLVM CONFIGURATION
-#===============================================================================
-# Set this to a valid LLVM installation dir
-set(LT_LLVM_INSTALL_DIR "" CACHE PATH "LLVM installation directory")
-
-# Add the location of LLVMConfig.cmake to CMake search paths (so that
-# find_package can locate it)
-list(APPEND CMAKE_PREFIX_PATH "${LT_LLVM_INSTALL_DIR}/lib/cmake/llvm/")
-
-# FIXME: This is a warkaround for #25. Remove once resolved and use
-# find_package(LLVM 11.0.0 REQUIRED CONFIG) instead.
-find_package(LLVM REQUIRED CONFIG)
-
-# UnitTest includes headers from LLVM - update the include paths accordingly
-include_directories(SYSTEM ${LLVM_INCLUDE_DIRS}, "${CMAKE_CURRENT_SOURCE_DIR}/../include")
-
-#===============================================================================
-# 2. LLVM-TUTOR BUILD CONFIGURATION
-#===============================================================================
-# Use the same C++ standard as LLVM does
-set(CMAKE_CXX_STANDARD 14 CACHE STRING "")
-
-# LLVM is normally built without RTTI. Be consistent with that.
-if(NOT LLVM_ENABLE_RTTI)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
-endif()
-
-#===============================================================================
-# 3. ADD THE TARGET
-#===============================================================================
-enable_testing()
-
-add_executable(UnitTest 
-    # List your source files here.
-    UnitTest.cpp
-)
-
-
-# Allow undefined symbols in shared objects on Darwin (this is the default
-# behaviour on Linux)
-target_link_libraries(UnitTest
-  "$<$<PLATFORM_ID:Darwin>:-undefined dynamic_lookup>")
-  target_link_libraries(
-  UnitTest
-  gtest_main
-)
-include(GoogleTest)
-gtest_discover_tests(UnitTest)

UnitTest/UnitTest.cpp

@@ -1,101 +0,0 @@
-#include <gtest/gtest.h>
-#include <sys/stat.h>
-
-#include "../include/AbstractCache.h"
-
-void fillSet(AbstractState &In, unsigned int Set) {
-  for (int I = 0; I < 4; I++) {
-    In.Sets[Set].Associativity[I].Blocks.push_front(I);
-  }
-}
-
-// Joined Set should remain the same
-TEST(UnitTest, MustJoinSameStates) {
-  AbstractCache AC;
-  AC.addEmptyNode(0);
-  fillSet(AC.Nodes[0], 0);
-  AC.addEmptyNode(1);
-  fillSet(AC.Nodes[1], 0);
-
-  AC.Nodes[0].mustJoin(AC.Nodes[1]);
-  for (auto B : AC.Nodes[0].Sets[0].Associativity) {
-    uint Age = B.first;
-    EXPECT_EQ(AC.Nodes[0].Sets[0].Associativity[Age].Blocks.front(),
-              AC.Nodes[1].Sets[0].Associativity[Age].Blocks.front());
-  }
-}
-
-void counterFillSet(AbstractState &In, unsigned int Set) {
-  for (int I = 0; I < 4; I++) {
-    In.Sets[Set].Associativity[I].Blocks.push_front((I + 1) % 4);
-  }
-}
-
-// Resulting state should be
-// Set[0]:
-//   Age[0]:
-//   Age[1]: 1
-//   Age[2]: 2
-//   Age[3]: 0 3
-TEST(UnitTest, MustJoinDifferentStates) {
-  AbstractCache AC;
-  AC.addEmptyNode(0);
-  counterFillSet(AC.Nodes[0], 0);
-  AC.addEmptyNode(1);
-  fillSet(AC.Nodes[1], 0);
-  std::cout << "==Before:==\n";
-  AC.Nodes[0].dumpSet(0);
-  AC.Nodes[1].dumpSet(0);
-
-  AC.Nodes[0].mustJoin(AC.Nodes[1]);
-  std::cout << "\n==After:==\n";
-  AC.Nodes[0].dumpSet(0);
-  for (auto B : AC.Nodes[0].Sets[0].Associativity) {
-    uint Age = B.first;
-    switch (Age) {
-    case 0:
-      EXPECT_TRUE(AC.Nodes[0].Sets[0].Associativity[Age].Blocks.empty());
-      break;
-    case 1:
-      EXPECT_EQ(AC.Nodes[0].Sets[0].Associativity[Age].Blocks.front(), 1);
-      break;
-    case 2:
-      EXPECT_EQ(AC.Nodes[0].Sets[0].Associativity[Age].Blocks.front(), 2);
-      break;
-    case 3:
-      // this test is not very exact the Set 0 with age 3 should contain (0,3)
-      // in arbitrary order
-      EXPECT_EQ(AC.Nodes[0].Sets[0].Associativity[Age].Blocks.size(), 2);
-      break;
-    default:
-      // should never be reached!
-      EXPECT_TRUE(false);
-    }
-  }
-}
-
-void fillSetHighNumbers(AbstractState &In, unsigned int Set) {
-  for (int I = 0; I < 4; I++) {
-    In.Sets[Set].Associativity[I].Blocks.push_front(10+I);
-  }
-}
-
-// resulting state should be empty
-TEST(UnitTest, MustJoinDisjunctStates) {
-  AbstractCache AC;
-  AC.addEmptyNode(0);
-  fillSetHighNumbers(AC.Nodes[0], 0);
-  AC.addEmptyNode(1);
-  fillSet(AC.Nodes[1], 0);
-  std::cout << "==Before:==\n";
-  AC.Nodes[0].dumpSet(0);
-  AC.Nodes[1].dumpSet(0);
-
-  AC.Nodes[0].mustJoin(AC.Nodes[1]);
-  std::cout << "\n==After:==\n";
-  AC.Nodes[0].dumpSet(0);
-  for (auto B : AC.Nodes[0].Sets[0].Associativity) {
-    uint Age = B.first;
-    EXPECT_TRUE(AC.Nodes[0].Sets[0].Associativity[Age].Blocks.empty());
-  }
-}

helper.sh

@@ -11,7 +11,7 @@ config () {
   mkdir build
   cd build
   echo "==== Configuring cmake ===="
-  cmake -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCMAKE_EXPORT_COMPILE_COMMANDS=1 -DLT_LLVM_INSTALL_DIR=/usr ..
+  cmake -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCMAKE_EXPORT_COMPILE_COMMANDS=1 -DLT_LLVM_INSTALL_DIR=$LLVM_DIR ../CacheAnalysisPass/
   cd ..
   cp build/compile_commands.json compile_commands.json
   echo "==== Done! ===="

include/AbstractCache.h

@@ -1,3 +1,4 @@
+
 #ifndef ABSTRACHTCACHESTATE_H
 #define ABSTRACHTCACHESTATE_H
 
@@ -10,6 +11,9 @@
 #include <ostream>
 #include <utility>
 
+#include <llvm/IR/BasicBlock.h>
+#include <llvm/Support/raw_ostream.h>
+
 #include "AbstractState.h"
 #include "Address.h"
 #include "ConcreteState.h"
@@ -288,34 +292,34 @@ public: // everything is public, because IDGAF
         removeNestedLoops(LoopBody, OrigNodeToUnrolledNode);
 
         if (Verbose && FoundLoopBody) {
-          std::cout << "Found LoopHead @: " << NodeNr << "\n";
+          llvm::outs() << "Found LoopHead @: " << NodeNr << "\n";
-          std::cout << "With LoopTail @: " << LoopTail << "\n";
+          llvm::outs() << "With LoopTail @: " << LoopTail << "\n";
-          std::cout << "With Body: {\n";
+          llvm::outs() << "With Body: {\n";
           int I = 1;
           for (auto Node : LoopBody) {
-            std::cout << Node << ", ";
+            llvm::outs() << Node << ", ";
             if (!(I++ % 5)) {
-              std::cout << "\n";
+              llvm::outs() << "\n";
             }
           }
-          std::cout << "}\n";
+          llvm::outs() << "}\n";
-          std::cout << "Unrolled States: {\n";
+          llvm::outs() << "Unrolled States: {\n";
           I = 1;
           for (auto Node : LoopBody) {
-            std::cout << OrigNodeToUnrolledNode[Node] << ", ";
+            llvm::outs() << OrigNodeToUnrolledNode[Node] << ", ";
             if (!(I++ % 5)) {
-              std::cout << "\n";
+              llvm::outs() << "\n";
             }
           }
-          std::cout << "}\n";
+          llvm::outs() << "}\n";
           I = 1;
-          std::cout << "OrigNodeToUnrolledNode: {\n";
+          llvm::outs() << "OrigNodeToUnrolledNode: {\n";
           for (auto Nr : OrigNodeToUnrolledNode) {
-            std::cout << Nr.first << "->" << Nr.second << ", ";
+            llvm::outs() << Nr.first << "->" << Nr.second << ", ";
             if (!(I++ % 3))
-              std::cout << "\n";
+              llvm::outs() << "\n";
           }
-          std::cout << "}\n";
+          llvm::outs() << "}\n";
         }
       }
     }
@@ -396,19 +400,19 @@ public: // everything is public, because IDGAF
    *
    */
   void dumpEdges() {
-    std::cout << "Dumping Edges:\n";
+    llvm::outs() << "Dumping Edges:\n";
     for (auto const &E : Edges) {
-      std::cout << E.first;
+      llvm::outs() << E.first;
       bool FirstPrint = true;
       for (unsigned int To : E.second) {
         if (FirstPrint) {
-          std::cout << " -> " << To;
+          llvm::outs() << " -> " << To;
           FirstPrint = false;
         } else {
-          std::cout << ", " << To;
+          llvm::outs() << ", " << To;
         }
       }
-      std::cout << "\n";
+      llvm::outs() << "\n";
     }
   }
 
@@ -449,6 +453,5 @@ public: // everything is public, because IDGAF
       Nodes[E.first].dump();
     }
   }
-
 };     // namespace
 #endif // ABSTRACHTCACHESTATE_H

include/AbstractState.h

@@ -12,6 +12,8 @@
 #include <sstream>
 #include <string>
 
+#include <llvm/Support/raw_ostream.h>
+
 #include "Address.h"
 // Forward declarations
 
@@ -105,8 +107,8 @@ public: // everything is public, because IDGAF
   void setUnrolled(unsigned int In) { Unrolled = In; }
 
   bool operator==(AbstractState In) {
-    for (int Index = 0; Index < 16; Index++) {
+    for (int Index; Index < 16; Index++) {
-      for (int Age = 0; Age < 4; Age++) {
+      for (int Age; Age < 4; Age++) {
         for (auto E1 : Sets[Index].Associativity[Age].Blocks) {
           // find E1 in In States Set and Age.
           if (std::find(In.Sets[Index].Associativity[Age].Blocks.begin(),
@@ -201,60 +203,46 @@ public: // everything is public, because IDGAF
       }
     }
     if (Verbose) {
-      std::cout << "Before:\n";
+      llvm::outs() << "Before:\n";
       this->dump();
     }
     // update this with PreAddr
     this->update(PreAddr);
     if (Verbose) {
-      std::cout << "Update Tag: " << PreAddr.Tag << "\n";
+      llvm::outs() << "Update Tag: " << PreAddr.Tag << "\n";
-      std::cout << "Update Set: " << PreAddr.Index << "\n";
+      llvm::outs() << "Update Set: " << PreAddr.Index << "\n";
-      std::cout << "After:\n";
+      llvm::outs() << "After:\n";
       this->dump();
     }
   }
 
-    void dumpSet(unsigned int Set) {
-    std::cout << Addr << " {\n";
-
-      std::cout << "Set[" << Set << "]: \n";
-      for (auto EntryPair : this->Sets[Set].Associativity) {
-        std::cout << "  Age[" << EntryPair.first << "]: ";
-        for (auto Block : EntryPair.second.Blocks) {
-          std::cout << Block << " ";
-        }
-        std::cout << "\n";
-      }
-    std::cout << "}\n";
-  }
-
   void dump() {
-    std::cout << Addr << " {\n";
+    llvm::outs() << Addr << " {\n";
-    std::cout << "Unrolled: " << Unrolled << "\n";
+    llvm::outs() << "Unrolled: " << Unrolled << "\n";
-    std::cout << "Computed: " << Computed << "\n";
+    llvm::outs() << "Computed: " << Computed << "\n";
-    std::cout << "Predecessors: ";
+    llvm::outs() << "Predecessors: ";
     for (auto PreNr : Predecessors) {
-      std::cout << PreNr << " ";
+      llvm::outs() << PreNr << " ";
     }
-    std::cout << "\n";
+    llvm::outs() << "\n";
 
-    std::cout << "Successors: ";
+    llvm::outs() << "Successors: ";
     for (auto SuccNr : Successors) {
-      std::cout << SuccNr << " ";
+      llvm::outs() << SuccNr << " ";
     }
-    std::cout << "\n";
+    llvm::outs() << "\n";
 
     for (auto SetPair : Sets) {
-      std::cout << "Set[" << SetPair.first << "]: \n";
+      llvm::outs() << "Set[" << SetPair.first << "]: \n";
       for (auto EntryPair : SetPair.second.Associativity) {
-        std::cout << "  Age[" << EntryPair.first << "]: ";
+        llvm::outs() << "  Age[" << EntryPair.first << "]: ";
         for (auto Block : EntryPair.second.Blocks) {
-          std::cout << Block << " ";
+          llvm::outs() << Block << " ";
         }
-        std::cout << "\n";
+        llvm::outs() << "\n";
       }
     }
-    std::cout << "}\n";
+    llvm::outs() << "}\n";
   }
 
 };     // namespace