Create FunctionCloningThreshold flag to limit the number of times functions can be cloned.

Functions are cloned for each function group they belong to. This can cause a function to be compiled N times for N function groups that all call this function.
When N is large, this will greatly increase the compile time and memory usage.

This flag limits the number of times a function can be cloned, such that if it's exceeded, we convert it to an indirectly called function.
It will only be compiled once, and runtime relocation is used to patch the function address to each function group which it belongs to.
The default value is 0, which means there is no limit.

Author: dlei6g

IGC/AdaptorCommon/ProcessFuncAttributes.cpp

@@ -887,22 +887,23 @@ bool InsertDummyKernelForSymbolTable::runOnModule(Module& M)
 
     bool needDummyKernel = false;
 
-    // Creates an empty dummy kernel.
-    // This kernel will only be used for creating the symbol table.
-    // All indirectly called functions will also be attached to this kernel's binary.
-    if (IGC_IS_FLAG_ENABLED(EnableFunctionPointer) &&
-        pCtx->type == ShaderType::OPENCL_SHADER)
+    // Check when we need to generate a dummy kernel. This is only useful for attaching
+    // the symbol table to its program output for indirect calls and global variable relocation.
+    if (IGC_IS_FLAG_ENABLED(EnableFunctionPointer) && pCtx->type == ShaderType::OPENCL_SHADER)
     {
-        if (pCtx->m_enableFunctionPointer)
-        {
+        if (pCtx->m_enableFunctionPointer) {
             // Symbols are needed for external functions and function pointers
             needDummyKernel = true;
         }
-        else if (!modMD->inlineProgramScopeOffsets.empty())
-        {
+        else if (!modMD->inlineProgramScopeOffsets.empty()) {
             // Create one also if global variables are present and require symbols
             needDummyKernel = true;
         }
+        else if (IGC_GET_FLAG_VALUE(FunctionCloningThreshold) > 0 && pCtx->enableFunctionCall()) {
+            // If this flag is enabled and there are any function calls, conservatively create a dummy kernel
+            // in case we need to transform normal calls into indirect calls to avoid cloning in GenCodeGenModule.cpp
+            needDummyKernel = true;
+        }
     }
 
     if (needDummyKernel)
@@ -925,7 +926,7 @@ bool InsertDummyKernelForSymbolTable::runOnModule(Module& M)
 
         // Promote SIMD size information from kernels, which has indirectly called
         // functions. All such functions will be connected to the default kernel in
-        // GenCodeGenModule.cpp (addIndirectFuncsToKernelGroup)
+        // GenCodeGenModule.cpp
         for (auto I = M.begin(), E = M.end(); I != E; ++I)
         {
             Function* F = &(*I);

IGC/Compiler/CISACodeGen/GenCodeGenModule.cpp

@@ -149,6 +149,25 @@ void GenXCodeGenModule::processFunction(Function& F)
     }
 
     IGC_ASSERT(CallerFGs.size() >= 1);
+
+    // Get the cloning threshold. If the number of function groups a function belongs to
+    // exceeds the threshold, instead of cloning the function N times, make it an indirect call
+    // and use relocation instead. The function will only be compiled once and runtime must relocate
+    // its address for each caller. This greatly saves on compile time when there are many function
+    // groups that all call the same function.
+    auto cloneTheshold = IGC_GET_FLAG_VALUE(FunctionCloningThreshold);
+    if (cloneTheshold > 0 && CallerFGs.size() > cloneTheshold)
+    {
+        auto pCtx = getAnalysis<CodeGenContextWrapper>().getCodeGenContext();
+        auto IFG = FGA->getIndirectCallGroup();
+        IGC_ASSERT(IFG);
+        F.addFnAttr("referenced-indirectly");
+        F.addFnAttr("visaStackCall");
+        pCtx->m_enableFunctionPointer = true;
+        FGA->addToFunctionGroup(&F, IFG, &F);
+        return;
+    }
+
     bool FirstPair = true;
     for (auto FGPair : CallerFGs)
     {
@@ -209,6 +228,25 @@ void GenXCodeGenModule::processSCC(std::vector<llvm::CallGraphNode*>* SCCNodes)
         }
     }
     IGC_ASSERT(CallerFGs.size() >= 1);
+
+    // Use the same cloning threshold for single function SCCs, but making every stack function
+    // in the SCC indirect calls to prevent cloning the entire SCC N times.
+    auto cloneTheshold = IGC_GET_FLAG_VALUE(FunctionCloningThreshold);
+    if (cloneTheshold > 0 && CallerFGs.size() > cloneTheshold)
+    {
+        auto pCtx = getAnalysis<CodeGenContextWrapper>().getCodeGenContext();
+        for (CallGraphNode* Node : (*SCCNodes))
+        {
+            Function* F = Node->getFunction();
+            auto IFG = FGA->getIndirectCallGroup();
+            IGC_ASSERT(IFG && F->hasFnAttribute("visaStackCall"));
+            F->addFnAttr("referenced-indirectly");
+            pCtx->m_enableFunctionPointer = true;
+            FGA->addToFunctionGroup(F, IFG, F);
+        }
+        return;
+    }
+
     bool FirstPair = true;
     for (auto FG : CallerFGs)
     {
@@ -602,7 +640,6 @@ void GenXFunctionGroupAnalysis::addIndirectFuncsToKernelGroup(llvm::Module* pMod
         Function* F = &(*I);
         if (F->isDeclaration() || isEntryFunc(pMdUtils, F)) continue;
 
-        // Add non-used function to default group
         if (F->hasFnAttribute("referenced-indirectly") || F->getNumUses() == 0)
         {
             IGC_ASSERT(getGroup(F) == nullptr);

IGC/Compiler/CISACodeGen/GenCodeGenModule.h

@@ -241,6 +241,10 @@ namespace IGC {
             return FG != nullptr && FG == IndirectCallGroup;
         }
 
+        FunctionGroup* getIndirectCallGroup() {
+            return IndirectCallGroup;
+        }
+
         /// \brief Check whether this is a group header.
         bool isGroupHead(llvm::Function* F) {
             return getGroupForHead(F) != nullptr;

IGC/common/igc_flags.def

@@ -360,6 +360,10 @@ DECLARE_IGC_REGKEY(bool, EnableLTODebug,                false, "Enable debug inf
 DECLARE_IGC_REGKEY(DWORD, FunctionControl,              0,     "Control function inlining/subroutine/stackcall. See value defs in igc_flags.hpp.", true)
 DECLARE_IGC_REGKEY(bool, EnableStackCallFuncCall,       false, "If enabled, the default function call mode will be set to stack call. Otherwise, subroutine call is used.", false)
 DECLARE_IGC_REGKEY(bool, ForceInlineStackCallWithImplArg, false, "If enabled, stack calls that uses implicit args will be force inlined.", true)
+DECLARE_IGC_REGKEY(DWORD, FunctionCloningThreshold,    0,
+    "Limits how many times functions can be cloned when called from multiple function groups." \
+    "If exceeding the cloning threshold, compile the function only once and use address relocation instead." \
+    "A value of '0' means no limit on times it can be cloned", true)
 DECLARE_IGC_REGKEY(DWORD, OCLInlineThreshold,           512,  "Setting OCL inline thershold", true)
 DECLARE_IGC_REGKEY(bool, DisableAddingAlwaysAttribute,  false, "Disable adding always attribute", true)
 DECLARE_IGC_REGKEY(bool, EnableForceGroupSize,          false, "Enable forcing thread Group Size ForceGroupSizeX and ForceGroupSizeY", false)