Update HRX binaries to FLM 1.0.5

hrx-integration/fetch-hrx-release.sh

@@ -80,15 +80,18 @@ actual_sha="$(sha256sum "$tarball" | awk '{print $1}')"
 # Public package ships as .tar.zst (fall back to gzip for legacy assets).
 # Decompress zstd via the standalone binary piped into tar, so extraction does
 # not depend on tar being built with its zstd plugin, and fail with a clear
-# message when the zstd package is not installed.
+# message when the zstd package is not installed. Do not preserve archive mtimes:
+# some HRX archives can carry future-dated entries, and CMake records imported
+# package configs as regeneration inputs. Future config mtimes make Ninja rerun
+# CMake until it aborts with "build.ninja still dirty after 100 tries".
 case "$HRX_RELEASE_ASSET" in
   *.tar.zst)
     command -v zstd >/dev/null 2>&1 ||
       die "zstd is required to extract $HRX_RELEASE_ASSET but was not found on PATH (install the 'zstd' package)"
-    zstd -dc "$tarball" | tar -C "$out_dir" -xf -
+    zstd -dc "$tarball" | tar -m -C "$out_dir" -xf -
     ;;
-  *.tar.gz|*.tgz) tar -C "$out_dir" -xzf "$tarball" ;;
-  *) tar -C "$out_dir" -xf "$tarball" ;;
+  *.tar.gz|*.tgz) tar -m -C "$out_dir" -xzf "$tarball" ;;
+  *) tar -m -C "$out_dir" -xf "$tarball" ;;
 esac
 
 # Locate the HRX CMake package config; its dir feeds find_package(hrx CONFIG).

hrx-integration/hrx-release.env

@@ -3,10 +3,10 @@
 
 # Pinned HRX (amdxdna) release consumed by the HRX runtime path.
 HRX_RELEASE_REPO="jtuyls/hrx"
-HRX_RELEASE_TAG="flm-hrx-amdxdna-v2026.07.30"
+HRX_RELEASE_TAG="flm-hrx-amdxdna-v2026.09.15"
 # For Linux.
-HRX_RELEASE_ASSET="hrx-amdxdna-2026.07.30-amdxdna-hal-native-rel-eb0b39f-linux-x86_64.tar.zst"
-HRX_RELEASE_SHA256="661ed94051cc6ad04f53739b2df7a791aecb658bc435bd5a6ff3c46716696345"
+HRX_RELEASE_ASSET="hrx-amdxdna-2026.09.15-amdxdna-hal-native-rel-c023c3e-linux-x86_64.tar.zst"
+HRX_RELEASE_SHA256="0a3437af76f6e2b5dcf0df52f26505c9f318d583328fd141c7f377170d14fe5b"
 # For Windows.
-HRX_RELEASE_ASSET_WINDOWS="hrx-amdxdna-2026.07.30-amdxdna-hal-native-rel-eb0b39f-windows-x86_64.zip"
-HRX_RELEASE_SHA256_WINDOWS="b3af74c9b393ce49ef71a3cbec2cbe92be6d40601858b41009d2bda57eadeb43"
+HRX_RELEASE_ASSET_WINDOWS="hrx-amdxdna-2026.09.15-amdxdna-hal-native-rel-c023c3e-windows-x86_64.zip"
+HRX_RELEASE_SHA256_WINDOWS="be7d3bc882b61234776be35aa98ee6cd0d1822e8281f64885472eed888170105"

src/CMakeLists.txt

@@ -61,6 +61,10 @@ endif()
 # and HRX-built .so/.dll/.lib never collide (see src/lib/xrt and src/lib/hrx).
 set(FLM_ENGINE_LIB_DIR "${CMAKE_SOURCE_DIR}/lib/${FLM_RUNTIME_NAME}")
 
