fix: add option to enable/disable heapless in ocloc

Related-To: GSD-10681
Signed-off-by: Kamil Kopryk <kamil.kopryk@intel.com>

Author: KamilKoprykIntel

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;
 }
 

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;
 }

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;
 

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.
 

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;
 

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

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

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