Interface verificarlo mca

CMakeLists.txt

@@ -369,6 +369,45 @@ install(PROGRAMS
   "${CMAKE_CURRENT_SOURCE_DIR}/scripts/raptor_plot_float_histogram.py"
   DESTINATION bin)
 
+if (DEFINED __RAPTOR_VERIFICARLOMCA_LIB_PATH)
+  foreach (LIB_PATH IN LISTS __RAPTOR_VERIFICARLOMCA_LIB_PATH)
+    if (NOT (LIB_PATH MATCHES "libinterflop_mca.so" OR LIB_PATH MATCHES "libinterflop_mca_int.so"))
+      message(SEND_ERROR "__RAPTOR_VERIFICARLOMCA_LIB_PATH ${LIB_PATH} does not include the expected library name")
+    elseif (NOT EXISTS "${LIB_PATH}")
+      message(SEND_ERROR "__RAPTOR_VERIFICARLOMCA_LIB_PATH ${LIB_PATH} does not exists")
+    else()
+      if (LIB_PATH MATCHES "libinterflop_mca.so")
+        if (DEFINED __RAPTOR_VERIFICARLOMCA_QUAD_LIB_PATH)
+          message(SEND_ERROR "Redefining __RAPTOR_VERIFICARLOMCA_QUAD_LIB_PATH ${LIB_PATH}, __RAPTOR_VERIFICARLOMCA_LIB_PATH ${__RAPTOR_VERIFICARLOMCA_LIB_PATH}")
+        endif()
+        set(__RAPTOR_VERIFICARLOMCA_QUAD_LIB_PATH ${LIB_PATH})
+      elseif (LIB_PATH MATCHES "libinterflop_mca_int.so")
+        if (DEFINED __RAPTOR_VERIFICARLOMCA_INT_LIB_PATH)
+          message(SEND_ERROR "Redefining __RAPTOR_VERIFICARLOMCA_INT_LIB_PATH ${LIB_PATH}, __RAPTOR_VERIFICARLOMCA_LIB_PATH ${__RAPTOR_VERIFICARLOMCA_LIB_PATH}")
+        endif()
+        set(__RAPTOR_VERIFICARLOMCA_INT_LIB_PATH ${LIB_PATH})
+      endif()
+    endif()
+  endforeach()
+  if (DEFINED __RAPTOR_VERIFICARLOMCA_QUAD_LIB_PATH) 
+    get_filename_component(__RAPTOR_VERIFICARLOMCA_QUAD_LIB_DIR "${__RAPTOR_VERIFICARLOMCA_QUAD_LIB_PATH}" DIRECTORY)
+    add_library(verificarlo SHARED IMPORTED)
+    set_target_properties(verificarlo PROPERTIES
+      IMPORTED_LOCATION "${__RAPTOR_VERIFICARLOMCA_QUAD_LIB_PATH}"
+      INTERFACE_INCLUDE_DIRECTORIES "${__RAPTOR_VERIFICARLOMCA_QUAD_LIB_DIR}/../include"
+    )
+    target_compile_definitions(verificarlo INTERFACE __RAPTOR_VERIFICARLOMCA_QUAD_MODE)
+  endif()
+  if (DEFINED __RAPTOR_VERIFICARLOMCA_INT_LIB_PATH)
+    get_filename_component(__RAPTOR_VERIFICARLOMCA_INT_LIB_DIR "${__RAPTOR_VERIFICARLOMCA_INT_LIB_PATH}" DIRECTORY)
+    add_library(verificarlo_int SHARED IMPORTED)
+    set_target_properties(verificarlo_int PROPERTIES
+      IMPORTED_LOCATION "${__RAPTOR_VERIFICARLOMCA_INT_LIB_PATH}"
+      INTERFACE_INCLUDE_DIRECTORIES "${__RAPTOR_VERIFICARLOMCA_QUAD_LIB_DIR}/../include"
+    )
+    target_compile_definitions(verificarlo_int INTERFACE __RAPTOR_VERIFICARLOMCA_INT_MODE)
+  endif()
+endif()
 add_subdirectory(runtime)
 add_subdirectory(test)
 add_subdirectory(wrappers)

pass/CMakeLists.txt

