fix: add option to enable/disable heapless in ocloc

KamilKoprykIntel · Compute-Runtime-Automation · commit 7c3468794e57 · 2025-02-24T17:06:26.000+01:00
Related-To: GSD-10681
Signed-off-by: Kamil Kopryk &lt;kamil.kopryk@intel.com&gt;
diff --git a/level_zero/core/source/module/module_imp.cpp b/level_zero/core/source/module/module_imp.cpp
@@ -155,7 +155,7 @@ std::string ModuleTranslationUnit::generateCompilerOptions(const char *buildOpti
     bool isDebuggerActive = neoDevice.getDebugger() != nullptr;
     NEO::CompilerOptions::concatenateAppend(internalOptions, compilerProductHelper.getCachingPolicyOptions(isDebuggerActive));
 
-    NEO::CompilerOptions::applyExtraInternalOptions(internalOptions, compilerProductHelper);
+    NEO::CompilerOptions::applyExtraInternalOptions(internalOptions, compilerProductHelper, NEO::CompilerOptions::HeaplessMode::defaultMode);
     return internalOptions;
 }
 
diff --git a/opencl/source/program/program.cpp b/opencl/source/program/program.cpp
@@ -109,7 +109,7 @@ std::string Program::getInternalOptions() const {
     CompilerOptions::concatenateAppend(internalOptions, CompilerOptions::preserveVec3Type);
     auto isDebuggerActive = pClDevice->getDevice().getDebugger() != nullptr;
     CompilerOptions::concatenateAppend(internalOptions, compilerProductHelper.getCachingPolicyOptions(isDebuggerActive));
-    CompilerOptions::applyExtraInternalOptions(internalOptions, compilerProductHelper);
+    CompilerOptions::applyExtraInternalOptions(internalOptions, compilerProductHelper, NEO::CompilerOptions::HeaplessMode::defaultMode);
 
     return internalOptions;
 }
diff --git a/opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp b/opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2024 Intel Corporation
+ * Copyright (C) 2018-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -4606,6 +4606,44 @@ TEST(OclocCompile, GivenStatefulAddressModeWhenInvalidArgsPAssedThenErrorIsRetur
     EXPECT_STRNE(output.c_str(), "");
 }
 
