update

Author: Changming Sun

tests/unittest/matrix_buffer.h

@@ -0,0 +1,105 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <cstdlib>      // For malloc, free, abort
+#include <cstddef>      // For size_t
+#include <functional>   // For std::function
+#include <algorithm>    // For std::fill_n
+#include <new>          // For std::bad_alloc (alternative to abort)
+
+// Include crtdbg.h for _malloc_dbg and _free_dbg on Windows debug builds
+#if defined(_WIN32) && !defined(NDEBUG) && defined(_DEBUG)
+#include <crtdbg.h>
+#endif
+
+template <typename T>
+class MatrixGuardBuffer {
+public:
+    MatrixGuardBuffer() :
+        buffer_(nullptr),
+        elements_allocated_(0) {
+    }
+
+    ~MatrixGuardBuffer() {
+        ReleaseBuffer();
+    }
+
+    // Disable copy and move semantics for simplicity
+    MatrixGuardBuffer(const MatrixGuardBuffer&) = delete;
+    MatrixGuardBuffer& operator=(const MatrixGuardBuffer&) = delete;
+    MatrixGuardBuffer(MatrixGuardBuffer&&) = delete;
+    MatrixGuardBuffer& operator=(MatrixGuardBuffer&&) = delete;
+
+    T* GetFilledBuffer(size_t elements, const std::function<void(T*, size_t)>& fill_func) {
+        if (elements == 0) {
+            ReleaseBuffer();
+            return nullptr;
+        }
+
+        if (elements > elements_allocated_) {
+            ReleaseBuffer(); 
+
+            size_t bytes_to_allocate = elements * sizeof(T);
+            if (elements != 0 && bytes_to_allocate / elements != sizeof(T)) { // Check for overflow before multiplication
+                // Handle overflow, e.g., by aborting or throwing
+                abort(); 
+            }
+            
+        #if defined(_WIN32) && !defined(NDEBUG) && defined(_DEBUG)
+            buffer_ = static_cast<T*>(_malloc_dbg(bytes_to_allocate, _NORMAL_BLOCK, __FILE__, __LINE__));
+        #else
+            buffer_ = static_cast<T*>(malloc(bytes_to_allocate));
+        #endif
+
+            if (buffer_ == nullptr) {
+                // Consider `throw std::bad_alloc();` for C++ style error handling.
+                abort(); 
+            }
+            elements_allocated_ = elements;
+        }
+
+        if (fill_func && buffer_ != nullptr) {
+            fill_func(buffer_, elements);
+        } else if (buffer_ == nullptr && elements > 0) {
+            abort(); // Should not happen if allocation failure aborts
+        }
+        
+        return buffer_;
+    }
+
+    T* GetBuffer(size_t elements, bool zero_fill = false) {
+        if (zero_fill) {
+            return GetFilledBuffer(
+                elements,
+                [](T* start, size_t count) {
+                    if (start && count > 0) {
+                        std::fill_n(start, count, T{}); // Value-initialize
+                    }
+                });
+        }
+
+        return GetFilledBuffer(
+            elements,
+            [](T* start, size_t count) {
+                //do nothing, so that we can catch read uninitialized values errors
+            });
+    }
+
+    void ReleaseBuffer() {
+        if (buffer_ != nullptr) {
+        #if defined(_WIN32) && !defined(NDEBUG) && defined(_DEBUG)
+            _free_dbg(buffer_, _NORMAL_BLOCK);
+        #else
+            free(buffer_);
+        #endif
+            buffer_ = nullptr;
+        }
+        elements_allocated_ = 0;
+    }
+
+private:
+    T* buffer_;
+    size_t elements_allocated_;
+};

tests/unittest/test_fgemm.h

@@ -202,7 +202,7 @@ class MlasFgemmTest : public MlasTestBase {
       for (size_t m = 0; m < M; m++) {
         for (size_t n = 0; n < N; n++, f++) {
           // Sensitive to comparing positive/negative zero.
-          ASSERT_EQ(C[f], CReference[f])
+          ASSERT_NEAR(C[f], CReference[f],1e-5)
               << " Diff @[" << batch << ", " << m << ", " << n << "] f=" << f << ", "
               << (Packed ? "Packed" : "NoPack") << "."
               << (Threaded ? "SingleThread" : "Threaded") << "/"

tests/unittest/test_main.cpp

@@ -57,6 +57,9 @@ bool AddTestRegister(TestRegister test_register) {
 }
 
 int main(int argc, char** argv) {
+  unsigned int current_control;
+  _controlfp_s(&current_control, 0, 0);                                                     // Get current control word
+  _controlfp_s(&current_control, ~(_EM_INVALID | _EM_ZERODIVIDE | _EM_DENORMAL), _MCW_EM);  // Unmask exceptions
   bool is_short_execute = (argc <= 1 || strcmp("--long", argv[1]) != 0);
   std::cout << "-------------------------------------------------------" << std::endl;
   if (is_short_execute) {

tests/unittest/test_scaleoutput.cpp

@@ -22,7 +22,7 @@ class MlasScaleOutputTest : public MlasTestBase {
                                                             std::numeric_limits<int16_t>::max());
 
     for (size_t s = 0; s < M * N; s++) {
-      Input[s] = int_distribution(generator);
+      Input[s] = int_distribution(generator); //It could be zero
       Output[s] = OutputRef[s] = real_distribution(generator);
     }
 
@@ -52,10 +52,14 @@ class MlasScaleOutputTest : public MlasTestBase {
     constexpr float epsilon = 1e-6f;
 
     for (size_t n = 0; n < M * N; n++) {
-      float diff = std::fabs((Output[n] - OutputRef[n]) / OutputRef[n]);
+      float outvalue = OutputRef[n]; // When `AccumulateMode` is false, there is a high chance that this value could be zero
+      float diff = std::fabs(Output[n] - outvalue) ;
+      if (outvalue != 0) {
+        diff /= outvalue;
+      }
       ASSERT_LE(diff, epsilon)
           << " @[" << n / N << "," << n % N << "], total:[" << M << "," << N << "], got:"
-          << Output[n] << ", expecting:" << OutputRef[n];
+          << Output[n] << ", expecting:" << outvalue;
     }
   }
 

tests/unittest/test_util.h

@@ -37,7 +37,9 @@
 #endif
 
 MLAS_THREADPOOL* GetMlasThreadPool(void);
-
+#ifdef BUILD_MLAS_NO_ONNXRUNTIME
+#include "matrix_buffer.h"
+#else
 template <typename T>
 class MatrixGuardBuffer {
  public:
@@ -163,7 +165,7 @@ class MatrixGuardBuffer {
   size_t _BaseBufferSize;
   T* _GuardAddress;
 };
-
+#endif
 class MlasTestBase {
  public:
   virtual ~MlasTestBase(void) {}