@@ -23,6 +23,10 @@ set(RAPTOR_SRC
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
+if (DEFINED __RAPTOR_VERIFICARLOMCA_LIB_PATH)
+    add_compile_definitions(__RAPTOR_HAS_VERIFICARLOMCA)
+endif()
+
 # on windows `PLUGIN_TOOL` doesn't link against LLVM.dll
 if ((WIN32 OR CYGWIN) AND LLVM_LINK_LLVM_DYLIB)
     add_llvm_library( LLVMRaptor-${LLVM_VERSION_MAJOR}

pass/Raptor.cpp

@@ -514,6 +514,11 @@ class RaptorBase {
   std::pair<FloatTruncation, unsigned>
   parseTruncation(CallInst *CI, TruncateMode Mode, unsigned ArgOffset) {
     unsigned ArgNum = CI->arg_size();
+    // Adjust ArgNum and ArgOffset for MCA which has an extra arg in the front
+    if (MCAType::isMCA(Mode)) {
+      ArgNum = ArgNum - 1;
+      ArgOffset = ArgOffset + 1;
+    }
     auto Cfrom = cast<ConstantInt>(CI->getArgOperand(ArgOffset));
     if (!Cfrom)
       EmitFailure("NotConstant", CI->getDebugLoc(), CI,
@@ -540,6 +545,12 @@ class RaptorBase {
                     "Mem mode truncation to IEEE not supported, switching to "
                     "equivalent MPFR.");
       }
+      if (MCAType::isMCA(Mode)) {
+        Constructor = FloatRepresentation::getMPFR;
+        EmitWarning("UnsupportedTruncation", *CI,
+                    "MCA mode truncation to IEEE not supported, switching to "
+                    "equivalent MPFR.");
+      }
       FloatRepresentation FRTo =
           Constructor((unsigned)Cto->getValue().getZExtValue());
       return {FloatTruncation(FRFrom, FRTo, Mode), 3};
@@ -564,7 +575,8 @@ class RaptorBase {
               4};
     }
 
-    EmitFailure("NotConstant", CI->getDebugLoc(), CI, "Unknown float type");
+    auto float_type = Cty->getValue().getZExtValue();
+    EmitFailure("NotConstant", CI->getDebugLoc(), CI, "Unknown float type", float_type);
     llvm_unreachable("Unknown float type");
   }
 
@@ -611,6 +623,10 @@ class RaptorBase {
     if (!F)
       return false;
     unsigned ArgNum = CI->arg_size();
+    // Adjust ArgNum for MCA which has an extra arg in the front
+    if (MCAType::isMCA(Mode)) {
+      ArgNum = ArgNum - 1;
+    }
     if (ArgNum != 4 && ArgNum != 5) {
       EmitFailure("TooManyArgs", CI->getDebugLoc(), CI,
                   "Had incorrect number of args to __raptor_truncate_func", *CI,
@@ -632,6 +648,43 @@ class RaptorBase {
     return true;
   }
 
+  bool HandleMCAFunc(CallInst *CI, TruncateMode Mode) {
+    IRBuilder<> Builder(CI);
+    Function *F = parseFunctionParameter(CI);
+    if (!F)
+      return false;
+    unsigned ArgNum = CI->arg_size();
+    if (ArgNum != 5 && ArgNum != 6) {
+      EmitFailure("TooManyArgs", CI->getDebugLoc(), CI,
+                  "Had incorrect number of args to __raptor_mca_func", *CI,
+                  " - expected 5 or 6");
+      return false;
+    }
+    auto Cmca = cast<ConstantInt>(CI->getArgOperand(1));
+    auto mcaTypeID = Cmca->getValue().getZExtValue();
+    if (mcaTypeID + 1 >= MCAType::NumMCAType) {
+      EmitFailure("WrongArgVal", CI->getDebugLoc(), CI,
+                  "Invalid input for MCA backend type.");
+      return false;
+    }
+    MCAType::MCAType mcaType = MCAType::get(mcaTypeID + 1);
+    auto mcaName = MCAType::getName(mcaTypeID + 1); 
+    if (mcaType == MCAType::NoMCAType) {
+      EmitFailure("Unsupported", CI->getDebugLoc(), CI,
+                  "Unsupported MCA backend type ", mcaTypeID, "(", mcaName,
+                  "), please build raptor with selected backend type.");
+      return false;
+    }
+    if (!isValidTruncMCAMode(TruncOpMode, mcaType)) {
+      EmitFailure("Unsupported", CI->getDebugLoc(), CI,
+                  "Unsupported truncate mode for the chosen MCA backend.");
+      return false;
+    }
+    // Add MCAType to TruncateMode to propagate it to the runtime library
+    TruncateMode truncMCAMode = MCAType::addToTruncateMode(Mode, mcaType);
+    return HandleTruncateFunc(CI, truncMCAMode);
+  }
+
   bool HandleTruncateValue(CallInst *CI, bool isTruncate) {
     IRBuilder<> Builder(CI);
     unsigned ArgSize = CI->arg_size();
@@ -834,6 +887,7 @@ class RaptorBase {
     SmallVector<CallInst *, 4> toTruncateFuncOp;
     SmallVector<CallInst *, 4> toTruncateValue;
     SmallVector<CallInst *, 4> toExpandValue;
+    SmallVector<CallInst *, 4> toMCAFuncOp;
   retry:;
     for (BasicBlock &BB : F) {
       for (Instruction &I : BB) {
@@ -1062,6 +1116,7 @@ class RaptorBase {
         bool truncateFuncMem = false;
         bool truncateValue = false;
         bool expandValue = false;
+        bool mcaFuncOp = false;
         if (false) {
         } else if (Fn->getName().contains("__raptor_log_flops")) {
           enableRaptor = true;
@@ -1078,6 +1133,9 @@ class RaptorBase {
         } else if (Fn->getName().contains("__raptor_expand_mem_value")) {
           enableRaptor = true;
           expandValue = true;
+        } else if (Fn->getName().contains("__raptor_mca_op_func")) {
+          enableRaptor = true;
+          mcaFuncOp = true;
         }
 
         if (enableRaptor) {
@@ -1129,6 +1187,8 @@ class RaptorBase {
             toTruncateValue.push_back(CI);
           else if (expandValue)
             toExpandValue.push_back(CI);
+          else if (mcaFuncOp)
+            toMCAFuncOp.push_back(CI);
 
           // TODO do we leave this?
           if (auto dc = dyn_cast<Function>(fn)) {
@@ -1153,6 +1213,8 @@ class RaptorBase {
       HandleTruncateValue(call, true);
     for (auto call : toExpandValue)
       HandleTruncateValue(call, false);
+    for (auto call : toMCAFuncOp)
+      HandleMCAFunc(call, TruncOpMode);
 
     return Changed;
   }

pass/RaptorLogic.cpp

@@ -439,7 +439,7 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
       }
     };
     if (TC.isToFPRT()) {
-      if (Mode == TruncOpMode) {
+      if (Mode == TruncOpMode || Mode == TruncOpMCAVerificarloMode) {
         if (TC.NeedTruncChange || TC.NeedNewScratch)
           AllocScratch();
         if (!TC.NeedNewScratch) {
@@ -470,6 +470,7 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
       break;
     case TruncOpMode:
     case TruncOpFullModuleMode:
+    case TruncOpMCAVerificarloMode:
       EmitWarning(
           "UnhandledTrunc", I,
           "Operation not handled - it will be executed in the original way.",
@@ -500,6 +501,7 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
       return floatMemTruncate(B, v, TC);
     case TruncOpMode:
     case TruncOpFullModuleMode:
+    case TruncOpMCAVerificarloMode:
       return floatValTruncate(B, v, TC);
     }
     llvm_unreachable("Unknown trunc mode");
@@ -511,6 +513,7 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
       return floatMemExpand(B, v, TC);
     case TruncOpMode:
     case TruncOpFullModuleMode:
+    case TruncOpMCAVerificarloMode:
       return floatValExpand(B, v, TC);
     }
     llvm_unreachable("Unknown trunc mode");
@@ -572,6 +575,7 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
     }
     case TruncOpMode:
     case TruncOpFullModuleMode:
+    case TruncOpMCAVerificarloMode:
       return;
     }
   }
@@ -615,6 +619,7 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
     }
     case TruncOpMode:
     case TruncOpFullModuleMode:
+    case TruncOpMCAVerificarloMode:
       return;
     }
   }
@@ -637,6 +642,7 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
     }
     case TruncOpMode:
     case TruncOpFullModuleMode:
+    case TruncOpMCAVerificarloMode:
       return;
     }
     llvm_unreachable("");
@@ -776,6 +782,7 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
     }
     case TruncOpMode:
     case TruncOpFullModuleMode:
+    case TruncOpMCAVerificarloMode:
       break;
     default:
       llvm_unreachable("Unknown trunc mode");
@@ -808,6 +815,7 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
     }
     case TruncOpMode:
     case TruncOpFullModuleMode:
+    case TruncOpMCAVerificarloMode:
       break;
     default:
       llvm_unreachable("Unknown trunc mode");
@@ -856,6 +864,7 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
         switch (Mode) {
         case TruncMemMode:
         case TruncOpMode:
+        case TruncOpMCAVerificarloMode:
           EmitWarning("FPNoFollow", CI,
                       "Will not follow FP through this indirect call.", CI);
           break;
@@ -873,6 +882,7 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
                       CI);
           break;
         case TruncOpMode:
+        case TruncOpMCAVerificarloMode:
           EmitWarning("FPNoFollow", CI,
                       "Will not truncate flops in this function call as the "
                       "definition is not available.",
@@ -922,13 +932,16 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
     CallBase *const newCall = cast<CallBase>(getNewFromOriginal(&CI));
     IRBuilder<> BuilderZ(newCall);
 
-    if (Mode != TruncOpMode && Mode != TruncMemMode)
+    if (Mode != TruncOpMode && Mode != TruncMemMode && 
+        Mode != TruncOpMCAVerificarloMode)
       return;
 
     RequestContext ctx(&CI, &BuilderZ);
     auto FTTs = getFunctionToTruncate(CI);
     auto NeedDirectCall = [&](auto FTT) {
-      return scratch && Mode == TruncOpMode && isa<CallInst>(&CI) &&
+      return scratch && (Mode == TruncOpMode || 
+                         Mode == TruncOpMCAVerificarloMode) && 
+             isa<CallInst>(&CI) &&
              !FTT.isCallbackFunc();
     };
     for (auto &FTT : FTTs) {
@@ -996,6 +1009,7 @@ class TruncateGenerator : public llvm::InstVisitor<TruncateGenerator>,
     }
     case TruncOpMode:
     case TruncOpFullModuleMode:
+    case TruncOpMCAVerificarloMode:
       break;
     default:
       llvm_unreachable("Unknown trunc mode");