+# The flash engine libs (qwen3vl_flash, gemma4e_flash) are always shipped in
+# src/lib/${FLM_RUNTIME_NAME} for every backend, so their model families are
+# always compiled in -- no probe/gate/macro needed.
+
 # ———————————————————————————————————————————————
 # NPU runtime discovery.
 #   HRX: consumed from its public CMake package via find_package(hrx).
@@ -403,22 +407,29 @@ if(MSVC)
     target_link_libraries(flm PUBLIC ${STATIC_LIBS})
 endif()
 
-# Link your custom libraries (these may still be DLLs if no static versions available)
-target_link_libraries(flm PUBLIC
+set(FLM_ENGINE_LINK_LIBS
     q4_npu_eXpress
     llama_npu
     qwen2_npu
     qwen2vl_npu
     qwen3_npu
     qwen3vl_npu
-    qwen3vl_flash
+)
+
+list(APPEND FLM_ENGINE_LINK_LIBS qwen3vl_flash)
+
+list(APPEND FLM_ENGINE_LINK_LIBS
     qwen3_5vl_npu
     qwen3_5_omni_npu
     qwen3_6_moe_npu
     gemma_npu
     gemma_text_npu
     gemma4e_npu
-    gemma4e_flash
+)
+
+list(APPEND FLM_ENGINE_LINK_LIBS gemma4e_flash)
+
+list(APPEND FLM_ENGINE_LINK_LIBS
     gemma4_12b_npu
     gpt_oss_npu
     whisper_npu
@@ -427,6 +438,11 @@ target_link_libraries(flm PUBLIC
     phi4_npu
     nanbeige_npu
     hunyuan_npu
+)
+
+# Link your custom libraries (these may still be DLLs if no static versions available)
+target_link_libraries(flm PUBLIC
+    ${FLM_ENGINE_LINK_LIBS}
     # flm's own code calls nothing in the four shared-runtime libs below -- the
     # engine .so above do -- so the linker's default --as-needed drops them from
     # DT_NEEDED entirely. The engines then have to find MHA/Dequant/... in some

src/common/AutoModel/modeling_gemma4e.cpp

@@ -1412,4 +1412,4 @@ StreamResult Gemma4e::parse_stream_content_impl(const std::string content, bool
 
     result.type = current_mode_;
     return result;
-}
+}

src/common/AutoModel/modeling_hunyuan.cpp

@@ -11,9 +11,12 @@
 /************              hunyuan-dense family            **************/
 Hunyuan::Hunyuan(flm_rt::device* npu_device_inst) : AutoModel(npu_device_inst, "Hunyuan") {
     this->single_turn = true;
-    // the translator emits one short line per turn and the caller already has it
-    // from the stream / return value, so the raw dump would only double the log
-    this->log_raw_output = false;
+    // The translator streams one short line per turn, so echoing the
+    // "Model RAW Output:" dump only doubles the interactive log; keep it off by
+    // default. Diagnostics (qualification, numerical-match) anchor per-turn
+    // parsing on that marker, so FLM_LOG_RAW_OUTPUT=1 forces it back on for them
+    // without changing the interactive default.
+    this->log_raw_output = env_forces_raw_output();
     // every turn either rewinds to the pinned prefix or clears, so the kv state
     // the trailing eos forward exists to preserve is discarded either way
     this->forward_on_eos = false;

src/common/AutoModel/modeling_qwen3vl.cpp

@@ -17,10 +17,6 @@ void Qwen3VL::create_engine() {
     this->lm_engine = std::make_unique<qwen3vl_npu>(*this->lm_config, this->npu.get(), this->MAX_L);
 }
 
-void Qwen3VL_Flash::create_engine() {
-    this->lm_engine = std::make_unique<qwen3vl_flash>(*this->lm_config, this->npu.get(), this->MAX_L);
-}
-
 void Qwen3VL::load_model(std::string model_path, json model_info, int default_context_length, bool enable_preemption) {
     this->_shared_load_model(model_path, model_info, default_context_length, enable_preemption);
 
@@ -430,6 +426,10 @@ StreamResult Qwen3VL::parse_stream_content(const std::string content) {
 
 /************              Qwen3VL_Flash            **************/
 
+void Qwen3VL_Flash::create_engine() {
+    this->lm_engine = std::make_unique<qwen3vl_flash>(*this->lm_config, this->npu.get(), this->MAX_L);
+}
+
 int Qwen3VL_Flash::_pin_system_prefix(const std::string& system_text) {
     // Full clear — drop any previous pin before building the new one.
     this->lm_engine->clear_context();

src/include/AutoModel/automodel.hpp

@@ -16,9 +16,12 @@
 #include <string>
 #include <type_traits>
 #include <any>
+#include <cstdlib>
+#include <cstring>
 #include "typedef.hpp"
 #include "causal_lm.hpp"
 #include "lm_config.hpp"
+
 #include "models/llama/llama_npu.hpp"
 #include "models/qwen2/qwen2_npu.hpp"
 #include "models/qwen3/qwen3_npu.hpp"
@@ -162,8 +165,18 @@ class AutoModel {
     std::vector<int> checkpoint_his;
 	/// \brief dump the undecorated model output to stdout once a turn ends
 	/// \note on by default; models whose turns are short and driven in bulk (the
-	///       hunyuan translator) turn it off so the log is not doubled.
+	///       hunyuan translator) turn it off so the log is not doubled. Those
+	///       models should seed this from env_forces_raw_output() so diagnostics
+	///       can opt back in without changing the interactive default.
 	bool log_raw_output = true;
+	/// \brief whether FLM_LOG_RAW_OUTPUT forces the "Model RAW Output:" dump on
+	/// \note the qualification harness and numerical-match anchor per-turn parsing
+	///       on that marker, so they set FLM_LOG_RAW_OUTPUT=1 to re-enable it for
+	///       models that quiet it by default; unset/empty/"0" leave the default.
+	static bool env_forces_raw_output() {
+		const char* value = std::getenv("FLM_LOG_RAW_OUTPUT");
+		return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
+	}
 	/// \brief run one more forward on the eos token once a turn ends
 	/// \note this keeps the kv cache aligned with token_history so a following
 	///       turn can append to it. Models that rewind or clear between turns

src/include/AutoModel/modeling_qwen3vl.hpp

@@ -225,4 +225,4 @@ class Qwen3VL_Thinking : public Qwen3VL {
         }
         std::string generate(chat_meta_info_t& meta_info, int length_limit, std::ostream& os, std::function<bool()> is_cancelled = [] { return false; }) override;
         std::string generate_with_prompt(chat_meta_info_t& meta_info, lm_uniform_input_t& input, int length_limit, std::ostream& os = std::cout) override;
-    };
+    };

src/include/buffer.hpp

@@ -11,6 +11,7 @@
 #include <cstring>
 #include <fstream>
 #include <iostream>
+#include <memory>
 #include <stdexcept>
 #include <string>
 #include <vector>
@@ -30,15 +31,25 @@
 /// \note A copy (or mapping) does not duplicate the underlying memory; it only maps the pointer.
 class bytes {
 protected:
+    // HRX engines (IRON) use shared_ptr so copies keep the BO mapped. Unique_ptr
+    // copies drop ownership and leave data_ dangling across the .so boundary.
+#if defined(FLM_USE_HRX)
+    std::shared_ptr<uint8_t[]> owned_data_;
+#else
     std::unique_ptr<uint8_t[]> owned_data_;
+#endif
     uint8_t* data_;
     size_t size_;
     bool is_owner_;
 #ifdef FLM_DEVICE_BUFFER
     bool is_bo_owner_;
     flm_rt::bo* bo_;
+#if defined(FLM_USE_HRX)
+    std::shared_ptr<flm_rt::bo> owned_bo_;
+#else
     std::unique_ptr<flm_rt::bo> owned_bo_;
 #endif
+#endif
 
 public:
     /// \brief constructor
@@ -52,11 +63,19 @@ class bytes {
 
     /// \brief copy constructor
     /// \param other the other bytes
+#if defined(FLM_USE_HRX)
+    bytes(const bytes& other) : owned_data_(other.owned_data_), data_(other.data_), size_(other.size_), is_owner_(other.is_owner_)
+#ifdef FLM_DEVICE_BUFFER
+        , is_bo_owner_(other.is_bo_owner_), bo_(other.bo_), owned_bo_(other.owned_bo_)
+#endif
+    {}
+#else
     bytes(const bytes& other) : owned_data_(nullptr), data_(other.data_), size_(other.size_), is_owner_(false)
 #ifdef FLM_DEVICE_BUFFER
         , is_bo_owner_(false), bo_(other.bo_), owned_bo_(nullptr)
 #endif
     {}
+#endif
 
     /// \brief move constructor
     /// \param other the other bytes
@@ -86,7 +105,11 @@ class bytes {
     {
         if (size > 0 && size < 8ull * 1024 * 1024 * 1024){
             try {
+#if defined(FLM_USE_HRX)
+                owned_data_ = std::shared_ptr<uint8_t[]>(new uint8_t[size]());
+#else
                 owned_data_ = std::make_unique<uint8_t[]>(size);
+#endif
             }
             catch (const std::bad_alloc& e) {
                 throw std::runtime_error(std::string("Failed to allocate bytes of size ") + std::to_string(size) + ": " + e.what());
@@ -128,10 +151,14 @@ class bytes {
             throw std::runtime_error("Invalid size for bytes allocation");
         }
         size_t alignment = 1024 * 1024;
-        int padded_size = (size + alignment - 1) / alignment * alignment; // 1MB alignment
+        size_t padded_size = (size + alignment - 1) / alignment * alignment; // 1MB alignment
 
         try {
+#if defined(FLM_USE_HRX)
+            owned_bo_ = std::make_shared<flm_rt::ext::bo>(device, padded_size);
+#else
             owned_bo_ = std::make_unique<flm_rt::ext::bo>(device, padded_size);
+#endif
         }
         catch (const std::exception& e) {
             throw std::runtime_error(std::string("Failed to allocate flm_rt::ext::bo: ") + e.what());
@@ -169,6 +196,17 @@ class bytes {
     /// \param other the other bytes
     bytes& operator=(const bytes& other) {
         if (this != &other) {
+#if defined(FLM_USE_HRX)
+            owned_data_ = other.owned_data_;
+            data_ = other.data_;
+            size_ = other.size_;
+            is_owner_ = other.is_owner_;
+#ifdef FLM_DEVICE_BUFFER
+            owned_bo_ = other.owned_bo_;
+            is_bo_owner_ = other.is_bo_owner_;
+            bo_ = other.bo_;
+#endif
+#else
             if (is_owner_){
                 owned_data_.reset();
             }
@@ -181,6 +219,7 @@ class bytes {
             }
             is_bo_owner_ = false;
             bo_ = other.bo_;
+#endif
 #endif
         }
         return *this;
@@ -257,7 +296,11 @@ class bytes {
             throw std::runtime_error("Cannot resize to zero size");
         }
         try {
+#if defined(FLM_USE_HRX)
+            owned_data_.reset(new uint8_t[new_size]());
+#else
             owned_data_.reset(new uint8_t[new_size]);
+#endif
         }
         catch (const std::bad_alloc& e) {
             throw std::runtime_error(std::string("Failed to allocate bytes of size ") + std::to_string(new_size) + ": " + e.what());
@@ -302,6 +345,8 @@ class bytes {
     /// \return the is bo owner
     bool is_bo_owner() const { return is_bo_owner_; }
 
+    bool has_bo() const { return bo_ != nullptr; }
+
     /// \brief sync to device (host writes -> device)
 #if defined(FLM_USE_HRX)
     void sync_to_device() { assert(bo_); bo_->flush(); }