hip-quant 2.2.4__tar.gz → 2.3.0__tar.gz

{hip_quant-2.2.4 → hip_quant-2.3.0}/MANIFEST.in

@@ -1,5 +1,6 @@
 include hip_quantize.dll
 include hip_quantize_rocm721.dll
+include hip_quantize_rocm101.dll
 include _C.cp312-win_amd64.pyd
 include hip_quant_types.h
 include hip_quant_util.h
@@ -12,6 +13,7 @@ recursive-include torch_ext *.cpp *.hip *.h
 exclude torch_ext/ple_directstorage.cpp
 exclude torch_ext/ple_directstorage.h
 exclude torch_ext/ple_directstorage_hip.hip
+exclude torch_ext/qad_ggml_tq1.hip
 recursive-include tests *.py
 recursive-include codebooks *.bin
 include torch_api.py

hip_quant-2.3.0/PKG-INFO

@@ -0,0 +1,369 @@
+Metadata-Version: 2.4
+Name: hip-quant
+Version: 2.3.0
+Summary: High-performance GPU tensor quantization and inference engine for AMD ROCm. Native AOT GEMV (K-Quants & I-Quants), State Space Model (SSM/DeltaNet) kernels, FP8 WMMA WaveAttention, and portable HIP C++ kernels for RDNA4, RDNA3, and CDNA.
+Author-email: Thenukegun10x <conormorris84@gmail.com>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           Copyright 2026 Thenukegun10x
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+Project-URL: Homepage, https://github.com/Thenukegun10x/HIP-Quant
+Project-URL: Documentation, https://github.com/Thenukegun10x/HIP-Quant/blob/main/README.md
+Project-URL: Source, https://github.com/Thenukegun10x/HIP-Quant
+Project-URL: Issues, https://github.com/Thenukegun10x/HIP-Quant/issues
+Keywords: quantization,gpu,hip,rocm,amd,fp8,wmma,attention,pytorch,ggml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: C++
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Provides-Extra: torch
+Requires-Dist: torch>=2.0; extra == "torch"
+Dynamic: license-file
+
+# hip-quant
+
+`hip-quant` is a Python library and native HIP kernel suite for AMD GPUs. It
+provides GGML-compatible quantization through a NumPy/ctypes API, plus a PyTorch
+extension for GPU-resident quantization, matrix operations, attention, and
+state-space kernels. It is a kernel and tensor library—not a complete chat or
+model-serving application.
+
+## What is included
+
+### Quantization and low-bit formats
+
+The NumPy API packs floating-point arrays into formats used by GGUF and related
+workflows, and can dequantize packed data to floating point. Supported format
+families include:
+
+- **Legacy formats:** `Q1_0`, `Q2_0`, `Q4_0`, `Q4_1`, `Q5_0`, `Q5_1`, `Q8_0`,
+  and `Q8_1`.
+- **K-quants:** `Q2_K` through `Q6_K`, plus `Q8_K`.
+- **I-quants:** `IQ1_S`, `IQ1_M`, `IQ2_XXS`, `IQ2_XS`, `IQ2_S`, `IQ3_XXS`,
+  `IQ3_S`, `IQ4_NL`, and `IQ4_XS`.
+- **Ternary formats:** `TQ1_0` and `TQ2_0`.
+- **Experimental codecs:** HQ2 and AQ2 variants in the GGML-facing API; the
+  separate `hq2` package also provides learned-codebook HQ2/HQ3/HQ8 tools.
+
+Importance-matrix weighting is supported for applicable quantizers. The API
+accepts a full matrix or a shared per-column vector where supported. Format
+availability and options differ between the NumPy and PyTorch APIs; see
+`GGML_TYPE` and the API modules for the precise interface.
+
+### PyTorch and native GPU kernels
+
+The optional PyTorch extension exposes lower-level operators for building
+GPU-resident inference and training paths, including:
+
+- **FP8 and microscaling:** E4M3/E5M2 quantize/dequantize, transpose and
+  block-scaled conversions, scaling metadata helpers, MXFP8 operations, and
+  FP8 linear/GEMM paths where supported.
+- **Quantized linear and decode:** selected GGUF-format GEMV kernels, embedding
+  lookup with on-the-fly dequantization, packed INT4 helpers, and FP8 weight or
+  activation paths.
+- **WaveAttention:** GFX12 FP8 WMMA prefill and decode, grouped-query attention,
+  optional sliding windows, long-context helpers, and packed INT4 KV data paths.
+  Native FP8, FP16, and BF16 training forward/backward paths are also exposed;
+  the FP16/BF16 paths are experimental. Use `precision="sdpa"` to select
+  PyTorch SDPA in the training wrapper.
+- **SSM / DeltaNet building blocks:** recurrent state updates, causal Conv1D,
+  gated RMSNorm, and related helpers for hybrid Transformer/SSM models.
+- **Runtime utilities:** HIP graph-capture helpers, GPU/device information,
+  safety checks on extension inputs, and the bundled `gpu-smi` monitor.
+
+These operators are intended to be composed into higher-level applications.
+For a model runner and CLI, see the separate `hip_inference` project.
+
+## Hardware and status
+
+The default PyTorch extension build targets `gfx90a`, `gfx942`, `gfx1100`–
+`gfx1103`, `gfx1200`, and `gfx1201`. GFX12 WMMA kernels require `gfx1200` or
+`gfx1201`; the RX 9070 XT (`gfx1201`) is the primary runtime-validation GPU.
+The RX 9070 is also `gfx1201`. A build target does not guarantee that every
+operator is available or validated on every GPU—support depends on the API,
+kernel, and architecture.
+
+The current `gfx1201` PyTorch target is AMD's Python 3.12 stack with
+`torch==2.14.0+rocm10.1.0`. The PyTorch extension is ABI-specific: it must be
+built for the same PyTorch/ROCm stack used at runtime. Do not load an extension
+from a different Torch or ROCm build. Native training kernels and experimental
+codecs may change; validate accuracy, performance, and memory use for your
+model and workload.
+
+## Install and build
+
+Create a Python 3.12 environment and install AMD's `gfx1201` PyTorch wheel:
+
+```powershell
+py -3.12 -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install --upgrade pip
+python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ `
+  "torch[device-gfx1201]==2.14.0+rocm10.1.0"
+```
+
+From an x64 Visual Studio developer shell with the matching ROCm toolchain,
+install the package and build its PyTorch extension:
+
+```powershell
+python -m pip install -e ".[torch]"
+python setup_torch.py build_ext --inplace
+```
+
+The NumPy/ctypes API uses the packaged HIP DLL and can be used independently of
+the PyTorch extension. On Windows the ROCm 10.1 DLL is preferred, with older
+DLLs retained as fallbacks. A compatible ROCm runtime is still required for the
+native HIP quantization path. See `build.ps1` for the DLL build entry point.
+
+## Quick start
+
+Quantize a NumPy matrix to Q4_K:
+
+```python
+import numpy as np
+from hip_quant import GGML_TYPE, quantize
+
+weights = np.random.randn(4096, 4096).astype(np.float32)
+packed = quantize(weights, GGML_TYPE["Q4_K"])
+```
+
+Convert a device tensor to FP8 E4M3 bytes with the PyTorch extension:
+
+```python
+import torch
+from hip_quant import torch_api
+
+x = torch.randn(1024, 1024, device="cuda", dtype=torch.bfloat16)
+x_fp8 = torch_api.quantize_e4m3(x)
+x_roundtrip = torch_api.dequantize_e4m3(x_fp8)
+```
+
+The command-line utility can list formats, inspect device/build availability,
+and quantize `.npy` arrays:
+
+```powershell
+hip-quant --list-types
+hip-quant --info
+hip-quant weights.npy weights-q4k.bin --type Q4_K
+```
+
+## Tests
+
+Run the CPU-safe pipeline tests with:
+
+```powershell
+python -m pytest tests/test_pipeline.py -q
+```
+
+GPU tests require a working extension built for the active PyTorch/ROCm ABI.
+GFX12 WMMA tests are opt-in with `HIP_QUANT_ENABLE_GFX12_WMMA=1`.
+
+## Documentation
+
+- [NumPy package API](__init__.py)
+- [PyTorch API](torch_api.py)
+- [GGML type IDs and CLI](__main__.py)
+- [GitHub Releases](https://github.com/Thenukegun10x/HIP-Quant/releases) for
+  version-specific changes
+- [Apache-2.0 license](LICENSE)

hip_quant-2.3.0/README.md

@@ -0,0 +1,146 @@
+# hip-quant
+
+`hip-quant` is a Python library and native HIP kernel suite for AMD GPUs. It
+provides GGML-compatible quantization through a NumPy/ctypes API, plus a PyTorch
+extension for GPU-resident quantization, matrix operations, attention, and
+state-space kernels. It is a kernel and tensor library—not a complete chat or
+model-serving application.
+
+## What is included
+
+### Quantization and low-bit formats
+
+The NumPy API packs floating-point arrays into formats used by GGUF and related
+workflows, and can dequantize packed data to floating point. Supported format
+families include:
+
+- **Legacy formats:** `Q1_0`, `Q2_0`, `Q4_0`, `Q4_1`, `Q5_0`, `Q5_1`, `Q8_0`,
+  and `Q8_1`.
+- **K-quants:** `Q2_K` through `Q6_K`, plus `Q8_K`.
+- **I-quants:** `IQ1_S`, `IQ1_M`, `IQ2_XXS`, `IQ2_XS`, `IQ2_S`, `IQ3_XXS`,
+  `IQ3_S`, `IQ4_NL`, and `IQ4_XS`.
+- **Ternary formats:** `TQ1_0` and `TQ2_0`.
+- **Experimental codecs:** HQ2 and AQ2 variants in the GGML-facing API; the
+  separate `hq2` package also provides learned-codebook HQ2/HQ3/HQ8 tools.
+
+Importance-matrix weighting is supported for applicable quantizers. The API
+accepts a full matrix or a shared per-column vector where supported. Format
+availability and options differ between the NumPy and PyTorch APIs; see
+`GGML_TYPE` and the API modules for the precise interface.
+
+### PyTorch and native GPU kernels
+
+The optional PyTorch extension exposes lower-level operators for building
+GPU-resident inference and training paths, including:
+
+- **FP8 and microscaling:** E4M3/E5M2 quantize/dequantize, transpose and
+  block-scaled conversions, scaling metadata helpers, MXFP8 operations, and
+  FP8 linear/GEMM paths where supported.
+- **Quantized linear and decode:** selected GGUF-format GEMV kernels, embedding
+  lookup with on-the-fly dequantization, packed INT4 helpers, and FP8 weight or
+  activation paths.
+- **WaveAttention:** GFX12 FP8 WMMA prefill and decode, grouped-query attention,
+  optional sliding windows, long-context helpers, and packed INT4 KV data paths.
+  Native FP8, FP16, and BF16 training forward/backward paths are also exposed;
+  the FP16/BF16 paths are experimental. Use `precision="sdpa"` to select
+  PyTorch SDPA in the training wrapper.
+- **SSM / DeltaNet building blocks:** recurrent state updates, causal Conv1D,
+  gated RMSNorm, and related helpers for hybrid Transformer/SSM models.
+- **Runtime utilities:** HIP graph-capture helpers, GPU/device information,
+  safety checks on extension inputs, and the bundled `gpu-smi` monitor.
+
+These operators are intended to be composed into higher-level applications.
+For a model runner and CLI, see the separate `hip_inference` project.
+
+## Hardware and status
+
+The default PyTorch extension build targets `gfx90a`, `gfx942`, `gfx1100`–
+`gfx1103`, `gfx1200`, and `gfx1201`. GFX12 WMMA kernels require `gfx1200` or
+`gfx1201`; the RX 9070 XT (`gfx1201`) is the primary runtime-validation GPU.
+The RX 9070 is also `gfx1201`. A build target does not guarantee that every
+operator is available or validated on every GPU—support depends on the API,
+kernel, and architecture.
+
+The current `gfx1201` PyTorch target is AMD's Python 3.12 stack with
+`torch==2.14.0+rocm10.1.0`. The PyTorch extension is ABI-specific: it must be
+built for the same PyTorch/ROCm stack used at runtime. Do not load an extension
+from a different Torch or ROCm build. Native training kernels and experimental
+codecs may change; validate accuracy, performance, and memory use for your
+model and workload.
+
+## Install and build
+
+Create a Python 3.12 environment and install AMD's `gfx1201` PyTorch wheel:
+
+```powershell
+py -3.12 -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install --upgrade pip
+python -m pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ `
+  "torch[device-gfx1201]==2.14.0+rocm10.1.0"
+```
+
+From an x64 Visual Studio developer shell with the matching ROCm toolchain,
+install the package and build its PyTorch extension:
+
+```powershell
+python -m pip install -e ".[torch]"
+python setup_torch.py build_ext --inplace
+```
+
+The NumPy/ctypes API uses the packaged HIP DLL and can be used independently of
+the PyTorch extension. On Windows the ROCm 10.1 DLL is preferred, with older
+DLLs retained as fallbacks. A compatible ROCm runtime is still required for the
+native HIP quantization path. See `build.ps1` for the DLL build entry point.
+
+## Quick start
+
+Quantize a NumPy matrix to Q4_K:
+
+```python
+import numpy as np
+from hip_quant import GGML_TYPE, quantize
+
+weights = np.random.randn(4096, 4096).astype(np.float32)
+packed = quantize(weights, GGML_TYPE["Q4_K"])
+```
+
+Convert a device tensor to FP8 E4M3 bytes with the PyTorch extension:
+
+```python
+import torch
+from hip_quant import torch_api
+
+x = torch.randn(1024, 1024, device="cuda", dtype=torch.bfloat16)
+x_fp8 = torch_api.quantize_e4m3(x)
+x_roundtrip = torch_api.dequantize_e4m3(x_fp8)
+```
+
+The command-line utility can list formats, inspect device/build availability,
+and quantize `.npy` arrays:
+
+```powershell
+hip-quant --list-types
+hip-quant --info
+hip-quant weights.npy weights-q4k.bin --type Q4_K
+```
+
+## Tests
+
+Run the CPU-safe pipeline tests with:
+
+```powershell
+python -m pytest tests/test_pipeline.py -q
+```
+
+GPU tests require a working extension built for the active PyTorch/ROCm ABI.
+GFX12 WMMA tests are opt-in with `HIP_QUANT_ENABLE_GFX12_WMMA=1`.
+
+## Documentation
+
+- [NumPy package API](__init__.py)
+- [PyTorch API](torch_api.py)
+- [GGML type IDs and CLI](__main__.py)
+- [GitHub Releases](https://github.com/Thenukegun10x/HIP-Quant/releases) for
+  version-specific changes
+- [Apache-2.0 license](LICENSE)

hip_quant-2.3.0/_C.cp312-win_amd64.pyd

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: hip_quant-2.3.0/_C.cp312-win_amd64.pyd
+size: 48294400 bytes
+sha256: 3010b91ebb80c2cff3ecd407dbca5ccc44ce14036fd5b151ac7b36a3f4bef700

{hip_quant-2.2.4 → hip_quant-2.3.0}/__init__.py

@@ -1,10 +1,11 @@
 import ctypes
+import glob
 import numpy as np
 import os
 import sys
 import warnings
 
-__version__ = "2.2.4"
+__version__ = "2.3.0"
 
 
 _TORCH_EXPORTS = {
@@ -329,7 +330,12 @@ def _add_runtime_dll_dirs():
         if path in seen or not os.path.isdir(path):
             continue
         seen.add(path)
-        _DLL_DIR_HANDLES.append(os.add_dll_directory(path))
+        try:
+            _DLL_DIR_HANDLES.append(os.add_dll_directory(path))
+        except OSError:
+            # These directories are optional search paths. A stale global
+            # HIP_PATH must not prevent loading from the active Torch runtime.
+            continue
 
 def _shared_library_candidates():
     env_dll = os.environ.get("HIP_QUANT_DLL") or os.environ.get("HIP_QUANT_DLL_PATH")
@@ -343,9 +349,15 @@ def _shared_library_candidates():
             )
         yield env_dll
 
-    win_names = ["hip_quantize_rocm721.dll", "hip_quantize.dll"]
-    if os.environ.get("HIP_QUANT_DLL_VARIANT", "").lower() in ("7.1", "71", "rocm71", "legacy"):
-        win_names.reverse()
+    variant = os.environ.get("HIP_QUANT_DLL_VARIANT", "").lower()
+    if variant in ("7.1", "71", "rocm71", "legacy"):
+        # Preserve access to the unversioned legacy DLL when explicitly asked.
+        win_names = ["hip_quantize.dll", "hip_quantize_rocm721.dll", "hip_quantize_rocm101.dll"]
+    elif variant in ("7.2.1", "721", "rocm721"):
+        win_names = ["hip_quantize_rocm721.dll", "hip_quantize_rocm101.dll", "hip_quantize.dll"]
+    else:
+        # The 10.1 build is the release default; older DLLs remain fallbacks.
+        win_names = ["hip_quantize_rocm101.dll", "hip_quantize_rocm721.dll", "hip_quantize.dll"]
     names = win_names if os.name == "nt" else ["libhip_quantize.so"]
     roots = [
         _PKG_DIR,

{hip_quant-2.2.4 → hip_quant-2.3.0}/build.ps1

@@ -1,7 +1,8 @@
 param(
-    [string]$Output = "hip_quantize.dll",
+    [string]$Output = "hip_quantize_rocm101.dll",
     [switch]$CDNA,
     [switch]$All,
+    [switch]$DevBuild,
     [string]$Arch = "",
     [string]$RocmBin = $env:HIP_QUANT_ROCM_BIN,
     [switch]$SkipSmi = $false,
@@ -10,6 +11,11 @@ param(
 
 $ErrorActionPreference = "Continue"
 
+if ((-not [string]::IsNullOrWhiteSpace($Arch) -or $CDNA) -and -not $DevBuild) {
+    Write-Error "-Arch and -CDNA narrow the DLL target set and are development-only. Pass -DevBuild to opt in; release builds must use the default multi-arch target list."
+    exit 2
+}
+
 function Get-ShortPath([string]$Path) {
     if (!(Test-Path -LiteralPath $Path)) {
         return $Path
@@ -30,6 +36,15 @@ function Get-ShortPath([string]$Path) {
 if ([string]::IsNullOrWhiteSpace($RocmBin)) {
     if ($env:HIP_QUANT_ROCM_BIN -and (Test-Path $env:HIP_QUANT_ROCM_BIN)) {
         $RocmBin = $env:HIP_QUANT_ROCM_BIN
+    } elseif ($env:HIP_QUANT_ROCM_HOME) {
+        $RocmBin = Join-Path $env:HIP_QUANT_ROCM_HOME "bin"
+        if (!(Test-Path (Join-Path $RocmBin "hipcc.exe"))) {
+            Write-Error "HIP_QUANT_ROCM_HOME has no bin\hipcc.exe: $env:HIP_QUANT_ROCM_HOME"
+            exit 1
+        }
+    } elseif (Test-Path "C:\TheRock\build-10.1\bin\hipcc.exe") {
+        # Default compiler for the Torch 2.14 / ROCm 10.1 release environment.
+        $RocmBin = "C:\TheRock\build-10.1\bin"
     } elseif ($env:ROCM_PATH -and (Test-Path (Join-Path $env:ROCM_PATH "bin"))) {
         $RocmBin = Join-Path $env:ROCM_PATH "bin"
     } elseif ($env:HIP_PATH -and (Test-Path (Join-Path $env:HIP_PATH "bin"))) {
@@ -59,6 +74,7 @@ $src_dir_arg = Get-ShortPath $src_dir
 $out_file = Join-Path $src_dir $Output
 $out_file_arg = Join-Path $src_dir_arg $Output
 
+Write-Host "HIP compiler: $hipcc"
 Write-Host "Compiling HIP quantization DLL..."
 
 # Determine target architectures

{hip_quant-2.2.4 → hip_quant-2.3.0}/device_info.py

@@ -52,7 +52,11 @@ def _add_runtime_dll_dirs():
         if path in seen or not os.path.isdir(path):
             continue
         seen.add(path)
-        _DLL_DIR_HANDLES.append(os.add_dll_directory(path))
+        try:
+            _DLL_DIR_HANDLES.append(os.add_dll_directory(path))
+        except OSError:
+            # Device probing is best-effort; ignore stale optional HIP paths.
+            continue
 
 _add_dll_directories = _add_runtime_dll_dirs
 
@@ -157,9 +161,13 @@ def _resolve_dll(dll_path=None):
             "HIP_QUANT_DLL / HIP_QUANT_DLL_PATH must be an absolute path, got "
             f"{env_dll!r}"
         )
-    win_names = ["hip_quantize_rocm721.dll", "hip_quantize.dll"]
-    if os.environ.get("HIP_QUANT_DLL_VARIANT", "").lower() in ("7.1", "71", "rocm71", "legacy"):
-        win_names.reverse()
+    variant = os.environ.get("HIP_QUANT_DLL_VARIANT", "").lower()
+    if variant in ("7.1", "71", "rocm71", "legacy"):
+        win_names = ["hip_quantize.dll", "hip_quantize_rocm721.dll", "hip_quantize_rocm101.dll"]
+    elif variant in ("7.2.1", "721", "rocm721"):
+        win_names = ["hip_quantize_rocm721.dll", "hip_quantize_rocm101.dll", "hip_quantize.dll"]
+    else:
+        win_names = ["hip_quantize_rocm101.dll", "hip_quantize_rocm721.dll", "hip_quantize.dll"]
     names = win_names if os.name == "nt" else ["libhip_quantize.so"]
     candidates = [env_dll] if env_dll else []
     for root in (_PKG_DIR, os.path.join(_PKG_DIR, ".."), os.path.join(_PKG_DIR, "..", "..", "src")):