+TEST(OclocCompile, GivenInvalidHeaplessModeOptionWhenOclocArgsAreParsedThenErrorIsReturned) {
+
+    MockOfflineCompiler ocloc;
+    std::vector<std::string> args = {
+        "ocloc",
+        "-file",
+        clFiles + "copybuffer.cl",
+        "-device",
+        gEnvironment->devicePrefix.c_str(),
+        "-heapless_mode",
+        "invalid"};
+    testing::internal::CaptureStdout();
+    int retVal = ocloc.parseCommandLine(args.size(), args);
+    EXPECT_EQ(OCLOC_INVALID_COMMAND_LINE, retVal);
+    std::string output = testing::internal::GetCapturedStdout();
+    EXPECT_STRNE(output.c_str(), "");
+}
+
+TEST(OclocCompile, GivenValidHeaplessModeOptionWhenOclocArgsAreParsedThenSuccessIsReturned) {
+
+    for (auto heaplessMode : {"enable", "disable", "default"}) {
+        MockOfflineCompiler ocloc;
+        std::vector<std::string> args = {
+            "ocloc",
+            "-file",
+            clFiles + "copybuffer.cl",
+            "-device",
+            gEnvironment->devicePrefix.c_str(),
+            "-heapless_mode",
+            heaplessMode};
+        testing::internal::CaptureStdout();
+        int retVal = ocloc.parseCommandLine(args.size(), args);
+        EXPECT_EQ(OCLOC_SUCCESS, retVal);
+        std::string output = testing::internal::GetCapturedStdout();
+        EXPECT_STREQ(output.c_str(), "");
+    }
+}
+
 TEST(OclocCompile, GivenStatefulAddressModeSetToBindlessWhenBuildThenBindlessModeInternalOptionsAreAdded) {
     MockOfflineCompiler ocloc;
 
diff --git a/shared/offline_compiler/source/offline_compiler.cpp b/shared/offline_compiler/source/offline_compiler.cpp
@@ -1075,6 +1075,19 @@ int OfflineCompiler::parseCommandLine(size_t numArgs, const std::vector<std::str
         } else if ("-stateful_address_mode" == currArg) {
             addressingMode = argv[argIndex + 1];
             argIndex++;
+        } else if (("-heapless_mode" == currArg) && hasMoreArgs) {
+            if (argv[argIndex + 1] == "enable") {
+                heaplessMode = CompilerOptions::HeaplessMode::enabled;
+            } else if (argv[argIndex + 1] == "disable") {
+                heaplessMode = CompilerOptions::HeaplessMode::disabled;
+            } else if (argv[argIndex + 1] == "default") {
+                heaplessMode = CompilerOptions::HeaplessMode::defaultMode;
+            } else {
+                argHelper->printf("Error: Invalid heapless mode.\n");
+                retVal = OCLOC_INVALID_COMMAND_LINE;
+                break;
+            }
+            argIndex++;
         } else if (("-config" == currArg) && hasMoreArgs) {
             parseHwInfoConfigString(argv[argIndex + 1], hwInfoConfig);
             if (!hwInfoConfig) {
@@ -1189,7 +1202,7 @@ void OfflineCompiler::appendExtraInternalOptions(std::string &internalOptions) {
     }
 
     CompilerOptions::concatenateAppend(internalOptions, compilerProductHelper->getCachingPolicyOptions(false));
-    CompilerOptions::applyExtraInternalOptions(internalOptions, *compilerProductHelper);
+    CompilerOptions::applyExtraInternalOptions(internalOptions, *compilerProductHelper, this->heaplessMode);
 }
 
 void OfflineCompiler::parseDebugSettings() {
@@ -1412,6 +1425,11 @@ Usage: ocloc [compile] -file <filename> -device <device_type> [-output <filename
                                             -stateful_address_mode default - default mode
                                             not defined: default mode.
 
+  -heapless_mode                            Enforce heapless mode for the binary. The possible values are:
+                                            -heapless_mode enable  - enforce generating in heapless mode
+                                            -heapless_mode disable - enforce generating in heapful mode
+                                            -heapless_mode default - default mode for current platform
+
   -config                                   Target hardware info config for a single device,
                                             e.g 1x4x8.
 
diff --git a/shared/offline_compiler/source/offline_compiler.h b/shared/offline_compiler/source/offline_compiler.h
@@ -8,6 +8,7 @@
 #pragma once
 
 #include "shared/offline_compiler/source/ocloc_api.h"
+#include "shared/source/compiler_interface/compiler_options.h"
 #include "shared/source/helpers/hw_info.h"
 #include "shared/source/helpers/non_copyable_or_moveable.h"
 #include "shared/source/utilities/arrayref.h"
@@ -199,6 +200,7 @@ All supported acronyms: %s.
     std::string internalOptionsReadFromFile = "";
     std::string formatToEnforce = "";
     std::string addressingMode = "default";
+    CompilerOptions::HeaplessMode heaplessMode = CompilerOptions::HeaplessMode::defaultMode;
     std::string irHash, genHash, dbgHash, elfHash;
     std::string cacheDir;
 
diff --git a/shared/source/compiler_interface/compiler_options.h b/shared/source/compiler_interface/compiler_options.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2024 Intel Corporation
+ * Copyright (C) 2019-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -184,5 +184,12 @@ std::string wrapInQuotes(const std::string &stringToWrap);
 
 void applyAdditionalInternalOptions(std::string &internalOptions);
 void applyAdditionalApiOptions(std::string &apiOptions);
+
+enum class HeaplessMode {
+    enabled,
+    disabled,
+    defaultMode,
+};
+
 } // namespace CompilerOptions
 } // namespace NEO
diff --git a/shared/source/compiler_interface/compiler_options_extra.cpp b/shared/source/compiler_interface/compiler_options_extra.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -9,7 +9,7 @@
 
 namespace NEO {
 namespace CompilerOptions {
-void applyExtraInternalOptions(std::string &internalOptions, const CompilerProductHelper &compilerProductHelper) {
+void applyExtraInternalOptions(std::string &internalOptions, const CompilerProductHelper &compilerProductHelper, HeaplessMode heaplessMode) {
 }
 
 } // namespace CompilerOptions
diff --git a/shared/source/compiler_interface/compiler_options_extra.h b/shared/source/compiler_interface/compiler_options_extra.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -13,8 +13,9 @@ namespace NEO {
 class CompilerProductHelper;
 
 namespace CompilerOptions {
+enum class HeaplessMode;
 
-void applyExtraInternalOptions(std::string &internalOptions, const CompilerProductHelper &compilerProductHelper);
+void applyExtraInternalOptions(std::string &internalOptions, const CompilerProductHelper &compilerProductHelper, CompilerOptions::HeaplessMode heaplessMode);
 
 } // namespace CompilerOptions
 } // namespace NEO

Original file line number	Diff line number	Diff line change
`@@ -155,7 +155,7 @@ std::string ModuleTranslationUnit::generateCompilerOptions(const char *buildOpti`
`155`	`155`	`bool isDebuggerActive = neoDevice.getDebugger() != nullptr;`
`156`	`156`	`NEO::CompilerOptions::concatenateAppend(internalOptions, compilerProductHelper.getCachingPolicyOptions(isDebuggerActive));`
`157`	`157`
`158`		`- NEO::CompilerOptions::applyExtraInternalOptions(internalOptions, compilerProductHelper);`
	`158`	`+ NEO::CompilerOptions::applyExtraInternalOptions(internalOptions, compilerProductHelper, NEO::CompilerOptions::HeaplessMode::defaultMode);`
`159`	`159`	`return internalOptions;`
`160`	`160`	`}`
`161`	`161`
Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,7 @@ std::string Program::getInternalOptions() const {`
`109`	`109`	`CompilerOptions::concatenateAppend(internalOptions, CompilerOptions::preserveVec3Type);`
`110`	`110`	`auto isDebuggerActive = pClDevice->getDevice().getDebugger() != nullptr;`
`111`	`111`	`CompilerOptions::concatenateAppend(internalOptions, compilerProductHelper.getCachingPolicyOptions(isDebuggerActive));`
`112`		`- CompilerOptions::applyExtraInternalOptions(internalOptions, compilerProductHelper);`
	`112`	`+ CompilerOptions::applyExtraInternalOptions(internalOptions, compilerProductHelper, NEO::CompilerOptions::HeaplessMode::defaultMode);`
`113`	`113`
`114`	`114`	`return internalOptions;`
`115`	`115`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2023 Intel Corporation`
	`2`	`+ * Copyright (C) 2023-2025 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -9,7 +9,7 @@`
`9`	`9`
`10`	`10`	`namespace NEO {`
`11`	`11`	`namespace CompilerOptions {`
`12`		`-void applyExtraInternalOptions(std::string &internalOptions, const CompilerProductHelper &compilerProductHelper) {`
	`12`	`+void applyExtraInternalOptions(std::string &internalOptions, const CompilerProductHelper &compilerProductHelper, HeaplessMode heaplessMode) {`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`} // namespace CompilerOptions`