Compile kernels per platform type (core/lp)

 compiled kernels are in (binary dir)/(family name with type) folder

Change-Id: Ied1827ab7f4ecc5c1de4c3535b1c0ba3b5cd86ee

Author: JablonskiMateusz

common_macros.cmake

@@ -93,3 +93,9 @@ macro(apply_macro_for_each_test_config type)
     macro_for_each_test_config()
   endforeach()
 endmacro()
+
+macro(get_family_name_with_type gen_type platform_type)
+  string(REPLACE "GEN" "Gen" gen_type_capitalized ${gen_type})
+  string(TOLOWER ${platform_type} platform_type_lower)
+  set(family_name_with_type ${gen_type_capitalized}${platform_type_lower})
+endmacro()

offline_compiler/offline_compiler.cpp

@@ -248,6 +248,9 @@ int OfflineCompiler::getHardwareInfo(const char *pDeviceName) {
         if (stringsAreEqual(pDeviceName, hardwarePrefix[productId])) {
             if (hardwareInfoTable[productId]) {
                 hwInfo = hardwareInfoTable[productId];
+                familyNameWithType.clear();
+                familyNameWithType.append(familyName[hwInfo->pPlatform->eRenderCoreFamily]);
+                familyNameWithType.append(getPlatformType(*hwInfo));
                 retVal = CL_SUCCESS;
                 break;
             }
@@ -530,15 +533,15 @@ void OfflineCompiler::parseDebugSettings() {
 ////////////////////////////////////////////////////////////////////////////////
 // ParseBinAsCharArray
 ////////////////////////////////////////////////////////////////////////////////
-std::string OfflineCompiler::parseBinAsCharArray(uint8_t *binary, size_t size, std::string &deviceName, std::string &fileName) {
+std::string OfflineCompiler::parseBinAsCharArray(uint8_t *binary, size_t size, std::string &fileName) {
     std::string builtinName = convertToPascalCase(fileName);
     std::ostringstream out;
 
     // Convert binary to cpp
     out << "#include <cstddef>\n";
     out << "#include <cstdint>\n\n";
-    out << "size_t " << builtinName << "BinarySize_" << deviceName << " = " << size << ";\n";
-    out << "uint32_t " << builtinName << "Binary_" << deviceName << "[" << (size + 3) / 4 << "] = {"
+    out << "size_t " << builtinName << "BinarySize_" << familyNameWithType << " = " << size << ";\n";
+    out << "uint32_t " << builtinName << "Binary_" << familyNameWithType << "[" << (size + 3) / 4 << "] = {"
         << std::endl
         << "    ";
 
@@ -572,11 +575,11 @@ std::string OfflineCompiler::parseBinAsCharArray(uint8_t *binary, size_t size, s
     out << "static RegisterEmbeddedResource register" << builtinName << "Bin(" << std::endl;
     out << "    createBuiltinResourceName(" << std::endl;
     out << "        EBuiltInOps::" << builtinName << "," << std::endl;
-    out << "        BuiltinCode::getExtension(BuiltinCode::ECodeType::Binary), \"" << deviceName << "\", 0)" << std::endl;
+    out << "        BuiltinCode::getExtension(BuiltinCode::ECodeType::Binary), \"" << familyNameWithType << "\", 0)" << std::endl;
     out << "        .c_str()," << std::endl;
     out << "    (const char *)" << builtinName << "Binary"
-        << "_" << deviceName << "," << std::endl;
-    out << "    " << builtinName << "BinarySize_" << deviceName << ");" << std::endl;
+        << "_" << familyNameWithType << "," << std::endl;
+    out << "    " << builtinName << "BinarySize_" << familyNameWithType << ");" << std::endl;
     out << "}" << std::endl;
 
     return out.str();
@@ -733,9 +736,9 @@ void OfflineCompiler::writeOutAllFiles() {
     std::string fileBase;
     std::string fileTrunk = getFileNameTrunk(inputFile);
     if (outputFile.empty()) {
-        fileBase = fileTrunk + "_" + deviceName;
+        fileBase = fileTrunk + "_" + familyNameWithType;
     } else {
-        fileBase = outputFile + "_" + deviceName;
+        fileBase = outputFile + "_" + familyNameWithType;
     }
 
     if (outputDirectory != "") {
@@ -789,7 +792,7 @@ void OfflineCompiler::writeOutAllFiles() {
         if (useCppFile) {
             std::string cppOutputFile = (outputDirectory == "") ? "" : outputDirectory + "/";
             cppOutputFile.append(fileBase + ".cpp");
-            std::string cpp = parseBinAsCharArray((uint8_t *)genBinary, genBinarySize, deviceName, fileTrunk);
+            std::string cpp = parseBinAsCharArray((uint8_t *)genBinary, genBinarySize, fileTrunk);
             writeDataToFile(cppOutputFile.c_str(), cpp.c_str(), cpp.size());
         }
     }

offline_compiler/offline_compiler.h

@@ -56,7 +56,7 @@ class OfflineCompiler {
         return quiet;
     }
 
-    std::string parseBinAsCharArray(uint8_t *binary, size_t size, std::string &deviceName, std::string &fileName);
+    std::string parseBinAsCharArray(uint8_t *binary, size_t size, std::string &fileName);
     static bool readOptionsFromFile(std::string &optionsOut, const std::string &file);
 
   protected:
@@ -76,6 +76,7 @@ class OfflineCompiler {
     const HardwareInfo *hwInfo = nullptr;
 
     std::string deviceName;
+    std::string familyNameWithType;
     std::string inputFile;
     std::string outputFile;
     std::string outputDirectory;

platforms.cmake

@@ -158,6 +158,14 @@ macro(SET_FLAGS_FOR GEN_TYPE)
     endforeach()
   endif()
 endmacro()
+macro(ADD_PLATFORM_FOR_GEN LIST_TYPE GEN_TYPE PLATFORM_NAME PLATFORM_TYPE)
+  ADD_ITEM_FOR_GEN("PLATFORMS" ${LIST_TYPE} ${GEN_TYPE} ${PLATFORM_NAME})
+  set(${GEN_TYPE}_HAS_${PLATFORM_TYPE} TRUE)
+  set(${PLATFORM_NAME}_IS_${PLATFORM_TYPE} TRUE)
+  if(NOT DEFAULT_${LIST_TYPE}_${GEN_TYPE}_${PLATFORM_TYPE}_PLATFORM)
+    string(TOLOWER ${PLATFORM_NAME} DEFAULT_${LIST_TYPE}_${GEN_TYPE}_${PLATFORM_TYPE}_PLATFORM)
+  endif()
+endmacro()
 
 SET_FLAGS_FOR("GEN8" "BDW")
 SET_FLAGS_FOR("GEN9" "SKL" "KBL" "BXT" "GLK" "CFL")
@@ -174,8 +182,8 @@ INIT_LIST("CONFIGURATIONS" "MT_TESTS")
 
 # Add supported and tested platforms
 if(SUPPORT_GEN8)
-  ADD_ITEM_FOR_GEN("PLATFORMS" "SUPPORTED" "GEN8" "BDW")
-  ADD_ITEM_FOR_GEN("PLATFORMS" "SUPPORTED_2_0" "GEN8" "BDW")
+  ADD_PLATFORM_FOR_GEN("SUPPORTED" "GEN8" "BDW" "CORE")
+  ADD_PLATFORM_FOR_GEN("SUPPORTED_2_0" "GEN8" "BDW" "CORE")
   if(TESTS_GEN8)
     ADD_ITEM_FOR_GEN("FAMILY_NAME" "TESTED" "GEN8" "BDWFamily")
     ADD_ITEM_FOR_GEN("PLATFORMS" "TESTED" "GEN8" "BDW")
@@ -191,8 +199,8 @@ if(SUPPORT_GEN9)
     ADD_ITEM_FOR_GEN("FAMILY_NAME" "TESTED" "GEN9" "SKLFamily")
   endif()
   if(SUPPORT_SKL)
-    ADD_ITEM_FOR_GEN("PLATFORMS" "SUPPORTED" "GEN9" "SKL")
-    ADD_ITEM_FOR_GEN("PLATFORMS" "SUPPORTED_2_0" "GEN9" "SKL")
+    ADD_PLATFORM_FOR_GEN("SUPPORTED" "GEN9" "SKL" "CORE")
+    ADD_PLATFORM_FOR_GEN("SUPPORTED_2_0" "GEN9" "SKL" "CORE")
     if(TESTS_SKL)
       ADD_ITEM_FOR_GEN("PLATFORMS" "TESTED" "GEN9" "SKL")
       ADD_ITEM_FOR_GEN("PLATFORMS" "TESTED_APPVERIFIER" "GEN9" "SKL")
@@ -203,24 +211,24 @@ if(SUPPORT_GEN9)
   endif()
 
   if(SUPPORT_KBL)
-    ADD_ITEM_FOR_GEN("PLATFORMS" "SUPPORTED" "GEN9" "KBL")
-    ADD_ITEM_FOR_GEN("PLATFORMS" "SUPPORTED_2_0" "GEN9" "KBL")
+    ADD_PLATFORM_FOR_GEN("SUPPORTED" "GEN9" "KBL" "CORE")
+    ADD_PLATFORM_FOR_GEN("SUPPORTED_2_0" "GEN9" "KBL" "CORE")
     if(TESTS_KBL)
       ADD_ITEM_FOR_GEN("PLATFORMS" "TESTED" "GEN9" "KBL")
       ADD_ITEM_FOR_GEN("CONFIGURATIONS" "UNIT_TESTS" "GEN9" "kbl/1/3/6")
     endif()
   endif()
 
   if(SUPPORT_GLK)
-    ADD_ITEM_FOR_GEN("PLATFORMS" "SUPPORTED" "GEN9" "GLK")
+    ADD_PLATFORM_FOR_GEN("SUPPORTED" "GEN9" "GLK" "LP")
     if(TESTS_GLK)
       ADD_ITEM_FOR_GEN("PLATFORMS" "TESTED" "GEN9" "GLK")
       ADD_ITEM_FOR_GEN("CONFIGURATIONS" "UNIT_TESTS" "GEN9" "glk/1/3/6")
     endif()
   endif()
 
   if(SUPPORT_CFL)
-    ADD_ITEM_FOR_GEN("PLATFORMS" "SUPPORTED" "GEN9" "CFL")
+    ADD_PLATFORM_FOR_GEN("SUPPORTED" "GEN9" "CFL" "CORE")
     ADD_ITEM_FOR_GEN("PLATFORMS" "SUPPORTED_2_0" "GEN9" "CFL")
     if(TESTS_CFL)
       ADD_ITEM_FOR_GEN("PLATFORMS" "TESTED" "GEN9" "CFL")
@@ -229,7 +237,7 @@ if(SUPPORT_GEN9)
   endif()
 
   if(SUPPORT_BXT)
-    ADD_ITEM_FOR_GEN("PLATFORMS" "SUPPORTED" "GEN9" "BXT")
+    ADD_PLATFORM_FOR_GEN("SUPPORTED" "GEN9" "BXT" "LP")
     if(TESTS_BXT)
       ADD_ITEM_FOR_GEN("PLATFORMS" "TESTED" "GEN9" "BXT")
       ADD_ITEM_FOR_GEN("CONFIGURATIONS" "AUB_TESTS" "GEN9" "bxt/1/3/6")

runtime/built_ins/built_ins_storage.cpp

@@ -200,11 +200,11 @@ std::unique_ptr<Program> BuiltinsLib::createProgramFromCode(const BuiltinCode &b
 BuiltinResourceT BuiltinsLib::getBuiltinResource(EBuiltInOps builtin, BuiltinCode::ECodeType requestedCodeType, Device &device) {
     BuiltinResourceT bc;
     std::string resourceNameGeneric = createBuiltinResourceName(builtin, BuiltinCode::getExtension(requestedCodeType));
-    std::string resourceNameForPlatform = createBuiltinResourceName(builtin, BuiltinCode::getExtension(requestedCodeType), device.getProductAbbrev());
-    std::string resourceNameForPlatformAndStepping = createBuiltinResourceName(builtin, BuiltinCode::getExtension(requestedCodeType), device.getProductAbbrev(),
-                                                                               device.getHardwareInfo().pPlatform->usRevId);
+    std::string resourceNameForPlatformType = createBuiltinResourceName(builtin, BuiltinCode::getExtension(requestedCodeType), device.getFamilyNameWithType());
+    std::string resourceNameForPlatformTypeAndStepping = createBuiltinResourceName(builtin, BuiltinCode::getExtension(requestedCodeType), device.getFamilyNameWithType(),
+                                                                                   device.getHardwareInfo().pPlatform->usRevId);
 
-    for (auto &rn : {resourceNameForPlatformAndStepping, resourceNameForPlatform, resourceNameGeneric}) { // first look for dedicated version, only fallback to generic one
+    for (auto &rn : {resourceNameForPlatformTypeAndStepping, resourceNameForPlatformType, resourceNameGeneric}) { // first look for dedicated version, only fallback to generic one
         for (auto &s : allStorages) {
             bc = s.get()->load(rn);
             if (bc.size() != 0) {

runtime/built_ins/builtins_binary.cmake

@@ -42,14 +42,13 @@ if(COMPILE_BUILT_INS)
   add_subdirectory(kernels)
 endif()
 
-macro(macro_for_each_platform)
-  foreach(GENERATED_BUILTIN ${GENERATED_BUILTINS})
-    list(APPEND GENERATED_BUILTINS_CPPS ${BUILTINS_INCLUDE_DIR}/${RUNTIME_GENERATED_${GENERATED_BUILTIN}_${GEN_TYPE_LOWER}_${PLATFORM_IT}})
-  endforeach()
-endmacro()
-
 macro(macro_for_each_gen)
-  apply_macro_for_each_platform()
+  foreach(PLATFORM_TYPE "CORE" "LP")
+    get_family_name_with_type(${GEN_TYPE} ${PLATFORM_TYPE})
+    foreach(GENERATED_BUILTIN ${GENERATED_BUILTINS})
+      list(APPEND GENERATED_BUILTINS_CPPS ${BUILTINS_INCLUDE_DIR}/${RUNTIME_GENERATED_${GENERATED_BUILTIN}_${family_name_with_type}})
+    endforeach()
+  endforeach()
   source_group("generated files\\${GEN_TYPE_LOWER}" FILES ${GENERATED_BUILTINS_CPPS})
 endmacro()
 

runtime/built_ins/kernels/CMakeLists.txt

@@ -39,16 +39,17 @@ set(BUILTINS_INCLUDE_DIR ${TargetDir} PARENT_SCOPE)
 set(BUILTIN_CPP "")
 
 # Define function for compiling built-ins (with cloc)
-function(compile_builtin gen_name builtin)
-  set(OUTPUTDIR "${BUILTINS_OUTDIR_WITH_ARCH}/${gen_name}")
-
+function(compile_builtin gen_type platform_type builtin)
+  string(TOLOWER ${gen_type} gen_type_lower)
+  get_family_name_with_type(${gen_type} ${platform_type})
+  set(OUTPUTDIR "${BUILTINS_OUTDIR_WITH_ARCH}/${gen_type_lower}")
   # get filename
   get_filename_component(FILENAME ${builtin} NAME)
 
   # get name of the file w/o extension
   get_filename_component(BASENAME ${builtin} NAME_WE)
 
-  set(OUTPUTPATH_BASE "${OUTPUTDIR}/${BASENAME}_${gen_name}")
+  set(OUTPUTPATH_BASE "${OUTPUTDIR}/${BASENAME}_${family_name_with_type}")
   set(OUTPUT_FILES
     ${OUTPUTPATH_BASE}.bc
     ${OUTPUTPATH_BASE}.bin
@@ -59,48 +60,38 @@ function(compile_builtin gen_name builtin)
   # function returns builtin cpp filename
   unset(BUILTIN_CPP)
   # set variable outside function
-  set(BUILTIN_CPP built_ins/${NEO_ARCH}/${gen_name}/${BASENAME}_${gen_name}.cpp PARENT_SCOPE)
-
-  if(MSVC)
-    add_custom_command(
-      OUTPUT ${OUTPUT_FILES}
-      COMMAND cloc -q -file ${FILENAME} -device ${gen_name} ${BUILTIN_OPTIONS} -${NEO_BITS} -out_dir ${OUTPUTDIR} -cpp_file -options "-cl-kernel-arg-info ${BUILTIN_DEBUG_OPTION}"
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-      DEPENDS ${builtin} cloc copy_compiler_files
-    )
+  set(BUILTIN_CPP built_ins/${NEO_ARCH}/${gen_type_lower}/${BASENAME}_${family_name_with_type}.cpp PARENT_SCOPE)
+  if(WIN32)
+    set(cloc_cmd_prefix cloc)
   else()
-    add_custom_command(
-      OUTPUT ${OUTPUT_FILES}
-      COMMAND LD_LIBRARY_PATH=$<TARGET_FILE_DIR:cloc> $<TARGET_FILE:cloc> -q -file ${FILENAME} -device ${gen_name} ${BUILTIN_OPTIONS} -${NEO_BITS} -out_dir ${OUTPUTDIR} -cpp_file -options "-cl-kernel-arg-info ${BUILTIN_DEBUG_OPTION}"
-      WORKING_DIRECTORY  ${CMAKE_CURRENT_SOURCE_DIR}
-      DEPENDS ${builtin} cloc copy_compiler_files
-    )
+    set(cloc_cmd_prefix LD_LIBRARY_PATH=$<TARGET_FILE_DIR:cloc> $<TARGET_FILE:cloc>)
   endif()
+  add_custom_command(
+    OUTPUT ${OUTPUT_FILES}
+    COMMAND ${cloc_cmd_prefix} -q -file ${FILENAME} -device ${DEFAULT_SUPPORTED_${gen_type}_${platform_type}_PLATFORM} ${BUILTIN_OPTIONS} -${NEO_BITS} -out_dir ${OUTPUTDIR}  -cpp_file -options "-cl-kernel-arg-info ${BUILTIN_DEBUG_OPTION}"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    DEPENDS ${builtin} cloc copy_compiler_files
+  )
 endfunction()
 
-macro(compile_builtins GEN_TYPE PLATFORM_IT)
-  string(TOLOWER ${PLATFORM_IT} PLATFORM_LOWER)
-  string(CONCAT GEN "_" ${GEN_TYPE} "_" ${PLATFORM_IT})
-
-  set (BUILTINS_COMMANDS)
-  foreach(GENERATED_BUILTIN ${GENERATED_BUILTINS})
-    compile_builtin(${PLATFORM_LOWER} ${GENERATED_BUILTIN}.igdrcl_built_in)
-    list(APPEND BUILTINS_COMMANDS ${TargetDir}/${BUILTIN_CPP})
-    set (RUNTIME_GENERATED_${GENERATED_BUILTIN}${GEN} ${BUILTIN_CPP} PARENT_SCOPE)
-  endforeach()
-
-  set(target_name builtins_${PLATFORM_LOWER})
-  add_custom_target(${target_name} DEPENDS ${BUILTINS_COMMANDS})
-  add_dependencies(builtins ${target_name})
-  set_target_properties(${target_name} PROPERTIES FOLDER "built_ins/${PLATFORM_LOWER}")
-endmacro()
-
-macro(macro_for_each_platform)
-  compile_builtins(${GEN_TYPE_LOWER} ${PLATFORM_IT})
-endmacro()
-
 macro(macro_for_each_gen)
-  apply_macro_for_each_platform()
+  foreach(PLATFORM_TYPE "CORE" "LP")
+    if(${GEN_TYPE}_HAS_${PLATFORM_TYPE})
+      get_family_name_with_type(${GEN_TYPE} ${PLATFORM_TYPE})
+      string(TOLOWER ${PLATFORM_TYPE} PLATFORM_TYPE_LOWER)
+      unset(BUILTINS_COMMANDS)
+      foreach(GENERATED_BUILTIN ${GENERATED_BUILTINS})
+        compile_builtin(${GEN_TYPE} ${PLATFORM_TYPE} ${GENERATED_BUILTIN}.igdrcl_built_in)
+        list(APPEND BUILTINS_COMMANDS ${TargetDir}/${BUILTIN_CPP})
+        set(RUNTIME_GENERATED_${GENERATED_BUILTIN}_${family_name_with_type} ${BUILTIN_CPP} PARENT_SCOPE)
+      endforeach()
+
+      set(target_name builtins_${family_name_with_type})
+      add_custom_target(${target_name} DEPENDS ${BUILTINS_COMMANDS})
+      add_dependencies(builtins ${target_name})
+      set_target_properties(${target_name} PROPERTIES FOLDER "built_ins/${family_name_with_type}")
+    endif()
+  endforeach()
 endmacro()
 
 apply_macro_for_each_gen("SUPPORTED")

runtime/device/device.cpp

@@ -213,6 +213,12 @@ const char *Device::getProductAbbrev() const {
     return hardwarePrefix[hwInfo.pPlatform->eProductFamily];
 }
 
+const std::string Device::getFamilyNameWithType() const {
+    std::string platformName = familyName[hwInfo.pPlatform->eRenderCoreFamily];
+    platformName.append(getPlatformType(hwInfo));
+    return platformName;
+}
+
 double Device::getProfilingTimerResolution() {
     return osTime->getDynamicDeviceTimerResolution(hwInfo);
 }

runtime/device/device.h

@@ -97,6 +97,7 @@ class Device : public BaseObject<_cl_device_id> {
     volatile uint32_t *getTagAddress() const;
 
     const char *getProductAbbrev() const;
+    const std::string getFamilyNameWithType() const;
 
     // This helper template is meant to simplify getDeviceInfo
     template <cl_device_info Param>

runtime/gen8/hw_info_bdw.cpp

@@ -73,7 +73,8 @@ const RuntimeCapabilityTable BDW::capabilityTable{
     {true, 50000, true, 5000, true, 200000}, // KmdNotifyProperties
     false,                                   // ftr64KBpages
     EngineType::ENGINE_RCS,                  // defaultEngineType
-    MemoryConstants::pageSize                //requiredPreemptionSurfaceSize
+    MemoryConstants::pageSize,               //requiredPreemptionSurfaceSize
+    true                                     // isBigCore
 };
 
 const HardwareInfo BDW_1x2x6::hwInfo = {