Add HELION_FORCE_AUTOTUNE=1 and update readme (#132)

Author: jansel

README.md

@@ -222,17 +222,30 @@ Changing these options results in often significantly different
 output Triton code, allowing the autotuner to explore a wide range of
 implementations from a single Helion kernel.
 
-## Logs and Debugging
+## Settings for Development and Debugging
 
-`HELION_LOGS` is the recommended way to emit debugging information from Helion.
+When developing kernels with Helion, you might prefer skipping autotuning for faster iteration. To
+do this, set the environment variable `HELION_USE_DEFAULT_CONFIG=1` or use the decorator argument
+`@helion.kernel(use_default_config=True)`. **Warning:** The default configuration is slow and not intended for
+production or performance testing.
+
+To view the generated Triton code, set the environment variable `HELION_PRINT_OUTPUT_CODE=1` or include
+`print_output_code=True` in the `@helion.kernel` decorator. This prints the Triton code to `stderr`, which is
+helpful for debugging and understanding Helion's compilation process.  One can also use
+`foo_kernel.bind(args).to_triton_code(config)` to get the Triton code as a string.
+
+To force autotuning, bypassing provided configurations, set `HELION_FORCE_AUTOTUNE=1` or invoke `foo_kernel.autotune(args,
+force=True)`.
+
+Additional settings are available in
+[settings.py](https://github.com/pytorch-labs/helion/blob/main/helion/runtime/settings.py).  If both an environment
+variable and a kernel decorator argument are set, the kernel decorator argument takes precedence, and the environment
+variable will be ignored.
+
+Enable logging by setting the environment variable `HELION_LOGS=all` for INFO-level logs, or `HELION_LOGS=+all`
+for DEBUG-level logs. Alternatively, you can specify logging for specific modules using a comma-separated list
+(e.g., `HELION_LOGS=+helion.runtime.kernel`).
 
-An example to this is
-```
-HELION_LOGS=helion.runtime.kernel python examples/add.py
-```
-will emit the generated Triton kernels at INFO level logging.
-Adding `+` in front of path like `+helion.runtime.kernel` will emit logs at
-DEBUG level.
 
 ## Requirements
 

helion/_logging/_internal.py

@@ -31,7 +31,7 @@ class LogRegistery:
     log_levels: dict[str, int] = field(default_factory=dict)
 
 
-_LOG_REGISTERY = LogRegistery()
+_LOG_REGISTERY = LogRegistery({"all": ["helion"]})
 
 
 def parse_log_value(value: str) -> None:

helion/runtime/kernel.py

@@ -194,22 +194,28 @@ def normalize_args(self, *args: object, **kwargs: object) -> tuple[object, ...]:
     def autotune(
         self,
         args: Sequence[object],
+        *,
+        force: bool = False,
         **options: object,
     ) -> Config:
         """
-        Perform autotuning to find the optimal configuration for
-        the kernel.  This uses the default setting, you can call
-        helion.autotune.* directly for more customization.
+        Perform autotuning to find the optimal configuration for the kernel.  This uses the
+        default setting, you can call helion.autotune.* directly for more customization.
+
+        If config= or configs= is provided to helion.kernel(), the search will be restricted to
+        the provided configs.  Use force=True to ignore the provided configs.
 
         Mutates (the bound version of) self so that `__call__` will run the best config found.
 
         :param args: Example arguments used for benchmarking during autotuning.
         :type args: list[object]
+        :param force: If True, force full autotuning even if a config is provided.
+        :type force: bool
         :return: The best configuration found during autotuning.
         :rtype: Config
         """
         args = self.normalize_args(*args)
-        return self.bind(args).autotune(args, **options)
+        return self.bind(args).autotune(args, force=force, **options)
 
     def __call__(self, *args: object, **kwargs: object) -> object:
         """
@@ -278,8 +284,6 @@ def __init__(self, kernel: Kernel, args: tuple[object, ...]) -> None:
                 self.host_function: HostFunction = HostFunction(
                     self.kernel.fn, self.fake_args, constexpr_args
                 )
-        if len(kernel.configs) == 1:
-            self.set_config(kernel.configs[0])
 
     @property
     def settings(self) -> Settings:
@@ -370,24 +374,34 @@ def _debug_str(self) -> str:
     def autotune(
         self,
         args: Sequence[object],
+        *,
+        force: bool = False,
         **kwargs: object,
     ) -> Config:
         """
-        Perform autotuning to find the optimal configuration for
-        the kernel.  This uses the default setting, you can call
-        helion.autotune.* directly for more customization.
+        Perform autotuning to find the optimal configuration for the kernel.  This uses the
+        default setting, you can call helion.autotune.* directly for more customization.
+
+        If config= or configs= is provided to helion.kernel(), the search will be restricted to
+        the provided configs.  Use force=True to ignore the provided configs.
 
         Mutates self so that `__call__` will run the best config found.
 
         :param args: Example arguments used for benchmarking during autotuning.
         :type args: list[object]
+        :param force: If True, force full autotuning even if a config is provided.
+        :type force: bool
         :return: The best configuration found during autotuning.
         :rtype: Config
         """
-        if self.kernel.configs:
-            from ..autotuner import FiniteSearch
+        force = force or self.settings.force_autotune
+        if not force and self.kernel.configs:
+            if len(self.kernel.configs) == 1:
+                (config,) = self.kernel.configs
+            else:
+                from ..autotuner import FiniteSearch
 
-            config = FiniteSearch(self, args, self.configs).autotune()
+                config = FiniteSearch(self, args, self.configs).autotune()
         else:
             from ..autotuner import DifferentialEvolutionSearch
 

helion/runtime/settings.py

@@ -61,6 +61,7 @@ class _Settings:
     )
     autotune_precompile: bool = sys.platform != "win32"
     print_output_code: bool = os.environ.get("HELION_PRINT_OUTPUT_CODE", "0") == "1"
+    force_autotune: bool = os.environ.get("HELION_FORCE_AUTOTUNE", "0") == "1"
 
 
 class Settings(_Settings):
@@ -79,6 +80,7 @@ class Settings(_Settings):
         "autotune_compile_timeout": "Timeout for Triton compilation in seconds used for autotuning. Default is 60 seconds.",
         "autotune_precompile": "If True, precompile the kernel before autotuning. Requires fork-safe environment.",
         "print_output_code": "If True, print the output code of the kernel to stderr.",
+        "force_autotune": "If True, force autotuning even if a config is provided.",
     }
     assert __slots__.keys() == {field.name for field in dataclasses.fields(_Settings)}