Revert "Make TARGET=GENERIC compatible with DYNAMIC_ARCH=1"

.drone.yml

@@ -8,7 +8,7 @@ platform:
 
 steps:
 - name: Build and Test
-  image: ubuntu:18.04
+  image: ubuntu:19.04
   environment:
     CC: gcc
     COMMON_FLAGS: 'DYNAMIC_ARCH=1 TARGET=ARMV8 NUM_THREADS=32'
@@ -32,7 +32,7 @@ platform:
 
 steps:
 - name: Build and Test
-  image: ubuntu:18.04
+  image: ubuntu:19.04
   environment:
     CC: gcc
     COMMON_FLAGS: 'DYNAMIC_ARCH=1 TARGET=ARMV6 NUM_THREADS=32'
@@ -92,7 +92,7 @@ steps:
     - mkdir build && cd build
     - cmake $CMAKE_FLAGS ..
     - make -j
-    - ctest -V
+    - ctest
 
 ---
 kind: pipeline
@@ -116,7 +116,7 @@ steps:
     - mkdir build && cd build
     - cmake $CMAKE_FLAGS ..
     - make -j
-    - ctest -V
+    - ctest
 
 ---
 kind: pipeline
@@ -140,77 +140,4 @@ steps:
     - mkdir build && cd build
     - cmake $CMAKE_FLAGS ..
     - make -j
-    - ctest -V
-
----
-kind: pipeline
-name: arm64_native_test
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: gcc
-    COMMON_FLAGS: 'USE_OPENMP=1'
-  commands:
-    - echo "MAKE_FLAGS:= $COMMON_FLAGS"
-    - apt-get update -y
-    - apt-get install -y make $CC gfortran perl python g++
-    - $CC --version
-    - make QUIET_MAKE=1 $COMMON_FLAGS
-    - make -C test $COMMON_FLAGS
-    - make -C ctest $COMMON_FLAGS
-    - make -C utest $COMMON_FLAGS
-    - make -C cpp_thread_test dgemm_tester
----
-kind: pipeline
-name: epyc_native_test
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: gcc
-    COMMON_FLAGS: 'USE_OPENMP=1'
-  commands:
-    - echo "MAKE_FLAGS:= $COMMON_FLAGS"
-    - apt-get update -y
-    - apt-get install -y make $CC gfortran perl python g++
-    - $CC --version
-    - make QUIET_MAKE=1 $COMMON_FLAGS
-    - make -C test $COMMON_FLAGS
-    - make -C ctest $COMMON_FLAGS
-    - make -C utest $COMMON_FLAGS
-    - make -C cpp_thread_test dgemm_tester
----
-kind: pipeline
-name: arm64_gcc10
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: ubuntu:20.04
-  environment:
-    CC: gcc-10
-    FC: gfortran-10
-    COMMON_FLAGS: 'TARGET=ARMV8 DYNAMIC_ARCH=1'
-  commands:
-    - echo "MAKE_FLAGS:= $COMMON_FLAGS"
-    - apt-get update -y
-    - apt-get install -y make $CC gfortran-10 perl python g++
-    - $CC --version
-    - make QUIET_MAKE=1 $COMMON_FLAGS
-    - make -C utest $COMMON_FLAGS
-    - make -C test $COMMON_FLAGS
-    
+    - ctest

.github/workflows/dynamic_arch.yml

@@ -1,103 +0,0 @@
-name: continuous build
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest]
-        fortran: [gfortran, flang]
-        build: [cmake, make]
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v2
-
-      - name: Compilation cache
-        uses: actions/cache@v2
-        with:
-          path: ~/.ccache
-          # We include the commit sha in the cache key, as new cache entries are
-          # only created if there is no existing entry for the key yet.
-          key: ${{ runner.os }}-ccache-${{ github.sha }}
-          # Restore any ccache cache entry, if none for
-          # ${{ runner.os }}-ccache-${{ github.sha }} exists
-          restore-keys: |
-            ${{ runner.os }}-ccache-
-
-      - name: Print system information
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            cat /proc/cpuinfo
-          elif [ "$RUNNER_OS" == "macOS" ]; then
-            sysctl -a | grep machdep.cpu
-          else
-            echo "$RUNNER_OS not supported"
-            exit 1
-          fi
-
-      - name: Install Dependencies
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            sudo apt-get install -y gfortran cmake ccache
-          elif [ "$RUNNER_OS" == "macOS" ]; then
-            brew install coreutils cmake ccache
-          else
-            echo "$RUNNER_OS not supported"
-            exit 1
-          fi
-          ccache -M 300M  # Limit the ccache size; Github's overall cache limit is 5GB
-
-      - name: gfortran build
-        if: matrix.build == 'make' && matrix.fortran == 'gfortran'
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            export PATH="/usr/lib/ccache:${PATH}"
-          elif [ "$RUNNER_OS" == "macOS" ]; then
-            export PATH="$(brew --prefix)/opt/ccache/libexec:${PATH}"
-          else
-            echo "$RUNNER_OS not supported"
-            exit 1
-          fi
-
-          make -j$(nproc) DYNAMIC_ARCH=1 USE_OPENMP=0
-
-      - name: flang build
-        if: matrix.build == 'make' && matrix.fortran == 'flang'
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            export PATH="/usr/lib/ccache:${PATH}"
-          elif [ "$RUNNER_OS" == "macOS" ]; then
-            exit 0
-          else
-            echo "$RUNNER_OS not supported"
-            exit 1
-          fi
-
-          cd /usr/
-          sudo wget -nv https://github.com/flang-compiler/flang/releases/download/flang_20190329/flang-20190329-x86-70.tgz
-          sudo tar xf flang-20190329-x86-70.tgz
-          sudo rm flang-20190329-x86-70.tgz
-          cd -
-
-          make -j$(nproc) DYNAMIC_ARCH=1 USE_OPENMP=0 FC=flang
-
-
-      - name: CMake gfortran build
-        if: matrix.build == 'cmake' && matrix.fortran == 'gfortran'
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            export PATH="/usr/lib/ccache:${PATH}"
-          elif [ "$RUNNER_OS" == "macOS" ]; then
-            export PATH="$(brew --prefix)/opt/ccache/libexec:${PATH}"
-          else
-            echo "$RUNNER_OS not supported"
-            exit 1
-          fi
-
-          mkdir build
-          cd build
-          cmake -DDYNAMIC_ARCH=1 -DNOFORTRAN=0 -DBUILD_WITHOUT_LAPACK=0  -DCMAKE_VERBOSE_MAKEFILE=ON -DCMAKE_BUILD_TYPE=Release ..
-          make -j$(nproc)

.github/workflows/nightly-Homebrew-build.yml

@@ -1,79 +0,0 @@
-# Only the "head" branch of the OpenBLAS package is tested
-
-on:
-  push:
-    paths:
-      - '**/nightly-Homebrew-build.yml'
-  pull_request:
-    branches:
-      - develop
-    paths:
-      - '**/nightly-Homebrew-build.yml'
-  schedule:
-    - cron: 45 7 * * *
-# This is 7:45 AM UTC daily, late at night in the USA
-
-# Since push and pull_request will still always be building and testing the `develop` branch,
-# it only makes sense to test if this file has been changed
-
-name: Nightly-Homebrew-Build
-jobs:
-  build-OpenBLAS-with-Homebrew:
-    runs-on: macos-latest
-    env:
-      DEVELOPER_DIR: /Applications/Xcode_11.4.1.app/Contents/Developer
-      HOMEBREW_DEVELOPER: "ON"
-      HOMEBREW_DISPLAY_INSTALL_TIMES: "ON"
-      HOMEBREW_NO_ANALYTICS: "ON"
-      HOMEBREW_NO_AUTO_UPDATE: "ON"
-      HOMEBREW_NO_BOTTLE_SOURCE_FALLBACK: "ON"
-      HOMEBREW_NO_INSTALL_CLEANUP: "ON"
-
-    steps:
-      - name: Random delay for cron job
-        run: |
-          delay=$(( RANDOM % 600 ))
-          printf 'Delaying for %s seconds on event %s' ${delay} "${{ github.event_name }}"
-          sleep ${delay}
-        if: github.event_name == 'schedule'
-
-      - uses: actions/checkout@v2
-        # This isn't even needed, technically. Homebrew will get `develop` via git
-
-      - name: Update Homebrew
-        if: github.event_name != 'pull_request'
-        run: brew update || true
-          
-      - name: Install prerequisites
-        run: brew install --fetch-HEAD --HEAD --only-dependencies --keep-tmp openblas
-
-      - name: Install and bottle OpenBLAS
-        run: brew install --fetch-HEAD --HEAD --build-bottle --keep-tmp openblas
-        # the HEAD flags tell Homebrew to build the develop branch fetch via git
-
-      - name: Create bottle
-        run: |
-          brew bottle -v openblas
-          mkdir bottles
-          mv *.bottle.tar.gz bottles
-
-      - name: Upload bottle
-        uses: actions/upload-artifact@v1
-        with:
-          name: openblas--HEAD.catalina.bottle.tar.gz
-          path: bottles
-
-      - name: Show linkage
-        run: brew linkage -v openblas
-
-      - name: Test openblas
-        run: brew test --HEAD --verbose openblas
-
-      - name: Audit openblas formula
-        run: |
-          brew audit --strict openblas
-          brew cat openblas
-
-      - name: Post logs on failure
-        if: failure()
-        run: brew gist-logs --with-hostname -v openblas

.gitignore

@@ -70,7 +70,6 @@ test/SBLAT2.SUMM
 test/SBLAT3.SUMM
 test/ZBLAT2.SUMM
 test/ZBLAT3.SUMM
-test/SHBLAT3.SUMM
 test/cblat1
 test/cblat2
 test/cblat3
@@ -80,7 +79,6 @@ test/dblat3
 test/sblat1
 test/sblat2
 test/sblat3
-test/test_shgemm
 test/zblat1
 test/zblat2
 test/zblat3
@@ -89,7 +87,4 @@ build.*
 *.swp
 benchmark/*.goto
 benchmark/smallscaling
-.vscode
-CMakeCache.txt
-CMakeFiles/*
-.vscode
+

.travis.yml

@@ -1,172 +1,113 @@
 # XXX: Precise is already deprecated, new default is Trusty.
 # https://blog.travis-ci.com/2017-07-11-trusty-as-default-linux-is-coming
-dist: focal
+dist: precise
 sudo: true
 language: c
 
 matrix:
   include:
     - &test-ubuntu
-#      os: linux
+      os: linux
       compiler: gcc
       addons:
         apt:
           packages:
             - gfortran
-#      before_script: &common-before
-#        - COMMON_FLAGS="DYNAMIC_ARCH=1 TARGET=NEHALEM NUM_THREADS=32"
-#      script:
-#        - make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
-#        - make -C test $COMMON_FLAGS $BTYPE
-#        - make -C ctest $COMMON_FLAGS $BTYPE
-#        - make -C utest $COMMON_FLAGS $BTYPE
-#      env:
-#        - TARGET_BOX=LINUX64
-#        - BTYPE="BINARY=64"
-#
-#    - <<: *test-ubuntu
-      os: linux-ppc64le
       before_script: &common-before
-        - COMMON_FLAGS="DYNAMIC_ARCH=1 TARGET=POWER8 NUM_THREADS=32"
+        - COMMON_FLAGS="DYNAMIC_ARCH=1 TARGET=NEHALEM NUM_THREADS=32"
       script:
-        - make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
+        - set -e
+        - travis_wait 45 make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
         - make -C test $COMMON_FLAGS $BTYPE
         - make -C ctest $COMMON_FLAGS $BTYPE
         - make -C utest $COMMON_FLAGS $BTYPE
       env:
-        # for matrix annotation only
-        - TARGET_BOX=PPC64LE_LINUX
-        - BTYPE="BINARY=64 USE_OPENMP=1"
+        - TARGET_BOX=LINUX64
+        - BTYPE="BINARY=64"
+
+        #    - <<: *test-ubuntu
+        #      os: linux-ppc64le
+        #      before_script:
+        #        - COMMON_FLAGS="DYNAMIC_ARCH=1 TARGET=POWER8 NUM_THREADS=32"
+        #      env:
+        #        # for matrix annotation only
+        #        - TARGET_BOX=PPC64LE_LINUX
+        #        - BTYPE="BINARY=64 USE_OPENMP=1"
 
     - <<: *test-ubuntu
-      os: linux
-      arch: s390x
-      before_script:
-        - COMMON_FLAGS="DYNAMIC_ARCH=1 TARGET=Z13 NUM_THREADS=32"
       env:
-        # for matrix annotation only
-        - TARGET_BOX=IBMZ_LINUX
+        - TARGET_BOX=LINUX64
         - BTYPE="BINARY=64 USE_OPENMP=1"
 
     - <<: *test-ubuntu
-      os: linux
-      dist: focal
-      arch: s390x
+      env:
+        - TARGET_BOX=LINUX64
+        - BTYPE="BINARY=64 INTERFACE64=1"
+
+    - <<: *test-ubuntu
       compiler: clang
-      before_script:
-        - COMMON_FLAGS="DYNAMIC_ARCH=1 TARGET=Z13 NUM_THREADS=32"
       env:
-        # for matrix annotation only
-        - TARGET_BOX=IBMZ_LINUX
-        - BTYPE="BINARY=64 USE_OPENMP=0 CC=clang"
+        - TARGET_BOX=LINUX64
+        - BTYPE="BINARY=64 CC=clang"
 
-#    - <<: *test-ubuntu
-#      env:
-#        - TARGET_BOX=LINUX64
-#        - BTYPE="BINARY=64 USE_OPENMP=1"
-#
-#    - <<: *test-ubuntu
-#      env:
-#        - TARGET_BOX=LINUX64
-#        - BTYPE="BINARY=64 INTERFACE64=1"
-#
-#    - <<: *test-ubuntu
-#      compiler: clang
-#      env:
-#        - TARGET_BOX=LINUX64
-#        - BTYPE="BINARY=64 CC=clang"
-#
-#    - <<: *test-ubuntu
-#      compiler: clang
-#      env:
-#        - TARGET_BOX=LINUX64
-#        - BTYPE="BINARY=64 INTERFACE64=1 CC=clang"
-#
-#    - <<: *test-ubuntu
-#      addons:
-#        apt:
-#          packages:
-#            - gcc-multilib
-#            - gfortran-multilib
-#      env:
-#        - TARGET_BOX=LINUX32
-#        - BTYPE="BINARY=32"
-#
-    - os: linux
-      arch: ppc64le
-      dist: bionic
-      compiler: gcc
-      before_script:
-        - sudo add-apt-repository 'ppa:ubuntu-toolchain-r/test' -y
-        - sudo apt-get update
-        - sudo apt-get install gcc-9 gfortran-9 -y
-      script:
-        - make QUIET_MAKE=1  BINARY=64 USE_OPENMP=1 CC=gcc-9 FC=gfortran-9
-        - make -C test $COMMON_FLAGS $BTYPE
-        - make -C ctest $COMMON_FLAGS $BTYPE
-        - make -C utest $COMMON_FLAGS $BTYPE 
+    - <<: *test-ubuntu
+      compiler: clang
       env:
-        # for matrix annotation only
-        - TARGET_BOX=PPC64LE_LINUX_P9
+        - TARGET_BOX=LINUX64
+        - BTYPE="BINARY=64 INTERFACE64=1 CC=clang"
+
+    - <<: *test-ubuntu
+      addons:
+        apt:
+          packages:
+            - gcc-multilib
+            - gfortran-multilib
+      env:
+        - TARGET_BOX=LINUX32
+        - BTYPE="BINARY=32"
 
     - os: linux
-      arch: ppc64le
-      dist: bionic
       compiler: gcc
-      before_script:
-        - sudo add-apt-repository 'ppa:ubuntu-toolchain-r/test' -y
-        - sudo apt-get update
-        - sudo apt-get install gcc-9 gfortran-9 -y
+      addons:
+        apt:
+          packages:
+            - binutils-mingw-w64-x86-64
+            - gcc-mingw-w64-x86-64
+            - gfortran-mingw-w64-x86-64
+      before_script: *common-before
       script:
-        - make QUIET_MAKE=1  BUILD_BFLOAT16=1 BINARY=64 USE_OPENMP=1 CC=gcc-9 FC=gfortran-9
-        - make -C test $COMMON_FLAGS $BTYPE
-        - make -C ctest $COMMON_FLAGS $BTYPE
-        - make -C utest $COMMON_FLAGS $BTYPE 
+        - travis_wait 45 make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
       env:
-        # for matrix annotation only
-        - TARGET_BOX=PPC64LE_LINUX_P9
+        - TARGET_BOX=WIN64
+        - BTYPE="BINARY=64 HOSTCC=gcc CC=x86_64-w64-mingw32-gcc FC=x86_64-w64-mingw32-gfortran"
 
-#    - os: linux
-#      compiler: gcc
-#      addons:
-#        apt:
-#          packages:
-#            - binutils-mingw-w64-x86-64
-#            - gcc-mingw-w64-x86-64
-#            - gfortran-mingw-w64-x86-64
-#      before_script: *common-before
-#      script:
-#        - travis_wait 45 make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
-#      env:
-#        - TARGET_BOX=WIN64
-#        - BTYPE="BINARY=64 HOSTCC=gcc CC=x86_64-w64-mingw32-gcc FC=x86_64-w64-mingw32-gfortran"
-#
     # Build & test on Alpine Linux inside chroot, i.e. on system with musl libc.
     # These jobs needs sudo, so Travis runs them on VM-based infrastructure
     # which is slower than container-based infrastructure used for jobs
     # that don't require sudo.
- #   - &test-alpine
- #     os: linux
- #     dist: trusty
- #     sudo: true
- #     language: minimal
- #     before_install:
- #       - "wget 'https://raw.githubusercontent.com/alpinelinux/alpine-chroot-install/v0.9.0/alpine-chroot-install' \
- #         && echo 'e5dfbbdc0c4b3363b99334510976c86bfa6cb251  alpine-chroot-install' | sha1sum -c || exit 1"
- #       - alpine() { /alpine/enter-chroot -u "$USER" "$@"; }
- #     install:
- #       - sudo sh alpine-chroot-install -p 'build-base gfortran perl linux-headers'
- #     before_script: *common-before
- #     script:
- #       # XXX: Disable some warnings for now to avoid exceeding Travis limit for log size.
- #       - alpine make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
- #             CFLAGS="-Wno-misleading-indentation -Wno-sign-conversion -Wno-incompatible-pointer-types"
- #       - alpine make -C test $COMMON_FLAGS $BTYPE
- #       - alpine make -C ctest $COMMON_FLAGS $BTYPE
- #       - alpine make -C utest $COMMON_FLAGS $BTYPE
- #     env:
- #       - TARGET_BOX=LINUX64_MUSL
- #       - BTYPE="BINARY=64"
+    - &test-alpine
+      os: linux
+      dist: trusty
+      sudo: true
+      language: minimal
+      before_install:
+        - "wget 'https://raw.githubusercontent.com/alpinelinux/alpine-chroot-install/v0.9.0/alpine-chroot-install' \
+          && echo 'e5dfbbdc0c4b3363b99334510976c86bfa6cb251  alpine-chroot-install' | sha1sum -c || exit 1"
+        - alpine() { /alpine/enter-chroot -u "$USER" "$@"; }
+      install:
+        - sudo sh alpine-chroot-install -p 'build-base gfortran perl linux-headers'
+      before_script: *common-before
+      script:
+        - set -e
+        # XXX: Disable some warnings for now to avoid exceeding Travis limit for log size.
+        - alpine make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
+              CFLAGS="-Wno-misleading-indentation -Wno-sign-conversion -Wno-incompatible-pointer-types"
+        - alpine make -C test $COMMON_FLAGS $BTYPE
+        - alpine make -C ctest $COMMON_FLAGS $BTYPE
+        - alpine make -C utest $COMMON_FLAGS $BTYPE
+      env:
+        - TARGET_BOX=LINUX64_MUSL
+        - BTYPE="BINARY=64"
 
     # XXX: This job segfaults in TESTS OF THE COMPLEX LEVEL 3 BLAS,
     # but only on Travis CI, cannot reproduce it elsewhere.
@@ -176,113 +117,62 @@ matrix:
     #    - TARGET_BOX=LINUX64_MUSL
     #    - BTYPE="BINARY=64 USE_OPENMP=1"
 
-#    - <<: *test-alpine
-#      env:
-#        - TARGET_BOX=LINUX64_MUSL
-#        - BTYPE="BINARY=64 INTERFACE64=1"
-#
-#    # Build with the same flags as Alpine do in OpenBLAS package.
-#    - <<: *test-alpine
-#      env:
-#        - TARGET_BOX=LINUX64_MUSL
-#        - BTYPE="BINARY=64 NO_AFFINITY=1 USE_OPENMP=0 NO_LAPACK=0 TARGET=CORE2"
+    - <<: *test-alpine
+      env:
+        - TARGET_BOX=LINUX64_MUSL
+        - BTYPE="BINARY=64 INTERFACE64=1"
 
-#    - &test-cmake
-#      os: linux
-#      compiler: clang
-#      addons:
-#        apt:
-#          packages:
-#            - gfortran
-#            - cmake
-#      dist: trusty
-#      sudo: true
-#      before_script:
-#        - COMMON_ARGS="-DTARGET=NEHALEM -DNUM_THREADS=32"
-#      script:
-#        - mkdir build
-#        - CONFIG=Release
-#        - cmake -Bbuild -H. $CMAKE_ARGS $COMMON_ARGS -DCMAKE_BUILD_TYPE=$CONFIG
-#        - cmake --build build --config $CONFIG -- -j2
-#      env:
-#        - CMAKE=1
-#    - <<: *test-cmake
-#      env:
-#        - CMAKE=1 CMAKE_ARGS="-DNOFORTRAN=1"
-#    - <<: *test-cmake
-#      compiler: gcc
-#      env:
-#        - CMAKE=1
+    # Build with the same flags as Alpine do in OpenBLAS package.
+    - <<: *test-alpine
+      env:
+        - TARGET_BOX=LINUX64_MUSL
+        - BTYPE="BINARY=64 NO_AFFINITY=1 USE_OPENMP=0 NO_LAPACK=0 TARGET=CORE2"
 
-#    - &test-macos
-#      os: osx
-#      osx_image: xcode11.5
-#      before_script:
-#        - COMMON_FLAGS="DYNAMIC_ARCH=1 NUM_THREADS=32"
-#      script:
-#        - travis_wait 45 make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
-#      env:
-#        - BTYPE="TARGET=NEHALEM BINARY=64 INTERFACE64=1 FC=gfortran-9"
-#
-#    - <<: *test-macos
-#      osx_image: xcode12
-#      before_script:
-#        - COMMON_FLAGS="DYNAMIC_ARCH=1 NUM_THREADS=32"
-#        - brew update
-#      script:
-#        - travis_wait 45 make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
-#      env:
-#        - BTYPE="TARGET=HASWELL USE_OPENMP=1 BINARY=64 INTERFACE64=1 CC=gcc-10 FC=gfortran-10"
-#
-#    - <<: *test-macos
-#      osx_image: xcode12
-#      before_script:
-#        - COMMON_FLAGS="DYNAMIC_ARCH=1 NUM_THREADS=32"
-#        - brew update
-#      script:
-#        - travis_wait 45 make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
-#      env:
-#        - BTYPE="TARGET=NEHALEM BINARY=64 INTERFACE64=1 FC=gfortran-10"      
-
-  #  - <<: *test-macos
-  #    osx_image: xcode10
-  #    env:
-  #      - BTYPE="TARGET=NEHALEM BINARY=32 NOFORTRAN=1"
-
-#    - <<: *test-macos
-#      osx_image: xcode11.5
-#      before_script:
-#        - COMMON_FLAGS="DYNAMIC_ARCH=1 NUM_THREADS=32"
-#        - brew update
-#      env:
-#        - CC="/Applications/Xcode-10.1.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang"
-#        - CFLAGS="-O2 -Wno-macro-redefined -isysroot /Applications/Xcode-10.1.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS12.1.sdk -arch arm64 -miphoneos-version-min=10.0"
-#        - CC="/Applications/Xcode-11.5.GM.Seed.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang"
-#        - CFLAGS="-O2 -Wno-macro-redefined -isysroot /Applications/Xcode-11.5.GM.Seed.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS13.5.sdk -arch arm64 -miphoneos-version-min=10.0"
-#        - BTYPE="TARGET=ARMV8 BINARY=64 HOSTCC=clang NOFORTRAN=1"
-#    - <<: *test-macos
-#      osx_image: xcode11.5
-#      env:
-##        - CC="/Applications/Xcode-10.1.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang"
-##        - CFLAGS="-O2 -mno-thumb -Wno-macro-redefined -isysroot /Applications/Xcode-10.1.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS12.1.sdk -arch armv7 -miphoneos-version-min=5.1"
-#        - CC="/Applications/Xcode-11.5.GM.Seed.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang"
-#        - CFLAGS="-O2 -mno-thumb -Wno-macro-redefined -isysroot /Applications/Xcode-11.5.GM.Seed.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS13.5.sdk -arch armv7 -miphoneos-version-min=5.1"
-#        - BTYPE="TARGET=ARMV7 HOSTCC=clang NOFORTRAN=1"
-
-    - &test-graviton2
+    - &test-cmake
       os: linux
-      arch: arm64-graviton2
-      dist: focal
-      group: edge
-      virt: lxd
-      compiler: gcc
+      compiler: clang
       addons:
         apt:
           packages:
             - gfortran
+            - cmake
+      dist: trusty
+      sudo: true
+      before_script:
+        - COMMON_ARGS="-DTARGET=NEHALEM -DNUM_THREADS=32"
       script:
-        - travis_wait 45 make && make lapack-test
-        
+        - set -e
+        - mkdir build
+        - CONFIG=Release
+        - cmake -Bbuild -H. $CMAKE_ARGS $COMMON_ARGS -DCMAKE_BUILD_TYPE=$CONFIG
+        - cmake --build build --config $CONFIG -- -j2
+      env:
+        - CMAKE=1
+    - <<: *test-cmake
+      env:
+        - CMAKE=1 CMAKE_ARGS="-DNOFORTRAN=1"
+    - <<: *test-cmake
+      compiler: gcc
+      env:
+        - CMAKE=1
+
+    - &test-macos
+      os: osx
+      osx_image: xcode10.1
+      before_script:
+        - COMMON_FLAGS="DYNAMIC_ARCH=1 TARGET=NEHALEM NUM_THREADS=32"
+        - brew update
+        - brew install gcc # for gfortran
+      script:
+        - travis_wait 45 make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
+      env:
+        - BTYPE="BINARY=64 INTERFACE64=1"
+
+    - <<: *test-macos
+      osx_image: xcode8.3
+      env:
+        - BTYPE="BINARY=32"
+
 # whitelist
 branches:
   only:

CMakeLists.txt

@@ -3,13 +3,10 @@
 ##
 
 cmake_minimum_required(VERSION 2.8.5)
-
 project(OpenBLAS C ASM)
-
 set(OpenBLAS_MAJOR_VERSION 0)
 set(OpenBLAS_MINOR_VERSION 3)
-set(OpenBLAS_PATCH_VERSION 20)
-
+set(OpenBLAS_PATCH_VERSION 8.dev)
 set(OpenBLAS_VERSION "${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}.${OpenBLAS_PATCH_VERSION}")
 
 # Adhere to GNU filesystem layout conventions
@@ -17,74 +14,51 @@ include(GNUInstallDirs)
 
 include(CMakePackageConfigHelpers)
 
-if(MSVC AND NOT DEFINED NOFORTRAN)
-  set(NOFORTRAN ON)
-endif()
 
 #######
 if(MSVC)
-  option(BUILD_WITHOUT_LAPACK "Do not build LAPACK and LAPACKE (Only BLAS or CBLAS)" ON)
+option(BUILD_WITHOUT_LAPACK "Do not build LAPACK and LAPACKE (Only BLAS or CBLAS)" ON)
 endif()
-
 option(BUILD_WITHOUT_CBLAS "Do not build the C interface (CBLAS) to the BLAS functions" OFF)
-
 option(DYNAMIC_ARCH "Include support for multiple CPU targets, with automatic selection at runtime (x86/x86_64, aarch64 or ppc only)" OFF)
-
 option(DYNAMIC_OLDER "Include specific support for older x86 cpu models (Penryn,Dunnington,Atom,Nano,Opteron) with DYNAMIC_ARCH" OFF)
-
 option(BUILD_RELAPACK "Build with ReLAPACK (recursive implementation of several LAPACK functions on top of standard LAPACK)" OFF)
-
-option(USE_LOCKING "Use locks even in single-threaded builds to make them callable from multiple threads" OFF)
-
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-  option(NO_AFFINITY "Disable support for CPU affinity masks to avoid binding processes from e.g. R or numpy/scipy to a single core" ON)
+option(NO_AFFINITY "Disable support for CPU affinity masks to avoid binding processes from e.g. R or numpy/scipy to a single core" ON)
 else()
-  set(NO_AFFINITY 1)
-endif()
-
-option(CPP_THREAD_SAFETY_TEST "Run a massively parallel DGEMM test to confirm thread safety of the library (requires OpenMP and about 1.3GB of RAM)" OFF)
-
-option(CPP_THREAD_SAFETY_GEMV "Run a massively parallel DGEMV test to confirm thread safety of the library (requires OpenMP)" OFF)
-option(BUILD_STATIC_LIBS "Build static library" OFF)
-if(NOT BUILD_STATIC_LIBS AND NOT BUILD_SHARED_LIBS)
-  set(BUILD_STATIC_LIBS ON CACHE BOOL "Build static library" FORCE)
-endif()
-if((BUILD_STATIC_LIBS AND BUILD_SHARED_LIBS) AND MSVC)
-  message(WARNING "Could not enable both BUILD_STATIC_LIBS and BUILD_SHARED_LIBS with MSVC, Disable BUILD_SHARED_LIBS")
-  set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build static library" FORCE)
+set(NO_AFFINITY 1)
 endif()
 
 # Add a prefix or suffix to all exported symbol names in the shared library.
 # Avoids conflicts with other BLAS libraries, especially when using
 # 64 bit integer interfaces in OpenBLAS.
+
 set(SYMBOLPREFIX "" CACHE STRING  "Add a prefix to all exported symbol names in the shared library to avoid conflicts with other BLAS libraries" )
-
 set(SYMBOLSUFFIX "" CACHE STRING  "Add a suffix to all exported symbol names in the shared library, e.g. _64 for INTERFACE64 builds" )
-
 #######
 if(BUILD_WITHOUT_LAPACK)
-  set(NO_LAPACK 1)
-  set(NO_LAPACKE 1)
+set(NO_LAPACK 1)
+set(NO_LAPACKE 1)
 endif()
 
 if(BUILD_WITHOUT_CBLAS)
-  set(NO_CBLAS 1)
+set(NO_CBLAS 1)
 endif()
 
 #######
 
 if(MSVC AND MSVC_STATIC_CRT)
-  set(CompilerFlags
-        CMAKE_CXX_FLAGS
-        CMAKE_CXX_FLAGS_DEBUG
-        CMAKE_CXX_FLAGS_RELEASE
-        CMAKE_C_FLAGS
-        CMAKE_C_FLAGS_DEBUG
-        CMAKE_C_FLAGS_RELEASE
-        )
-  foreach(CompilerFlag ${CompilerFlags})
-    string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
-  endforeach()
+    set(CompilerFlags
+            CMAKE_CXX_FLAGS
+            CMAKE_CXX_FLAGS_DEBUG
+            CMAKE_CXX_FLAGS_RELEASE
+            CMAKE_C_FLAGS
+            CMAKE_C_FLAGS_DEBUG
+            CMAKE_C_FLAGS_RELEASE
+            )
+    foreach(CompilerFlag ${CompilerFlags})
+      string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
+    endforeach()
 endif()
 
 message(WARNING "CMake support is experimental. It does not yet support all build options and may not produce the same Makefiles that OpenBLAS ships with.")
@@ -112,13 +86,9 @@ if (NOT NO_LAPACK)
   list(APPEND SUBDIRS lapack)
 endif ()
 
-if (NOT DEFINED BUILD_BFLOAT16)
- set (BUILD_BFLOAT16 false)
-endif ()
 # set which float types we want to build for
 if (NOT DEFINED BUILD_SINGLE AND NOT DEFINED BUILD_DOUBLE AND NOT DEFINED BUILD_COMPLEX AND NOT DEFINED BUILD_COMPLEX16)
   # if none are defined, build for all
-  # set(BUILD_BFLOAT16 true)
   set(BUILD_SINGLE true)
   set(BUILD_DOUBLE true)
   set(BUILD_COMPLEX true)
@@ -150,11 +120,6 @@ if (BUILD_COMPLEX16)
   list(APPEND FLOAT_TYPES "ZCOMPLEX") # defines COMPLEX and DOUBLE
 endif ()
 
-if (BUILD_BFLOAT16)
-  message(STATUS "Building Half Precision")
-  #  list(APPEND FLOAT_TYPES "BFLOAT16") # defines nothing
-endif ()
-
 if (NOT DEFINED CORE OR "${CORE}" STREQUAL "UNKNOWN")
   message(FATAL_ERROR "Detecting CPU failed. Please set TARGET explicitly, e.g. make TARGET=your_cpu_target. Please read README for details.")
 endif ()
@@ -163,10 +128,9 @@ endif ()
 set( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
 set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
 if(MSVC)
-  set( CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG ${PROJECT_BINARY_DIR}/lib/Debug)
-  set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${PROJECT_BINARY_DIR}/lib/Release)
+set( CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG ${PROJECT_BINARY_DIR}/lib/Debug)
+set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${PROJECT_BINARY_DIR}/lib/Release)
 endif ()
-
 # get obj vars into format that add_library likes: $<TARGET_OBJS:objlib> (see http://www.cmake.org/cmake/help/v3.0/command/add_library.html)
 set(TARGET_OBJS "")
 foreach (SUBDIR ${SUBDIRS})
@@ -204,63 +168,12 @@ if (${DYNAMIC_ARCH})
 endif ()
 
 # add objects to the openblas lib
-if(NOT NO_LAPACK)
-  add_library(LAPACK OBJECT ${LA_SOURCES})
-  list(APPEND TARGET_OBJS "$<TARGET_OBJECTS:LAPACK>")
-endif()
-if(NOT NO_LAPACKE)
-  add_library(LAPACKE OBJECT ${LAPACKE_SOURCES})
-  list(APPEND TARGET_OBJS "$<TARGET_OBJECTS:LAPACKE>")
-endif()
-if(BUILD_RELAPACK)
-  add_library(RELAPACK OBJECT ${RELA_SOURCES})
-  list(APPEND TARGET_OBJS "$<TARGET_OBJECTS:RELAPACK>")
-endif()
-set(OpenBLAS_LIBS "")
-if(BUILD_STATIC_LIBS)
-  add_library(${OpenBLAS_LIBNAME}_static STATIC ${TARGET_OBJS} ${OpenBLAS_DEF_FILE})
-  target_include_directories(${OpenBLAS_LIBNAME}_static INTERFACE $<INSTALL_INTERFACE:include/openblas${SUFFIX64}>)
-  list(APPEND OpenBLAS_LIBS ${OpenBLAS_LIBNAME}_static)
-endif()
-if(BUILD_SHARED_LIBS)
-  add_library(${OpenBLAS_LIBNAME}_shared SHARED ${TARGET_OBJS} ${OpenBLAS_DEF_FILE})
-  target_include_directories(${OpenBLAS_LIBNAME}_shared INTERFACE $<INSTALL_INTERFACE:include/openblas${SUFFIX64}>)
-  list(APPEND OpenBLAS_LIBS ${OpenBLAS_LIBNAME}_shared)
-endif()
-if(BUILD_STATIC_LIBS)
-  add_library(${OpenBLAS_LIBNAME} ALIAS ${OpenBLAS_LIBNAME}_static)
-else()
-  add_library(${OpenBLAS_LIBNAME} ALIAS ${OpenBLAS_LIBNAME}_shared)
-endif()
-
-set_target_properties(${OpenBLAS_LIBS} PROPERTIES OUTPUT_NAME ${OpenBLAS_LIBNAME})
+add_library(${OpenBLAS_LIBNAME} ${LA_SOURCES} ${LAPACKE_SOURCES} ${RELA_SOURCES} ${TARGET_OBJS} ${OpenBLAS_DEF_FILE})
+target_include_directories(${OpenBLAS_LIBNAME} INTERFACE $<INSTALL_INTERFACE:include/openblas${SUFFIX64}>)
 
 # Android needs to explicitly link against libm
 if(ANDROID)
-  if(BUILD_STATIC_LIBS)
-    target_link_libraries(${OpenBLAS_LIBNAME}_static m)
-  endif()
-  if(BUILD_SHARED_LIBS)
-    target_link_libraries(${OpenBLAS_LIBNAME}_shared m)
-  endif()
-endif()
-
-if (APPLE AND DYNAMIC_ARCH AND BUILD_SHARED_LIBS)
-  set (CMAKE_C_USE_RESPONSE_FILE_FOR_OBJECTS 1)
-  if (NOT NOFORTRAN)  
-  set (CMAKE_Fortran_USE_RESPONSE_FILE_FOR_OBJECTS 1)
-  set (CMAKE_Fortran_CREATE_SHARED_LIBRARY
- "sh -c 'cat ${CMAKE_BINARY_DIR}/CMakeFiles/openblas_shared.dir/objects*.rsp | xargs -n 1024 ar -ru libopenblas.a && exit 0' "
- "sh -c 'ar -ru libopenblas.a ${CMAKE_BINARY_DIR}/driver/others/CMakeFiles/driver_others.dir/xerbla.c.o && exit 0' "
- "sh -c 'echo \"\" | ${CMAKE_Fortran_COMPILER} -o dummy.o -c -x f95-cpp-input - '"
- "sh -c '${CMAKE_Fortran_COMPILER} -fpic -shared -Wl,-all_load -Wl,-force_load,libopenblas.a -Wl,-noall_load dummy.o -o ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libopenblas.${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}.dylib'"
- "sh -c 'ls -l ${CMAKE_BINARY_DIR}/lib'")
-  else ()
-  set (CMAKE_C_CREATE_SHARED_LIBRARY
-   "sh -c 'cat ${CMAKE_BINARY_DIR}/CMakeFiles/openblas_shared.dir/objects*.rsp | xargs -n 1024 ar -ru libopenblas.a && exit 0' "
-   "sh -c 'ar -ru libopenblas.a ${CMAKE_BINARY_DIR}/driver/others/CMakeFiles/driver_others.dir/xerbla.c.o && exit 0' "
-   "sh -c '${CMAKE_C_COMPILER} -fpic -shared -Wl,-all_load -Wl,-force_load,libopenblas.a -Wl,-noall_load -o ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libopenblas.${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}.dylib'")
-  endif ()
+  target_link_libraries(${OpenBLAS_LIBNAME} m)
 endif()
 
 # Handle MSVC exports
@@ -269,21 +182,21 @@ if(MSVC AND BUILD_SHARED_LIBS)
     include("${PROJECT_SOURCE_DIR}/cmake/export.cmake")
   else()
     # Creates verbose .def file (51KB vs 18KB)
-    set_target_properties(${OpenBLAS_LIBNAME}_shared PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS true)
+    set_target_properties(${OpenBLAS_LIBNAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS true)
   endif()
 endif()
 
 # Set output for libopenblas
-set_target_properties( ${OpenBLAS_LIBS} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
-set_target_properties( ${OpenBLAS_LIBS} PROPERTIES LIBRARY_OUTPUT_NAME_DEBUG "${OpenBLAS_LIBNAME}_d")
-set_target_properties( ${OpenBLAS_LIBS} PROPERTIES EXPORT_NAME "OpenBLAS")
+set_target_properties( ${OpenBLAS_LIBNAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
+set_target_properties( ${OpenBLAS_LIBNAME} PROPERTIES LIBRARY_OUTPUT_NAME_DEBUG "${OpenBLAS_LIBNAME}_d")
+set_target_properties( ${OpenBLAS_LIBNAME} PROPERTIES EXPORT_NAME "OpenBLAS")
 
 foreach (OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
   string( TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG )
 
-  set_target_properties( ${OpenBLAS_LIBS} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${PROJECT_BINARY_DIR}/lib/${OUTPUTCONFIG} )
-  set_target_properties( ${OpenBLAS_LIBS} PROPERTIES LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${PROJECT_BINARY_DIR}/lib/${OUTPUTCONFIG} )
-  set_target_properties( ${OpenBLAS_LIBS} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${PROJECT_BINARY_DIR}/lib/${OUTPUTCONFIG} )
+  set_target_properties( ${OpenBLAS_LIBNAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${PROJECT_BINARY_DIR}/lib/${OUTPUTCONFIG} )
+  set_target_properties( ${OpenBLAS_LIBNAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${PROJECT_BINARY_DIR}/lib/${OUTPUTCONFIG} )
+  set_target_properties( ${OpenBLAS_LIBNAME} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${PROJECT_BINARY_DIR}/lib/${OUTPUTCONFIG} )
 endforeach()
 
 enable_testing()
@@ -292,17 +205,10 @@ if (USE_THREAD)
   # Add threading library to linker
   find_package(Threads)
   if (THREADS_HAVE_PTHREAD_ARG)
-    set_target_properties(${OpenBLAS_LIBS} PROPERTIES
-      COMPILE_OPTIONS "-pthread"
-      INTERFACE_COMPILE_OPTIONS "-pthread"
-    )
-  endif()
-  if(BUILD_STATIC_LIBS)
-    target_link_libraries(${OpenBLAS_LIBNAME}_static ${CMAKE_THREAD_LIBS_INIT})
-  endif()
-  if(BUILD_SHARED_LIBS)
-    target_link_libraries(${OpenBLAS_LIBNAME}_shared ${CMAKE_THREAD_LIBS_INIT})
+    set_property(TARGET ${OpenBLAS_LIBNAME} PROPERTY COMPILE_OPTIONS "-pthread")
+    set_property(TARGET ${OpenBLAS_LIBNAME} PROPERTY INTERFACE_COMPILE_OPTIONS "-pthread")
   endif()
+  target_link_libraries(${OpenBLAS_LIBNAME} ${CMAKE_THREAD_LIBS_INIT})
 endif()
 
 #if (MSVC OR NOT NOFORTRAN)
@@ -311,116 +217,100 @@ if (NOT NO_CBLAS)
   add_subdirectory(utest)
 endif()
 
-if (NOT NOFORTRAN)
+if (NOT MSVC AND NOT NOFORTRAN)
   # Build test and ctest
   add_subdirectory(test)
   if(NOT NO_CBLAS)
     add_subdirectory(ctest)
   endif()
-  add_subdirectory(lapack-netlib/TESTING)
-  if (CPP_THREAD_SAFETY_TEST OR CPP_THREAD_SAFETY_GEMV)
-    add_subdirectory(cpp_thread_test)
-  endif()
 endif()
 
-set_target_properties(${OpenBLAS_LIBS} PROPERTIES
+set_target_properties(${OpenBLAS_LIBNAME} PROPERTIES
   VERSION ${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}
   SOVERSION ${OpenBLAS_MAJOR_VERSION}
 )
 
 if (BUILD_SHARED_LIBS AND BUILD_RELAPACK)
   if (NOT MSVC)
-    target_link_libraries(${OpenBLAS_LIBNAME}_shared "-Wl,-allow-multiple-definition")
+    target_link_libraries(${OpenBLAS_LIBNAME} "-Wl,-allow-multiple-definition")
   else()
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /FORCE:MULTIPLE")
+    target_link_libraries(${OpenBLAS_LIBNAME} "/FORCE:MULTIPLE")
   endif()
 endif()
 
-if (BUILD_SHARED_LIBS AND NOT ${SYMBOLPREFIX}${SYMBOLSUFFIX} STREQUAL "")
-  if (NOT DEFINED ARCH)
-    set(ARCH_IN "x86_64")
-  else()
-    set(ARCH_IN ${ARCH})
-  endif()
+if (BUILD_SHARED_LIBS AND NOT ${SYMBOLPREFIX}${SYMBOLSUFIX} STREQUAL "")
+if (NOT DEFINED ARCH)
+  set(ARCH_IN "x86_64")
+else()
+  set(ARCH_IN ${ARCH})
+endif()
 
-  if (${CORE} STREQUAL "generic")
-    set(ARCH_IN "GENERIC")
-  endif ()
+if (${CORE} STREQUAL "generic")
+  set(ARCH_IN "GENERIC")
+endif ()
 
-  if (NOT DEFINED EXPRECISION)
-    set(EXPRECISION_IN 0)
-  else()
-    set(EXPRECISION_IN ${EXPRECISION})
-  endif()
+if (NOT DEFINED EXPRECISION)
+  set(EXPRECISION_IN 0)
+else()
+  set(EXPRECISION_IN ${EXPRECISION})
+endif()
 
-  if (NOT DEFINED NO_CBLAS)
-    set(NO_CBLAS_IN 0)
-  else()
-    set(NO_CBLAS_IN ${NO_CBLAS})
-  endif()
+if (NOT DEFINED NO_CBLAS)
+  set(NO_CBLAS_IN 0)
+else()
+  set(NO_CBLAS_IN ${NO_CBLAS})
+endif()
 
-  if (NOT DEFINED NO_LAPACK)
-    set(NO_LAPACK_IN 0)
-  else()
-    set(NO_LAPACK_IN ${NO_LAPACK})
-  endif()
+if (NOT DEFINED NO_LAPACK)
+  set(NO_LAPACK_IN 0)
+else()
+  set(NO_LAPACK_IN ${NO_LAPACK})
+endif()
 
-  if (NOT DEFINED NO_LAPACKE)
-    set(NO_LAPACKE_IN 0)
-  else()
-    set(NO_LAPACKE_IN ${NO_LAPACKE})
-  endif()
+if (NOT DEFINED NO_LAPACKE)
+  set(NO_LAPACKE_IN 0)
+else()
+  set(NO_LAPACKE_IN ${NO_LAPACKE})
+endif()
 
-  if (NOT DEFINED NEED2UNDERSCORES)
-    set(NEED2UNDERSCORES_IN 0)
-  else()
-    set(NEED2UNDERSCORES_IN ${NEED2UNDERSCORES})
-  endif()
+if (NOT DEFINED NEED2UNDERSCORES)
+  set(NEED2UNDERSCORES_IN 0)
+else()
+  set(NEED2UNDERSCORES_IN ${NEED2UNDERSCORES})
+endif()
 
-  if (NOT DEFINED ONLY_CBLAS)
-    set(ONLY_CBLAS_IN 0)
-  else()
-    set(ONLY_CBLAS_IN ${ONLY_CBLAS})
-  endif()
+if (NOT DEFINED ONLY_CBLAS)
+  set(ONLY_CBLAS_IN 0)
+else()
+  set(ONLY_CBLAS_IN ${ONLY_CBLAS})
+endif()
 
-  if (NOT DEFINED BU)
-    set(BU _)
-  endif()
+if (NOT DEFINED BU)
+  set(BU _)
+endif()
 
-  if (NOT ${SYMBOLPREFIX} STREQUAL "")
-    message(STATUS "adding prefix ${SYMBOLPREFIX} to names of exported symbols in ${OpenBLAS_LIBNAME}")
-  endif()
-  if (NOT ${SYMBOLSUFFIX} STREQUAL "")
-    message(STATUS "adding suffix ${SYMBOLSUFFIX} to names of exported symbols in ${OpenBLAS_LIBNAME}")
-  endif()
-
-  add_custom_command(TARGET ${OpenBLAS_LIBNAME}_shared POST_BUILD
-    COMMAND perl  ${PROJECT_SOURCE_DIR}/exports/gensymbol "objcopy" "${ARCH}" "${BU}" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" \"${SYMBOLPREFIX}\" \"${SYMBOLSUFFIX}\" "${BUILD_LAPACK_DEPRECATED}" > ${PROJECT_BINARY_DIR}/objcopy.def
-    COMMAND objcopy -v --redefine-syms ${PROJECT_BINARY_DIR}/objcopy.def  ${PROJECT_BINARY_DIR}/lib/lib${OpenBLAS_LIBNAME}.so
-    COMMENT "renaming symbols"
-    )
+if (NOT ${SYMBOLPREFIX} STREQUAL "")
+message(STATUS "adding prefix ${SYMBOLPREFIX} to names of exported symbols in ${OpenBLAS_LIBNAME}")
+endif()
+if (NOT ${SYMBOLSUFFIX} STREQUAL "")
+message(STATUS "adding suffix ${SYMBOLSUFFIX} to names of exported symbols in ${OpenBLAS_LIBNAME}")
+endif()
+	add_custom_command(TARGET ${OpenBLAS_LIBNAME} POST_BUILD
+  	COMMAND perl  ${PROJECT_SOURCE_DIR}/exports/gensymbol "objcopy" "${ARCH}" "${BU}" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" \"${SYMBOLPREFIX}\" \"${SYMBOLSUFFIX}\" "${BUILD_LAPACK_DEPRECATED}" > ${PROJECT_BINARY_DIR}/objcopy.def
+        COMMAND objcopy -v --redefine-syms ${PROJECT_BINARY_DIR}/objcopy.def  ${PROJECT_BINARY_DIR}/lib/lib${OpenBLAS_LIBNAME}.so
+        COMMENT "renaming symbols"
+        )
 endif()
 
 
 # Install project
 
 # Install libraries
-if(BUILD_SHARED_LIBS AND BUILD_STATIC_LIBS)
-  install(TARGETS ${OpenBLAS_LIBNAME}_shared
-    EXPORT "OpenBLAS${SUFFIX64}Targets"
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )
-  install(TARGETS ${OpenBLAS_LIBNAME}_static
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )
-else()
-  install(TARGETS ${OpenBLAS_LIBS}
-    EXPORT "OpenBLAS${SUFFIX64}Targets"
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )
-endif()
+install(TARGETS ${OpenBLAS_LIBNAME}
+	EXPORT "OpenBLAS${SUFFIX64}Targets"
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )
 
 # Install headers
 set(CMAKE_INSTALL_INCLUDEDIR ${CMAKE_INSTALL_INCLUDEDIR}/openblas${SUFFIX64})
@@ -456,46 +346,32 @@ if(NOT NOFORTRAN)
 endif()
 
 if(NOT NO_CBLAS)
-  message (STATUS "Generating cblas.h in ${CMAKE_INSTALL_INCLUDEDIR}")
-  set(CBLAS_H ${CMAKE_BINARY_DIR}/generated/cblas.h)
-  file(READ ${CMAKE_CURRENT_SOURCE_DIR}/cblas.h CBLAS_H_CONTENTS)
-  string(REPLACE "common" "openblas_config" CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS}")
-  if (NOT ${SYMBOLPREFIX} STREQUAL "")
-    string(REPLACE " cblas" " ${SYMBOLPREFIX}cblas" CBLAS_H_CONTENTS	"${CBLAS_H_CONTENTS_NEW}")
-    string(REPLACE " openblas" " ${SYMBOLPREFIX}openblas" CBLAS_H_CONTENTS_NEW	"${CBLAS_H_CONTENTS}")
-    string (REPLACE " ${SYMBOLPREFIX}openblas_complex" " openblas_complex" CBLAS_H_CONTENTS	"${CBLAS_H_CONTENTS_NEW}")
-    string(REPLACE " goto" " ${SYMBOLPREFIX}goto" CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS}")
-  endif()
-  if (NOT ${SYMBOLSUFFIX} STREQUAL "")
-    string(REGEX REPLACE "(cblas[^ (]*)" "\\1${SYMBOLSUFFIX}" CBLAS_H_CONTENTS	"${CBLAS_H_CONTENTS_NEW}")
-    string(REGEX REPLACE "(openblas[^ (]*)" "\\1${SYMBOLSUFFIX}" CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS}")
-    string(REGEX REPLACE "(openblas_complex[^ ]*)${SYMBOLSUFFIX}" "\\1" CBLAS_H_CONTENTS	"${CBLAS_H_CONTENTS_NEW}")
-    string(REGEX REPLACE "(goto[^ (]*)" "\\1${SYMBOLSUFFIX}" CBLAS_H_CONTENTS_NEW	"${CBLAS_H_CONTENTS}")
-  endif()
-  file(WRITE ${CBLAS_H} "${CBLAS_H_CONTENTS_NEW}")
-  install (FILES ${CBLAS_H} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+	message (STATUS "Generating cblas.h in ${CMAKE_INSTALL_INCLUDEDIR}")
+
+	set(CBLAS_H ${CMAKE_BINARY_DIR}/generated/cblas.h)
+	file(READ ${CMAKE_CURRENT_SOURCE_DIR}/cblas.h CBLAS_H_CONTENTS)
+	string(REPLACE "common" "openblas_config" CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS}")
+	file(WRITE ${CBLAS_H} "${CBLAS_H_CONTENTS_NEW}")
+	install (FILES ${CBLAS_H} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 endif()
 
 if(NOT NO_LAPACKE)
-  message (STATUS "Copying LAPACKE header files to ${CMAKE_INSTALL_INCLUDEDIR}")
-  if(BUILD_STATIC_LIBS)
-    add_dependencies( ${OpenBLAS_LIBNAME}_static genlapacke)
-  endif()
-  if(BUILD_SHARED_LIBS)
-    add_dependencies( ${OpenBLAS_LIBNAME}_shared genlapacke)
-  endif()
-  FILE(GLOB_RECURSE INCLUDE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/lapack-netlib/LAPACKE/*.h")
-  install (FILES ${INCLUDE_FILES} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+	message (STATUS "Copying LAPACKE header files to ${CMAKE_INSTALL_INCLUDEDIR}")
+	add_dependencies( ${OpenBLAS_LIBNAME} genlapacke)
+	FILE(GLOB_RECURSE INCLUDE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/lapack-netlib/LAPACKE/*.h")
+	install (FILES ${INCLUDE_FILES} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 
-  ADD_CUSTOM_TARGET(genlapacke
-  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/lapack-netlib/LAPACKE/include/lapacke_mangling_with_flags.h.in "${CMAKE_BINARY_DIR}/lapacke_mangling.h"
-  )
-  install (FILES ${CMAKE_BINARY_DIR}/lapacke_mangling.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/openblas${SUFFIX64})
+	ADD_CUSTOM_TARGET(genlapacke
+	COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/lapack-netlib/LAPACKE/include/lapacke_mangling_with_flags.h.in "${CMAKE_BINARY_DIR}/lapacke_mangling.h"
+	)
+	install (FILES ${CMAKE_BINARY_DIR}/lapacke_mangling.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/openblas${SUFFIX64})
 endif()
 
-# Install pkg-config files
-configure_file(${PROJECT_SOURCE_DIR}/cmake/openblas.pc.in ${PROJECT_BINARY_DIR}/openblas${SUFFIX64}.pc @ONLY)
-install (FILES ${PROJECT_BINARY_DIR}/openblas${SUFFIX64}.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig/)
+include(FindPkgConfig QUIET)
+if(PKG_CONFIG_FOUND)
+	configure_file(${PROJECT_SOURCE_DIR}/cmake/openblas.pc.in ${PROJECT_BINARY_DIR}/openblas${SUFFIX64}.pc @ONLY)
+	install (FILES ${PROJECT_BINARY_DIR}/openblas${SUFFIX64}.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig/)
+endif()
 
 
 # GNUInstallDirs "DATADIR" wrong here; CMake search path wants "share".
@@ -515,3 +391,4 @@ install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PN}ConfigVersion.cmake
 install(EXPORT "${PN}${SUFFIX64}Targets"
         NAMESPACE "${PN}${SUFFIX64}::"
         DESTINATION ${CMAKECONFIG_INSTALL_DIR})
+

CONTRIBUTORS.md

@@ -171,36 +171,3 @@ In chronological order:
   * [2019-02-01] added missing Blas Level-1,2 (single precision)  simd codes
   * [2019-03-14] power9 dgemm/dtrmm kernel
   * [2019-04-29] power9 sgemm/strmm kernel 
-
-* Jiachen Wang <https://github.com/wjc404>
-  * [2019-07-29] optimize AVX2 DGEMM
-  * [2019-10-20] AVX512 DGEMM kernel (4x8)
-  * [2019-11-06] optimize AVX512 SGEMM
-  * [2019-11-12] AVX512 CGEMM & ZGEMM kernels
-  * [2019-12-23] optimize AVX2 CGEMM and ZGEMM
-  * [2019-12-30] AVX2 CGEMM3M & ZGEMM3M kernels
-  * [2020-01-07] optimize AVX2 SGEMM and STRMM
-
-* Rajalakshmi Srinivasaraghavan <https://github.com/RajalakshmiSR>
-  * [2020-04-15] Half-precision GEMM for bfloat16
-
-* Marius Hillenbrand <https://github.com/mhillenibm>
-  * [2020-05-12] Revise dynamic architecture detection for IBM z
-  * [2020-05-12] Add new sgemm and strmm kernel for IBM z14
-  * [2020-09-07] Fix builds with clang on IBM z, including dynamic architecture support
-
-* Danfeng Zhang <https://github.com/craft-zhang>
-  * [2020-05-20] Improve performance of SGEMM and STRMM on Arm Cortex-A53
-
-* PingTouGe Semiconductor Co., Ltd.
-  * [2020-10] Add RISC-V Vector (0.7.1) support. Optimize BLAS kernels for Xuantie C910
-
-* River Dillon <oss@outerpassage.net>
-  * [2021-07-10] fix compilation with musl libc
-
-* Bine Brank <https://github.com/binebrank>
-  * [2021-10-27] Add vector-length-agnostic DGEMM kernels for Arm SVE
-  * [2021-11-20] Vector-length-agnostic Arm SVE copy routines for DGEMM, DTRMM, DSYMM
-  * [2021-11-12] SVE kernels for SGEMM, STRMM and corresponding SVE copy functions
-  * [2022-01-06] SVE kernels for CGEMM, ZGEMM, CTRMM, ZTRMM and corresponding SVE copy functions
-  * [2022-01-18] SVE kernels and copy functions for TRSM

Changelog.txt

@@ -1,651 +1,45 @@
 OpenBLAS ChangeLog
-====================================================================
-Version 0.3.20
- 20-Feb-2022
-
-general:
- - some code cleanup, with added casts etc.
- - fixed obtaining the cpu count with OpenMP and OMP_PROC_BIND unset
- - fixed pivot index calculation by ?LASWP for negative increments other than one
- - fixed input argument check in LAPACK ? GEQRT2
- - improved the check for a Fortran compiler in CMAKE builds
- - disabled building OpenBLAS' optimized versions of LAPACK complex SPMV,SPR,SYMV,SYR with NO_LAPACK=1
- - fixed building of LAPACK on certain distributed filesystems with parallel gmake
- - fixed building the shared library on MacOS with classic flang
-
-x86_64:
- - fixed cross-compilation with CMAKE for CORE2 target
- - fixed miscompilation of AVX512 code in DYNAMIC_ARCH builds
- - added support for the "incidental" AVX512 hardware in Alder Lake when enabled in BIOS
-
-E2K:
- - add new architecture (Russian Elbrus E2000 family)
-
-SPARC:
- - fix IMIN/IMAX
-
-ARMV8:
- - added SVE-enabled CGEMM and ZGEMM kernels for ARMV8SVE and A64FX
- - added support for Neoverse N2 and V1 cpus
-
-MIPS,MIPS64:
- - fixed autodetection of MSA capability
-
-LOONGARCH64:
- - added an optimized DGEMM kernel
-
-====================================================================
-Version 0.3.19
- 19-Dec-2021
- 
- general:
- - reverted unsafe TRSV/ZRSV optimizations introduced in 0.3.16
- - fixed a potential thread race in the thread buffer reallocation routines
-   that were introduced in 0.3.18
- - fixed miscounting of thread pool size on Linux with OMP_PROC_BIND=TRUE
- - fixed CBLAS interfaces for CSROT/ZSROT and CROTG/ZROTG
- - made automatic library suffix for CMAKE builds with INTERFACE64 available
-   to CBLAS-only builds
-
-x86_64:
- - DYNAMIC_ARCH builds now fall back to the cpu with most similar capabilities
-   when an unknown CPUID is encountered, instead of defaulting to Prescott
- - added cpu detection for Intel Alder Lake
- - added cpu detection for Intel Sapphire Rapids
- - added an optimized SBGEMM kernel for Sapphire Rapids
- - fixed DYNAMIC_ARCH builds on OSX with CMAKE
- - worked around DYNAMIC_ARCH builds made on Sandybridge failing on SkylakeX
- - fixed missing thread initialization for static builds on Windows/MSVC
- - fixed an excessive read in ZSYMV
-
-POWER:
- - added support for POWER10 in big-endian mode
- - added support for building with CMAKE
- - added optimized SGEMM and DGEMM kernels for small matrix sizes
-
-ARMV8:
- - added basic support and cputype detection for Fujitsu A64FX
- - added a generic ARMV8SVE target  
- - added SVE-enabled SGEMM and DGEMM kernels for ARMV8SVE and A64FX
- - added optimized CGEMM and ZGEMM kernels for Cortex A53 and A55 cpus
- - fixed cpuid detection for Apple M1 and improved performance
- - improved compiler flag setting in CMAKE builds
-
-RISCV64:
- - fixed improper initialization in CSCAL/ZSCAL for strided access patterns
-
-MIPS:
- - added a GENERIC target for MIPS32
- - added support for cross-compiling to MIPS32 on x86_64 using CMAKE
-
-MIPS64:
- - fixed misdetection of MSA capability
-
-====================================================================
-Version 0.3.18
- 02-Oct-2021
-
-general:
- - when the build-time number of preconfigured threads is exceeded
-   at runtime (typically by an external program calling BLAS functions
-   from a larger number of threads in parallel), OpenBLAS will now 
-   allocate an auxiliary control structure for up to 512 additional
-   threads instead of aborting
- - added support for Loongson's LoongArch64 cpu architecture
- - fixed building OpenBLAS with CMAKE and -DBUILD_BFLOAT16=ON
- - added support for building OpenBLAS as a CMAKE subproject
- - added support for building for Windows/ARM64 targets with clang
- - improved support for building with the IBM xlf compiler
- - imported Reference-LAPACK PR 625 (out-of-bounds reads in ?LARRV)
- - imported Reference-LAPACK PR 597 for testsuite compatibility with
-   LLVM's libomp
-
-x86_64:
- - added SkylakeX S/DGEMM kernels for small problem sizes (M*N*K<=1000000)
- - added optimized SBGEMM for Intel Cooper Lake
- - reinstated the performance patch for AVX512 SGEMV_T with a proper fix
- - added a workaround for a gcc11 tree-vectorizer bug that caused spurious
-   failures in the test programs for complex BLAS3 when compiling at -O3
-   (the default for cmake "release" builds)
- - added support for runtime cpu count detection under Haiku OS
- - worked around a long-standing miscompilation issue of the Haswell DGEMV_T
-   kernel with gcc that could produce NaN output in some corner cases
-
-POWER:
- - improved performance of DASUM on POWER10
-
-ARMV8:
- - fixed crashes (use of reserved register x18) on Apple M1 under OSX
- - fixed building with gcc releases earlier than 5.1
-
-MIPS:
- - fixed building under BSD
-
-MIPS64:
- - fixed building under BSD
-
-====================================================================
-Version 0.3.17
- 15-Jul-2021
-
-common:
- - reverted the optimization of SGEMV_N/DGEMV_N for small input sizes
-   and consecutive arguments as it led to stack overflows on x86_64
-   with some operating systems (notably OSX and Windows)
- 
- x86_64:
-  - reverted the performance patch for SGEMV_T on AVX512 as it caused
-    wrong results in some applications
-    
- SPARC:
-  - fixed compilation with compilers other than gcc
-====================================================================
-Version 0.3.16
- 11-Jul-2021
-
-common:
- - drastically reduced the stack size requirements for running the LAPACK
-   testsuite (Reference-LAPACK PR 553)
- - fixed spurious test failures in the LAPACK testsuite (Reference-LAPACK
-   PR 564)
- - expressly setting DYNAMIC_ARCH=0 no longer enables dynamic_arch mode 
- - improved performance of xGER, xSPR, xSPR2, xSYR, xSYR2, xTRSV, SGEMV_N 
-   and DGEMV_N, for small input sizes and consecutive arguments
- - improved performance of xGETRF, xPORTF and xPOTRI for small input sizes
-   by disabling multithreading
- - fixed installing with BSD versions of the "install" utility
-
-RISCV:
- - fixed the implementation of xIMIN
- - improved the performance of DSDOT
- - fixed linking of the tests on C910V with current vendor gcc
-
-POWER:
-- fixed SBGEMM computation for some odd value inputs
-- fixed compilation for PPCG4, PPC970, POWER3, POWER4 and POWER5
-
-x86_64:
- - improved performance of SGEMV_N and SGEMV_T for small N on AVX512-capable cpus
- - worked around a miscompilation of ZGEMM/ZTRMM on Sandybridge with old gcc
-   versions
- - fixed compilation with MS Visual Studio versions older than 2017
- - fixed macro name collision with winnt.h from the latest Win10 SDK
- - added cpu type autodetection for Intel Ice Lake SP
- - fixed cpu type autodetection for Intel Tiger Lake
- - added cpu type autodetection for recent Centaur/Zhaoxin models
- - fixed compilation with musl libc
-
-ARM64:
-- fixed compilation with gcc/gfortran on the Apple M1
-- fixed linking of the tests on FreeBSD
-- fixed missing restore of a register in the recently rewritten DNRM2 kernel
-  for ThunderX2 and Neoverse N1 that could cause spurious failures in e.g.
-  DGEEV
-- added compiler optimization flags for the EMAG8180
-- added initial support for Cortex A55
-
-ARM:
-- fixed linking of the tests on FreeBSD
-
-====================================================================
-Version 0.3.15
-  2-May-2021
-
-common:
- - imported improvements and bugfixes from Reference-LAPACK 3.9.1
- - imported LAPACKE interface fixes from Reference-LAPACK PRs 534 + 537
- - fixed a problem in the cpu detection of 0.3.14 that prevented cross-compilation
- - fixed a sequence problem in the generation of softlinks to the library in GMAKE
-
-RISC V:
- - fixed compilation on RISCV (missing entry in getarch)
- - fixed a potential division by zero in CROTG and ZROTG
-
-POWER:
- - fixed LAPACK testsuite failures seen with the NVIDIA HPC compiler
- - improved CGEMM, DGEMM and ZGEMM performance on POWER10
- - added an optimized ZGEMV kernel for POWER10
- - fixed a potential division by zero in CROTG and ZROTG
-
-x86_64:
- - added support for Intel Control-flow Enforcement Technology (CET)
- - reverted the DOMATCOPY_RT code to the generic C version
- - fixed a bug in the AVX512 SGEMM kernel introduced in 0.3.14
- - fixed misapplication of -msse flag to non-SSE cpus in DYNAMIC_ARCH
- - added support for compilation of the benchmarks on older OSX versions
- - fix propagation of the NO_AVX512 option in CMAKE builds
- - fix compilation of the AVX512 SGEMM kernel with clang-cl on Windows
- - fixed compilation of the CTESTs with INTERFACE64=1 (random faults on OSX)
- - corrected the Haswell DROT kernel to require AVX2/FMA3 rather than AVX512
-
-ARM:
- - fixed a potential division by zero in CROTG and ZROTG
- - fixed a potential overflow in IMATCOPY/ZIMATCOPY and the CTESTs
-
-ARM64:
- - fixed spurious reads outside the array in the SGEMM tcopy macro
- - fixed a potential division by zero in CROTG and ZROTG
- - fixed a segmentation fault in DYNAMIC_ARCH builds (reappeared in 0.3.14)
-
-MIPS
- - fixed a potential division by zero in CROTG and ZROTG
- - fixed a potential overflow in IMATCOPY/ZIMATCOPY and the CTESTs
-
-MIPS64:
- - fixed a potential division by zero in CROTG and ZROTG
-
-SPARC:
- - fixed a potential division by zero in CROTG and ZROTG
-
-====================================================================
-Version 0.3.14
- 17-Mar-2021
- 
- common:
-	* Fixed a race condition on thread shutdown in non-OpenMP builds
-	* Fixed custom BUFFERSIZE option getting ignored in gmake builds
-	* Fixed CMAKE compilation of the TRMM kernels for GENERIC platforms
-	* Added CBLAS interfaces for CROTG, ZROTG, CSROT and ZDROT
-	* Improved performance of OMATCOPY_RT across all platforms
-	* Changed perl scripts to use env instead of a hardcoded /usr/bin/perl
-	* Fixed potential misreading of the GCC compiler version in the build scripts
-	* Fixed convergence problems in LAPACK complex GGEV/GGES (Reference-LAPACK #477)
-	* Reduced the stacksize requirements for running the LAPACK testsuite (Reference-LAPACK #335)
-
- RISCV:
- 	* Fixed compilation on RISCV (missing entry in getarch)
-	
- POWER:
- 	* Fixed compilation for DYNAMIC_ARCH with clang and with old gcc versions
-	* Added support for compilation on FreeBSD/ppc64le
- 	* Added optimized POWER10 kernels for SSCAL, DSCAL, CSCAL, ZSCAL
-	* Added optimized POWER10 kernels for SROT, DROT, CDOT, SASUM, DASUM
-	* Improved SSWAP, DSWAP, CSWAP, ZSWAP performance on POWER10
-	* Improved SCOPY and CCOPY performance on POWER10
-	* Improved SGEMM and DGEMM performance on POWER10
-	* Added support for compilation with the NVIDIA HPC compiler
-
- x86_64:
-	* Added an optimized bfloat16 GEMM kernel for Cooperlake
-	* Added CPUID autodetection for Intel Rocket Lake and Tiger Lake cpus
-	* Improved the performance of SASUM,DASUM,SROT,DROT on AMD Ryzen cpus
-	* Added support for compilation with the NAG Fortran compiler
-	* Fixed recognition of the AMD AOCC compiler
-	* Fixed compilation for DYNAMIC_ARCH with clang on Windows
-	* Added support for running the BLAS/CBLAS tests on Windows
-	* Fixed signatures of the tls callback functions for Windows x64
-	* Fixed various issues with fma intrinsics support handling 
-
- ARM:
-	* Added support for embedded Cortex M targets via a new option EMBEDDED
-
- ARMV8:
- 	* Fixed the THUNDERX2T99 and NEOVERSEN1 DNRM2/ZNRM2 kernels for inputs with Inf
-	* Added support for the DYNAMIC_LIST option
-	* Added support for compilation with the NVIDIA HPC compiler
- 	* Added support for compiling with the NAG Fortran compiler
-
-====================================================================
-Version 0.3.13
- 12-Dec-2020
- 
- common:
-	* Added a generic bfloat16 SBGEMV kernel
-	* Fixed a potentially severe memory leak after fork in OpenMP builds
-	  that was introduced in 0.3.12
-	* Added detection of the Fujitsu Fortran compiler
-	* Added detection of the (e)gfortran compiler on OpenBSD
-	* Added support for overriding the default name of the library independently
-	  from symbol suffixing in the gmake builds (already supported in cmake)
-
-RISCV:
-	* Added a RISC V port optimized for C910V
-
-POWER:
-	* Added optimized POWER10 kernels for SAXPY, CAXPY, SDOT, DDOT and DGEMV_N
-	* Improved DGEMM performance on POWER10
-	* Improved STRSM and DTRSM performance on POWER9 and POWER10
-	* Fixed segmemtation faults in DYNAMIC_ARCH builds
- 	* Fixed compilation with the PGI compiler
-
-x86:
-	* Fixed compilation of kernels that require SSE2 intrinsics since 0.3.12
-	
-x86_64:
-	* Added an optimized bfloat16 SBGEMV kernel for SkylakeX and Cooperlake
-	* Improved the performance of SASUM and DASUM kernels through parallelization
-	* Improved the performance of SROT and DROT kernels
-	* Improved the performance of multithreaded xSYRK
-	* Fixed OpenMP builds that use the LLVM Clang compiler together with GNU gfortran
-	  (where linking of both the LLVM libomp and GNU libgomp could lead to lockups or
-	  wrong results)
-	* Fixed miscompilations by old gcc 4.6
-	* Fixed misdetection of AVX2 capability in some Sandybridge cpus
-	* Fixed lockups in builds combining DYNAMIC_ARCH with TARGET=GENERIC on OpenBSD
-
-ARM64:
-	* Fixed segmemtation faults in DYNAMIC_ARCH builds
-
-MIPS:
-	* Improved kernels for Loongson 3R3 ("3A") and 3R4 ("3B") models, including MSA
-	* Fixed bugs in the MSA kernels for CGEMM, CTRMM, CGEMV and ZGEMV
-	* Added handling of zero increments in the MSA kernels for SSWAP and DSWAP
-	* Added DYNAMIC_ARCH support for MIPS64 (currently Loongson3R3/3R4 only)
-
-SPARC:
-	* Fixed building 32 and 64 bit SPARC kernels with the SolarisStudio compilers
-
-====================================================================
-Version 0.3.12
- 24-Oct-2020
-
-common:
-	* Fixed missing BLAS/LAPACK functions (inadvertently dropped during
-	  the build system restructuring)
-	* Fixed argument conversion macro in LAPACKE_zgesvdq (LAPACK #458)
-
-POWER:
-	* Added optimized SCOPY/CCOPY kernels for POWER10
-	* Increased and unified the default size of the GEMM BUFFER
-	* Fixed building for POWER10 in DYNAMIC_ARCH mode
-	* POWER10 compatibility test now checks binutils version as well
-	* Cleaned up compiler warnings
-
-x86_64:
-	* corrected compiler version checks for AVX2 compatibility
-	* added compiler option -mavx2 for building with flang
-	* fixed direct SGEMM pathway for small matrix sizes (broken by
-	  the code refactoring in 0.3.11)
-	* fixed unhandled partial register clobbers in several kernels
-	  for AXPY,DOT,GEMV_N and GEMV_T flagged by gcc10 tree-vectorizer
-
-ARMV8:
-	* improved Apple Vortex support to include cross-compiling
-
-====================================================================
-Version 0.3.11
- 17-Oct-2020
-
-common:
- 	* API change:
-	  the newly added BFLOAT16 functions were renamed to use the
-	  letter "B" instead of "H" to avoid potential confusion with
-	  the IEEE "half precision float" type, i.e. the 0.3.10
-	  SHGEMM is now SBGEMM and the corresponding build option
-	  was changed from "BUILD_HALF" to "BUILD_BFLOAT16".
-	* Reduced the default BLAS3_MEM_ALLOC_THRESHOLD (used as an upper
-	  limit for placing temporary arrays on the stack) to be compatible
-	  with a stack size of 1mb (as imposed by the JAVA runtime library) 
-	* Added mixed-precision dot function SBDOT and utility functions
-	  shstobf16, shdtobf16, sbf16tos and dbf16tod to convert between
-	  single or double precision float arrays and bfloat16 arrays
-	* Fixed prototypes of LAPACK_?ggsvp and LAPACK_?ggsvd functions
-	  in lapack.h
-	* Fixed underflow and rounding errors in LAPACK SLANV2 and DLANV2
-	  (causing miscalculations in e.g. SHSEQR/DHSEQR, LAPACK issue #263)
-	* Fixed workspace calculation in LAPACK ?GELQ (LAPACK issue #415)
-	* Fixed several bugs in the LAPACK testsuite
-	* Improved performance of TRMM and TRSM for certain problem sizes
-	* Fixed infinite recursions and workspace miscalculations in ReLAPACK
-	* CMAKE builds no longer require pkg-config for creating the .pc file
-	* Makefile builds no longer misread NO_CBLAS=0 or NO_LAPACK=0 as 
-	  enabling these options
-	* Fixed detection of gfortran when invoked through an mpi wrapper
-	* Improve thread reinitialization performance with OpenMP after a fork 
-	* Added support for building only the subset of the library required
-	  for a particular precision by specifying BUILD_SINGLE, BUILD_DOUBLE
-	* Optional function name prefixes and suffixes are now correctly
-	  reflected in the generated cblas.h
-	* Added CMAKE build support for the LAPACK and multithreading tests
-
-POWER:
-	* Added optimized support for POWER10
-	* Added support for compiling for POWER8 in 32bit mode
-	* Added support for compilation with LLVM/clang
-	* Added support for compilation with NVIDIA/PGI compilers
-	* Fixed building on big-endian POWER8
-	* Fixed miscompilation of ZDOTC by gcc10
-	* Fixed alignment errors in the POWER8 SAXPY kernel
-	* Improved CPU detection on AIX
-	* Supported building with older compilers on POWER9
-
-x86_64:
-	* Added support for Intel Cooperlake
-	* Added autodetection of AMD Renoir/Matisse/Zen3 cpus
-	* Added autodetection of Intel Comet Lake cpus
-	* Reimplemented ?sum, ?dot and daxpy using universal intrinsics
-	* Reset the fpu state before using the fpu on Windows as a workaround
-	  for a problem introduced in Windows 10 build 19041 (a.k.a. SDK 2004)
-	* Fixed potentially undefined behaviour in the dot and gemv_t kernels
-	* Fixed a potential segmentation fault in DYNAMIC_ARCH builds
-	* Fixed building for ZEN with PGI/NVIDIA and AMD AOCC compilers
-	
-ARMV7:
-	* Fixed cpu detection on BSD-like systems
-
-ARMV8:
-	* Added preliminary support for Apple Vortex cpus
-	* Added support for the Cavium ThunderX3T110 cpu
-	* Fixed cpu detection on BSD-like systems
-	* Fixed compilation in -std=C18 mode
-
-IBM Z:
-	* Added support for compiling with the clang compiler
-	* Improved GEMM performance on Z14
-
-====================================================================
-Version 0.3.10
- 14-Jun-2020
-
-common:
-	* Improved thread locking behaviour in blas_server and parallel getrf                         
-	* Imported bugfix 394 from LAPACK (spurious reference to "XERBL"
-	  due to overlong lines)
-	* Imported bugfix 403 from LAPACK (compile option "recursive" required
-	  for correctness with Intel and PGI)
-	* Imported bugfix 408 from LAPACK (wrong scaling in ZHEEQUB)
-	* Imported bugfix 411 from LAPACK (infinite loop in LARGV/LARTG/LARTGP)
-	* Fixed mismatches between BUFFERSIZE and GEMM_UNROLL parameters that
-	  could lead to crashes at large matrix sizes  
-	* Restored internal soname in dynamic libraries on FreeBSD and Dragonfly 
-	* Added API (openblas_setaffinity) to set the thread affinity on Linux
-	* Added initial infrastructure for half-precision floating point 
-	  (bfloat16) support with a generic implementation of SHGEMM     
-	* Added CMAKE build system support for building the cblas_Xgemm3m
-	  functions
-	* Fixed CMAKE support for building in a path with embedded spaces
-	* Fixed CMAKE (non)handling of NO_EXPRECISION and MAX_STACK_ALLOC
-	* Fixed GCC version detection in the Makefiles
-	* Allowed overriding the names of AR, AS and LD in Makefile builds
-
-POWER:
-	* Fixed big-endian POWER8 ELFv2 builds on FreeBSD
-	* Fixed GCC version checks and DYNAMIC_ARCH builds on POWER9
-	* Fixed CMAKE build support for POWER9
-	* fixed a potential race condition in the thread buffer allocation
-	* Worked around LAPACK test failures on PPC G4
-
-MIPS:
-	* Fixed a potential race condition in the thread buffer allocation
-	* Added support for MIPS 24K/24KE family based on P5600 kernels
-
-MIPS64:
-	* fixed a potential race condition in the thread buffer allocation
-	* Added TARGET=GENERIC
-
-ARMV7:
-	* Fixed a race condition in the thread buffer allocation
-
-ARMV8:
-	* Fixed a race condition in the thread buffer allocation
-	* Fixed zero initialisation in the assembly for SGEMM and DGEMM BETA
-	* Improved performance of the ThunderX2 DAXPY kernel
-	* Added an optimized SGEMM kernel for Cortex A53    
-	* Fixed Makefile support for INTERFACE64 (8-byte integer)
-
-x86_64:
-	* Fixed a syntax error in the CMAKE setup for SkylakeX
-	* Improved performance of STRSM on Haswell, SkylakeX and Ryzen
-	* Improved SGEMM performance on SGEMM for workloads with ldc a
-	  multiple of 1024
-	* Improved DGEMM performance on Skylake X
-	* Fixed unwanted AVX512-dependency of SGEMM in DYNAMIC_ARCH
-	  builds created on SkylakeX
-	* Removed data alignment requirement in the SSE2 copy kernels
-	  that could cause spurious crashes
-	* Added a workaround for an optimizer bug in AppleClang 11.0.3
-	* Fixed LAPACK test failures due to wrong options for Intel Fortran
-	* Fixed compilation and LAPACK test results with recent Flang
-	  and AMD AOCC
-	* Fixed DYNAMIC_ARCH builds with CMAKE on OS X
-	* Fixed missing exports of cblas_i?amin, cblas_i?min, cblas_i?max,
-	  cblas_?sum, cblas_?gemm3m in the shared library on OS 
-	* Fixed reporting of cpu name in DYNAMIC_ARCH builds (would sometimes
-	  show the name of an older generation chip supported by the same kernels)
-
-IBM Z:
-	* Improved performance of SGEMM/STRMM and DGEMM/DTRMM on Z14
-
-====================================================================
-Version 0.3.9
- 1-Mar-2020
- 
- common:
- 	* Fixed a miscompilation of the GETRF functions with CMAKE
-	* Imported bugfix 390 from LAPACK (missing NaN propagation in xCOMBSSQ)
-	* The size of the memory buffer used for splitting GEMM tasks across
-          multiple threads can now be configured in the build system.
-
-POWER:
-	* Fixed several compilation problems related to endianness
-	  and ELF version on POWER8 and POWER9
-	* Fixed use of the absolute value IAMIN/IAMAX instead of IMIN/IMAX
-	* Fixed a race condition in the level3 blas code
-	
-MIPS64:
-	* Fixed use of the absoltute value IAMIN/IAMAX instead of IMIN/IMAX
-	
-ARMV7:
-	* Fixed a race condition in the level3 blas code
-	* Fixed compilation on Android
-ARMV8:
-	* Added support for Ampere EMAG8180
-	* Added support for Neoverse N1
-	* Improved performance of the blas_lock function
-	* Fixed a race condition in the level3 blas code
-	* Fixed a performance regression on TSV110-based servers
-
-x86_64:
-	* Fixed a long-standing error with undeclared register overwrites
-	  in the DSCAL microkernel for HASWELL,SKYLAKEX and ZEN
-	* Fixed a long-standing bug in the SSE implementation of IAMAX
-	* Fixed a CMAKE build failure with DYNAMIC_ARCH
-	* Fixed cpu autodetection of Goldmont+, Cannon Lake and Ice Lake
-	* Fixed a compilation failure on OSX with compiler name containing dash
-	* Fixed compilation with MinGW on SkylakeX
-	* Improved speed of the AVX512 GEMM3M kernel on SkylakeX
-	* Added an AVX512 STRMM kernel for SkylakeX
-	* Improved GEMM performance on Haswell and Zen
-
-zarch:
-	* fixed compilation of the DYNAMIC_ARCH code
-	
-====================================================================
-Version 0.3.8
- 9-Feb-2020
-
-common: 
-`	* LAPACK has been updated to 3.9.0 (plus patches up to 
-	  January 2nd, 2020)
-	* CMAKE support has been improved in several areas including
-	  cross-compilation
-	* a thread race condition in the GEMM3M kernels was resolved
-	* the "generic" (plain C) gemm beta kernel used by many targets
-	  has been sped up
-	* an optimized version of the LAPACK trtrs functions has been added
-	* an incompatibilty between the LAPACK tests and the OpenBLAS
-	  implementation of XERBLA was resolved, removing the numerous
-	  warnings about wrong error exits in the former 
-	* support for NetBSD has been added
-	* support for compilation with g95 and non-GNU versions of ld
-	  has been improved
-	* support for compilation with (upcoming) gcc 10 has been added
-
-POWER:
-	* worked around miscompilation of several POWER8 and POWER9 
-	  kernels by older versions of gcc
-	* added support for big-endian POWER8 and for compilation on AIX
-	* corrected bugs in the big-endian support for PPC440 and PPC970
-	* DYNAMIC_ARCH support is now available in CMAKE builds as well
-
-ARMV8:
-	* performance of DGEMM_BETA and SGEMM_NCOPY has been improved
-	* compilation for 32bit works again 
-	* performance of the RPCC function has been improved
-	* improved performance on small systems
-	* DYNAMIC_ARCH support is now available in CMAKE builds as well
-	* cross-compilation from OSX to IOS was simplified
- 
-x86_64:
-	* a new AVX512 DGEMM kernel was added and the AVX512 SGEMM kernel
-	  was significantly improved
-	* optimized AVX512 kernels for CGEMM and ZGEMM have been added
-	* AVX2 kernels for STRMM, SGEMM, and CGEMM have been significantly
-	  sped up and optimized CGEMM3M and ZGEMM3M kernels have been added 
-	* added support for QEMU virtual cpus
-	* a compilation problem with PGI and SUN compilers was fixed
-	* Intel "Goldmont plus" is now autodetected
-	* a potential crash on program exit on MS Windows has been fixed
-
-x86:
-	* an unwanted case sensitivity in the implementation of LSAME
-  	  on older 32bit AMD cpus was fixed
-
-zarch:
-	* Z15 is now supported as Z14
-	* DYNAMIC_ARCH is now available on ZARCH as well
-
 ====================================================================
 Version 0.3.7
 11-Aug 2019
 
 common:
-  * having the gmake special variables TARGET_ARCH or TARGET_MACH
-    defined no longer causes build failures in ctest or utest
-  * defining NO_AFFINITY or USE_TLS to 0 in gmake builds no longer
-    has the same effect as setting them to 1
-  * a new test program was added to allow checking the library for
-    thread safety
-  * a new option USE_LOCKING was added to ensure thread safety when
-    OpenBLAS itself is built without multithreading but will be 
-    called from multiple threads.
-  * a build failure on Linux with glibc versions earlier than 2.5
-    was fixed
-  * a runtime error with CPU enumeration (and NO_AFFINITY not set)
-    on glibc 2.6 was fixed
-  * NO_AFFINITY was added to the CMAKE options (and defaults to being
-    active on Linux, as in the gmake builds)
+        * having the gmake special variables TARGET_ARCH or TARGET_MACH
+          defined no longer causes build failures in ctest or utest
+        * defining NO_AFFINITY or USE_TLS to 0 in gmake builds no longer
+          has the same effect as setting them to 1
+        * a new test program was added to allow checking the library for
+          thread safety
+        * a new option USE_LOCKING was added to ensure thread safety when
+          OpenBLAS itself is built without multithreading but will be 
+          called from multiple threads.
+        * a build failure on Linux with glibc versions earlier than 2.5
+          was fixed
+        * a runtime error with CPU enumeration (and NO_AFFINITY not set)
+          on glibc 2.6 was fixed
+        * NO_AFFINITY was added to the CMAKE options (and defaults to being
+          active on Linux, as in the gmake builds)
 
 x86_64:
-  * the build-time logic for detection of AVX512 availability in
-    the processor and compiler was fixed
-  * gmake builds on OSX now set the internal name of the library to 
-    libopenblas.0.dylib (consistent with CMAKE)
-  * the Haswell DGEMM kernel received a significant speedup through
-    improved prefetch and load instructions
-  * performance of DGEMM, DTRMM, DTRSM and ZDOT on Zen/Zen2 was markedly
-    increased by avoiding vpermpd instructions
-  * the SKYLAKEX (AVX512) DGEMM helper functions have now been disabled
-    to fix remaining errors in DGEMM, DSYMM and DTRMM
+        * the build-time logic for detection of AVX512 availability in
+          the processor and compiler was fixed
+        * gmake builds on OSX now set the internal name of the library to 
+          libopenblas.0.dylib (consistent with CMAKE)
+        * the Haswell DGEMM kernel received a significant speedup through
+          improved prefetch and load instructions
+        * performance of DGEMM, DTRMM, DTRSM and ZDOT on Zen/Zen2 was markedly
+          increased by avoiding vpermpd instructions
+        * the SKYLAKEX (AVX512) DGEMM helper functions have now been disabled
+          to fix remaining errors in DGEMM, DSYMM and DTRMM
 
-POWER:
-  * added support for building on FreeBSD/powerpc64 and FreeBSD/ppc970
-  * added optimized kernels for POWER9 SGEMM and STRMM
+## POWER:
+        * added support for building on FreeBSD/powerpc64 and FreeBSD/ppc970
+        * added optimized kernels for POWER9 SGEMM and STRMM
 
-ARMV7:
-  * fixed the softfp implementations of xAMAX and IxAMAX
-  * removed the predefined -march= flags on both ARMV5 and ARMV6 as
-    they were appropriate for only a subset of platforms
+## ARMV7:
+        * fixed the softfp implementations of xAMAX and IxAMAX
+        * removed the predefined -march= flags on both ARMV5 and ARMV6 as
+          they were appropriate for only a subset of platforms
 
 ====================================================================
 Version 0.3.6

Jenkinsfile

@@ -1,9 +0,0 @@
-node {
-        stage('Checkout') {
-            checkout
-        }
-
-        stage('Build') {
-            sh("make")
-        }
-}

Makefile

@@ -32,7 +32,7 @@ export NOFORTRAN
 export NO_LAPACK
 endif
 
-LAPACK_NOOPT := $(filter-out -O0 -O1 -O2 -O3 -Ofast -O -Og -Os,$(LAPACK_FFLAGS))
+LAPACK_NOOPT := $(filter-out -O0 -O1 -O2 -O3 -Ofast,$(LAPACK_FFLAGS))
 
 SUBDIRS_ALL = $(SUBDIRS) test ctest utest exports benchmark ../laswp ../bench cpp_thread_test
 
@@ -56,27 +56,10 @@ ifneq ($(INTERFACE64), 0)
 	@echo "  Use 64 bits int    (equivalent to \"-i8\" in Fortran)      "
 endif
 endif
-	@$(CC) --version > /dev/null 2>&1;\
-	if [ $$? -eq 0 ]; then \
-	   cverinfo=`$(CC) --version | sed -n '1p'`; \
-	   if [ -z "$${cverinfo}" ]; then \
-	   cverinfo=`$(CC) --version | sed -n '2p'`; \
-	   fi; \
-	   echo "  C compiler       ... $(C_COMPILER)  (cmd & version : $${cverinfo})";\
-	else  \
-	   echo "  C compiler       ... $(C_COMPILER)  (command line : $(CC))";\
-	fi
+
+	@echo "  C compiler       ... $(C_COMPILER)  (command line : $(CC))"
 ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
-	@$(FC) --version > /dev/null 2>&1;\
-	if [ $$? -eq 0 ]; then \
-	   fverinfo=`$(FC) --version | sed -n '1p'`; \
-	   if [ -z "$${fverinfo}" ]; then \
-	   fverinfo=`$(FC) --version | sed -n '2p'`; \
-	   fi; \
-	   echo "  Fortran compiler ... $(F_COMPILER)  (cmd & version : $${fverinfo})";\
-	else \
-	   echo "  Fortran compiler ... $(F_COMPILER)  (command line : $(FC))";\
-	fi
+	@echo "  Fortran compiler ... $(F_COMPILER)  (command line : $(FC))"
 endif
 ifneq ($(OSNAME), AIX)
 	@echo -n "  Library Name     ... $(LIBNAME)"
@@ -85,13 +68,9 @@ else
 endif
 
 ifndef SMP
-	@echo " (Single-threading)  "
+	@echo " (Single threaded)  "
 else
-	@echo " (Multi-threading; Max num-threads is $(NUM_THREADS))"
-endif
-
-ifeq ($(DYNAMIC_ARCH), 1)
-	@echo "  Supporting multiple $(ARCH) cpu models with minimum requirement for the common code being $(CORE)"
+	@echo " (Multi threaded; Max num-threads is $(NUM_THREADS))"
 endif
 
 ifeq ($(USE_OPENMP), 1)
@@ -118,12 +97,12 @@ endif
 
 shared :
 ifneq ($(NO_SHARED), 1)
-ifeq ($(OSNAME), $(filter $(OSNAME),Linux SunOS Android Haiku FreeBSD DragonFly))
+ifeq ($(OSNAME), $(filter $(OSNAME),Linux SunOS Android Haiku))
 	@$(MAKE) -C exports so
 	@ln -fs $(LIBSONAME) $(LIBPREFIX).so
 	@ln -fs $(LIBSONAME) $(LIBPREFIX).so.$(MAJOR_VERSION)
 endif
-ifeq ($(OSNAME), $(filter $(OSNAME),OpenBSD NetBSD))
+ifeq ($(OSNAME), $(filter $(OSNAME),FreeBSD OpenBSD NetBSD DragonFly))
 	@$(MAKE) -C exports so
 	@ln -fs $(LIBSONAME) $(LIBPREFIX).so
 endif
@@ -147,7 +126,7 @@ ifndef NO_FBLAS
 	$(MAKE) -C test all
 endif
 	$(MAKE) -C utest all
-ifneq ($(NO_CBLAS), 1)
+ifndef NO_CBLAS
 	$(MAKE) -C ctest all
 ifeq ($(CPP_THREAD_SAFETY_TEST), 1)
 	$(MAKE) -C cpp_thread_test all
@@ -167,6 +146,7 @@ ifeq ($(NO_SHARED), 1)
 	$(error OpenBLAS: neither static nor shared are enabled.)
 endif
 endif
+	@-ln -fs $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
 	@for d in $(SUBDIRS) ; \
 	do if test -d $$d; then \
 	  $(MAKE) -C $$d $(@F) || exit 1 ; \
@@ -195,7 +175,6 @@ endif
 ifdef USE_THREAD
 	@echo USE_THREAD=$(USE_THREAD) >>  Makefile.conf_last
 endif
-	@-ln -fs $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
 	@touch lib.grd
 
 prof : prof_blas prof_lapack
@@ -250,7 +229,7 @@ ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
 	@$(MAKE) -C $(NETLIB_LAPACK_DIR) lapacklib
 	@$(MAKE) -C $(NETLIB_LAPACK_DIR) tmglib
 endif
-ifneq ($(NO_LAPACKE), 1)
+ifndef NO_LAPACKE
 	@$(MAKE) -C $(NETLIB_LAPACK_DIR) lapackelib
 endif
 endif
@@ -268,26 +247,21 @@ prof_lapack : lapack_prebuild
 
 lapack_prebuild :
 ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
-	-@echo "FC          = $(FC)" > $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "override FFLAGS      = $(LAPACK_FFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "FFLAGS_DRV  = $(LAPACK_FFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "FORTRAN     = $(FC)" > $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "OPTS        = $(LAPACK_FFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "POPTS       = $(LAPACK_FPFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "FFLAGS_NOOPT       = -O0 $(LAPACK_NOOPT)" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "NOOPT       = -O0 $(LAPACK_NOOPT)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "PNOOPT      = $(LAPACK_FPFLAGS) -O0" >> $(NETLIB_LAPACK_DIR)/make.inc
-ifeq ($(C_COMPILER)$(F_COMPILER)$(USE_OPENMP), CLANGGFORTRAN1)
-	-@echo "LDFLAGS     = $(FFLAGS) $(EXTRALIB) -lomp" >> $(NETLIB_LAPACK_DIR)/make.inc
-else
-	-@echo "LDFLAGS     = $(FFLAGS) $(EXTRALIB)" >> $(NETLIB_LAPACK_DIR)/make.inc
-endif
+	-@echo "LOADOPTS    = $(FFLAGS) $(EXTRALIB)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "CC          = $(CC)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "override CFLAGS      = $(LAPACK_CFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "AR          = $(AR)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "ARFLAGS     = $(ARFLAGS) -ru" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "override ARCH        = $(AR)" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "ARCHFLAGS   = $(ARFLAGS) -ru" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "RANLIB      = $(RANLIB)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "LAPACKLIB   = ../../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "TMGLIB      = ../../../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "LAPACKLIB   = ../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "TMGLIB      = ../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "BLASLIB     = ../../../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "LAPACKELIB  = ../../../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "LAPACKELIB  = ../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "LAPACKLIB_P = ../$(LIBNAME_P)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "SUFFIX      = $(SUFFIX)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "PSUFFIX     = $(PSUFFIX)" >> $(NETLIB_LAPACK_DIR)/make.inc
@@ -311,18 +285,6 @@ else
 endif
 ifeq ($(BUILD_LAPACK_DEPRECATED), 1)
 	-@echo "BUILD_DEPRECATED      = 1" >> $(NETLIB_LAPACK_DIR)/make.inc
-endif
-ifeq ($(BUILD_SINGLE), 1)
-	-@echo "BUILD_SINGLE      = 1" >> $(NETLIB_LAPACK_DIR)/make.inc
-endif
-ifeq ($(BUILD_DOUBLE), 1)
-	-@echo "BUILD_DOUBLE      = 1" >> $(NETLIB_LAPACK_DIR)/make.inc
-endif
-ifeq ($(BUILD_COMPLEX), 1)
-	-@echo "BUILD_COMPLEX      = 1" >> $(NETLIB_LAPACK_DIR)/make.inc
-endif
-ifeq ($(BUILD_COMPLEX16), 1)
-	-@echo "BUILD_COMPLEX16      = 1" >> $(NETLIB_LAPACK_DIR)/make.inc
 endif
 	-@echo "LAPACKE_WITH_TMG      = 1" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@cat  make.inc >> $(NETLIB_LAPACK_DIR)/make.inc
@@ -355,9 +317,9 @@ lapack-test :
 	$(MAKE) -j 1 -C $(NETLIB_LAPACK_DIR)/TESTING/EIG xeigtstc  xeigtstd  xeigtsts  xeigtstz 
 	$(MAKE) -j 1 -C $(NETLIB_LAPACK_DIR)/TESTING/LIN xlintstc  xlintstd  xlintstds  xlintstrfd  xlintstrfz  xlintsts  xlintstz  xlintstzc xlintstrfs xlintstrfc
 ifneq ($(CROSS), 1)
-	( cd $(NETLIB_LAPACK_DIR)/INSTALL; $(MAKE) all; ./testlsame; ./testslamch; ./testdlamch; \
+	( cd $(NETLIB_LAPACK_DIR)/INSTALL; make all; ./testlsame; ./testslamch; ./testdlamch; \
         ./testsecond; ./testdsecnd; ./testieee; ./testversion )
-	(cd $(NETLIB_LAPACK_DIR); ./lapack_testing.py -r -b TESTING)
+	(cd $(NETLIB_LAPACK_DIR); ./lapack_testing.py -r )
 endif
 
 lapack-runtest:
@@ -387,12 +349,11 @@ clean ::
 	@$(MAKE) -C kernel clean
 #endif
 	@$(MAKE) -C reference clean
-	@rm -f *.$(LIBSUFFIX) *.so *~ *.exe getarch getarch_2nd *.dll *.lib *.$(SUFFIX) *.dwf $(LIBPREFIX).$(LIBSUFFIX) $(LIBPREFIX)_p.$(LIBSUFFIX) $(LIBPREFIX).so.$(MAJOR_VERSION) *.lnk myconfig.h *.so.renamed *.a.renamed *.so.0
+	@rm -f *.$(LIBSUFFIX) *.so *~ *.exe getarch getarch_2nd *.dll *.lib *.$(SUFFIX) *.dwf $(LIBPREFIX).$(LIBSUFFIX) $(LIBPREFIX)_p.$(LIBSUFFIX) $(LIBPREFIX).so.$(MAJOR_VERSION) *.lnk myconfig.h
 ifeq ($(OSNAME), Darwin)
 	@rm -rf getarch.dSYM getarch_2nd.dSYM
 endif
 	@rm -f Makefile.conf config.h Makefile_kernel.conf config_kernel.h st* *.dylib
-	@rm -f cblas.tmp cblas.tmp2
 	@touch $(NETLIB_LAPACK_DIR)/make.inc
 	@$(MAKE) -C $(NETLIB_LAPACK_DIR) clean
 	@rm -f $(NETLIB_LAPACK_DIR)/make.inc $(NETLIB_LAPACK_DIR)/lapacke/include/lapacke_mangling.h

Makefile.arm

@@ -1,7 +1,7 @@
 ifeq ($(CORE), $(filter $(CORE),ARMV7 CORTEXA9 CORTEXA15))
 ifeq ($(OSNAME), Android)
-CCOMMON_OPT += -mfpu=neon -march=armv7-a
-FCOMMON_OPT += -mfpu=neon -march=armv7-a
+CCOMMON_OPT += -mfpu=neon
+FCOMMON_OPT += -mfpu=neon
 else
 CCOMMON_OPT += -mfpu=vfpv3 -march=armv7-a
 FCOMMON_OPT += -mfpu=vfpv3 -march=armv7-a
@@ -12,8 +12,3 @@ ifeq ($(CORE), ARMV6)
 CCOMMON_OPT += -mfpu=vfp
 FCOMMON_OPT += -mfpu=vfp
 endif
-
-ifdef HAVE_NEON
-CCOMMON_OPT += -mfpu=neon
-FCOMMON_OPT += -mfpu=neon
-endif

Makefile.arm64

@@ -1,234 +1,45 @@
-ifneq ($(C_COMPILER), PGI)
-
-ifeq ($(C_COMPILER), CLANG)
-ISCLANG=1
-endif
-ifneq (1, $(filter 1,$(GCCVERSIONGT4) $(ISCLANG)))
-CCOMMON_OPT += -march=armv8-a
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8-a
-endif
-
-
-else 
-
 
 ifeq ($(CORE), ARMV8)
 CCOMMON_OPT += -march=armv8-a
-ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8-a
 endif
-endif
-
-ifeq ($(CORE), ARMV8SVE)
-CCOMMON_OPT += -march=armv8-a+sve
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8-a+sve
-endif
-endif
 
 ifeq ($(CORE), CORTEXA53)
 CCOMMON_OPT += -march=armv8-a -mtune=cortex-a53
-ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8-a -mtune=cortex-a53
 endif
-endif
 
 ifeq ($(CORE), CORTEXA57)
 CCOMMON_OPT += -march=armv8-a -mtune=cortex-a57
-ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8-a -mtune=cortex-a57
 endif
-endif
 
 ifeq ($(CORE), CORTEXA72)
 CCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
-ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
 endif
-endif
 
 ifeq ($(CORE), CORTEXA73)
 CCOMMON_OPT += -march=armv8-a -mtune=cortex-a73
-ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8-a -mtune=cortex-a73
 endif
-endif
-
-# Use a72 tunings because Neoverse-N1 is only available
-# in GCC>=9
-ifeq ($(CORE), NEOVERSEN1)
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ7) $(ISCLANG)))
-ifeq ($(GCCVERSIONGTEQ9), 1)
-CCOMMON_OPT += -march=armv8.2-a -mtune=neoverse-n1
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.2-a -mtune=neoverse-n1
-endif
-else
-CCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
-endif
-endif
-else
-CCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
-endif
-endif
-endif
-
-# Use a72 tunings because Neoverse-V1 is only available
-# in GCC>=9.4
-ifeq ($(CORE), NEOVERSEV1)
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ7) $(ISCLANG)))
-ifeq ($(GCCVERSIONGTEQ9), 1)
-ifeq (1, $(filter 1,$(GCCMINORVERSIONGTEQ4) $(GCCVERSIONGTEQ10)))
-CCOMMON_OPT += -march=armv8.4-a -mtune=neoverse-v1
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.4-a -mtune=neoverse-v1
-endif
-else
-CCOMMON_OPT += -march=armv8.4-a -mtune=native
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.4-a -mtune=native
-endif
-endif
-else
-CCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
-endif
-endif
-else
-CCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
-endif
-endif
-endif
-
-# Use a72 tunings because Neoverse-N2 is only available
-# in GCC>=9.4
-ifeq ($(CORE), NEOVERSEN2)
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ7) $(ISCLANG)))
-ifeq ($(GCCVERSIONGTEQ9), 1)
-ifeq (1, $(filter 1,$(GCCMINORVERSIONGTEQ4) $(GCCVERSIONGTEQ10)))
-CCOMMON_OPT += -march=armv8.5-a -mtune=neoverse-n2
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.5-a -mtune=neoverse-n2
-endif
-else
-CCOMMON_OPT += -march=armv8.5-a -mtune=native
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.5-a -mtune=native
-endif
-endif
-else
-CCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
-endif
-endif
-else
-CCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
-endif
-endif
-endif
-
-# Use a53 tunings because a55 is only available in GCC>=8.1
-ifeq ($(CORE), CORTEXA55)
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ7) $(ISCLANG)))
-ifeq ($(GCCVERSIONGTEQ8), 1)
-CCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a55
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a55
-endif
-else
-CCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a53
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a53
-endif
-endif
-else
-CCOMMON_OPT += -march=armv8-a -mtune=cortex-a53
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8-a -mtune=cortex-a53
-endif
-endif
-endif
 
 ifeq ($(CORE), THUNDERX)
 CCOMMON_OPT += -march=armv8-a -mtune=thunderx
-ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8-a -mtune=thunderx
 endif
-endif
 
 ifeq ($(CORE), FALKOR)
 CCOMMON_OPT += -march=armv8-a -mtune=falkor
-ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8-a -mtune=falkor
 endif
-endif
 
 ifeq ($(CORE), THUNDERX2T99)
 CCOMMON_OPT += -march=armv8.1-a -mtune=thunderx2t99
-ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8.1-a -mtune=thunderx2t99
 endif
-endif
 
-ifeq ($(CORE), THUNDERX3T110)
-ifeq ($(GCCVERSIONGTEQ10), 1)
-CCOMMON_OPT += -march=armv8.3-a -mtune=thunderx3t110
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.3-a -mtune=thunderx3t110
-endif
-else
-CCOMMON_OPT += -march=armv8.1-a -mtune=thunderx2t99
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.1-a -mtune=thunderx2t99
-endif
-endif
-endif
-
-ifeq ($(CORE), VORTEX)
-CCOMMON_OPT += -march=armv8.3-a
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.3-a
-endif
-endif
-
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ9) $(ISCLANG)))
 ifeq ($(CORE), TSV110)
 CCOMMON_OPT += -march=armv8.2-a -mtune=tsv110
-ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8.2-a -mtune=tsv110
 endif
-endif
-endif
-
-ifeq ($(GCCVERSIONGTEQ9), 1)
-ifeq ($(CORE), EMAG8180)
-CCOMMON_OPT += -march=armv8-a -mtune=emag
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8-a -mtune=emag
-endif
-endif
-endif
-
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ11) $(ISCLANG)))
-ifeq ($(CORE), A64FX)
-CCOMMON_OPT += -march=armv8.2-a+sve -mtune=a64fx
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.2-a+sve -mtune=a64fx
-endif
-endif
-endif
-
-endif
-
-endif

Makefile.install

@@ -9,18 +9,10 @@ OPENBLAS_INCLUDE_DIR := $(PREFIX)/include
 OPENBLAS_LIBRARY_DIR := $(PREFIX)/lib
 OPENBLAS_BINARY_DIR := $(PREFIX)/bin
 OPENBLAS_BUILD_DIR := $(CURDIR)
-OPENBLAS_CMAKE_DIR := $(OPENBLAS_LIBRARY_DIR)/cmake/$(LIBSONAMEBASE)
+OPENBLAS_CMAKE_DIR := $(OPENBLAS_LIBRARY_DIR)/cmake/openblas
 OPENBLAS_CMAKE_CONFIG := OpenBLASConfig.cmake
 OPENBLAS_CMAKE_CONFIG_VERSION := OpenBLASConfigVersion.cmake
 OPENBLAS_PKGCONFIG_DIR := $(OPENBLAS_LIBRARY_DIR)/pkgconfig
-PKG_EXTRALIB := $(EXTRALIB)
-ifeq ($(USE_OPENMP), 1)
-  ifeq ($(C_COMPILER), PGI)
-          PKG_EXTRALIB += -lomp
-  else	  
-          PKG_EXTRALIB += -lgomp
-  endif
-endif	  
 
 .PHONY : install
 .NOTPARALLEL : install
@@ -53,59 +45,43 @@ install : 	lib.grd
 
 ifndef NO_CBLAS
 	@echo Generating cblas.h in $(DESTDIR)$(OPENBLAS_INCLUDE_DIR)
-	@cp cblas.h cblas.tmp
-ifdef SYMBOLPREFIX
-	@sed 's/cblas[^( ]*/$(SYMBOLPREFIX)&/g' cblas.tmp > cblas.tmp2
-	@sed 's/openblas[^( ]*/$(SYMBOLPREFIX)&/g'  cblas.tmp2 > cblas.tmp
-	#change back any openblas_complex_float and double that got hit
-	@sed 's/$(SYMBOLPREFIX)openblas_complex_/openblas_complex_/g'  cblas.tmp > cblas.tmp2
-	@sed 's/goto[^( ]*/$(SYMBOLPREFIX)&/g'  cblas.tmp2 > cblas.tmp
-endif
-ifdef SYMBOLSUFFIX
-	@sed 's/cblas[^( ]*/&$(SYMBOLSUFFIX)/g' cblas.tmp > cblas.tmp2
-	@sed 's/openblas[^( ]*/&$(SYMBOLSUFFIX)/g'  cblas.tmp2 > cblas.tmp
-	#change back any openblas_complex_float and double that got hit
-	@sed 's/\(openblas_complex_\)\([^ ]*\)$(SYMBOLSUFFIX)/\1\2 /g'  cblas.tmp > cblas.tmp2
-	@sed 's/goto[^( ]*/&$(SYMBOLSUFFIX)/g'  cblas.tmp2 > cblas.tmp
-endif
-	@sed 's/common/openblas_config/g' cblas.tmp > "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/cblas.h"
+	@sed 's/common/openblas_config/g' cblas.h > "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/cblas.h"
 endif
 
 ifneq ($(OSNAME), AIX)
 ifndef NO_LAPACKE
 	@echo Copying LAPACKE header files to $(DESTDIR)$(OPENBLAS_INCLUDE_DIR)
-	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapack.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapack.h"
-	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke.h"
-	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_config.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_config.h"
-	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_mangling_with_flags.h.in "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_mangling.h"
-	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_utils.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_utils.h"
+	@-install -pm644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke.h"
+	@-install -pm644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_config.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_config.h"
+	@-install -pm644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_mangling_with_flags.h.in "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_mangling.h"
+	@-install -pm644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_utils.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_utils.h"
 endif
 
 #for install static library
 ifneq ($(NO_STATIC),1)
 	@echo Copying the static library to $(DESTDIR)$(OPENBLAS_LIBRARY_DIR)
-	@install -m644 $(LIBNAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
+	@install -pm644 $(LIBNAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
 	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
 	ln -fs $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
 endif
 #for install shared library
 ifneq ($(NO_SHARED),1)
 	@echo Copying the shared library to $(DESTDIR)$(OPENBLAS_LIBRARY_DIR)
-ifeq ($(OSNAME), $(filter $(OSNAME),Linux SunOS Android Haiku FreeBSD DragonFly))
-	@install -m755 $(LIBSONAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
+ifeq ($(OSNAME), $(filter $(OSNAME),Linux SunOS Android Haiku))
+	@install -pm755 $(LIBSONAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
 	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
 	ln -fs $(LIBSONAME) $(LIBPREFIX).so ; \
 	ln -fs $(LIBSONAME) $(LIBPREFIX).so.$(MAJOR_VERSION)
 endif
 
-ifeq ($(OSNAME), $(filter $(OSNAME),OpenBSD NetBSD))
+ifeq ($(OSNAME), $(filter $(OSNAME),FreeBSD OpenBSD NetBSD DragonFly))
 	@cp $(LIBSONAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
 	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
 	ln -fs $(LIBSONAME) $(LIBPREFIX).so
 endif
 ifeq ($(OSNAME), Darwin)
 	@-cp $(LIBDYNNAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
-	@-install_name_tool -id "$(OPENBLAS_LIBRARY_DIR)/$(LIBPREFIX).$(MAJOR_VERSION).dylib" "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)/$(LIBDYNNAME)"
+	@-install_name_tool -id "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)/$(LIBDYNNAME)" "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)/$(LIBDYNNAME)"
 	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
 	ln -fs $(LIBDYNNAME) $(LIBPREFIX).dylib ; \
 	ln -fs $(LIBDYNNAME) $(LIBPREFIX).$(MAJOR_VERSION).dylib
@@ -124,7 +100,6 @@ else
 #install on AIX has different options syntax
 ifndef NO_LAPACKE
 	@echo Copying LAPACKE header files to $(DESTDIR)$(OPENBLAS_INCLUDE_DIR)
-	@-installbsd -c -m 644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapack.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapack.h"
 	@-installbsd -c -m 644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke.h"
 	@-installbsd -c -m 644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_config.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_config.h"
 	@-installbsd -c -m 644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_mangling_with_flags.h.in "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_mangling.h"
@@ -150,13 +125,13 @@ endif
 endif
 
 #Generating openblas.pc
-	@echo Generating $(LIBSONAMEBASE).pc in "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)"
-	@echo 'libdir='$(OPENBLAS_LIBRARY_DIR) > "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE).pc"
-	@echo 'includedir='$(OPENBLAS_INCLUDE_DIR) >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE).pc"
-	@echo 'openblas_config= USE_64BITINT='$(USE_64BITINT) 'DYNAMIC_ARCH='$(DYNAMIC_ARCH) 'DYNAMIC_OLDER='$(DYNAMIC_OLDER) 'NO_CBLAS='$(NO_CBLAS) 'NO_LAPACK='$(NO_LAPACK) 'NO_LAPACKE='$(NO_LAPACKE) 'NO_AFFINITY='$(NO_AFFINITY) 'USE_OPENMP='$(USE_OPENMP) $(CORE) 'MAX_THREADS='$(NUM_THREADS)>> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE).pc"
-	@echo 'version='$(VERSION) >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE).pc"
-	@echo 'extralib='$(PKG_EXTRALIB) >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE).pc"
-	@cat openblas.pc.in >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE).pc"
+	@echo Generating openblas.pc in "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)"
+	@echo 'libdir='$(OPENBLAS_LIBRARY_DIR) > "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/openblas.pc"
+	@echo 'includedir='$(OPENBLAS_INCLUDE_DIR) >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/openblas.pc"
+	@echo 'openblas_config= USE_64BITINT='$(USE_64BITINT) 'DYNAMIC_ARCH='$(DYNAMIC_ARCH) 'DYNAMIC_OLDER='$(DYNAMIC_OLDER) 'NO_CBLAS='$(NO_CBLAS) 'NO_LAPACK='$(NO_LAPACK) 'NO_LAPACKE='$(NO_LAPACKE) 'NO_AFFINITY='$(NO_AFFINITY) 'USE_OPENMP='$(USE_OPENMP) $(CORE) 'MAX_THREADS='$(NUM_THREADS)>> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/openblas.pc"
+	@echo 'version='$(VERSION) >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/openblas.pc"
+	@echo 'extralib='$(EXTRALIB) >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/openblas.pc"
+	@cat openblas.pc.in >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/openblas.pc"
 
 
 #Generating OpenBLASConfig.cmake
@@ -191,3 +166,4 @@ endif
 	@echo "  endif ()" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
 	@echo "endif ()" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
 	@echo Install OK!
+

Makefile.loongarch64

@@ -1,3 +0,0 @@
-ifdef BINARY64
-else
-endif

Makefile.power

@@ -9,85 +9,23 @@ else
 USE_OPENMP = 1
 endif
 
-ifeq ($(CORE), POWER10)
-ifneq ($(C_COMPILER), PGI)
-CCOMMON_OPT += -Ofast -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math
-ifeq ($(F_COMPILER), IBM)
-FCOMMON_OPT += -O2 -qrecur -qnosave
-else
-FCOMMON_OPT += -O2 -frecursive -mcpu=power10 -mtune=power10  -fno-fast-math
-endif
-endif
-endif
-
 ifeq ($(CORE), POWER9)
-ifneq ($(C_COMPILER), PGI)
-CCOMMON_OPT += -Ofast -mvsx -fno-fast-math
-ifeq ($(C_COMPILER), GCC)
-ifneq ($(GCCVERSIONGT4), 1)
-$(warning your compiler is too old to fully support POWER9, getting a newer version of gcc is recommended)
-CCOMMON_OPT += -mcpu=power8 -mtune=power8 
+ifeq ($(USE_OPENMP), 1)
+COMMON_OPT += -Ofast -mcpu=power9 -mtune=power9 -mvsx -malign-power -DUSE_OPENMP -fno-fast-math -fopenmp
+FCOMMON_OPT += -O2 -frecursive -mcpu=power9 -mtune=power9 -malign-power -DUSE_OPENMP -fno-fast-math -fopenmp
 else
-CCOMMON_OPT += -mcpu=power9 -mtune=power9 
-endif
-else
-CCOMMON_OPT += -mcpu=power9 -mtune=power9
-endif
-else
-CCOMMON_OPT += -fast -Mvect=simd -Mcache_align
-endif
-ifneq ($(F_COMPILER), PGI)
-ifeq ($(F_COMPILER), IBM)
-FCOMMON_OPT += -O2 -qrecur -qnosave
-else
-FCOMMON_OPT += -O2 -frecursive -fno-fast-math
-endif
-ifeq ($(C_COMPILER), GCC)
-ifneq ($(GCCVERSIONGT4), 1)
-$(warning your compiler is too old to fully support POWER9, getting a newer version of gcc is recommended)
-FCOMMON_OPT += -mcpu=power8 -mtune=power8 
-else
-FCOMMON_OPT += -mcpu=power9 -mtune=power9 
-endif
-else
-FCOMMON_OPT += -mcpu=power9 -mtune=power9
-endif
-else
-FCOMMON_OPT += -O2 -Mrecursive
+COMMON_OPT += -Ofast -mcpu=power9 -mtune=power9 -mvsx -malign-power -fno-fast-math
+FCOMMON_OPT += -O2 -frecursive -mcpu=power9 -mtune=power9 -malign-power -fno-fast-math
 endif
 endif
 
 ifeq ($(CORE), POWER8)
-ifneq ($(C_COMPILER), PGI)
-CCOMMON_OPT += -Ofast -mcpu=power8 -mtune=power8 -mvsx  -fno-fast-math
-else
-CCOMMON_OPT += -fast -Mvect=simd -Mcache_align
-endif
-ifneq ($(F_COMPILER), PGI)
-ifeq ($(OSNAME), AIX)
-ifeq ($(F_COMPILER), IBM)
-FCOMMON_OPT += -O2 -qrecur -qnosave
-else
-FCOMMON_OPT += -O1 -frecursive -mcpu=power8 -mtune=power8  -fno-fast-math 
-endif
-else
-FCOMMON_OPT += -O2 -frecursive -mcpu=power8 -mtune=power8  -fno-fast-math 
-endif
-else
-FCOMMON_OPT += -O2 -Mrecursive
-endif
-endif
-
 ifeq ($(USE_OPENMP), 1)
-ifneq ($(C_COMPILER), PGI)
-CCOMMON_OPT += -DUSE_OPENMP -fopenmp
+COMMON_OPT += -Ofast -mcpu=power8 -mtune=power8 -mvsx -malign-power -DUSE_OPENMP -fno-fast-math -fopenmp
+FCOMMON_OPT += -O2 -frecursive -mcpu=power8 -mtune=power8 -malign-power -DUSE_OPENMP -fno-fast-math -fopenmp
 else
-CCOMMON_OPT += -DUSE_OPENMP -mp
-endif
-ifneq ($(F_COMPILER), PGI)
-FCOMMON_OPT += -DUSE_OPENMP -fopenmp
-else
-FCOMMON_OPT += -DUSE_OPENMP -mp
+COMMON_OPT += -Ofast -mcpu=power8 -mtune=power8 -mvsx -malign-power -fno-fast-math
+FCOMMON_OPT += -O2 -frecursive -mcpu=power8 -mtune=power8 -malign-power -fno-fast-math
 endif
 endif
 
@@ -130,9 +68,6 @@ CCOMMON_OPT	+= -mpowerpc64 -maix64
 ifeq ($(COMPILER_F77), g77)
 FCOMMON_OPT	+= -mpowerpc64 -maix64
 endif
-ifeq ($(F_COMPILER), GFORTRAN)
-FCOMMON_OPT	+= -mpowerpc64 -maix64
-endif
 ifeq ($(COMPILER_F77), xlf)
 FCOMMON_OPT	+= -q64
 endif

Makefile.prebuild

@@ -3,10 +3,6 @@
 export BINARY
 export USE_OPENMP
 
-ifdef DYNAMIC_ARCH
-override HOST_CFLAGS += -DDYNAMIC_ARCH
-endif
-
 ifdef TARGET_CORE
 TARGET_MAKE = Makefile_kernel.conf
 TARGET_CONF = config_kernel.h
@@ -21,11 +17,7 @@ ifdef CPUIDEMU
 EXFLAGS = -DCPUIDEMU -DVENDOR=99
 endif
 
-ifeq ($(TARGET), MIPS24K)
-TARGET_FLAGS = -mips32r2
-endif
-
-ifeq ($(TARGET), MIPS1004K)
+ifeq ($(TARGET), 1004K)
 TARGET_FLAGS = -mips32r2
 endif
 
@@ -45,16 +37,12 @@ ifeq ($(TARGET), I6500)
 TARGET_FLAGS = -mips64r6
 endif
 
-ifeq ($(TARGET), C910V)
-TARGET_FLAGS = -march=rv64gcvxthead -mabi=lp64v
-endif
-
 all: getarch_2nd
 	./getarch_2nd  0 >> $(TARGET_MAKE)
 	./getarch_2nd  1 >> $(TARGET_CONF)
 
 config.h : c_check f_check getarch
-	perl ./c_check $(TARGET_MAKE) $(TARGET_CONF) $(CC) $(TARGET_FLAGS) $(CFLAGS)
+	perl ./c_check $(TARGET_MAKE) $(TARGET_CONF) $(CC) $(TARGET_FLAGS)
 ifneq ($(ONLY_CBLAS), 1)
 	perl ./f_check $(TARGET_MAKE) $(TARGET_CONF) $(FC) $(TARGET_FLAGS)
 else
@@ -71,13 +59,13 @@ endif
 
 
 getarch : getarch.c cpuid.S dummy $(CPUIDEMU)
-	$(HOSTCC) $(HOST_CFLAGS) $(EXFLAGS) -o $(@F) getarch.c cpuid.S $(CPUIDEMU)
+	$(HOSTCC) $(CFLAGS) $(EXFLAGS) -o $(@F) getarch.c cpuid.S $(CPUIDEMU)
 
 getarch_2nd : getarch_2nd.c config.h dummy
 ifndef TARGET_CORE
-	$(HOSTCC) -I. $(HOST_CFLAGS) -o $(@F) getarch_2nd.c
+	$(HOSTCC) -I. $(CFLAGS) -o $(@F) getarch_2nd.c
 else
-	$(HOSTCC) -I. $(HOST_CFLAGS) -DBUILD_KERNEL -o $(@F) getarch_2nd.c
+	$(HOSTCC) -I. $(CFLAGS) -DBUILD_KERNEL -o $(@F) getarch_2nd.c
 endif
 
 dummy:

Makefile.riscv64

@@ -1,4 +0,0 @@
-ifeq ($(CORE), C910V)
-CCOMMON_OPT += -march=rv64gcvxthead -mabi=lp64v
-FCOMMON_OPT += -march=rv64gcvxthead -mabi=lp64v -static
-endif

Makefile.rule

@@ -3,7 +3,7 @@
 #
 
 # This library's version
-VERSION = 0.3.20
+VERSION = 0.3.8.dev
 
 # If you set the suffix, the library name will be libopenblas_$(LIBNAMESUFFIX).a
 # and libopenblas_$(LIBNAMESUFFIX).so. Meanwhile, the soname in shared library
@@ -97,15 +97,6 @@ VERSION = 0.3.20
 # they need to wait for the preceding API calls to finish or risk data corruption.
 # NUM_PARALLEL = 2
 
-# When multithreading, OpenBLAS needs to use a memory buffer for communicating
-# and collating results for individual subranges of the original matrix. Since
-# the original GotoBLAS of the early 2000s, the default size of this buffer has
-# been set at a value of 32<<20 (which is 32MB) on x86_64 , twice that on PPC.
-# If you expect to handle large problem sizes (beyond about 30000x30000) uncomment
-# this line and adjust the (32<<n) factor if necessary. Usually an insufficient value
-# manifests itself as a crash in the relevant scal kernel (sscal_k, dscal_k etc) 
-# BUFFERSIZE = 25
-
 # If you don't need to install the static library, please comment this in.
 # NO_STATIC = 1
 
@@ -272,36 +263,7 @@ COMMON_PROF = -pg
 # work at all.
 #
 # CPP_THREAD_SAFETY_TEST = 1
-#
-# use this to run only the less memory-hungry GEMV test
-# CPP_THREAD_SAFETY_GEMV = 1
 
-
-# If you want to enable the experimental BFLOAT16 support
-# BUILD_BFLOAT16 = 1
-
-
-# Set the thread number threshold beyond which the job array for the threaded level3 BLAS
-# will be allocated on the heap rather than the stack. (This array alone requires 
-# NUM_THREADS*NUM_THREADS*128 bytes of memory so should not pose a problem at low cpu
-# counts, but obviously it is not the only item that ends up on the stack.
-# The default value of 32 ensures that the overall requirement is compatible
-# with the default 1MB stacksize imposed by having the Java VM loaded without use
-# of its -Xss parameter.
-# The value of 160 formerly used from about version 0.2.7 until 0.3.10 is easily compatible
-# with the common Linux stacksize of 8MB but will cause crashes with unwary use of the java
-# VM e.g. in Octave or with the java-based libhdfs in numpy or scipy code
-# BLAS3_MEM_ALLOC_THRESHOLD = 160
-
-
-
-# By default the library contains BLAS functions (and LAPACK if selected) for all input types.
-# To build a smaller library supporting e.g. only single precision real (SGEMM etc.) or only
-# the functions for complex numbers, uncomment the desired type(s) below
-# BUILD_SINGLE = 1
-# BUILD_DOUBLE = 1
-# BUILD_COMPLEX = 1
-# BUILD_COMPLEX16 = 1
 #
 #  End of user configuration
 #

Makefile.sparc

@@ -3,29 +3,21 @@ RANLIB  = ranlib
 
 ifdef BINARY64
 
-ifeq ($(C_COMPILER), GCC)
 CCOMMON_OPT += -mcpu=v9 -m64
-else
-CCOMMON_OPT +=  -m64
-endif
 ifeq ($(COMPILER_F77), g77)
 FCOMMON_OPT += -mcpu=v9 -m64
 endif
-ifeq ($(COMPILER_F77), f95)
-FCOMMON_OPT += -m64
+ifeq ($(COMPILER_F77), f90)
+FCOMMON_OPT += -xarch=v9
 endif
 else
 
-ifeq ($(C_COMPILER), GCC)
 CCOMMON_OPT += -mcpu=v9
-else
-CCOMMON_OPT +=  -xarch=v9
-endif
 
 ifeq ($(COMPILER_F77), g77)
 FCOMMON_OPT += -mcpu=v9
 endif
-ifeq ($(COMPILER_F77), f95)
+ifeq ($(COMPILER_F77), f90)
 FCOMMON_OPT += -xarch=v8plusb
 endif
 
@@ -45,4 +37,4 @@ LIBSUNPERF	= -L/opt/SUNWspro/lib/v9 -L/opt/SUNWspro/prod/lib/v9 \
 else
 LIBSUNPERF	= -L/opt/SUNWspro/lib -L/opt/SUNWspro/prod/lib \
 		-Wl,-R,/opt/SUNWspro/lib -lsunperf -lompstubs -lfui -lfsu -lsunmath
-endif
+endif

Makefile.system

@@ -6,13 +6,14 @@
 INCLUDED = 1
 
 ifndef TOPDIR
-TOPDIR = . 
+TOPDIR = .
 endif
 
-# we need to use the host system's architecture for getarch compile options even especially when cross-compiling
+# If ARCH is not set, we use the host system's architecture for getarch compile options.
+ifndef ARCH
 HOSTARCH := $(shell uname -m)
-ifeq ($(HOSTARCH), amd64)
-HOSTARCH=x86_64
+else
+HOSTARCH = $(ARCH)
 endif
 
 # Catch conflicting usage of ARCH in some BSD environments
@@ -20,24 +21,10 @@ ifeq ($(ARCH), amd64)
 override ARCH=x86_64
 else ifeq ($(ARCH), powerpc64)
 override ARCH=power
-else ifeq ($(ARCH), powerpc64le)
-override ARCH=power
-else ifeq ($(ARCH), powerpc)
-override ARCH=power
 else ifeq ($(ARCH), i386)
 override ARCH=x86
-else ifeq ($(ARCH), armv6)
-override ARCH=arm
-else ifeq ($(ARCH), armv7)
-override ARCH=arm
 else ifeq ($(ARCH), aarch64)
 override ARCH=arm64
-else ifeq ($(ARCH), mipsel)
-override ARCH=mips
-else ifeq ($(ARCH), mips64el)
-override ARCH=mips64
-else ifeq ($(ARCH), zarch)
-override ARCH=zarch
 endif
 
 NETLIB_LAPACK_DIR = $(TOPDIR)/lapack-netlib
@@ -78,18 +65,6 @@ endif
 #
 #  Beginning of system configuration
 #
-ifneq ($(BUILD_SINGLE),1)
-ifneq ($(BUILD_DOUBLE),1)
-ifneq ($(BUILD_COMPLEX),1)
-ifneq ($(BUILD_COMPLEX16),1)
-override BUILD_SINGLE=1
-override BUILD_DOUBLE=1
-override BUILD_COMPLEX=1
-override BUILD_COMPLEX16=1
-endif
-endif
-endif
-endif
 
 ifndef HOSTCC
 HOSTCC	 = $(CC)
@@ -98,12 +73,6 @@ endif
 ifdef TARGET
 GETARCH_FLAGS := -DFORCE_$(TARGET)
 GETARCH_FLAGS += -DUSER_TARGET
-ifeq ($(TARGET), GENERIC)
-ifeq ($(DYNAMIC_ARCH), 1)
-override NO_EXPRECISION=1
-export NO_EXPRECISION
-endif
-endif
 endif
 
 # Force fallbacks for 32bit
@@ -115,12 +84,6 @@ endif
 ifeq ($(TARGET), SKYLAKEX)
 GETARCH_FLAGS := -DFORCE_NEHALEM
 endif
-ifeq ($(TARGET), COOPERLAKE)
-GETARCH_FLAGS := -DFORCE_NEHALEM
-endif
-ifeq ($(TARGET), SAPPHIRERAPIDS)
-GETARCH_FLAGS := -DFORCE_NEHALEM
-endif
 ifeq ($(TARGET), SANDYBRIDGE)
 GETARCH_FLAGS := -DFORCE_NEHALEM
 endif
@@ -142,17 +105,9 @@ endif
 ifeq ($(TARGET), ARMV8)
 GETARCH_FLAGS := -DFORCE_ARMV7
 endif
-ifeq ($(TARGET), POWER8)
-GETARCH_FLAGS := -DFORCE_POWER6
-endif
-ifeq ($(TARGET), POWER9)
-GETARCH_FLAGS := -DFORCE_POWER6
-endif
-ifeq ($(TARGET), POWER10)
-GETARCH_FLAGS := -DFORCE_POWER6
-endif
 endif
 
+
 #TARGET_CORE will override TARGET which is used in DYNAMIC_ARCH=1.
 #
 ifdef TARGET_CORE
@@ -168,12 +123,6 @@ endif
 ifeq ($(TARGET_CORE), SKYLAKEX)
 GETARCH_FLAGS := -DFORCE_NEHALEM
 endif
-ifeq ($(TARGET_CORE), COOPERLAKE)
-GETARCH_FLAGS := -DFORCE_NEHALEM
-endif
-ifeq ($(TARGET_CORE), SAPPHIRERAPIDS)
-GETARCH_FLAGS := -DFORCE_NEHALEM
-endif
 ifeq ($(TARGET_CORE), SANDYBRIDGE)
 GETARCH_FLAGS := -DFORCE_NEHALEM
 endif
@@ -197,7 +146,7 @@ endif
 
 # On x86_64 build getarch with march=native unless the compiler is PGI. This is required to detect AVX512 support in getarch.
 ifeq ($(HOSTARCH), x86_64)
-ifeq ($(findstring pgcc,$(HOSTCC))$(findstring nvc,$(HOSTCC)),)
+ifeq ($(findstring pgcc,$(HOSTCC)),)
 GETARCH_FLAGS += -march=native
 endif
 endif
@@ -258,46 +207,16 @@ else
 ONLY_CBLAS = 0
 endif
 
-#For small matrix optimization
-ifeq ($(ARCH), x86_64)
-SMALL_MATRIX_OPT = 1
-else ifeq ($(CORE), POWER10)
-SMALL_MATRIX_OPT = 1
-endif
-ifeq ($(SMALL_MATRIX_OPT), 1)
-CCOMMON_OPT += -DSMALL_MATRIX_OPT
-endif
-
 # This operation is expensive, so execution should be once.
 ifndef GOTOBLAS_MAKEFILE
 export GOTOBLAS_MAKEFILE = 1
 
-# Determine if the assembler is GNU Assembler
-HAVE_GAS := $(shell $(AS) -v < /dev/null 2>&1 | grep GNU 2>&1 >/dev/null ; echo $$?)
-GETARCH_FLAGS += -DHAVE_GAS=$(HAVE_GAS)
-
 # Generating Makefile.conf and config.h
-DUMMY := $(shell $(MAKE) -C $(TOPDIR) -f Makefile.prebuild CC="$(CC)" FC="$(FC)" HOSTCC="$(HOSTCC)" HOST_CFLAGS="$(GETARCH_FLAGS)" CFLAGS="$(CFLAGS)" BINARY=$(BINARY) USE_OPENMP=$(USE_OPENMP) DYNAMIC_ARCH=$(DYNAMIC_ARCH) TARGET_CORE=$(TARGET_CORE) ONLY_CBLAS=$(ONLY_CBLAS) TARGET=$(TARGET) all)
+DUMMY := $(shell $(MAKE) -C $(TOPDIR) -f Makefile.prebuild CC="$(CC)" FC="$(FC)" HOSTCC="$(HOSTCC)" CFLAGS="$(GETARCH_FLAGS)" BINARY=$(BINARY) USE_OPENMP=$(USE_OPENMP) TARGET_CORE=$(TARGET_CORE) ONLY_CBLAS=$(ONLY_CBLAS) TARGET=$(TARGET) all)
 
 ifndef TARGET_CORE
 include $(TOPDIR)/Makefile.conf
 else
-HAVE_NEON=
-HAVE_VFP=
-HAVE_VFPV3=
-HAVE_VFPV4=
-HAVE_MMX=
-HAVE_SSE=
-HAVE_SSE2=
-HAVE_SSE3=
-HAVE_SSSE3=
-HAVE_SSE4_1=
-HAVE_SSE4_2=
-HAVE_SSE4A=
-HAVE_SSE5=
-HAVE_AVX=
-HAVE_AVX2=
-HAVE_FMA3=
 include $(TOPDIR)/Makefile_kernel.conf
 endif
 
@@ -323,7 +242,7 @@ else
 SMP = 1
 endif
 else
-ifeq ($(NUM_THREADS), 1)
+ifeq ($(NUM_THREAD), 1)
 SMP =
 else
 SMP = 1
@@ -340,10 +259,10 @@ endif
 
 ARFLAGS	=
 CPP	= $(COMPILER) -E
-AR	?= $(CROSS_SUFFIX)ar
-AS	?= $(CROSS_SUFFIX)as
-LD	?= $(CROSS_SUFFIX)ld
-RANLIB	?= $(CROSS_SUFFIX)ranlib
+AR	= $(CROSS_SUFFIX)ar
+AS	= $(CROSS_SUFFIX)as
+LD	= $(CROSS_SUFFIX)ld
+RANLIB	= $(CROSS_SUFFIX)ranlib
 NM	= $(CROSS_SUFFIX)nm
 DLLWRAP = $(CROSS_SUFFIX)dllwrap
 OBJCOPY = $(CROSS_SUFFIX)objcopy
@@ -356,28 +275,6 @@ NO_LAPACK = 1
 override FEXTRALIB = 
 endif
 
-ifeq ($(C_COMPILER), GCC)
-GCCVERSIONGTEQ4 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 4)
-GCCVERSIONGT4 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \> 4)
-GCCVERSIONGT5 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \> 5)
-GCCVERSIONGTEQ7 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 7)
-GCCVERSIONGTEQ8 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 8)
-GCCVERSIONGTEQ9 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 9)
-GCCVERSIONGTEQ11 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 11)
-GCCVERSIONGTEQ10 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 10)
-# Note that the behavior of -dumpversion is compile-time-configurable for
-# gcc-7.x and newer. Use -dumpfullversion there
-ifeq ($(GCCVERSIONGTEQ7),1)
-	GCCDUMPVERSION_PARAM := -dumpfullversion
-else
-	GCCDUMPVERSION_PARAM := -dumpversion
-endif
-GCCMINORVERSIONGTEQ1 := $(shell expr `$(CC) $(GCCDUMPVERSION_PARAM) | cut -f2 -d.` \>= 1)
-GCCMINORVERSIONGTEQ2 := $(shell expr `$(CC) $(GCCDUMPVERSION_PARAM) | cut -f2 -d.` \>= 2)
-GCCMINORVERSIONGTEQ4 := $(shell expr `$(CC) $(GCCDUMPVERSION_PARAM) | cut -f2 -d.` \>= 4)
-GCCMINORVERSIONGTEQ7 := $(shell expr `$(CC) $(GCCDUMPVERSION_PARAM) | cut -f2 -d.` \>= 7)
-endif
-
 #
 #  OS dependent settings
 #
@@ -410,12 +307,6 @@ ifeq ($(OSNAME), AIX)
 EXTRALIB	+= -lm
 endif
 
-ifeq ($(OSNAME), FreeBSD)
-ifeq ($(ARCH), $(filter $(ARCH),arm arm64))
-EXTRALIB	+= -lm
-endif
-endif
-
 ifeq ($(OSNAME), WINNT)
 NEED_PIC = 0
 NO_EXPRECISION = 1
@@ -430,9 +321,13 @@ ifeq ($(C_COMPILER), CLANG)
 CCOMMON_OPT	+= -DMS_ABI
 endif
 
-#Version tests for supporting specific features (MS_ABI, POWER9 intrinsics)
+ifeq ($(C_COMPILER), GCC)
+#Test for supporting MS_ABI
+GCCVERSIONGTEQ4 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 4)
+GCCVERSIONGT4 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \> 4)
+GCCMINORVERSIONGTEQ7 := $(shell expr `$(CC) -dumpversion | cut -f2 -d.` \>= 7)
 ifeq ($(GCCVERSIONGT4), 1)
-# GCC Major version > 4
+# GCC Majar version > 4
 # It is compatible with MSVC ABI.
 CCOMMON_OPT	+= -DMS_ABI
 endif
@@ -444,6 +339,7 @@ ifeq ($(GCCMINORVERSIONGTEQ7), 1)
 CCOMMON_OPT	+= -DMS_ABI
 endif
 endif
+endif
 
 # Ensure the correct stack alignment on Win32
 # http://permalink.gmane.org/gmane.comp.lib.openblas.general/97
@@ -635,7 +531,7 @@ DYNAMIC_CORE += HASWELL ZEN
 endif
 ifneq ($(NO_AVX512), 1)
 ifneq ($(NO_AVX2), 1)
-DYNAMIC_CORE += SKYLAKEX COOPERLAKE
+DYNAMIC_CORE += SKYLAKEX
 endif
 endif
 endif
@@ -650,96 +546,15 @@ endif
 
 ifeq ($(ARCH), arm64)
 DYNAMIC_CORE =  ARMV8
-DYNAMIC_CORE += CORTEXA53
 DYNAMIC_CORE += CORTEXA57
-DYNAMIC_CORE += CORTEXA72
-DYNAMIC_CORE += CORTEXA73
-DYNAMIC_CORE += NEOVERSEN1
-DYNAMIC_CORE += NEOVERSEV1
-DYNAMIC_CORE += NEOVERSEN2
-DYNAMIC_CORE += CORTEXA55
-DYNAMIC_CORE += FALKOR
 DYNAMIC_CORE += THUNDERX
 DYNAMIC_CORE += THUNDERX2T99
-DYNAMIC_CORE += TSV110
-DYNAMIC_CORE += EMAG8180
-DYNAMIC_CORE += THUNDERX3T110
-ifdef DYNAMIC_LIST
-override DYNAMIC_CORE = ARMV8 $(DYNAMIC_LIST)
-XCCOMMON_OPT = -DDYNAMIC_LIST -DDYN_ARMV8
-XCCOMMON_OPT += $(foreach dcore,$(DYNAMIC_LIST),-DDYN_$(dcore))
 endif
-endif
-
-ifeq ($(ARCH), mips64)
-DYNAMIC_CORE = LOONGSON3R3 LOONGSON3R4
-endif
-
-ifeq ($(ARCH), zarch)
-DYNAMIC_CORE = ZARCH_GENERIC
-
-# if the compiler accepts -march=arch11 or -march=z13 and can compile a file
-# with z13-specific inline assembly, then we can include support for Z13.
-# note: -march=z13 is equivalent to -march=arch11 yet some compiler releases
-# only support one or the other.
-# note: LLVM version 6.x supported -march=z13 yet could not handle vector
-# registers in inline assembly, so the check for supporting the -march flag is
-# not enough.
-ZARCH_TEST_COMPILE=-c $(TOPDIR)/kernel/zarch/damin_z13.c -I$(TOPDIR) -o /dev/null > /dev/null 2> /dev/null
-ZARCH_CC_SUPPORTS_ARCH11=$(shell $(CC) -march=arch11 $(ZARCH_TEST_COMPILE) && echo 1)
-ZARCH_CC_SUPPORTS_Z13=$(shell $(CC) -march=z13 $(ZARCH_TEST_COMPILE) && echo 1)
-
-ifeq ($(or $(ZARCH_CC_SUPPORTS_ARCH11), $(ZARCH_CC_SUPPORTS_Z13)), 1)
-DYNAMIC_CORE += Z13
-CCOMMON_OPT += -DDYN_Z13
-else
-$(info OpenBLAS: Not building Z13 kernels because the compiler $(CC) does not support it)
-endif
-
-# as above for z13, check for -march=arch12 and z14 support in the compiler.
-ZARCH_CC_SUPPORTS_ARCH12=$(shell $(CC) -march=arch12 $(ZARCH_TEST_COMPILE) && echo 1)
-ZARCH_CC_SUPPORTS_Z14=$(shell $(CC) -march=z14 $(ZARCH_TEST_COMPILE) && echo 1)
-ifeq ($(or $(ZARCH_CC_SUPPORTS_ARCH12), $(ZARCH_CC_SUPPORTS_Z14)), 1)
-DYNAMIC_CORE += Z14
-CCOMMON_OPT += -DDYN_Z14
-else
-$(info OpenBLAS: Not building Z14 kernels because the compiler $(CC) does not support it)
-endif
-
-endif # ARCH zarch
 
 ifeq ($(ARCH), power)
-ifneq ($(C_COMPILER), PGI)
 DYNAMIC_CORE = POWER6
 DYNAMIC_CORE += POWER8
-ifneq ($(C_COMPILER), GCC)
 DYNAMIC_CORE += POWER9
-DYNAMIC_CORE += POWER10
-CCOMMON_OPT += -DHAVE_P10_SUPPORT
-endif
-ifeq ($(C_COMPILER), GCC)
-ifeq ($(GCCVERSIONGT5), 1)
-DYNAMIC_CORE += POWER9
-else
-$(info, OpenBLAS: Your gcc version is too old to build the POWER9 kernels.)
-endif
-LDVERSIONGTEQ35 := $(shell expr `$(CC) -Wl,--version 2> /dev/null | head -1 | cut -f2 -d "." | cut -f1 -d "-"` \>= 35)
-ifeq ($(GCCVERSIONGTEQ11)$(LDVERSIONGTEQ35), 11)
-DYNAMIC_CORE += POWER10
-CCOMMON_OPT += -DHAVE_P10_SUPPORT
-else ifeq ($(GCCVERSIONGTEQ10), 1)
-ifeq ($(GCCMINORVERSIONGTEQ2)$(LDVERSIONGTEQ35), 11)
-DYNAMIC_CORE += POWER10
-CCOMMON_OPT += -DHAVE_P10_SUPPORT
-endif
-else
-$(info, OpenBLAS: Your gcc version is too old to build the POWER10 kernels.)
-endif
-endif
-else
-DYNAMIC_CORE = POWER8
-DYNAMIC_CORE += POWER9
-endif
 endif
 
 # If DYNAMIC_CORE is not set, DYNAMIC_ARCH cannot do anything, so force it to empty
@@ -794,27 +609,9 @@ endif
 ifeq ($(ARCH), arm64)
 NO_BINARY_MODE  = 1
 BINARY_DEFINED  = 1
-ifdef INTERFACE64
-ifneq ($(INTERFACE64), 0)
-ifeq ($(F_COMPILER), GFORTRAN)
-FCOMMON_OPT +=  -fdefault-integer-8
-endif
-ifeq ($(F_COMPILER), FLANG)
-FCOMMON_OPT += -i8
-endif
-endif
-endif
 endif
 
-ifeq ($(ARCH), riscv64)
-NO_BINARY_MODE  = 1
-BINARY_DEFINED  = 1
-endif
 
-ifeq ($(ARCH), loongarch64)
-NO_BINARY_MODE  = 1
-BINARY_DEFINED  = 1
-endif
 
 
 #
@@ -847,17 +644,17 @@ CCOMMON_OPT += -mabi=32
 BINARY_DEFINED = 1
 endif
 
-ifeq ($(CORE), $(filter $(CORE),LOONGSON3R3 LOONGSON3R4))
-CCOMMON_OPT += -march=loongson3a
-FCOMMON_OPT += -march=loongson3a
+ifeq ($(CORE), LOONGSON3A)
+CCOMMON_OPT += -march=mips64
+FCOMMON_OPT += -march=mips64
 endif
 
-ifeq ($(CORE), MIPS24K)
-CCOMMON_OPT += -mips32r2 -mtune=24kc  $(MSA_FLAGS)
-FCOMMON_OPT += -mips32r2 -mtune=24kc  $(MSA_FLAGS)
+ifeq ($(CORE), LOONGSON3B)
+CCOMMON_OPT += -march=mips64
+FCOMMON_OPT += -march=mips64
 endif
 
-ifeq ($(CORE), MIPS1004K)
+ifeq ($(CORE), 1004K)
 CCOMMON_OPT += -mips32r2   $(MSA_FLAGS)
 FCOMMON_OPT += -mips32r2   $(MSA_FLAGS)
 endif
@@ -886,21 +683,12 @@ ifeq ($(OSNAME), AIX)
 BINARY_DEFINED = 1
 endif
 
-ifeq ($(ARCH), loongarch64)
-ifeq ($(CORE), LOONGSON3R5)
-CCOMMON_OPT += -march=loongarch64 -mabi=lp64
-FCOMMON_OPT += -march=loongarch64 -mabi=lp64
-endif
-endif
-
 endif
 
 ifndef BINARY_DEFINED
 ifneq ($(OSNAME), AIX)
 ifdef BINARY64
-ifneq ($(ARCH), riscv64)
 CCOMMON_OPT += -m64
-endif
 else
 CCOMMON_OPT += -m32
 endif
@@ -910,45 +698,10 @@ endif
 endif
 
 ifeq ($(C_COMPILER), PGI)
-PGCVERSIONGT20 := $(shell expr `$(CC) --version|sed -n "2p" |sed -e "s/[^0-9.]//g" |cut -d "." -f 1` \> 20)
-PGCVERSIONEQ20 := $(shell expr `$(CC) --version|sed -n "2p" |sed -e "s/[^0-9.]//g" |cut -d "." -f 1` == 20)
-PGCMINORVERSIONGE11 := $(shell expr `$(CC) --version|sed -n "2p" |cut -d "-" -f 1 |sed -e "s/[^0-9.]//g" |cut -c 4-5` \>= 11)
-PGCVERSIONCHECK := $(PGCVERSIONGT20)$(PGCVERSIONEQ20)$(PGCMINORVERSIONGE11)
-ifeq ($(PGCVERSIONCHECK), $(filter $(PGCVERSIONCHECK), 100 101 011))
-NEWPGI := 1
-PGCVERSIONGT21 := $(shell expr `$(CC) --version|sed -n "2p" |sed -e "s/[^0-9.]//g" |cut -d "." -f 1` \> 21)
-PGCVERSIONEQ21 := $(shell expr `$(CC) --version|sed -n "2p" |sed -e "s/[^0-9.]//g" |cut -d "." -f 1` == 21)
-PGCVERSIONCHECK2 := $(PGCVERSIONGT21)$(PGCVERSIONEQ21)$(PGCMINORVERSIONGE11)
-ifeq ($(PGCVERSIONCHECK2), $(filter $(PGCVERSIONCHECK2), 100 101 011))
-NEWPGI2 := 1
-endif
-endif
 ifdef BINARY64
-ifeq ($(ARCH), x86_64)
-ifneq ($(NEWPGI2),1)
-CCOMMON_OPT += -tp p7-64
+CCOMMON_OPT += -tp p7-64 -D__MMX__ -Mnollvm
 else
-CCOMMON_OPT += -tp px
-endif
-ifneq ($(NEWPGI),1)
-CCOMMON_OPT +=  -D__MMX__ -Mnollvm
-endif
-else
-ifeq ($(ARCH), power)
-ifeq ($(CORE), POWER8)
-CCOMMON_OPT += -tp pwr8
-endif
-ifeq ($(CORE), POWER9)
-CCOMMON_OPT += -tp pwr9
-endif
-endif
-endif
-else
-ifneq ($(NEWPGI2),1)
 CCOMMON_OPT += -tp p7
-else
-CCOMMON_OPT += -tp px
-endif
 endif
 endif
 
@@ -964,29 +717,8 @@ endif
 #  Fortran Compiler dependent settings
 #
 
-ifeq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -dcfuns -recursive -ieee=full -w=obs -thread_safe
-ifdef INTERFACE64
-ifneq ($(INTERFACE64), 0)
-FCOMMON_OPT += -i8
-endif
-endif
-ifeq ($(USE_OPENMP), 1)
-FCOMMON_OPT += -openmp
-endif
-endif
-
 ifeq ($(F_COMPILER), FLANG)
 CCOMMON_OPT += -DF_INTERFACE_FLANG
-FCOMMON_OPT += -Mrecursive -Kieee
-ifeq ($(OSNAME), Linux)
-ifeq ($(ARCH), x86_64)
-FLANG_VENDOR := $(shell $(FC) --version|head -1 |cut -f 1 -d " ")
-ifeq ($(FLANG_VENDOR), AMD)
-FCOMMON_OPT += -fno-unroll-loops
-endif
-endif
-endif
 ifdef BINARY64
 ifdef INTERFACE64
 ifneq ($(INTERFACE64), 0)
@@ -1027,9 +759,6 @@ else
 FCOMMON_OPT += -m32
 endif
 endif
-ifneq ($(NO_LAPACKE), 1)
-FCOMMON_OPT += -fno-second-underscore
-endif
 endif
 endif
 
@@ -1057,10 +786,8 @@ endif
 else
 ifdef BINARY64
 ifneq ($(OSNAME), AIX)
-ifneq ($(ARCH), riscv64)
 FCOMMON_OPT += -m64
 endif
-endif
 ifdef INTERFACE64
 ifneq ($(INTERFACE64), 0)
 FCOMMON_OPT +=  -fdefault-integer-8
@@ -1084,7 +811,6 @@ ifneq ($(INTERFACE64), 0)
 FCOMMON_OPT += -i8
 endif
 endif
-FCOMMON_OPT += -recursive -fp-model strict -assume protect-parens
 ifeq ($(USE_OPENMP), 1)
 FCOMMON_OPT += -fopenmp
 endif
@@ -1124,32 +850,10 @@ ifneq ($(INTERFACE64), 0)
 FCOMMON_OPT += -i8
 endif
 endif
-ifeq ($(ARCH), x86_64)
-ifneq ($(NEWPGI2),1)
 FCOMMON_OPT += -tp p7-64
 else
-FCOMMON_OPT += -tp px
-endif
-else
-ifeq ($(ARCH), power)
-ifeq ($(CORE), POWER6)
-$(warning NVIDIA HPC compilers do not support POWER6.)
-endif
-ifeq ($(CORE), POWER8)
-FCOMMON_OPT += -tp pwr8
-endif
-ifeq ($(CORE), POWER9)
-FCOMMON_OPT += -tp pwr9
-endif
-ifeq ($(CORE), POWER10)
-$(warning NVIDIA HPC compilers do not support POWER10.)
-endif
-endif
-endif
-else
 FCOMMON_OPT += -tp p7
 endif
-FCOMMON_OPT += -Mrecursive -Kieee
 ifeq ($(USE_OPENMP), 1)
 FCOMMON_OPT += -mp
 endif
@@ -1186,11 +890,11 @@ FCOMMON_OPT += -n32
 else
 FCOMMON_OPT += -n64
 endif
-ifeq ($(CORE), LOONGSON3R3)
+ifeq ($(CORE), LOONGSON3A)
 FCOMMON_OPT += -loongson3 -static
 endif
 
-ifeq ($(CORE), LOONGSON3R4)
+ifeq ($(CORE), LOONGSON3B)
 FCOMMON_OPT += -loongson3 -static
 endif
 
@@ -1216,11 +920,11 @@ CCOMMON_OPT += -n32
 else
 CCOMMON_OPT += -n64
 endif
-ifeq ($(CORE), LOONGSON3R3)
+ifeq ($(CORE), LOONGSON3A)
 CCOMMON_OPT += -loongson3 -static
 endif
 
-ifeq ($(CORE), LOONGSON3R4)
+ifeq ($(CORE), LOONGSON3B)
 CCOMMON_OPT += -loongson3 -static
 endif
 
@@ -1239,25 +943,16 @@ CCOMMON_OPT  += -w
 ifeq ($(ARCH), x86)
 CCOMMON_OPT  += -m32
 else
-ifdef BINARY64
-CCOMMON_OPT  += -m64
-else
-CCOMMON_OPT  += -m32
-endif
+FCOMMON_OPT  += -m64
 endif
 endif
 
 ifeq ($(F_COMPILER), SUN)
 CCOMMON_OPT  += -DF_INTERFACE_SUN
-FCOMMON_OPT  += -ftrap=%none -xrecursive
 ifeq ($(ARCH), x86)
 FCOMMON_OPT  += -m32
 else
-ifdef BINARY64
 FCOMMON_OPT  += -m64
-else
-FCOMMON_OPT  += -m32
-endif
 endif
 ifeq ($(USE_OPENMP), 1)
 FCOMMON_OPT += -xopenmp=parallel
@@ -1288,8 +983,6 @@ CCOMMON_OPT += -fPIC
 endif
 ifeq ($(F_COMPILER), SUN)
 FCOMMON_OPT  += -pic
-else ifeq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -PIC
 else
 FCOMMON_OPT += -fPIC
 endif
@@ -1333,8 +1026,10 @@ ifdef SMP
 CCOMMON_OPT	+= -DSMP_SERVER
 
 ifeq ($(ARCH), mips64)
+ifneq ($(CORE), LOONGSON3B)
 USE_SIMPLE_THREADED_LEVEL3 = 1
 endif
+endif
 
 ifeq ($(USE_OPENMP), 1)
 # USE_SIMPLE_THREADED_LEVEL3 = 1
@@ -1367,10 +1062,6 @@ CCOMMON_OPT	 += -DUSE_PAPI
 EXTRALIB	 += -lpapi -lperfctr
 endif
 
-ifdef BUFFERSIZE
-CCOMMON_OPT	 += -DBUFFERSIZE=$(BUFFERSIZE)
-endif
-
 ifdef DYNAMIC_THREADS
 CCOMMON_OPT	 += -DDYNAMIC_THREADS
 endif
@@ -1387,22 +1078,6 @@ ifeq ($(USE_TLS), 1)
 CCOMMON_OPT += -DUSE_TLS
 endif
 
-ifeq ($(BUILD_BFLOAT16), 1)
-CCOMMON_OPT += -DBUILD_BFLOAT16
-endif
-ifeq ($(BUILD_SINGLE), 1)
-CCOMMON_OPT += -DBUILD_SINGLE=1
-endif
-ifeq ($(BUILD_DOUBLE), 1)
-CCOMMON_OPT += -DBUILD_DOUBLE=1
-endif
-ifeq ($(BUILD_COMPLEX), 1)
-CCOMMON_OPT += -DBUILD_COMPLEX=1
-endif
-ifeq ($(BUILD_COMPLEX16), 1)
-CCOMMON_OPT += -DBUILD_COMPLEX16=1
-endif
-
 CCOMMON_OPT += -DVERSION=\"$(VERSION)\"
 
 ifndef SYMBOLPREFIX
@@ -1413,14 +1088,10 @@ ifndef SYMBOLSUFFIX
 SYMBOLSUFFIX =
 endif
 
-ifndef LIBSONAMEBASE
-LIBSONAMEBASE = openblas
-endif
-
 ifndef LIBNAMESUFFIX
-LIBNAMEBASE = $(SYMBOLPREFIX)$(LIBSONAMEBASE)$(SYMBOLSUFFIX)
+LIBNAMEBASE = $(SYMBOLPREFIX)openblas$(SYMBOLSUFFIX)
 else
-LIBNAMEBASE = $(SYMBOLPREFIX)$(LIBSONAMEBASE)$(SYMBOLSUFFIX)_$(LIBNAMESUFFIX)
+LIBNAMEBASE = $(SYMBOLPREFIX)openblas$(SYMBOLSUFFIX)_$(LIBNAMESUFFIX)
 endif
 
 ifeq ($(OSNAME), CYGWIN_NT)
@@ -1433,11 +1104,6 @@ KERNELDIR	= $(TOPDIR)/kernel/$(ARCH)
 
 include $(TOPDIR)/Makefile.$(ARCH)
 
-ifneq ($(C_COMPILER), PGI)
-ifneq ($(C_COMPILER), SUN)
-CCOMMON_OPT     += -UASMNAME -UASMFNAME -UNAME -UCNAME -UCHAR_NAME -UCHAR_CNAME
-endif
-endif
 CCOMMON_OPT	+= -DASMNAME=$(FU)$(*F) -DASMFNAME=$(FU)$(*F)$(BU) -DNAME=$(*F)$(BU) -DCNAME=$(*F) -DCHAR_NAME=\"$(*F)$(BU)\" -DCHAR_CNAME=\"$(*F)\"
 
 ifeq ($(CORE), PPC440)
@@ -1454,9 +1120,11 @@ endif
 
 ifneq ($(ARCH), x86_64)
 ifneq ($(ARCH), x86)
+ifneq ($(CORE), LOONGSON3B)
 NO_AFFINITY = 1
 endif
 endif
+endif
 
 ifdef NO_AFFINITY
 ifeq ($(NO_AFFINITY), 0)
@@ -1528,6 +1196,7 @@ endif
 
 override CFLAGS     += $(COMMON_OPT) $(CCOMMON_OPT) -I$(TOPDIR)
 override PFLAGS     += $(COMMON_OPT) $(CCOMMON_OPT) -I$(TOPDIR) -DPROFILE $(COMMON_PROF)
+
 override FFLAGS     += $(COMMON_OPT) $(FCOMMON_OPT)
 override FPFLAGS    += $(FCOMMON_OPT) $(COMMON_PROF)
 #MAKEOVERRIDES =
@@ -1548,10 +1217,6 @@ LAPACK_FFLAGS := $(FFLAGS)
 LAPACK_FPFLAGS := $(FPFLAGS)
 endif
 
-ifeq ($(F_COMPILER),NAG)
-LAPACK_FFLAGS := $(filter-out -msse3 -mssse3 -msse4.1 -mavx -mavx2 -mskylake-avx512 ,$(FFLAGS))
-endif
-
 LAPACK_CFLAGS = $(CFLAGS)
 LAPACK_CFLAGS += -DHAVE_LAPACK_CONFIG_H
 ifdef INTERFACE64
@@ -1637,8 +1302,6 @@ export OSNAME
 export ARCH
 export CORE
 export LIBCORE
-export __BYTE_ORDER__
-export ELF_VERSION
 export PGCPATH
 export CONFIG
 export CC
@@ -1674,25 +1337,17 @@ export HAVE_SSE4_2
 export HAVE_SSE4A
 export HAVE_SSE5
 export HAVE_AVX
-export HAVE_AVX2
-export HAVE_FMA3
 export HAVE_VFP
 export HAVE_VFPV3
 export HAVE_VFPV4
 export HAVE_NEON
-ifndef NO_MSA
-  export HAVE_MSA
-  export MSA_FLAGS
-endif
+export HAVE_MSA
+export MSA_FLAGS
 export KERNELDIR
 export FUNCTION_PROFILE
 export TARGET_CORE
 export NO_AVX512
-export NO_AVX2
-export BUILD_BFLOAT16
 
-export SBGEMM_UNROLL_M
-export SBGEMM_UNROLL_N
 export SGEMM_UNROLL_M
 export SGEMM_UNROLL_N
 export DGEMM_UNROLL_M

Makefile.tail

@@ -1,18 +1,16 @@
-SBBLASOBJS_P = $(SBBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 SBLASOBJS_P = $(SBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 DBLASOBJS_P = $(DBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 QBLASOBJS_P = $(QBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 CBLASOBJS_P = $(CBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 ZBLASOBJS_P = $(ZBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 XBLASOBJS_P = $(XBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
-SBEXTOBJS_P = $(SBEXTOBJS:.$(SUFFIX)=.$(PSUFFIX))
 
 COMMONOBJS_P = $(COMMONOBJS:.$(SUFFIX)=.$(PSUFFIX))
 
 HPLOBJS_P   = $(HPLOBJS:.$(SUFFIX)=.$(PSUFFIX))
 
-BLASOBJS    = $(SBEXTOBJS) $(SBBLASOBJS)  $(SBLASOBJS)   $(DBLASOBJS)   $(CBLASOBJS)   $(ZBLASOBJS) $(CBAUXOBJS)
-BLASOBJS_P  = $(SBEXTOBJS_P) $(SBBLASOBJS_P) $(SBLASOBJS_P) $(DBLASOBJS_P) $(CBLASOBJS_P) $(ZBLASOBJS_P) $(CBAUXOBJS_P)
+BLASOBJS    = $(SBLASOBJS)   $(DBLASOBJS)   $(CBLASOBJS)   $(ZBLASOBJS)
+BLASOBJS_P  = $(SBLASOBJS_P) $(DBLASOBJS_P) $(CBLASOBJS_P) $(ZBLASOBJS_P)
 
 ifdef EXPRECISION
 BLASOBJS   += $(QBLASOBJS)   $(XBLASOBJS)
@@ -24,23 +22,19 @@ BLASOBJS   += $(QBLASOBJS)   $(XBLASOBJS)
 BLASOBJS_P += $(QBLASOBJS_P) $(XBLASOBJS_P)
 endif
 
-$(SBBLASOBJS) $(SBBLASOBJS_P) : override CFLAGS += -DBFLOAT16 -UDOUBLE  -UCOMPLEX
 $(SBLASOBJS) $(SBLASOBJS_P) : override CFLAGS += -UDOUBLE  -UCOMPLEX
 $(DBLASOBJS) $(DBLASOBJS_P) : override CFLAGS += -DDOUBLE  -UCOMPLEX
 $(QBLASOBJS) $(QBLASOBJS_P) : override CFLAGS += -DXDOUBLE -UCOMPLEX
 $(CBLASOBJS) $(CBLASOBJS_P) : override CFLAGS += -UDOUBLE  -DCOMPLEX
 $(ZBLASOBJS) $(ZBLASOBJS_P) : override CFLAGS += -DDOUBLE  -DCOMPLEX
 $(XBLASOBJS) $(XBLASOBJS_P) : override CFLAGS += -DXDOUBLE -DCOMPLEX
-$(SBEXTOBJS) $(SBEXTOBJS_P) : override CFLAGS += -DBFLOAT16 -UDOUBLE  -UCOMPLEX
 
-$(SBBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
 $(SBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
 $(DBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
 $(QBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
 $(CBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
 $(ZBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
 $(XBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
-$(SBEXTOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
 
 libs    :: $(BLASOBJS) $(COMMONOBJS)
 	$(AR) $(ARFLAGS) -ru $(TOPDIR)/$(LIBNAME) $^

Makefile.x86

@@ -1,21 +1,5 @@
 # COMPILER_PREFIX = mingw32-
 
-ifneq ($(DYNAMIC_ARCH),1)
-ADD_CPUFLAGS = 1
-else
-ifdef TARGET_CORE
-ADD_CPUFLAGS = 1
-endif
-endif
-
-ifdef ADD_CPUFLAGS
-ifdef HAVE_SSE
-CCOMMON_OPT += -msse
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -msse
-endif
-endif
-endif
 
 ifeq ($(OSNAME), Interix)
 ARFLAGS		= -m x86
@@ -70,20 +54,3 @@ LIBATLAS	= -L$(ATLASPATH)/32 -lcblas -lf77blas -latlas -lm
 else
 LIBATLAS	= -L$(ATLASPATH)/32 -lptf77blas -lptatlas -lpthread -lm
 endif
-ifdef HAVE_SSE2
-CCOMMON_OPT += -msse2
-FCOMMON_OPT += -msse2
-endif
-ifdef HAVE_SSE3
-CCOMMON_OPT += -msse3
-FCOMMON_OPT += -msse3
-ifdef HAVE_SSSE3
-CCOMMON_OPT += -mssse3
-FCOMMON_OPT += -mssse3
-endif
-ifdef HAVE_SSE4_1
-CCOMMON_OPT += -msse4.1
-FCOMMON_OPT += -msse4.1
-endif
-endif
-

Makefile.x86_64

@@ -8,159 +8,36 @@ endif
 endif
 endif
 
-
-ifneq ($(DYNAMIC_ARCH),1)
-ADD_CPUFLAGS = 1
-else
-ifdef TARGET_CORE
-ADD_CPUFLAGS = 1
-endif
-endif
-
-ifdef ADD_CPUFLAGS
-ifdef HAVE_SSE3
-CCOMMON_OPT += -msse3
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -msse3
-endif
-endif
-ifdef HAVE_SSSE3
-CCOMMON_OPT += -mssse3
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -mssse3
-endif
-endif
-ifdef HAVE_SSE4_1
-CCOMMON_OPT += -msse4.1
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -msse4.1
-endif
-endif
-ifndef OLDGCC
-ifdef HAVE_AVX
-CCOMMON_OPT += -mavx
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -mavx
-endif
-endif
-endif
-ifndef NO_AVX2
-ifdef HAVE_AVX2
-CCOMMON_OPT += -mavx2
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -mavx2
-endif
-endif
-endif
-
 ifeq ($(CORE), SKYLAKEX)
+ifndef DYNAMIC_ARCH
 ifndef NO_AVX512
 CCOMMON_OPT += -march=skylake-avx512
-ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=skylake-avx512
-endif
 ifeq ($(OSNAME), CYGWIN_NT)
 CCOMMON_OPT += -fno-asynchronous-unwind-tables
-FCOMMON_OPT += -fno-asynchronous-unwind-tables
 endif
 ifeq ($(OSNAME), WINNT)
 ifeq ($(C_COMPILER), GCC)
 CCOMMON_OPT += -fno-asynchronous-unwind-tables
-FCOMMON_OPT += -fno-asynchronous-unwind-tables
+endif
 endif
 endif
 endif
 endif
 
-ifeq ($(CORE), COOPERLAKE)
-ifndef NO_AVX512
-ifeq ($(C_COMPILER), GCC)
-# cooperlake support was added in 10.1
-ifeq ($(GCCVERSIONGTEQ10)$(GCCMINORVERSIONGTEQ1), 11)
-CCOMMON_OPT += -march=cooperlake
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=cooperlake
-endif
-else  # gcc not support, fallback to avx512
-CCOMMON_OPT += -march=skylake-avx512
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=skylake-avx512
-endif
-endif
-endif
-ifeq ($(OSNAME), CYGWIN_NT)
-CCOMMON_OPT += -fno-asynchronous-unwind-tables
-FCOMMON_OPT += -fno-asynchronous-unwind-tables
-endif
-ifeq ($(OSNAME), WINNT)
-ifeq ($(C_COMPILER), GCC)
-CCOMMON_OPT += -fno-asynchronous-unwind-tables
-FCOMMON_OPT += -fno-asynchronous-unwind-tables
-endif
-endif
-endif
-endif
-
-ifeq ($(CORE), SAPPHIRERAPIDS)
-ifndef NO_AVX512
-ifeq ($(C_COMPILER), GCC)
-# sapphire rapids support was added in 11
-ifeq ($(GCCVERSIONGTEQ11), 1)
-CCOMMON_OPT += -march=sapphirerapids
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=sapphirerapids
-endif
-else  # gcc not support, fallback to avx512
-CCOMMON_OPT += -march=skylake-avx512
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=skylake-avx512
-endif
-endif
-endif
-ifeq ($(OSNAME), CYGWIN_NT)
-CCOMMON_OPT += -fno-asynchronous-unwind-tables
-FCOMMON_OPT += -fno-asynchronous-unwind-tables
-endif
-ifeq ($(OSNAME), WINNT)
-ifeq ($(C_COMPILER), GCC)
-CCOMMON_OPT += -fno-asynchronous-unwind-tables
-FCOMMON_OPT += -fno-asynchronous-unwind-tables
-endif
-endif
-endif
-endif
-
-ifdef HAVE_AVX2
+ifeq ($(CORE), HASWELL)
+ifndef DYNAMIC_ARCH
 ifndef NO_AVX2
 ifeq ($(C_COMPILER), GCC)
-# AVX2 support was added in 4.7.0
-GCCVERSIONCHECK := $(GCCVERSIONGT4)$(GCCVERSIONGTEQ4)$(GCCMINORVERSIONGTEQ7)
-ifeq ($(GCCVERSIONCHECK), $(filter $(GCCVERSIONCHECK), 011 110 111))
 CCOMMON_OPT += -mavx2
 endif
-else 
-ifeq ($(C_COMPILER), CLANG)
-CCOMMON_OPT += -mavx2
-endif
-endif
 ifeq ($(F_COMPILER), GFORTRAN)
-# AVX2 support was added in 4.7.0
-GCCVERSIONGTEQ4 := $(shell expr `$(FC) -dumpversion | cut -f1 -d.` \>= 4)
-GCCVERSIONGTEQ5 := $(shell expr `$(FC) -dumpversion | cut -f1 -d.` \>= 5)
-GCCMINORVERSIONGTEQ7 := $(shell expr `$(FC) -dumpversion | cut -f2 -d.` \>= 7)
-GCCVERSIONCHECK := $(GCCVERSIONGTEQ5)$(GCCVERSIONGTEQ4)$(GCCMINORVERSIONGTEQ7)
-ifeq ($(GCCVERSIONCHECK), $(filter $(GCCVERSIONCHECK), 011 110 111))
-FCOMMON_OPT += -mavx2
-endif
-else
-ifeq ($(F_COMPILER), FLANG)
 FCOMMON_OPT += -mavx2
 endif
 endif
 endif
 endif
 
-endif
 
 
 ifeq ($(OSNAME), Interix)

Makefile.zarch

@@ -5,12 +5,6 @@ FCOMMON_OPT += -march=z13 -mzvector
 endif
 
 ifeq ($(CORE), Z14)
-CCOMMON_OPT += -march=z14 -mzvector -O3
+CCOMMON_OPT += -march=z14 -mzvector
 FCOMMON_OPT += -march=z14 -mzvector
 endif
-
-# Enable floating-point expression contraction for clang, since it is the
-# default for gcc
-ifeq ($(C_COMPILER), CLANG)
-CCOMMON_OPT += -ffp-contract=on
-endif

README.md

@@ -2,40 +2,30 @@
 
 [![Join the chat at https://gitter.im/xianyi/OpenBLAS](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/xianyi/OpenBLAS?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-Travis CI: [![Build Status](https://travis-ci.com/xianyi/OpenBLAS.svg?branch=develop)](https://travis-ci.com/xianyi/OpenBLAS)
+Travis CI: [![Build Status](https://travis-ci.org/xianyi/OpenBLAS.svg?branch=develop)](https://travis-ci.org/xianyi/OpenBLAS)
 
 AppVeyor: [![Build status](https://ci.appveyor.com/api/projects/status/09sohd35n8nkkx64/branch/develop?svg=true)](https://ci.appveyor.com/project/xianyi/openblas/branch/develop)
 
-Drone CI: [![Build Status](https://cloud.drone.io/api/badges/xianyi/OpenBLAS/status.svg?branch=develop)](https://cloud.drone.io/xianyi/OpenBLAS/)
-
 [![Build Status](https://dev.azure.com/xianyi/OpenBLAS/_apis/build/status/xianyi.OpenBLAS?branchName=develop)](https://dev.azure.com/xianyi/OpenBLAS/_build/latest?definitionId=1&branchName=develop)
 
-
 ## Introduction
 
-OpenBLAS is an optimized BLAS (Basic Linear Algebra Subprograms) library based on GotoBLAS2 1.13 BSD version.
+OpenBLAS is an optimized BLAS library based on GotoBLAS2 1.13 BSD version.
 
 Please read the documentation on the OpenBLAS wiki pages: <https://github.com/xianyi/OpenBLAS/wiki>.
 
-For a general introduction to the BLAS routines, please refer to the extensive documentation of their reference implementation hosted at netlib:
-<https://www.netlib.org/blas>. On that site you will likewise find documentation for the reference implementation of the higher-level library LAPACK - the **L**inear **A**lgebra **Pack**age that comes included with OpenBLAS. If you are looking for a general primer or refresher on Linear Algebra, the set of six
-20-minute lecture videos by Prof. Gilbert Strang on either MIT OpenCourseWare <https://ocw.mit.edu/resources/res-18-010-a-2020-vision-of-linear-algebra-spring-2020/> or Youtube <https://www.youtube.com/playlist?list=PLUl4u3cNGP61iQEFiWLE21EJCxwmWvvek> may be helpful.
-
 ## Binary Packages
 
 We provide official binary packages for the following platform:
 
   * Windows x86/x86_64
 
-You can download them from [file hosting on sourceforge.net](https://sourceforge.net/projects/openblas/files/) or from the Releases section of the github project page, [https://github.com/xianyi/OpenBLAS/releases](https://github.com/xianyi/OpenBLAS/releases).
+You can download them from [file hosting on sourceforge.net](https://sourceforge.net/projects/openblas/files/).
 
 ## Installation from Source
 
 Download from project homepage, https://xianyi.github.com/OpenBLAS/, or check out the code
-using Git from https://github.com/xianyi/OpenBLAS.git. (If you want the most up to date version, be
-sure to use the develop branch - master is several years out of date due to a change of maintainership.)
-Buildtime parameters can be chosen in Makefile.rule, see there for a short description of each option.
-Most can also be given directly on the make or cmake command line.
+using Git from https://github.com/xianyi/OpenBLAS.git.
 
 ### Dependencies
 
@@ -50,10 +40,7 @@ Building OpenBLAS requires the following to be installed:
 
 Simply invoking `make` (or `gmake` on BSD) will detect the CPU automatically.
 To set a specific target CPU, use `make TARGET=xxx`, e.g. `make TARGET=NEHALEM`.
-The full target list is in the file `TargetList.txt`. For building with `cmake`, the
-usual conventions apply, i.e. create a build directory either underneath the toplevel
-OpenBLAS source directory or separate from it, and invoke `cmake` there with the path
-to the source tree and any build options you plan to set.
+The full target list is in the file `TargetList.txt`.
 
 ### Cross compile
 
@@ -66,10 +53,6 @@ Examples:
   ```sh
   make BINARY=64 CC=mips64el-unknown-linux-gnu-gcc FC=mips64el-unknown-linux-gnu-gfortran HOSTCC=gcc TARGET=LOONGSON3A
   ```
-  or same with the newer mips-crosscompiler put out by Loongson that defaults to the 32bit ABI:
-  ```sh
-  make HOSTCC=gcc CC='/opt/mips-loongson-gcc7.3-linux-gnu/2019.06-29/bin/mips-linux-gnu-gcc -mabi=64' FC='/opt/mips-loongson-gcc7.3-linux-gnu/2019.06-29/bin/mips-linux-gnu-gfortran -mabi=64' TARGET=LOONGSON3A
-  ```
 
 * On an x86 box, compile this library for a loongson3a CPU with loongcc (based on Open64) compiler:
   ```sh
@@ -118,7 +101,7 @@ The default installation directory is `/opt/OpenBLAS`.
 
 ## Supported CPUs and Operating Systems
 
-Please read `GotoBLAS_01Readme.txt` for older CPU models already supported by the 2010 GotoBLAS.
+Please read `GotoBLAS_01Readme.txt`.
 
 ### Additional supported CPUs
 
@@ -126,20 +109,14 @@ Please read `GotoBLAS_01Readme.txt` for older CPU models already supported by th
 
 - **Intel Xeon 56xx (Westmere)**: Used GotoBLAS2 Nehalem codes.
 - **Intel Sandy Bridge**: Optimized Level-3 and Level-2 BLAS with AVX on x86-64.
-- **Intel Haswell**: Optimized Level-3 and Level-2 BLAS with AVX2 and FMA on x86-64.
-- **Intel Skylake-X**: Optimized Level-3 and Level-2 BLAS with AVX512 and FMA on x86-64.
-- **Intel Cooper Lake**: as Skylake-X with improved BFLOAT16 support.
+- **Intel Haswell**: Optimized Level-3 and Level-2 BLAS with AVX2 and FMA  on x86-64.
+- **Intel Skylake**: Optimized Level-3 and Level-2 BLAS with AVX512 and FMA  on x86-64.
 - **AMD Bobcat**: Used GotoBLAS2 Barcelona codes.
 - **AMD Bulldozer**: x86-64 ?GEMM FMA4 kernels. (Thanks to Werner Saar)
 - **AMD PILEDRIVER**: Uses Bulldozer codes with some optimizations.
 - **AMD STEAMROLLER**: Uses Bulldozer codes with some optimizations.
 - **AMD ZEN**: Uses Haswell codes with some optimizations.
 
-#### MIPS32
-
-- **MIPS 1004K**: uses P5600 codes
-- **MIPS 24K**: uses P5600 codes
-
 #### MIPS64
 
 - **ICT Loongson 3A**: Optimized Level-3 BLAS and the part of Level-1,2.
@@ -152,71 +129,28 @@ Please read `GotoBLAS_01Readme.txt` for older CPU models already supported by th
 
 #### ARM64
 
-- **ARMv8**: Basic ARMV8 with small caches, optimized Level-3 and Level-2 BLAS
-- **Cortex-A53**: same as ARMV8 (different cpu specifications)
-- **Cortex-A55**: same as ARMV8 (different cpu specifications)
-- **Cortex A57**: Optimized Level-3 and Level-2 functions
-- **Cortex A72**: same as A57 ( different cpu specifications)
-- **Cortex A73**: same as A57 (different cpu specifications)
-- **Falkor**: same as A57 (different cpu specifications)
-- **ThunderX**: Optimized some Level-1 functions
-- **ThunderX2T99**: Optimized Level-3 BLAS and parts of Levels 1 and 2
-- **ThunderX3T110**
-- **TSV110**: Optimized some Level-3 helper functions
-- **EMAG 8180**: preliminary support based on A57
-- **Neoverse N1**: (AWS Graviton2) preliminary support
-- **Apple Vortex**: preliminary support based on ARMV8
+- **ARMv8**: Experimental
+- **ARM Cortex-A57**: Experimental
 
 #### PPC/PPC64
 
 - **POWER8**: Optimized BLAS, only for PPC64LE (Little Endian), only with `USE_OPENMP=1`
 - **POWER9**: Optimized Level-3 BLAS (real) and some Level-1,2. PPC64LE with OpenMP only. 
-- **POWER10**:
 
 #### IBM zEnterprise System
 
-- **Z13**: Optimized Level-3 BLAS and Level-1,2
-- **Z14**: Optimized Level-3 BLAS and (single precision) Level-1,2
-
-#### RISC-V
-
-- **C910V**: Optimized Level-3 BLAS (real) and Level-1,2 by RISC-V Vector extension 0.7.1.
-  ```sh
-  make HOSTCC=gcc TARGET=C910V CC=riscv64-unknown-linux-gnu-gcc FC=riscv64-unknown-linux-gnu-gfortran
-  ```
-  (also known to work on C906)
-
-### Support for multiple targets in a single library
-
-OpenBLAS can be built for multiple targets with runtime detection of the target cpu by specifiying `DYNAMIC_ARCH=1` in Makefile.rule, on the gmake command line or as `-DDYNAMIC_ARCH=TRUE` in cmake.
-
-For **x86_64**, the list of targets this activates contains Prescott, Core2, Nehalem, Barcelona, Sandybridge, Bulldozer, Piledriver, Steamroller, Excavator, Haswell, Zen, SkylakeX. For cpu generations not included in this list, the corresponding older model is used. If you also specify `DYNAMIC_OLDER=1`, specific support for Penryn, Dunnington, Opteron, Opteron/SSE3, Bobcat, Atom and Nano is added. Finally there is an option `DYNAMIC_LIST` that allows to specify an individual list of targets to include instead of the default.
-
-`DYNAMIC_ARCH` is also supported on **x86**, where it translates to Katmai, Coppermine, Northwood, Prescott, Banias,
-Core2, Penryn, Dunnington, Nehalem, Athlon, Opteron, Opteron_SSE3, Barcelona, Bobcat, Atom and Nano.
-
-On **ARMV8**, it enables support for CortexA53, CortexA57, CortexA72, CortexA73, Falkor, ThunderX, ThunderX2T99, TSV110 as well as generic ARMV8 cpus.
-
-For **POWER**, the list encompasses POWER6, POWER8 and POWER9, on **ZARCH** it comprises Z13 and Z14.
-
-The `TARGET` option can be used in conjunction with `DYNAMIC_ARCH=1` to specify which cpu model should be assumed for all the
-common code in the library, usually you will want to set this to the oldest model you expect to encounter.
-Please note that it is not possible to combine support for different architectures, so no combined 32 and 64 bit or x86_64 and arm64 in the same library.
+- **Z13**: Optimized Level-3 BLAS and Level-1,2 (double precision)
+- **Z14**: Optimized Level-3 BLAS and Level-1,2 (single precision)
 
 ### Supported OS
 
 - **GNU/Linux**
 - **MinGW or Visual Studio (CMake)/Windows**: Please read <https://github.com/xianyi/OpenBLAS/wiki/How-to-use-OpenBLAS-in-Microsoft-Visual-Studio>.
-- **Darwin/macOS/OSX/iOS**: Experimental. Although GotoBLAS2 already supports Darwin, we are not OSX/iOS experts.
+- **Darwin/macOS**: Experimental. Although GotoBLAS2 supports Darwin, we are not macOS experts.
 - **FreeBSD**: Supported by the community. We don't actively test the library on this OS.
 - **OpenBSD**: Supported by the community. We don't actively test the library on this OS.
-- **NetBSD**: Supported by the community. We don't actively test the library on this OS.
 - **DragonFly BSD**: Supported by the community. We don't actively test the library on this OS.
 - **Android**: Supported by the community. Please read <https://github.com/xianyi/OpenBLAS/wiki/How-to-build-OpenBLAS-for-Android>.
-- **AIX**: Supported on PPC up to POWER8
-- **Haiku**: Supported by the community. We don't actively test the library on this OS.
-- **SunOS**: Supported by the community. We don't actively test the library on this OS.
-- **Cortex-M**: Supported by the community. Please read <https://github.com/xianyi/OpenBLAS/wiki/How-to-use-OpenBLAS-on-Cortex-M>.
 
 ## Usage
 
@@ -248,8 +182,7 @@ We provide the following functions to control the number of threads at runtime:
 void goto_set_num_threads(int num_threads);
 void openblas_set_num_threads(int num_threads);
 ```
-Note that these are only used once at library initialization, and are not available for
-fine-tuning thread numbers in individual BLAS calls. 
+
 If you compile this library with `USE_OPENMP=1`, you should use the above functions too.
 
 ## Reporting bugs
@@ -272,7 +205,7 @@ Please see Changelog.txt to view the differences between OpenBLAS and GotoBLAS2
 * Please use Clang version 3.1 and above to compile the library on Sandy Bridge microarchitecture.
   Clang 3.0 will generate the wrong AVX binary code.
 * Please use GCC version 6 or LLVM version 6 and above to compile Skylake AVX512 kernels.
-* The number of CPUs/cores should be less than or equal to 256. On Linux `x86_64` (`amd64`),
+* The number of CPUs/cores should less than or equal to 256. On Linux `x86_64` (`amd64`),
   there is experimental support for up to 1024 CPUs/cores and 128 numa nodes if you build
   the library with `BIGNUMA=1`.
 * OpenBLAS does not set processor affinity by default.

TargetList.txt

@@ -22,8 +22,6 @@ SANDYBRIDGE
 HASWELL
 SKYLAKEX
 ATOM
-COOPERLAKE
-SAPPHIRERAPIDS
 
 b)AMD CPU:
 ATHLON
@@ -51,7 +49,6 @@ POWER6
 POWER7
 POWER8
 POWER9
-POWER10
 PPCG4
 PPC970
 PPC970MP
@@ -61,8 +58,7 @@ CELL
 
 3.MIPS CPU:
 P5600
-MIPS1004K
-MIPS24K
+1004K
 
 4.MIPS64 CPU:
 SICORTEX
@@ -92,26 +88,12 @@ CORTEXA53
 CORTEXA57
 CORTEXA72
 CORTEXA73
-NEOVERSEN1
-NEOVERSEV1
-NEOVERSEN2
-CORTEXA55
-EMAG8180
 FALKOR
 THUNDERX
 THUNDERX2T99
 TSV110
-THUNDERX3T110
-VORTEX
 
 9.System Z:
 ZARCH_GENERIC
 Z13
 Z14
-
-10.RISC-V 64:
-RISCV64_GENERIC
-C910V
-
-11.LOONGARCH64:
-LOONGSON3R5

appveyor.yml

@@ -29,15 +29,15 @@ environment:
   global:
     CONDA_INSTALL_LOCN: C:\\Miniconda36-x64
   matrix:
-#    - COMPILER: clang-cl
-#      WITH_FORTRAN: ON
-#    - COMPILER: clang-cl
-#      DYNAMIC_ARCH: ON
-#      WITH_FORTRAN: OFF
-#    - COMPILER: cl
-#    - COMPILER: MinGW64-gcc-7.2.0-mingw
-#      DYNAMIC_ARCH: OFF
-#      WITH_FORTRAN: ignore
+    - COMPILER: clang-cl
+      WITH_FORTRAN: yes
+    - COMPILER: clang-cl
+      DYNAMIC_ARCH: ON
+      WITH_FORTRAN: no
+    - COMPILER: cl
+    - COMPILER: MinGW64-gcc-7.2.0-mingw
+      DYNAMIC_ARCH: OFF
+      WITH_FORTRAN: ignore
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       COMPILER: MinGW-gcc-6.3.0-32   
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -46,10 +46,13 @@ environment:
     
 install:
   - if [%COMPILER%]==[clang-cl] call %CONDA_INSTALL_LOCN%\Scripts\activate.bat
-  - if [%COMPILER%]==[clang-cl] conda update --yes -n base conda
   - if [%COMPILER%]==[clang-cl] conda config --add channels conda-forge --force
-  - if [%COMPILER%]==[clang-cl] conda config --set auto_update_conda false
-  - if [%COMPILER%]==[clang-cl] conda install --yes --quiet clangdev cmake ninja flang=11.0.1
+  - if [%COMPILER%]==[clang-cl] conda install --yes --quiet clangdev cmake
+
+  - if [%WITH_FORTRAN%]==[no] conda install --yes --quiet ninja
+  - if [%WITH_FORTRAN%]==[yes] conda install --yes --quiet -c isuruf kitware-ninja
+  - if [%WITH_FORTRAN%]==[yes] conda install --yes --quiet flang
+
   - if [%COMPILER%]==[clang-cl] call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat" x64
   - if [%COMPILER%]==[clang-cl] set "LIB=%CONDA_INSTALL_LOCN%\Library\lib;%LIB%"
   - if [%COMPILER%]==[clang-cl] set "CPATH=%CONDA_INSTALL_LOCN%\Library\include;%CPATH%"
@@ -65,14 +68,15 @@ before_build:
   - if [%COMPILER%]==[MinGW64-gcc-7.2.0-mingw] cmake -G "MinGW Makefiles" -DNOFORTRAN=1 ..
   - if [%COMPILER%]==[MinGW-gcc-6.3.0-32] cmake -G "MSYS Makefiles" -DNOFORTRAN=1 ..
   - if [%COMPILER%]==[MinGW-gcc-5.3.0] cmake -G "MSYS Makefiles" -DNOFORTRAN=1 ..
-  - if [%WITH_FORTRAN%]==[OFF] cmake -G "Ninja" -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_C_COMPILER=clang-cl -DCMAKE_MT=mt -DMSVC_STATIC_CRT=ON ..
-  - if [%WITH_FORTRAN%]==[ON] cmake -G "Ninja" -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_C_COMPILER=clang-cl -DCMAKE_Fortran_COMPILER=flang -DCMAKE_MT=mt -DBUILD_WITHOUT_LAPACK=no -DNOFORTRAN=0 ..
-  - if [%USE_OPENMP%]==[ON] cmake -DUSE_OPENMP=ON ..
+  - if [%WITH_FORTRAN%]==[no] cmake -G "Ninja" -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_C_COMPILER=clang-cl -DMSVC_STATIC_CRT=ON ..
+  - if [%WITH_FORTRAN%]==[yes] cmake -G "Ninja" -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_C_COMPILER=clang-cl -DCMAKE_Fortran_COMPILER=flang -DBUILD_WITHOUT_LAPACK=no -DNOFORTRAN=0 ..
   - if [%DYNAMIC_ARCH%]==[ON] cmake -DDYNAMIC_ARCH=ON -DDYNAMIC_LIST='CORE2;NEHALEM;SANDYBRIDGE;BULLDOZER;HASWELL' ..
 
 build_script:
   - cmake --build .
 
 test_script:
-  - ctest -j2
+  - echo Running Test
+  - cd utest
+  - openblas_utest
   

azure-pipelines.yml

@@ -4,22 +4,14 @@ trigger:
   branches:
     include:
       - develop
-resources:
-  containers:
-      - container: oneapi-hpckit
-        image: intel/oneapi-hpckit:latest
-        options: '-v /usr/bin/sudo:/usr/bin/sudo -v /usr/lib/sudo/libsudo_util.so.0:/usr/lib/sudo/libsudo_util.so.0 -v /usr/lib/sudo/sudoers.so:/usr/lib/sudo/sudoers.so'
-      - container: oneapi-basekit
-        image: intel/oneapi-basekit:latest
-        options: '-v /usr/bin/sudo:/usr/bin/sudo -v /usr/lib/sudo/libsudo_util.so.0:/usr/lib/sudo/libsudo_util.so.0 -v /usr/lib/sudo/sudoers.so:/usr/lib/sudo/sudoers.so'
- 
+
 jobs:
 # manylinux1 is useful to test because the
 # standard Docker container uses an old version
 # of gcc / glibc
 - job: manylinux1_gcc
   pool:
-    vmImage: 'ubuntu-latest'
+    vmImage: 'ubuntu-16.04'
   steps:
   - script: |
       echo "FROM quay.io/pypa/manylinux1_x86_64
@@ -35,7 +27,7 @@ jobs:
     displayName: Run manylinux1 docker build
 - job: Intel_SDE_skx
   pool:
-    vmImage: 'ubuntu-latest'
+    vmImage: 'ubuntu-16.04'
   steps:
   - script: |
       # at the time of writing the available Azure Ubuntu vm image
@@ -57,207 +49,3 @@ jobs:
       # we need a privileged docker run for sde process attachment
       docker run --privileged intel_sde
     displayName: 'Run AVX512 SkylakeX docker build / test'
-
-- job: Windows_cl
-  pool:
-     vmImage: 'windows-latest'
-  steps:   
-  - task: CMake@1
-    inputs:
-      workingDirectory: 'build' # Optional
-      cmakeArgs: '-G "Visual Studio 16 2019" ..'
-  - task: CMake@1
-    inputs:
-      cmakeArgs: '--build . --config Release'
-      workingDirectory: 'build'
-  - script: |
-      cd build
-      cd utest
-      dir
-      openblas_utest.exe
-
-- job: Windows_mingw_gmake
-  pool:
-     vmImage: 'windows-latest'
-  steps:   
-  - script: |
-      mingw32-make CC=gcc FC=gfortran DYNAMIC_ARCH=1 DYNAMIC_LIST="NEHALEM SANDYBRIDGE HASWELL"
-
-- job: Windows_clang_cmake
-  pool:
-     vmImage: 'windows-latest'
-  steps:
-  - script: |
-      set "PATH=C:\Miniconda\Scripts;C:\Miniconda\Library\bin;C:\Miniconda\Library\usr\bin;C:\Miniconda\condabin;%PATH%"
-      set "LIB=C:\Miniconda\Library\lib;%LIB%"
-      set "CPATH=C:\Miniconda\Library\include;%CPATH%
-      conda config --add channels conda-forge --force
-      conda config --set auto_update_conda false
-      conda install --yes ninja
-      call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
-      mkdir build 
-      cd build
-      cmake -G "Ninja" -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_MT=mt -DCMAKE_BUILD_TYPE=Release -DNOFORTRAN=1 -DMSVC_STATIC_CRT=ON ..
-      cmake --build . --config Release
-      ctest
-
-- job: Windows_flang_clang
-  pool:
-     vmImage: 'windows-latest'
-  steps:
-  - script: |
-      set "PATH=C:\Miniconda\Scripts;C:\Miniconda\Library\bin;C:\Miniconda\Library\usr\bin;C:\Miniconda\condabin;%PATH%"
-      set "LIB=C:\Miniconda\Library\lib;%LIB%"
-      set "CPATH=C:\Miniconda\Library\include;%CPATH%"
-      conda config --add channels conda-forge --force
-      conda config --set auto_update_conda false
-      conda install --yes --quiet ninja flang
-      mkdir build 
-      cd build
-      call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
-      cmake -G "Ninja" -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_Fortran_COMPILER=flang -DCMAKE_MT=mt -DCMAKE_BUILD_TYPE=Release -DMSVC_STATIC_CRT=ON ..
-      cmake --build . --config Release
-      ctest
-
-- job: OSX_OpenMP
-  pool:
-     vmImage: 'macOS-10.15'
-  steps:   
-  - script: |
-      brew update
-      make TARGET=CORE2 DYNAMIC_ARCH=1 USE_OPENMP=1 INTERFACE64=1 CC=gcc-10 FC=gfortran-10
-      make TARGET=CORE2 DYNAMIC_ARCH=1 USE_OPENMP=1 INTERFACE64=1 CC=gcc-10 FC=gfortran-10 PREFIX=../blasinst install
-      ls -lR ../blasinst
-     
-- job: OSX_GCC_Nothreads
-  pool:
-     vmImage: 'macOS-10.15'
-  steps:   
-  - script: |
-      brew update
-      make USE_THREADS=0 CC=gcc-10 FC=gfortran-10
-     
-- job: OSX_OpenMP_Clang
-  pool:
-     vmImage: 'macOS-10.15'
-  variables:
-     LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
-     LIBRARY_PATH: /usr/local/opt/llvm/lib
-  steps:   
-  - script: |
-      brew update
-      brew install llvm libomp
-      make TARGET=CORE2 USE_OPENMP=1 INTERFACE64=1 DYNAMIC_ARCH=1 CC=/usr/local/opt/llvm/bin/clang FC=gfortran-10
-
-- job: OSX_OpenMP_Clang_cmake
-  pool:
-     vmImage: 'macOS-10.15'
-  variables:
-     LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
-     LIBRARY_PATH: /usr/local/opt/llvm/lib
-  steps:   
-  - script: |
-      brew update
-      brew install llvm libomp
-      mkdir build
-      cd build
-      cmake -DTARGET=CORE2 -DUSE_OPENMP=1 -DINTERFACE64=1 -DDYNAMIC_ARCH=1 -DCMAKE_C_COMPILER=/usr/local/opt/llvm/bin/clang -DNOFORTRAN=1 -DNO_AVX512=1 ..
-      make
-      ctest
-      
-- job: OSX_dynarch_cmake
-  pool:
-     vmImage: 'macOS-10.15'
-  variables:
-     LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
-     LIBRARY_PATH: /usr/local/opt/llvm/lib
-  steps:   
-  - script: |
-      mkdir build
-      cd build
-      cmake -DTARGET=CORE2 -DDYNAMIC_ARCH=1 -DCMAKE_C_COMPILER=gcc-10 -DCMAKE_Fortran_COMPILER=gfortran-10 -DBUILD_SHARED_LIBS=ON ..
-      cmake --build .
-      ctest
-      
-- job: OSX_Ifort_Clang
-  pool:
-     vmImage: 'macOS-10.15'
-  variables:
-     LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
-     MACOS_HPCKIT_URL: https://registrationcenter-download.intel.com/akdlm/irc_nas/17643/m_HPCKit_p_2021.2.0.2903_offline.dmg
-     LIBRARY_PATH: /usr/local/opt/llvm/lib
-     MACOS_FORTRAN_COMPONENTS: intel.oneapi.mac.ifort-compiler
-  steps:   
-  - script: |
-      brew update
-      brew install llvm libomp
-      sudo mkdir -p /opt/intel
-      sudo chown $USER /opt/intel
-    displayName: prepare for cache restore
-  - task: Cache@2
-    inputs:
-      path: /opt/intel/oneapi
-      key: '"install" | "$(MACOS_HPCKIT_URL)" | "$(MACOS_FORTRAN_COMPONENTS)"'
-      cacheHitVar: CACHE_RESTORED
-  - script: | 
-      curl --output webimage.dmg --url $(MACOS_HPCKIT_URL) --retry 5 --retry-delay 5
-      hdiutil attach webimage.dmg
-      sudo /Volumes/"$(basename "$(MACOS_HPCKIT_URL)" .dmg)"/bootstrapper.app/Contents/MacOS/bootstrapper -s --action install --components="$(MACOS_FORTRAN_COMPONENTS)" --eula=accept --continue-with-optional-error=yes --log-dir=.
-      installer_exit_code=$?
-      hdiutil detach /Volumes/"$(basename "$URL" .dmg)" -quiet
-      exit $installer_exit_code
-    displayName: install
-    condition: ne(variables.CACHE_RESTORED, 'true')
-  - script: | 
-      source /opt/intel/oneapi/setvars.sh
-      make CC=/usr/local/opt/llvm/bin/clang FC=ifort
- 
-- job: OSX_NDK_ARMV7
-  pool:
-     vmImage: 'macOS-10.15'
-  steps:   
-  - script: | 
-      brew update
-      brew install --cask android-ndk
-      export ANDROID_NDK_HOME=/usr/local/share/android-ndk
-      make TARGET=ARMV7 ONLY_CBLAS=1 CC=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/darwin-x86_64/bin/armv7a-linux-androideabi21-clang AR=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-ar HOSTCC=gcc ARM_SOFTFP_ABI=1 -j4
-
-- job: OSX_IOS_ARMV8
-  pool:
-     vmImage: 'macOS-11'
-  variables:
-     CC: /Applications/Xcode_12.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-     CFLAGS: -O2 -Wno-macro-redefined -isysroot /Applications/Xcode_12.4.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS14.4.sdk -arch arm64 -miphoneos-version-min=10.0
-  steps:
-  - script: |
-     make TARGET=ARMV8 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1
-
-- job: OSX_IOS_ARMV7
-  pool:
-     vmImage: 'macOS-10.15'
-  variables:
-     CC: /Applications/Xcode_12.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-     CFLAGS: -O2 -mno-thumb -Wno-macro-redefined -isysroot /Applications/Xcode_12.4.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS14.4.sdk -arch armv7 -miphoneos-version-min=5.1
-  steps:
-  - script: |
-     make TARGET=ARMV7 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1
-
-- job: ALPINE_MUSL
-  pool:
-     vmImage: 'ubuntu-latest'
-  steps:
-  - script: |
-        wget https://raw.githubusercontent.com/alpinelinux/alpine-chroot-install/v0.13.2/alpine-chroot-install \
-          && echo '60c7e0b5d82e21d1a549fc9a46ba3b36688c09dc  alpine-chroot-install' | sha1sum -c \
-          || exit 1
-        alpine() { /alpine/enter-chroot -u "$USER" "$@"; }
-        sudo sh alpine-chroot-install -p 'build-base gfortran perl linux-headers sudo'
-        alpine make DYNAMIC_ARCH=1 BINARY=64
-        alpine make DYNAMIC_ARCH=1 BINARY=64 PREFIX=mytestdir install
-        alpine ls -l mytestdir/include
-        alpine echo "// tests that inclusion of openblas_config.h works with musl" >test_install.c
-        alpine echo "#include <openblas_config.h>" >>test_install.c
-        alpine echo "int main(){" >> test_install.c
-        alpine echo "cpu_set_t* cpu_set = NULL;}" >>test_install.c
-        alpine gcc -Imytestdir/include test_install.c -Lmytestdir/lib -lopenblas -lpthread -lgfortran -o test_install
-        

benchmark/amax.c

@@ -1,133 +0,0 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef AMAX
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define AMAX BLASFUNC(dzamax)
-#else
-#define AMAX BLASFUNC(scamax)
-#endif
-#else
-#ifdef DOUBLE
-#define AMAX BLASFUNC(damax)
-#else
-#define AMAX BLASFUNC(samax)
-#endif
-#endif
-
-int main(int argc, char *argv[])
-{
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x = 1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from = 1;
-  int to = 200;
-  int step = 1;
-
-  double time1, timeg;
-
-  argc--;
-  argv++;
-
-  if (argc > 0)
-  {
-    from = atol(*argv);
-    argc--;
-    argv++;
-  }
-  if (argc > 0)
-  {
-    to = MAX(atol(*argv), from);
-    argc--;
-    argv++;
-  }
-  if (argc > 0)
-  {
-    step = atol(*argv);
-    argc--;
-    argv++;
-  }
-
-  if ((p = getenv("OPENBLAS_LOOPS")))
-    loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))
-    inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step, inc_x, loops);
-
-  if ((x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL)
-  {
-    fprintf(stderr, "Out of Memory!!\n");
-    exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for (m = from; m <= to; m += step)
-  {
-
-    timeg = 0;
-    fprintf(stderr, " %6d : ", (int)m);
-
-    for (l = 0; l < loops; l++)
-    {
-
-      for (i = 0; i < m * COMPSIZE * abs(inc_x); i++)
-      {
-        x[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
-      }
-
-      begin();
-      AMAX(&m, x, &inc_x);
-      end();
-      timeg += getsec();
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-            " %10.2f MFlops %10.6f sec\n",
-            COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/amin.c

@@ -1,137 +0,0 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef AMIN
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define AMIN BLASFUNC(dzamin)
-#else
-#define AMIN BLASFUNC(scamin)
-#endif
-#else
-#ifdef DOUBLE
-#define AMIN BLASFUNC(damin)
-#else
-#define AMIN BLASFUNC(samin)
-#endif
-#endif
-
-int main(int argc, char *argv[])
-{
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x = 1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from = 1;
-  int to = 200;
-  int step = 1;
-
-  double time1, timeg;
-
-  argc--;
-  argv++;
-
-  if (argc > 0)
-  {
-    from = atol(*argv);
-    argc--;
-    argv++;
-  }
-  if (argc > 0)
-  {
-    to = MAX(atol(*argv), from);
-    argc--;
-    argv++;
-  }
-  if (argc > 0)
-  {
-    step = atol(*argv);
-    argc--;
-    argv++;
-  }
-
-  if ((p = getenv("OPENBLAS_LOOPS")))
-    loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))
-    inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step, inc_x, loops);
-
-  if ((x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL)
-  {
-    fprintf(stderr, "Out of Memory!!\n");
-    exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for (m = from; m <= to; m += step)
-  {
-
-    timeg = 0;
-
-    fprintf(stderr, " %6d : ", (int)m);
-
-    for (l = 0; l < loops; l++)
-    {
-
-      for (i = 0; i < m * COMPSIZE * abs(inc_x); i++)
-      {
-        x[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
-      }
-
-      begin();
-
-      AMIN(&m, x, &inc_x);
-
-      end();
-
-      timeg += getsec();
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-            " %10.2f MFlops %10.6f sec\n",
-            COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/asum.c

@@ -25,108 +25,169 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef ASUM
 
 #ifdef COMPLEX
 #ifdef DOUBLE
-#define ASUM BLASFUNC(dzasum)
+#define ASUM   BLASFUNC(dzasum)
 #else
-#define ASUM BLASFUNC(scasum)
+#define ASUM   BLASFUNC(scasum)
 #endif
 #else
 #ifdef DOUBLE
-#define ASUM BLASFUNC(dasum)
+#define ASUM   BLASFUNC(dasum)
 #else
-#define ASUM BLASFUNC(sasum)
+#define ASUM   BLASFUNC(sasum)
 #endif
 #endif
 
-int main(int argc, char *argv[])
-{
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
+int main(int argc, char *argv[]){
 
   FLOAT *x;
   FLOAT result;
   blasint m, i;
-  blasint inc_x = 1;
+  blasint inc_x=1;
   int loops = 1;
   int l;
   char *p;
 
-  int from = 1;
-  int to = 200;
-  int step = 1;
-  double time1, timeg;
+  int from =   1;
+  int to   = 200;
+  int step =   1;
 
-  argc--;
-  argv++;
+  struct timeval start, stop;
+  double time1,timeg;
 
-  if (argc > 0)
-  {
-    from = atol(*argv);
-    argc--;
-    argv++;
-  }
-  if (argc > 0)
-  {
-    to = MAX(atol(*argv), from);
-    argc--;
-    argv++;
-  }
-  if (argc > 0)
-  {
-    step = atol(*argv);
-    argc--;
-    argv++;
+  argc--;argv++;
+
+  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
+  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
+  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
+
+  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
+  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
+
+  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
+
+  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
+    fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-  if ((p = getenv("OPENBLAS_LOOPS")))
-    loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))
-    inc_x = atoi(p);
 
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step, inc_x, loops);
-
-  if ((x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL)
-  {
-    fprintf(stderr, "Out of Memory!!\n");
-    exit(1);
-  }
-
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
   fprintf(stderr, "   SIZE       Flops\n");
 
-  for (m = from; m <= to; m += step)
+  for(m = from; m <= to; m += step)
   {
 
-    timeg = 0;
+   timeg=0;
 
-    fprintf(stderr, " %6d : ", (int)m);
+   fprintf(stderr, " %6d : ", (int)m);
 
-    for (l = 0; l < loops; l++)
-    {
 
-      for (i = 0; i < m * COMPSIZE * abs(inc_x); i++)
-      {
-        x[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
-      }
-      begin();
-      result = ASUM(&m, x, &inc_x);
-      end();
-      timeg += getsec();
+   for (l=0; l<loops; l++)
+   {
+
+   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
+			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+
+    	gettimeofday( &start, (struct timezone *)0);
+
+    	result = ASUM (&m, x, &inc_x);
+
+    	gettimeofday( &stop, (struct timezone *)0);
+
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
+	timeg += time1;
+
     }
-    if (loops > 1)
-      timeg /= loops;
+
+    timeg /= loops;
 
 #ifdef COMPLEX
     fprintf(stderr, " %10.2f MFlops %10.6f sec\n", 4. * (double)m / timeg * 1.e-6, timeg);
 #else
     fprintf(stderr, " %10.2f MFlops %10.6f sec\n", 2. * (double)m / timeg * 1.e-6, timeg);
 #endif
+
   }
 
   return 0;

benchmark/axpby.c

@@ -1,124 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef AXPBY
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define AXPBY   BLASFUNC(zaxpby)
-#else
-#define AXPBY   BLASFUNC(caxpby)
-#endif
-#else
-#ifdef DOUBLE
-#define AXPBY   BLASFUNC(daxpby)
-#else
-#define AXPBY   BLASFUNC(saxpby)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x, *y;
-  FLOAT alpha[2] = { 2.0, 2.0 };
-  FLOAT beta[2] = {2.0, 2.0};
-  blasint m, i;
-  blasint inc_x=1,inc_y=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);       argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);    argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);       argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-  if ((p = getenv("OPENBLAS_INCY")))   inc_y = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Inc_y = %d Loops = %d\n", from, to, step,inc_x,inc_y,loops);
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-    timeg=0;
-
-    fprintf(stderr, " %6d : ", (int)m);
-
-
-    for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-            x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-    }
-
-    for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
-            y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-    }
-
-    for (l=0; l<loops; l++)
-    {
-        begin();
-        AXPBY (&m, alpha, x, &inc_x, beta, y, &inc_y );
-        end();
-        timeg += getsec();
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-        " %10.2f MFlops %10.6f sec\n",
-        (COMPSIZE * COMPSIZE * 4. - COMPSIZE) * (double)m / timeg * 1.e-6, timeg);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/axpy.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef AXPY
 
@@ -43,6 +49,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *x, *y;
@@ -56,6 +127,8 @@ int main(int argc, char *argv[]){
   int from =   1;
   int to   = 200;
   int step =   1;
+
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -78,7 +151,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -102,13 +175,13 @@ int main(int argc, char *argv[]){
    	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
 			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    	}
-    	begin();
+    	gettimeofday( &start, (struct timezone *)0);
 
     	AXPY (&m, alpha, x, &inc_x, y, &inc_y );
 
-    	end();
+    	gettimeofday( &stop, (struct timezone *)0);
 
-    	time1 = getsec();
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
 	timeg += time1;
 
@@ -117,7 +190,7 @@ int main(int argc, char *argv[]){
     timeg /= loops;
 
     fprintf(stderr,
-	    " %10.2f MFlops %10.9f sec\n",
+	    " %10.2f MFlops %10.6f sec\n",
 	    COMPSIZE * COMPSIZE * 2. * (double)m / timeg * 1.e-6, timeg);
 
   }

benchmark/bench.h

@@ -1,116 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-#ifdef __CYGWIN32__
-#include <sys/time.h>
-#elif defined(__APPLE__)
-#include <mach/mach_time.h>
-#endif
-#include "common.h"
-
-#if defined(__WIN32__) || defined(__WIN64__)
-
-#ifndef DELTA_EPOCH_IN_MICROSECS
-#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
-#endif
-
-int gettimeofday(struct timeval *tv, void *tz){
-
-  FILETIME ft;
-  unsigned __int64 tmpres = 0;
-  static int tzflag;
-
-  if (NULL != tv)
-    {
-      GetSystemTimeAsFileTime(&ft);
-
-      tmpres |= ft.dwHighDateTime;
-      tmpres <<= 32;
-      tmpres |= ft.dwLowDateTime;
-
-      /*converting file time to unix epoch*/
-      tmpres /= 10;  /*convert into microseconds*/
-      tmpres -= DELTA_EPOCH_IN_MICROSECS;
-      tv->tv_sec = (long)(tmpres / 1000000UL);
-      tv->tv_usec = (long)(tmpres % 1000000UL);
-    }
-
-  return 0;
-}
-
-#endif
-
-#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
-
-static void *huge_malloc(BLASLONG size){
-  int shmid;
-  void *address;
-
-#ifndef SHM_HUGETLB
-#define SHM_HUGETLB 04000
-#endif
-
-  if ((shmid =shmget(IPC_PRIVATE,
-		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
-		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
-    printf( "Memory allocation failed(shmget).\n");
-    exit(1);
-  }
-
-  address = shmat(shmid, NULL, SHM_RND);
-
-  if ((BLASLONG)address == -1){
-    printf( "Memory allocation failed(shmat).\n");
-    exit(1);
-  }
-
-  shmctl(shmid, IPC_RMID, 0);
-
-  return address;
-}
-
-
-#define malloc huge_malloc
-
-#endif
-
-#if defined(__WIN32__) || defined(__WIN64__) || !defined(_POSIX_TIMERS)
-  struct timeval start, stop;
-#elif defined(__APPLE__)
- mach_timebase_info_data_t info;
- uint64_t start = 0, stop = 0;
-#else
-  struct timespec start = { 0, 0 }, stop = { 0, 0 };
-#endif
-
-double getsec()
-{
-#if defined(__WIN32__) || defined(__WIN64__) || !defined(_POSIX_TIMERS)
-    return (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
-#elif defined(__APPLE__)
-    mach_timebase_info(&info);
-    return (double)(((stop - start) * info.numer)/info.denom) * 1.e-9;
-#else
-    return (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_nsec - start.tv_nsec)) * 1.e-9;
-#endif
-}
-
-void begin() {
-#if defined(__WIN32__) || defined(__WIN64__) || !defined(_POSIX_TIMERS)
-    gettimeofday( &start, (struct timezone *)0);
-#elif defined(__APPLE__)
-    start = clock_gettime_nsec_np(CLOCK_UPTIME_RAW);
-#else
-    clock_gettime(CLOCK_REALTIME, &start);
-#endif
-}
-
-void end() {
-#if defined(__WIN32__) || defined(__WIN64__) || !defined(_POSIX_TIMERS)
-    gettimeofday( &stop, (struct timezone *)0);
-#elif defined(__APPLE__)
-    stop = clock_gettime_nsec_np(CLOCK_UPTIME_RAW);
-#else
-    clock_gettime(CLOCK_REALTIME, &stop);
-#endif
-}

benchmark/cholesky.c

@@ -36,7 +36,12 @@
 /* or implied, of The University of Texas at Austin.                 */
 /*********************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
 
 double fabs(double);
 
@@ -66,6 +71,41 @@ double fabs(double);
 #endif
 #endif
 
+
+
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+
 static __inline double getmflops(int ratio, int m, double secs){
 
   double mm = (double)m;
@@ -105,6 +145,7 @@ int main(int argc, char *argv[]){
 
   FLOAT maxerr;
 
+  struct timeval start, stop;
   double time1;
 
   argc--;argv++;
@@ -132,46 +173,46 @@ int main(int argc, char *argv[]){
 #ifndef COMPLEX
       if (uplos & 1) {
 	for (j = 0; j < m; j++) {
-	  for(i = 0; i < j; i++)     a[(long)i + (long)j * (long)m] = 0.;
-	                             a[(long)j + (long)j * (long)m] = ((double) rand() / (double) RAND_MAX) + 8.;
-	  for(i = j + 1; i < m; i++) a[(long)i + (long)j * (long)m] = ((double) rand() / (double) RAND_MAX) - 0.5;
+	  for(i = 0; i < j; i++)     a[i + j * m] = 0.;
+	                             a[j + j * m] = ((double) rand() / (double) RAND_MAX) + 8.;
+	  for(i = j + 1; i < m; i++) a[i + j * m] = ((double) rand() / (double) RAND_MAX) - 0.5;
 	}
       } else {
 	for (j = 0; j < m; j++) {
-	  for(i = 0; i < j; i++)     a[(long)i + (long)j * (long)m] = ((double) rand() / (double) RAND_MAX) - 0.5;
-	                             a[(long)j + (long)j * (long)m] = ((double) rand() / (double) RAND_MAX) + 8.;
-	  for(i = j + 1; i < m; i++) a[(long)i + (long)j * (long)m] = 0.;
+	  for(i = 0; i < j; i++)     a[i + j * m] = ((double) rand() / (double) RAND_MAX) - 0.5;
+	                             a[j + j * m] = ((double) rand() / (double) RAND_MAX) + 8.;
+	  for(i = j + 1; i < m; i++) a[i + j * m] = 0.;
 	}
       }
 #else
       if (uplos & 1) {
 	for (j = 0; j < m; j++) {
 	  for(i = 0; i < j; i++) {
-	    a[((long)i + (long)j * (long)m) * 2 + 0] = 0.;
-	    a[((long)i + (long)j * (long)m) * 2 + 1] = 0.;
+	    a[(i + j * m) * 2 + 0] = 0.;
+	    a[(i + j * m) * 2 + 1] = 0.;
 	  }
 
-	  a[((long)j + (long)j * (long)m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
-	  a[((long)j + (long)j * (long)m) * 2 + 1] = 0.;
+	  a[(j + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
+	  a[(j + j * m) * 2 + 1] = 0.;
 
 	  for(i = j + 1; i < m; i++) {
-	    a[((long)i + (long)j * (long)m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) - 0.5;
-	    a[((long)i + (long)j * (long)m) * 2 + 1] = ((double) rand() / (double) RAND_MAX) - 0.5;
+	    a[(i + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) - 0.5;
+	    a[(i + j * m) * 2 + 1] = ((double) rand() / (double) RAND_MAX) - 0.5;
 	  }
 	}
       } else {
 	for (j = 0; j < m; j++) {
 	  for(i = 0; i < j; i++) {
-	    a[((long)i + (long)j * (long)m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) - 0.5;
-	    a[((long)i + (long)j * (long)m) * 2 + 1] = ((double) rand() / (double) RAND_MAX) - 0.5;
+	    a[(i + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) - 0.5;
+	    a[(i + j * m) * 2 + 1] = ((double) rand() / (double) RAND_MAX) - 0.5;
 	  }
 
-	  a[((long)j + (long)j * (long)m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
-	  a[((long)j + (long)j * (long)m) * 2 + 1] = 0.;
+	  a[(j + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
+	  a[(j + j * m) * 2 + 1] = 0.;
 
 	  for(i = j + 1; i < m; i++) {
-	    a[((long)i + (long)j * (long)m) * 2 + 0] = 0.;
-	    a[((long)i + (long)j * (long)m) * 2 + 1] = 0.;
+	    a[(i + j * m) * 2 + 0] = 0.;
+	    a[(i + j * m) * 2 + 1] = 0.;
 	  }
 	}
       }
@@ -179,31 +220,29 @@ int main(int argc, char *argv[]){
 
       SYRK(uplo[uplos], trans[uplos], &m, &m, alpha, a, &m, beta, b, &m);
 
-      begin();
+      gettimeofday( &start, (struct timezone *)0);
 
       POTRF(uplo[uplos], &m, b, &m, &info);
 
-      end();
+      gettimeofday( &stop, (struct timezone *)0);
 
       if (info != 0) {
 	fprintf(stderr, "Info = %d\n", info);
 	exit(1);
       }
 
-     time1 = getsec();
+     time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
+      maxerr = 0.;
 
       if (!(uplos & 1)) {
 	for (j = 0; j < m; j++) {
 	  for(i = 0; i <= j; i++) {
 #ifndef COMPLEX
-	    if (maxerr < fabs(a[(long)i + (long)j * (long)m] - b[(long)i + (long)j * (long)m]))
-	        maxerr = fabs(a[(long)i + (long)j * (long)m] - b[(long)i + (long)j * (long)m]);
+	    if (maxerr < fabs(a[i + j * m] - b[i + j * m])) maxerr = fabs(a[i + j * m] - b[i + j * m]);
 #else
-	    if (maxerr < fabs(a[((long)i + (long)j * (long)m) * 2 + 0] - b[((long)i + (long)j * (long)m) * 2 + 0]))
-	        maxerr = fabs(a[((long)i + (long)j * (long)m) * 2 + 0] - b[((long)i + (long)j * (long)m) * 2 + 0]);
-	    if (maxerr < fabs(a[((long)i + (long)j * (long)m) * 2 + 1] - b[((long)i + (long)j * (long)m) * 2 + 1]))
-	        maxerr = fabs(a[((long)i + (long)j * (long)m) * 2 + 1] - b[((long)i + (long)j * (long)m) * 2 + 1]);
+	    if (maxerr < fabs(a[(i + j * m) * 2 + 0] - b[(i + j * m) * 2 + 0])) maxerr = fabs(a[(i + j * m) * 2 + 0] - b[(i + j * m) * 2 + 0]);
+	    if (maxerr < fabs(a[(i + j * m) * 2 + 1] - b[(i + j * m) * 2 + 1])) maxerr = fabs(a[(i + j * m) * 2 + 1] - b[(i + j * m) * 2 + 1]);
 #endif
 	  }
 	}
@@ -211,13 +250,10 @@ int main(int argc, char *argv[]){
 	for (j = 0; j < m; j++) {
 	  for(i = j; i < m; i++) {
 #ifndef COMPLEX
-	    if (maxerr < fabs(a[(long)i + (long)j * (long)m] - b[(long)i + (long)j * (long)m]))
-	        maxerr = fabs(a[(long)i + (long)j * (long)m] - b[(long)i + (long)j * (long)m]);
+	    if (maxerr < fabs(a[i + j * m] - b[i + j * m])) maxerr = fabs(a[i + j * m] - b[i + j * m]);
 #else
-	    if (maxerr < fabs(a[((long)i + (long)j * (long)m) * 2 + 0] - b[((long)i + (long)j * (long)m) * 2 + 0]))
-	        maxerr = fabs(a[((long)i + (long)j * (long)m) * 2 + 0] - b[((long)i + (long)j * (long)m) * 2 + 0]);
-	    if (maxerr < fabs(a[((long)i + (long)j * (long)m) * 2 + 1] - b[((long)i + (long)j * (long)m) * 2 + 1]))
-	        maxerr = fabs(a[((long)i + (long)j * (long)m) * 2 + 1] - b[((long)i + (long)j * (long)m) * 2 + 1]);
+	    if (maxerr < fabs(a[(i + j * m) * 2 + 0] - b[(i + j * m) * 2 + 0])) maxerr = fabs(a[(i + j * m) * 2 + 0] - b[(i + j * m) * 2 + 0]);
+	    if (maxerr < fabs(a[(i + j * m) * 2 + 1] - b[(i + j * m) * 2 + 1])) maxerr = fabs(a[(i + j * m) * 2 + 1] - b[(i + j * m) * 2 + 1]);
 #endif
 	  }
 	}

benchmark/copy.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef COPY
 
@@ -43,6 +49,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *x, *y;
@@ -57,9 +128,8 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
-  double time1 = 0.0, timeg = 0.0;
-  long nanos = 0;
-  time_t seconds = 0;
+  struct timeval start, stop;
+  double time1,timeg;
 
   argc--;argv++;
 
@@ -81,7 +151,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -93,27 +163,35 @@ int main(int argc, char *argv[]){
    timeg=0;
 
    fprintf(stderr, " %6d : ", (int)m);
-   for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-       x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   }
 
-   for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
-       y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   }
 
    for (l=0; l<loops; l++)
    {
-       begin();
-       COPY (&m, x, &inc_x, y, &inc_y );
-       end();
-       timeg += getsec();
-   }
 
-      timeg /= loops;
+   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
+			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
 
-      fprintf(stderr,
-	    " %10.2f MBytes %12.9f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg / 1.e6, timeg);
+   	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
+			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+    	gettimeofday( &start, (struct timezone *)0);
+
+    	COPY (&m, x, &inc_x, y, &inc_y );
+
+    	gettimeofday( &stop, (struct timezone *)0);
+
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
+	timeg += time1;
+
+    }
+
+    timeg /= loops;
+
+    fprintf(stderr,
+	    " %10.2f MBytes %10.6f sec\n",
+	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
 
   }
 

benchmark/dot.c

@@ -25,16 +25,89 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef DOT
 
+
 #ifdef DOUBLE
 #define DOT   BLASFUNC(ddot)
 #else
 #define DOT   BLASFUNC(sdot)
 #endif
 
+
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *x, *y;
@@ -49,6 +122,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -71,7 +145,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -95,12 +169,15 @@ int main(int argc, char *argv[]){
    	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
 			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    	}
-    	begin();
+    	gettimeofday( &start, (struct timezone *)0);
 
     	result = DOT (&m, x, &inc_x, y, &inc_y );
 
-    	end();
-	    timeg += getsec();
+    	gettimeofday( &stop, (struct timezone *)0);
+
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
+	timeg += time1;
 
     }
 

benchmark/geev.c

@@ -36,7 +36,13 @@
 /* or implied, of The University of Texas at Austin.                 */
 /*********************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef GEEV
 
@@ -68,6 +74,71 @@ extern void GEEV( char* jobvl, char* jobvr, blasint* n, FLOAT* a,
                 FLOAT* vr, blasint* ldvr, FLOAT* work, blasint* lwork, FLOAT *rwork, blasint* info );
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a,*vl,*vr,*wi,*wr,*work,*rwork;
@@ -83,6 +154,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1;
 
   argc--;argv++;
@@ -123,7 +195,7 @@ int main(int argc, char *argv[]){
 
     for(j = 0; j < to; j++){
       for(i = 0; i < to * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)to * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	a[i + j * to * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       }
     }
 
@@ -142,7 +214,7 @@ int main(int argc, char *argv[]){
   }
 
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -151,7 +223,7 @@ int main(int argc, char *argv[]){
   for(m = from; m <= to; m += step){
 
     fprintf(stderr, " %6d : ", (int)m);
-    begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     lwork = -1;
 #ifndef COMPLEX
@@ -167,14 +239,14 @@ int main(int argc, char *argv[]){
     GEEV (&job, &jobr, &m, a, &m, wr, vl, &m, vr, &m, work, &lwork,rwork, &info);
 #endif
 
-    end();
+    gettimeofday( &stop, (struct timezone *)0);
 
     if (info) {
       fprintf(stderr, "failed to compute eigenvalues .. %d\n", info);
       exit(1);
     }
 
-    time1 = getsec();
+    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
     fprintf(stderr,
 	    " %10.2f MFlops : %10.2f Sec : %d\n",

benchmark/gemm.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef GEMM
 
@@ -33,8 +39,6 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef DOUBLE
 #define GEMM   BLASFUNC(dgemm)
-#elif defined(HALF)
-#define GEMM   BLASFUNC(sbgemm)
 #else
 #define GEMM   BLASFUNC(sgemm)
 #endif
@@ -49,10 +53,74 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
-  IFLOAT *a, *b;
-  FLOAT *c;
+  FLOAT *a, *b, *c;
   FLOAT alpha[] = {1.0, 0.0};
   FLOAT beta [] = {0.0, 0.0};
   char transa = 'N';
@@ -68,6 +136,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1, timeg;
 
   argc--;argv++;
@@ -115,25 +184,25 @@ int main(int argc, char *argv[]){
     k = to;
   }
 
-  if (( a = (IFLOAT *)malloc(sizeof(IFLOAT) * m * k * COMPSIZE)) == NULL) {
+  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * m * k * COMPSIZE)) == NULL) {
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
-  if (( b = (IFLOAT *)malloc(sizeof(IFLOAT) * k * n * COMPSIZE)) == NULL) {
+  if (( b = (FLOAT *)malloc(sizeof(FLOAT) * k * n * COMPSIZE)) == NULL) {
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
   if (( c = (FLOAT *)malloc(sizeof(FLOAT) * m * n * COMPSIZE)) == NULL) {
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
   for (i = 0; i < m * k * COMPSIZE; i++) {
-    a[i] = ((IFLOAT) rand() / (IFLOAT) RAND_MAX) - 0.5;
+    a[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
   }
   for (i = 0; i < k * n * COMPSIZE; i++) {
-    b[i] = ((IFLOAT) rand() / (IFLOAT) RAND_MAX) - 0.5;
+    b[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
   }
   for (i = 0; i < m * n * COMPSIZE; i++) {
     c[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
@@ -156,14 +225,14 @@ int main(int argc, char *argv[]){
     ldc = m;
 
     fprintf(stderr, " M=%4d, N=%4d, K=%4d : ", (int)m, (int)n, (int)k);
-    begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     for (j=0; j<loops; j++) {
       GEMM (&transa, &transb, &m, &n, &k, alpha, a, &lda, b, &ldb, beta, c, &ldc);
     }
 
-    end();
-    time1 = getsec();
+    gettimeofday( &stop, (struct timezone *)0);
+    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
     timeg = time1/loops;
     fprintf(stderr,

benchmark/gemm3m.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef GEMM
 
@@ -47,6 +53,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *b, *c;
@@ -62,6 +133,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -91,7 +163,7 @@ int main(int argc, char *argv[]){
 	loops = atoi(p);
 
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -109,18 +181,22 @@ int main(int argc, char *argv[]){
   
     	for(j = 0; j < m; j++){
       		for(i = 0; i < m * COMPSIZE; i++){
-			a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-			b[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-			c[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+			a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+			b[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+			c[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       		}
     	}
 
-    	begin();
+    	gettimeofday( &start, (struct timezone *)0);
 
     	GEMM (&trans, &trans, &m, &m, &m, alpha, a, &m, b, &m, beta, c, &m );
 
-    	end();
-	    timeg += getsec();
+    	gettimeofday( &stop, (struct timezone *)0);
+
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
+	timeg += time1;
+
     }
 
     timeg /= loops;

benchmark/gemv.c

@@ -25,7 +25,12 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
 
 
 #undef GEMV
@@ -47,6 +52,72 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 
 #endif
+
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *x, *y;
@@ -66,6 +137,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -109,7 +181,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -125,7 +197,7 @@ int main(int argc, char *argv[]){
    		fprintf(stderr, " %6dx%d : ", (int)m,(int)n);
    		for(j = 0; j < m; j++){
       			for(i = 0; i < n * COMPSIZE; i++){
-				a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+				a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       			}
    		}
 
@@ -136,13 +208,13 @@ int main(int argc, char *argv[]){
 				x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    			}
 
-   			for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
+   			for(i = 0; i < n * COMPSIZE * abs(inc_y); i++){
 				y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    			}
-    			begin();
+    			gettimeofday( &start, (struct timezone *)0);
     			GEMV (&trans, &m, &n, alpha, a, &m, x, &inc_x, beta, y, &inc_y );
-    			end();
-    			time1 = getsec();
+    			gettimeofday( &stop, (struct timezone *)0);
+    			time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 			timeg += time1;
 
     		}
@@ -162,7 +234,7 @@ int main(int argc, char *argv[]){
    		fprintf(stderr, " %6dx%d : ", (int)m,(int)n);
    		for(j = 0; j < m; j++){
       			for(i = 0; i < n * COMPSIZE; i++){
-				a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+				a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       			}
    		}
 
@@ -173,13 +245,13 @@ int main(int argc, char *argv[]){
 				x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    			}
 
-   			for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
+   			for(i = 0; i < n * COMPSIZE * abs(inc_y); i++){
 				y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    			}
-    			begin();
+    			gettimeofday( &start, (struct timezone *)0);
     			GEMV (&trans, &m, &n, alpha, a, &m, x, &inc_x, beta, y, &inc_y );
-    			end();
-    			time1 = getsec();
+    			gettimeofday( &stop, (struct timezone *)0);
+    			time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 			timeg += time1;
 
     		}

benchmark/ger.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef GER
 
@@ -43,6 +49,72 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 #endif
 
+
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *x, *y;
@@ -59,6 +131,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -92,7 +165,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -109,7 +182,7 @@ int main(int argc, char *argv[]){
 
    for(j = 0; j < m; j++){
       		for(i = 0; i < n * COMPSIZE; i++){
-			a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+			a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       		}
    }
 
@@ -125,13 +198,16 @@ int main(int argc, char *argv[]){
     for (l=0; l<loops; l++)
     {
 
-    	begin();
+    	gettimeofday( &start, (struct timezone *)0);
 
     	GER (&m, &n, alpha, x, &inc_x, y, &inc_y, a , &m);
 
-    	end();
-      
-      timeg += getsec();
+    	gettimeofday( &stop, (struct timezone *)0);
+
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
+	timeg += time1;
+
     }
 
     timeg /= loops;

benchmark/gesv.c

@@ -36,7 +36,12 @@
 /* or implied, of The University of Texas at Austin.                 */
 /*********************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
 
 double fabs(double);
 
@@ -61,6 +66,71 @@ double fabs(double);
 #endif
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *b;
@@ -72,6 +142,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1;
 
   argc--;argv++;
@@ -94,7 +165,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -106,35 +177,39 @@ int main(int argc, char *argv[]){
 
     for(j = 0; j < m; j++){
       for(i = 0; i < m * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       }
     }
 
     for(j = 0; j < m; j++){
       for(i = 0; i < m * COMPSIZE; i++){
-	b[(long)i + (long)j * (long)m * COMPSIZE] = 0.0;
+	b[i + j * m * COMPSIZE] = 0.0;
       }
     }
 
 
     for (j = 0; j < m; ++j) {
       for (i = 0; i < m * COMPSIZE; ++i) {
-	b[i] += a[(long)i + (long)j * (long)m * COMPSIZE];
+	b[i] += a[i + j * m * COMPSIZE];
       }
     }
 
-    begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     GESV (&m, &m, a, &m, ipiv, b, &m,  &info);
 
-    end();
+    gettimeofday( &stop, (struct timezone *)0);
+
+
+    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
 
-    time1 = getsec();
 
     fprintf(stderr,
 	    "%10.2f MFlops %10.6f s\n",
 	    COMPSIZE * COMPSIZE * (2. / 3. * (double)m * (double)m * (double)m + 2. * (double)m * (double)m * (double)m ) / (time1) * 1.e-6 , time1);
 
+
   }
 
   return 0;

benchmark/getri.c

@@ -36,7 +36,12 @@
 /* or implied, of The University of Texas at Austin.                 */
 /*********************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
 
 #undef GETRF
 #undef GETRI
@@ -67,22 +72,84 @@
 
 extern void GETRI(blasint *m, FLOAT *a, blasint *lda, blasint *ipiv, FLOAT *work, blasint *lwork, blasint *info);
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a,*work;
   FLOAT wkopt[4];
   blasint *ipiv;
-  blasint m, i, j, l, info,lwork;
+  blasint m, i, j, info,lwork;
 
   int from =   1;
   int to   = 200;
   int step =   1;
-  int loops =  1;
 
-  double time1,timeg;
-  
-  char *p;
-  char btest = 'I';
+  struct timeval start, stop;
+  double time1;
 
   argc--;argv++;
 
@@ -90,9 +157,6 @@ int main(int argc, char *argv[]){
   if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
   if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
 
-  if ((p = getenv("OPENBLAS_TEST"))) btest=*p;
-  
-  if ((p = getenv("OPENBLAS_LOOPS"))) loops=*p;
 
   fprintf(stderr, "From : %3d  To : %3d Step = %3d\n", from, to, step);
 
@@ -108,7 +172,7 @@ int main(int argc, char *argv[]){
 
     for(j = 0; j < to; j++){
       for(i = 0; i < to * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)to * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	a[i + j * to * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       }
     }
 
@@ -124,48 +188,39 @@ int main(int argc, char *argv[]){
   }
 
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
   fprintf(stderr, "   SIZE           FLops           Time          Lwork\n");
 
   for(m = from; m <= to; m += step){
-    timeg = 0.;
+
     fprintf(stderr, " %6d : ", (int)m);
 
-    for (l = 0; l < loops; l++) {
-
-    if (btest == 'F') begin();
     GETRF (&m, &m, a, &m, ipiv, &info);
-    if (btest == 'F') {
-      end();
-      timeg += getsec();
-    }
+
     if (info) {
       fprintf(stderr, "Matrix is not singular .. %d\n", info);
       exit(1);
     }
 
-    if (btest == 'I') begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     lwork = -1;
     GETRI(&m, a, &m, ipiv, wkopt, &lwork, &info);
 
     lwork = (blasint)wkopt[0];
     GETRI(&m, a, &m, ipiv, work, &lwork, &info);
-    if (btest == 'I') end();
+    gettimeofday( &stop, (struct timezone *)0);
 
     if (info) {
       fprintf(stderr, "failed compute inverse matrix .. %d\n", info);
       exit(1);
     }
 
-    if (btest == 'I') 
-      timeg += getsec();
-    
-    } // loops
-    time1 = timeg/(double)loops;
+    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
     fprintf(stderr,
 	    " %10.2f MFlops : %10.2f Sec : %d\n",
 	    COMPSIZE * COMPSIZE * (4.0/3.0 * (double)m * (double)m *(double)m - (double)m *(double)m + 5.0/3.0* (double)m) / time1 * 1.e-6,time1,lwork);

benchmark/hbmv.c

@@ -1,134 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef HBMV
-
-#ifdef DOUBLE
-#define HBMV   BLASFUNC(zhbmv)
-#else
-#define HBMV   BLASFUNC(chbmv)
-#endif
-
-int main(int argc, char *argv[]){
-
-    FLOAT *a, *x, *y;
-    FLOAT alpha[] = {1.0, 1.0};
-    FLOAT beta [] = {0.0, 0.0};
-    blasint k = 1;
-    char uplo='L';
-    blasint m, i, j;
-    blasint inc_x=1, inc_y=1;
-    int loops = 1;
-    int l;
-    char *p;
-
-    int from =   1;
-    int to   = 200;
-    int step =   1;
-
-    double time1,timeg;
-
-    argc--;argv++;
-
-    if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-    if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-    if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-    if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-    if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-    if ((p = getenv("OPENBLAS_INCY")))   inc_y = atoi(p);
-    if ((p = getenv("OPENBLAS_UPLO")))   uplo=*p;
-    if ((p = getenv("OPENBLAS_K")))      k = atoi(p);
-    
-    fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = '%c' k = %d Inc_x = %d Inc_y = %d Loops = %d\n", 
-                            from, to, step, uplo, k, inc_x, inc_y, loops);
-
-    if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");
-        exit(1);
-    }
-
-    if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");
-        exit(1);
-    }
-
-    if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");
-        exit(1);
-    }
-
-#ifdef __linux
-    srandom(getpid());
-#endif
-
-    fprintf(stderr, "   SIZE       Flops\n");
-
-    for(m = from; m <= to; m += step) {
-
-        timeg=0;
-
-        fprintf(stderr, " %6dx%d : ", (int)m, (int)m);
-
-        for(j = 0; j < m; j++) {
-            for(i = 0; i < m * COMPSIZE; i++) {
-                a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-            }
-        }
-
-    for (l = 0; l < loops; l++) {
-
-        for (i = 0; i < m * COMPSIZE * abs(inc_x); i++) {
-            x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        for (i = 0; i < m * COMPSIZE * abs(inc_y); i++) {
-            y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        begin();
-
-        HBMV (&uplo, &m, &k, alpha, a, &m, x, &inc_x, beta, y, &inc_y );
-
-        end();
-
-        timeg += getsec();
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr, " %10.2f MFlops\n",
-            COMPSIZE * COMPSIZE * 2. * (double)(2 * k + 1) * (double)m / timeg * 1.e-6);
-    }
-
-    return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/hemm.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef HEMM
 
@@ -35,6 +41,72 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define HEMM   BLASFUNC(chemm)
 #endif
 
+
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *b, *c;
@@ -54,6 +126,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1;
 
   argc--;argv++;
@@ -78,7 +151,7 @@ int main(int argc, char *argv[]){
 
 
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -91,19 +164,21 @@ int main(int argc, char *argv[]){
 
     for(j = 0; j < m; j++){
       for(i = 0; i < m * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-	b[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-	c[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	b[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	c[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       }
     }
 
-    begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     HEMM (&side, &uplo, &m, &m, alpha, a, &m, b, &m, beta, c, &m );
 
-    end();
+    gettimeofday( &stop, (struct timezone *)0);
 
-    time1 = getsec();
+    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
+    gettimeofday( &start, (struct timezone *)0);
 
     fprintf(stderr,
 	    " %10.2f MFlops\n",

benchmark/hemv.c

@@ -25,16 +25,89 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef HEMV
 
+
 #ifdef DOUBLE
 #define HEMV   BLASFUNC(zhemv)
 #else
 #define HEMV   BLASFUNC(chemv)
 #endif
 
+
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *x, *y;
@@ -51,6 +124,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -78,7 +152,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -93,7 +167,7 @@ int main(int argc, char *argv[]){
 
    for(j = 0; j < m; j++){
       		for(i = 0; i < m * COMPSIZE; i++){
-			a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+			a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       		}
    }
 
@@ -108,13 +182,13 @@ int main(int argc, char *argv[]){
    	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
 			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    	}
-    	begin();
+    	gettimeofday( &start, (struct timezone *)0);
 
     	HEMV (&uplo, &m, alpha, a, &m, x, &inc_x, beta, y, &inc_y );
 
-    	end();
+    	gettimeofday( &stop, (struct timezone *)0);
 
-    	time1 = getsec();
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
 	timeg += time1;
 

benchmark/her.c

@@ -1,109 +0,0 @@
-/***************************************************************************
-Copyright (c) 2020, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef HER
-
-#ifdef DOUBLE
-#define HER   BLASFUNC(zher)
-#else
-#define HER   BLASFUNC(cher)
-#endif
-
-int main(int argc, char *argv[]){
-
-    FLOAT *a, *x;
-    FLOAT alpha[] = {1.0, 1.0};
-    blasint incx = 1;
-    char *p;
-
-    char uplo='U';
-    char trans='N';
-
-    if ((p = getenv("OPENBLAS_UPLO"))) uplo=*p;
-    if ((p = getenv("OPENBLAS_TRANS"))) trans=*p;
-
-    blasint m, i, j;
-
-    int from =   1;
-    int to   = 200;
-    int step =   1;
-    double time1;
-
-    argc--;argv++;
-
-    if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-    if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-    if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-    fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c Trans = %c\n", from, to, step,uplo,trans);
-
-
-    if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-        fprintf(stderr,"Out of Memory!!\n");exit(1);
-    }
-
-    if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * COMPSIZE)) == NULL){
-        fprintf(stderr,"Out of Memory!!\n");exit(1);
-    }
-
-
-
-#ifdef __linux
-    srandom(getpid());
-#endif
-
-    fprintf(stderr, "   SIZE       Flops\n");
-
-    for(m = from; m <= to; m += step)
-    {
-        fprintf(stderr, " %6d : ", (int)m);
-
-        for(j = 0; j < m; j++){
-            for(i = 0; i < m * COMPSIZE; i++){
-                a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-            }
-            x[ (long)j * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        begin();
-
-        HER (&uplo, &m, alpha, x, &incx, a, &m );
-
-        end();
-
-        time1 = getsec();
-
-        fprintf(stderr,
-                " %10.2f MFlops\n",
-                COMPSIZE * COMPSIZE * 1. * (double)m * (double)m / time1 * 1.e-6);
-
-    }
-
-    return 0;
-}

benchmark/her2.c

@@ -1,113 +0,0 @@
-/***************************************************************************
-Copyright (c) 2020, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef HER2
-
-#ifdef DOUBLE
-#define HER2   BLASFUNC(zher2)
-#else
-#define HER2   BLASFUNC(cher2)
-#endif
-
-int main(int argc, char *argv[]){
-
-    FLOAT *a, *x, *y;
-    FLOAT alpha[] = {1.0, 1.0};
-    blasint inc = 1;
-    char *p;
-
-    char uplo='U';
-    char trans='N';
-
-    if ((p = getenv("OPENBLAS_UPLO"))) uplo=*p;
-    if ((p = getenv("OPENBLAS_TRANS"))) trans=*p;
-
-    blasint m, i, j;
-
-    int from =   1;
-    int to   = 200;
-    int step =   1;
-
-    double time1;
-
-    argc--;argv++;
-
-    if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-    if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-    if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-    fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c Trans = %c\n", from, to, step,uplo,trans);
-
-
-    if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-        fprintf(stderr,"Out of Memory!!\n");exit(1);
-    }
-
-    if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * COMPSIZE)) == NULL){
-        fprintf(stderr,"Out of Memory!!\n");exit(1);
-    }
-
-    if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * COMPSIZE)) == NULL){
-        fprintf(stderr,"Out of Memory!!\n");exit(1);
-    }
-
-#ifdef __linux
-    srandom(getpid());
-#endif
-
-    fprintf(stderr, "   SIZE       Flops\n");
-
-    for(m = from; m <= to; m += step)
-    {
-        fprintf(stderr, " %6d : ", (int)m);
-
-        for(j = 0; j < m; j++){
-            for(i = 0; i < m * COMPSIZE; i++){
-                a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-            }
-            x[ (long)j * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-            y[ (long)j * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        begin();
-
-        HER2 (&uplo, &m, alpha, x, &inc, y, &inc, a, &m );
-
-        end();
-
-        time1 = getsec();
-
-        fprintf(stderr,
-                " %10.2f MFlops\n",
-                COMPSIZE * COMPSIZE * 2. * (double)m * (double)m / time1 * 1.e-6);
-
-    }
-
-    return 0;
-}

benchmark/her2k.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef HER2K
 #ifdef DOUBLE
@@ -34,6 +40,72 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define HER2K   BLASFUNC(cher2k)
 #endif
 
+
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *b, *c;
@@ -53,6 +125,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1;
 
   argc--;argv++;
@@ -77,7 +150,7 @@ int main(int argc, char *argv[]){
 
 
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -90,19 +163,21 @@ int main(int argc, char *argv[]){
 
     for(j = 0; j < m; j++){
       for(i = 0; i < m * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-	b[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-	c[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	b[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	c[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       }
     }
 
-    begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     HER2K (&uplo, &trans, &m, &m, alpha, a, &m, b, &m, beta, c, &m );
 
-    end();
+    gettimeofday( &stop, (struct timezone *)0);
 
-    time1 = getsec();
+    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
+    gettimeofday( &start, (struct timezone *)0);
 
     fprintf(stderr,
 	    " %10.2f MFlops\n",

benchmark/herk.c

@@ -25,16 +25,89 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef HERK
 
+
 #ifdef DOUBLE
 #define HERK   BLASFUNC(zherk)
 #else
 #define HERK   BLASFUNC(cherk)
 #endif
 
+
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *c;
@@ -54,6 +127,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1;
 
   argc--;argv++;
@@ -75,7 +149,7 @@ int main(int argc, char *argv[]){
 
 
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -88,22 +162,25 @@ int main(int argc, char *argv[]){
 
     for(j = 0; j < m; j++){
       for(i = 0; i < m * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-	c[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	c[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       }
     }
 
-    begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     HERK (&uplo, &trans, &m, &m, alpha, a, &m, beta, c, &m );
 
-    end();
+    gettimeofday( &stop, (struct timezone *)0);
 
-    time1 = getsec();
+    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
+    gettimeofday( &start, (struct timezone *)0);
 
     fprintf(stderr,
 	    " %10.2f MFlops\n",
 	    COMPSIZE * COMPSIZE * 1. * (double)m * (double)m * (double)m / time1 * 1.e-6);
+
   }
 
   return 0;

benchmark/hpmv.c

@@ -1,133 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef HPMV
-
-#ifdef DOUBLE
-#define HPMV   BLASFUNC(zhpmv)
-#else
-#define HPMV   BLASFUNC(chpmv)
-#endif
-
-int main(int argc, char *argv[]){
-
-    FLOAT *a, *x, *y;
-    FLOAT alpha[] = {1.0, 1.0};
-    FLOAT beta [] = {1.0, 1.0};
-    char uplo='L';
-    blasint m, i, j;
-    blasint inc_x=1, inc_y=1;
-    int loops = 1;
-    int l;
-    char *p;
-
-    int from =   1;
-    int to   = 200;
-    int step =   1;
-
-    double time1,timeg;
-
-    argc--;argv++;
-
-    if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-    if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-    if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-    if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-    if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-    if ((p = getenv("OPENBLAS_INCY")))   inc_y = atoi(p);
-    if ((p = getenv("OPENBLAS_UPLO")))   uplo=*p;
-
-    fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = '%c' Inc_x = %d Inc_y = %d Loops = %d\n", from, to, step,uplo,inc_x,inc_y,loops);
-
-    if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");
-        exit(1);
-    }
-
-    if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");
-        exit(1);
-    }
-
-    if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");
-        exit(1);
-    }
-
-#ifdef __linux
-    srandom(getpid());
-#endif
-
-    fprintf(stderr, "   SIZE       Flops\n");
-
-    for(m = from; m <= to; m += step) {
-
-        timeg=0;
-
-        fprintf(stderr, " %6dx%d : ", (int)m, (int)m);
-
-        for(j = 0; j < m; j++) {
-            for(i = 0; i < m * COMPSIZE; i++) {
-                a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-            }
-        }
-
-    for (l = 0; l < loops; l++) {
-
-        for (i = 0; i < m * COMPSIZE * abs(inc_x); i++) {
-            x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        for (i = 0; i < m * COMPSIZE * abs(inc_y); i++) {
-            y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        begin();
-
-        HPMV (&uplo, &m, alpha, a, x, &inc_x, beta, y, &inc_y );
-
-        end();
-
-        time1 = getsec();
-
-        timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr, " %10.2f MFlops\n",
-            COMPSIZE * COMPSIZE * 2. * (double)m * (double)m / timeg * 1.e-6);
-    }
-
-    return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/iamax.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef IAMAX
 
@@ -43,6 +49,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *x;
@@ -56,6 +127,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -73,7 +145,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -94,13 +166,13 @@ int main(int argc, char *argv[]){
 			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    	}
 
-    	begin();
+    	gettimeofday( &start, (struct timezone *)0);
 
     	IAMAX (&m, x, &inc_x);
 
-    	end();
+    	gettimeofday( &stop, (struct timezone *)0);
 
-    	time1 = getsec();
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
 	timeg += time1;
 
@@ -109,7 +181,7 @@ int main(int argc, char *argv[]){
     timeg /= loops;
 
     fprintf(stderr,
-	    " %10.2f MBytes %10.6f sec\n",
+	    " %10.2f MFlops %10.6f sec\n",
 	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
 
   }

benchmark/iamin.c

@@ -1,120 +0,0 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef IAMIN
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define IAMIN   BLASFUNC(izamin)
-#else
-#define IAMIN   BLASFUNC(icamin)
-#endif
-#else
-#ifdef DOUBLE
-#define IAMIN   BLASFUNC(idamin)
-#else
-#define IAMIN   BLASFUNC(isamin)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-   timeg=0;
-
-   fprintf(stderr, " %6d : ", (int)m);
-
-
-   for (l=0; l<loops; l++)
-   {
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-    	begin();
-
-    	IAMIN (&m, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-
-  }
-  
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/imax.c

@@ -1,114 +0,0 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef IMAX
-
-#ifndef COMPLEX
-#ifdef DOUBLE
-#define IMAX   BLASFUNC(idmax)
-#else
-#define IMAX   BLASFUNC(ismax)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-   timeg=0;
-
-   fprintf(stderr, " %6d : ", (int)m);
-
-
-   for (l=0; l<loops; l++)
-   {
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-    	begin();
-
-    	IMAX (&m, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/imin.c

@@ -1,114 +0,0 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef IMIN
-
-#ifndef COMPLEX
-#ifdef DOUBLE
-#define IMIN   BLASFUNC(idmin)
-#else
-#define IMIN   BLASFUNC(ismin)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-   timeg=0;
-
-   fprintf(stderr, " %6d : ", (int)m);
-
-
-   for (l=0; l<loops; l++)
-   {
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-    	begin();
-
-    	IMIN (&m, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/linpack.c

@@ -36,7 +36,12 @@
 /* or implied, of The University of Texas at Austin.                 */
 /*********************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
 
 double fabs(double);
 
@@ -67,26 +72,88 @@ double fabs(double);
 #endif
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *b;
   blasint *ipiv;
 
-  blasint m, i, j, l, info;
+  blasint m, i, j, info;
   blasint unit =   1;
 
   int from =   1;
   int to   = 200;
   int step =   1;
-  int loops =  1;
 
   FLOAT maxerr;
 
-  double time1, time2, timeg1,timeg2;
+  struct timeval start, stop;
+  double time1, time2;
 
-  char *p;
-  if ((p = getenv("OPENBLAS_LOOPS"))) loops=*p;
-  
   argc--;argv++;
 
   if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
@@ -107,19 +174,19 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
   fprintf(stderr, "   SIZE       Residual     Decompose            Solve           Total\n");
 
   for(m = from; m <= to; m += step){
-    timeg1 = timeg2 = 0.;
+
     fprintf(stderr, " %6d : ", (int)m);
-    for (l = 0; l < loops; l++) {
+
     for(j = 0; j < m; j++){
       for(i = 0; i < m * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       }
     }
 
@@ -127,38 +194,36 @@ int main(int argc, char *argv[]){
 
     for (j = 0; j < m; ++j) {
       for (i = 0; i < m * COMPSIZE; ++i) {
-	b[i] += a[(long)i + (long)j * (long)m * COMPSIZE];
+	b[i] += a[i + j * m * COMPSIZE];
       }
     }
 
-    begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     GETRF (&m, &m, a, &m, ipiv, &info);
 
-    end();
+    gettimeofday( &stop, (struct timezone *)0);
 
     if (info) {
       fprintf(stderr, "Matrix is not singular .. %d\n", info);
       exit(1);
     }
 
-    timeg1 += getsec();
+    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
-    begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     GETRS("N", &m, &unit, a, &m, ipiv, b, &m, &info);
 
-    end();
+    gettimeofday( &stop, (struct timezone *)0);
 
     if (info) {
       fprintf(stderr, "Matrix is not singular .. %d\n", info);
       exit(1);
     }
 
-    timeg2 += getsec();
-    } //loops
-    time1=timeg1/(double)loops;
-    time2=timeg2/(double)loops;
+    time2 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
     maxerr = 0.;
 
     for(i = 0; i < m; i++){

benchmark/max.c

@@ -1,113 +0,0 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef NAMAX
-
-#ifndef COMPLEX
-#ifdef DOUBLE
-#define NAMAX   BLASFUNC(dmax)
-#else
-#define NAMAX   BLASFUNC(smax)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-   timeg=0;
-
-   fprintf(stderr, " %6d : ", (int)m);
-
-
-   for (l=0; l<loops; l++)
-   {
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-    	begin();
-
-    	NAMAX (&m, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/min.c

@@ -1,113 +0,0 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef NAMIN
-
-#ifndef COMPLEX
-#ifdef DOUBLE
-#define NAMIN   BLASFUNC(dmin)
-#else
-#define NAMIN   BLASFUNC(smin)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-   timeg=0;
-
-   fprintf(stderr, " %6d : ", (int)m);
-
-
-   for (l=0; l<loops; l++)
-   {
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-    	begin();
-
-    	NAMIN (&m, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/nrm2.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef NRM2
 
@@ -43,6 +49,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *x;
@@ -56,6 +127,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -73,7 +145,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -94,13 +166,13 @@ int main(int argc, char *argv[]){
 			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    	}
 
-    	begin();
+    	gettimeofday( &start, (struct timezone *)0);
 
     	NRM2 (&m, x, &inc_x);
 
-    	end();
+    	gettimeofday( &stop, (struct timezone *)0);
 
-    	time1 = getsec();
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
 	timeg += time1;
 

benchmark/potrf.c

@@ -36,7 +36,12 @@
 /* or implied, of The University of Texas at Austin.                 */
 /*********************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
 
 double fabs(double);
 
@@ -81,7 +86,37 @@ double fabs(double);
 // extern void POTRI(char *uplo, blasint *m, FLOAT *a, blasint *lda, blasint *info);
 // extern void POTRS(char *uplo, blasint *m, blasint *n, FLOAT *a, blasint *lda, FLOAT *b, blasint *ldb, blasint *info);
 
+#if defined(__WIN32__) || defined(__WIN64__)
 
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
 
 int main(int argc, char *argv[]){
 
@@ -99,15 +134,15 @@ int main(int argc, char *argv[]){
   char *p;
   char btest = 'F';
 
-  blasint m, i, j, l, info, uplos=0;
-  double flops = 0.;
+  blasint m, i, j, info, uplos=0;
+  double flops;
 
   int from =   1;
   int to   = 200;
   int step =   1;
-  int loops =  1;
 
-  double time1, timeg;
+  struct timeval start, stop;
+  double time1;
 
   argc--;argv++;
 
@@ -120,8 +155,6 @@ int main(int argc, char *argv[]){
 
   if ((p = getenv("OPENBLAS_TEST"))) btest=*p;
 
-  if ((p = getenv("OPENBLAS_LOOPS"))) loops=*p;
-
   fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c\n", from, to, step,*uplo[uplos]);
 
   if (( a    = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
@@ -132,53 +165,51 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-
   for(m = from; m <= to; m += step){
-    timeg=0.;
-	  for (l = 0; l < loops; l++) {
+
 #ifndef COMPLEX
       if (uplos & 1) {
 	for (j = 0; j < m; j++) {
-	  for(i = 0; i < j; i++)     a[(long)i + (long)j * (long)m] = 0.;
-	  a[(long)j + (long)j * (long)m] = ((double) rand() / (double) RAND_MAX) + 8.;
-	  for(i = j + 1; i < m; i++) a[(long)i + (long)j * (long)m] = ((double) rand() / (double) RAND_MAX) - 0.5;
+	  for(i = 0; i < j; i++)     a[i + j * m] = 0.;
+	                             a[j + j * m] = ((double) rand() / (double) RAND_MAX) + 8.;
+	  for(i = j + 1; i < m; i++) a[i + j * m] = ((double) rand() / (double) RAND_MAX) - 0.5;
 	}
       } else {
 	for (j = 0; j < m; j++) {
-	  for(i = 0; i < j; i++)     a[(long)i + (long)j * (long)m] = ((double) rand() / (double) RAND_MAX) - 0.5;
-	  a[(long)j + (long)j * (long)m] = ((double) rand() / (double) RAND_MAX) + 8.;
-	  for(i = j + 1; i < m; i++) a[(long)i + (long)j * (long)m] = 0.;
+	  for(i = 0; i < j; i++)     a[i + j * m] = ((double) rand() / (double) RAND_MAX) - 0.5;
+	                             a[j + j * m] = ((double) rand() / (double) RAND_MAX) + 8.;
+	  for(i = j + 1; i < m; i++) a[i + j * m] = 0.;
 	}
       }
 #else
       if (uplos & 1) {
 	for (j = 0; j < m; j++) {
 	  for(i = 0; i < j; i++) {
-	    a[((long)i + (long)j * (long)m) * 2 + 0] = 0.;
-	    a[((long)i + (long)j * (long)m) * 2 + 1] = 0.;
+	    a[(i + j * m) * 2 + 0] = 0.;
+	    a[(i + j * m) * 2 + 1] = 0.;
 	  }
 
-	  a[((long)j + (long)j * (long)m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
-	  a[((long)j + (long)j * (long)m) * 2 + 1] = 0.;
+	  a[(j + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
+	  a[(j + j * m) * 2 + 1] = 0.;
 
 	  for(i = j + 1; i < m; i++) {
-	    a[((long)i + (long)j * (long)m) * 2 + 0] = 0;
-	    a[((long)i + (long)j * (long)m) * 2 + 1] = ((double) rand() / (double) RAND_MAX) - 0.5;
+	    a[(i + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) - 0.5;
+	    a[(i + j * m) * 2 + 1] = ((double) rand() / (double) RAND_MAX) - 0.5;
 	  }
 	}
       } else {
 	for (j = 0; j < m; j++) {
 	  for(i = 0; i < j; i++) {
-	    a[((long)i + (long)j * (long)m) * 2 + 0] = 0.;
-	    a[((long)i + (long)j * (long)m) * 2 + 1] = ((double) rand() / (double) RAND_MAX) - 0.5;
+	    a[(i + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) - 0.5;
+	    a[(i + j * m) * 2 + 1] = ((double) rand() / (double) RAND_MAX) - 0.5;
 	  }
 
-	  a[((long)j + (long)j * (long)m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
-	  a[((long)j + (long)j * (long)m) * 2 + 1] = 0.;
+	  a[(j + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
+	  a[(j + j * m) * 2 + 1] = 0.;
 
 	  for(i = j + 1; i < m; i++) {
-	    a[((long)i + (long)j * (long)m) * 2 + 0] = 0.;
-	    a[((long)i + (long)j * (long)m) * 2 + 1] = 0.;
+	    a[(i + j * m) * 2 + 0] = 0.;
+	    a[(i + j * m) * 2 + 1] = 0.;
 	  }
 	}
       }
@@ -186,19 +217,19 @@ int main(int argc, char *argv[]){
 
       SYRK(uplo[uplos], trans[uplos], &m, &m, alpha, a, &m, beta, b, &m);
 
-      begin();
+      gettimeofday( &start, (struct timezone *)0);
 
       POTRF(uplo[uplos], &m, b, &m, &info);
 
-      end();
+      gettimeofday( &stop, (struct timezone *)0);
 
       if (info != 0) {
 	fprintf(stderr, "Potrf info = %d\n", info);
 	exit(1);
       }
 
-      if ( btest == 'F')
-	      timeg += getsec();
+      time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+      flops = COMPSIZE * COMPSIZE * (1.0/3.0 * (double)m * (double)m *(double)m +1.0/2.0* (double)m *(double)m + 1.0/6.0* (double)m) / time1 * 1.e-6;
 
       if ( btest == 'S' )
       {
@@ -209,43 +240,39 @@ int main(int argc, char *argv[]){
       		}
     	}
 
-      	begin();
+      	gettimeofday( &start, (struct timezone *)0);
 
       	POTRS(uplo[uplos], &m, &m, b, &m, a, &m,  &info);
 
-      	end();
+      	gettimeofday( &stop, (struct timezone *)0);
 
       	if (info != 0) {
 		fprintf(stderr, "Potrs info = %d\n", info);
 		exit(1);
         }
-        timeg += getsec();
+        time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+        flops = COMPSIZE * COMPSIZE * (2.0 * (double)m * (double)m *(double)m ) / time1 * 1.e-6;
+
       }
 	
       if ( btest == 'I' )
       {
 	
-      	begin();
+      	gettimeofday( &start, (struct timezone *)0);
 
       	POTRI(uplo[uplos], &m, b, &m, &info);
 
-      	end();
+      	gettimeofday( &stop, (struct timezone *)0);
 
       	if (info != 0) {
 		fprintf(stderr, "Potri info = %d\n", info);
 		exit(1);
         }
-        timeg += getsec();
-      }
-    } // loops
 
-      time1 = timeg/(double)loops;
-	if ( btest == 'F')
-		flops = COMPSIZE * COMPSIZE * (1.0/3.0 * (double)m * (double)m *(double)m +1.0/2.0* (double)m *(double)m + 1.0/6.0* (double)m) / time1 * 1.e-6;
-	if ( btest == 'S')
-		flops = COMPSIZE * COMPSIZE * (2.0 * (double)m * (double)m *(double)m ) / time1 * 1.e-6;
-	if ( btest == 'I')
-		flops = COMPSIZE * COMPSIZE * (2.0/3.0 * (double)m * (double)m *(double)m +1.0/2.0* (double)m *(double)m + 5.0/6.0* (double)m) / time1 * 1.e-6;
+        time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+        flops = COMPSIZE * COMPSIZE * (2.0/3.0 * (double)m * (double)m *(double)m +1.0/2.0* (double)m *(double)m + 5.0/6.0* (double)m) / time1 * 1.e-6;
+      }
+	
       fprintf(stderr, "%8d : %10.2f MFlops : %10.3f Sec : Test=%c\n",m,flops ,time1,btest);
 
 

benchmark/rot.c

@@ -25,11 +25,16 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
 
-#undef ROT
 
-#ifndef COMPLEX
+#undef DOT
+
 
 #ifdef DOUBLE
 #define ROT   BLASFUNC(drot)
@@ -37,14 +42,70 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define ROT   BLASFUNC(srot)
 #endif
 
-#else
 
-#ifdef DOUBLE
-#define ROT   BLASFUNC(zdrot)
-#else
-#define ROT   BLASFUNC(csrot)
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
 #endif
 
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
 #endif
 
 int main(int argc, char *argv[]){
@@ -63,6 +124,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -85,7 +147,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -98,31 +160,32 @@ int main(int argc, char *argv[]){
 
    fprintf(stderr, " %6d : ", (int)m);
 
-   for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-		x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   }
-
-   for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
-		y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   }
 
    for (l=0; l<loops; l++)
    {
-    	begin();
+
+   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
+			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+
+   	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
+			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+    	gettimeofday( &start, (struct timezone *)0);
 
     	ROT (&m, x, &inc_x, y, &inc_y, c, s);
 
-    	end();
+    	gettimeofday( &stop, (struct timezone *)0);
 
-    	time1 = getsec();
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
-	    timeg += time1;
+	timeg += time1;
 
-   }
+    }
 
-   timeg /= loops;
+    timeg /= loops;
 
-   fprintf(stderr,
+    fprintf(stderr,
 	    " %10.2f MFlops %10.6f sec\n",
 	    COMPSIZE * COMPSIZE * 6. * (double)m / timeg * 1.e-6, timeg);
 

benchmark/rotm.c

@@ -1,138 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
-GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef ROTM
-
-#ifdef DOUBLE
-#define ROTM BLASFUNC(drotm)
-#else
-#define ROTM BLASFUNC(srotm)
-#endif
-
-int main(int argc, char *argv[])
-{
-
-    FLOAT *x, *y;
-    // FLOAT result;
-    blasint m, i;
-    blasint inc_x = 1, inc_y = 1;
-    FLOAT param[5] = {1, 2.0, 3.0, 4.0, 5.0};
-    int loops = 1;
-    int l;
-    char *p;
-
-    int from = 1;
-    int to = 200;
-    int step = 1;
-
-    
-    double time1, timeg;
-
-    argc--;
-    argv++;
-
-    if (argc > 0) {
-        from = atol(*argv);
-        argc--;
-        argv++;
-    }
-    if (argc > 0) {
-        to = MAX(atol(*argv), from);
-        argc--;
-        argv++;
-    }
-    if (argc > 0) {
-        step = atol(*argv);
-        argc--;
-        argv++;
-    }
-
-    if ((p = getenv("OPENBLAS_LOOPS")))
-        loops = atoi(p);
-    if ((p = getenv("OPENBLAS_INCX")))
-        inc_x = atoi(p);
-    if ((p = getenv("OPENBLAS_INCY")))
-        inc_y = atoi(p);
-
-    fprintf(
-        stderr,
-        "From : %3d  To : %3d Step = %3d Inc_x = %d Inc_y = %d Loops = %d\n",
-        from, to, step, inc_x, inc_y, loops);
-
-    if ((x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) ==
-        NULL) {
-        fprintf(stderr, "Out of Memory!!\n");
-        exit(1);
-    }
-
-    if ((y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) ==
-        NULL) {
-        fprintf(stderr, "Out of Memory!!\n");
-        exit(1);
-    }
-
-#ifdef __linux
-    srandom(getpid());
-#endif
-
-    fprintf(stderr, "   SIZE       Flops\n");
-
-    for (m = from; m <= to; m += step) {
-
-        timeg = 0;
-
-        fprintf(stderr, " %6d : ", (int)m);
-        for (i = 0; i < m * COMPSIZE * abs(inc_x); i++) {
-            x[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
-        }
-
-        for (i = 0; i < m * COMPSIZE * abs(inc_y); i++) {
-            y[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
-        }
-
-        for (l = 0; l < loops; l++) {
-            begin();
-
-            ROTM(&m, x, &inc_x, y, &inc_y, param);
-
-            end();
-
-            time1 = getsec();
-
-            timeg += time1;
-        }
-
-        timeg /= loops;
-
-        fprintf(stderr, " %10.2f MFlops %10.6f sec\n",
-                COMPSIZE * COMPSIZE * 6. * (double)m / timeg * 1.e-6, timeg);
-    }
-
-    return 0;
-}

benchmark/scal.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef SCAL
 
@@ -43,6 +49,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *x, *y;
@@ -57,6 +128,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -78,7 +150,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -102,13 +174,13 @@ int main(int argc, char *argv[]){
    	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
 			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    	}
-    	begin();
+    	gettimeofday( &start, (struct timezone *)0);
 
     	SCAL (&m, alpha, x, &inc_x);
 
-    	end();
+    	gettimeofday( &stop, (struct timezone *)0);
 
-    	time1 = getsec();
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
 	timeg += time1;
 

benchmark/spmv.c

@@ -1,146 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef SPMV
-
-#ifndef COMPLEX
-
-#ifdef DOUBLE
-#define SPMV   BLASFUNC(dspmv)
-#else
-#define SPMV   BLASFUNC(sspmv)
-#endif
-
-#else
-
-#ifdef DOUBLE
-#define SPMV   BLASFUNC(zspmv)
-#else
-#define SPMV   BLASFUNC(cspmv)
-#endif
-
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a, *x, *y;
-  FLOAT alpha[] = {1.0, 1.0};
-  FLOAT beta [] = {1.0, 1.0};
-  char uplo='L';
-  blasint m, i, j;
-  blasint inc_x=1,inc_y=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-  if ((p = getenv("OPENBLAS_INCY")))   inc_y = atoi(p);
-  if ((p = getenv("OPENBLAS_UPLO")))  uplo=*p;
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = '%c' Inc_x = %d Inc_y = %d Loops = %d\n", from, to, step,uplo,inc_x,inc_y,loops);
-
-  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-   timeg=0;
-
-   fprintf(stderr, " %6dx%d : ", (int)m,(int)m);
-
-   for(j = 0; j < m; j++){
-      		for(i = 0; i < m * COMPSIZE; i++){
-			a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-      		}
-   }
-
-
-    for (l=0; l<loops; l++)
-    {
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
-			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-    	begin();
-
-    	SPMV (&uplo, &m, alpha, a, x, &inc_x, beta, y, &inc_y );
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m * (double)m / timeg * 1.e-6);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/spr.c

@@ -1,124 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef SPR
-
-#ifdef DOUBLE
-#define SPR   BLASFUNC(dspr)
-#else
-#define SPR   BLASFUNC(sspr)
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a,*c;
-  FLOAT alpha[] = {1.0, 1.0};
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  char uplo='U';
-
-  if ((p = getenv("OPENBLAS_UPLO"))) uplo=*p;
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-  blasint m, i, j;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c Inc_x = %d\n", from, to, step,uplo,inc_x);
-
-
-  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( c = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops		Time\n");
-
-  for(m = from; m <= to; m += step)
-  {
-	timeg=0;
-	
-    fprintf(stderr, " %6d : ", (int)m);
-	
-	for (l=0; l<loops; l++)
-    {
-
-		for(j = 0; j < m; j++){
-		  for(i = 0; i < m * COMPSIZE; i++){
-			a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-		  }
-		}
-		for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			c[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-		}
-
-		begin();
-
-		SPR (&uplo, &m, alpha, c, &inc_x, a);
-
-		end();
-
-		time1 = getsec();
-		
-		timeg += time1;
-   }
-	
-	timeg /= loops;
-	 
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * COMPSIZE * 1. * (double)m * (double)m  / timeg * 1.e-6, timeg);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/spr2.c

@@ -1,135 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-
-#undef SPR2
-
-#ifdef DOUBLE
-#define SPR2   BLASFUNC(dspr2)
-#else
-#define SPR2   BLASFUNC(sspr2)
-#endif
-
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a,*b,*c;
-  FLOAT alpha[] = {1.0, 1.0};
-  blasint inc_x=1,inc_y=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  char uplo='U';
-
-  if ((p = getenv("OPENBLAS_UPLO"))) uplo=*p;
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-  blasint m, i, j;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c Inc_x = %d Inc_y = %d\n", from, to, step,uplo,inc_x,inc_y);
-
-
-  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-  
-  if (( b = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( c = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops		Time\n");
-
-  for(m = from; m <= to; m += step)
-  {
-    timeg=0;
-	
-    fprintf(stderr, " %6d : ", (int)m);
-	
-	for (l=0; l<loops; l++)
-    {
-
-		for(j = 0; j < m; j++){
-		  for(i = 0; i < m * COMPSIZE; i++){
-			a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-		  }
-		}
-		
-		for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
-			b[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-		}
-		
-		for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			c[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-		}
-
-		begin();
-
-		SPR2 (&uplo, &m, alpha, c, &inc_x, b, &inc_y, a);
-
-		end();
-
-		time1 = getsec();
-		
-		timeg += time1;
-   }
-	
-    timeg /= loops;
-	 
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m * (double)m  / timeg * 1.e-6, timeg);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/swap.c

@@ -25,7 +25,12 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
 
 
 #undef SWAP
@@ -44,6 +49,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *x, *y;
@@ -58,6 +128,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -80,7 +151,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -104,13 +175,13 @@ int main(int argc, char *argv[]){
    	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
 			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    	}
-    	begin();
+    	gettimeofday( &start, (struct timezone *)0);
 
     	SWAP (&m, x, &inc_x, y, &inc_y );
 
-    	end();
+    	gettimeofday( &stop, (struct timezone *)0);
 
-    	time1 = getsec();
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
 	timeg += time1;
 

benchmark/symm.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef SYMM
 
@@ -47,6 +53,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *b, *c;
@@ -66,6 +137,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1;
 
   argc--;argv++;
@@ -90,7 +162,7 @@ int main(int argc, char *argv[]){
 
 
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -103,19 +175,21 @@ int main(int argc, char *argv[]){
 
     for(j = 0; j < m; j++){
       for(i = 0; i < m * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-	b[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-	c[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	b[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	c[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       }
     }
 
-    begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     SYMM (&side, &uplo, &m, &m, alpha, a, &m, b, &m, beta, c, &m );
 
-    end();
+    gettimeofday( &stop, (struct timezone *)0);
 
-    time1 = getsec();
+    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
+    gettimeofday( &start, (struct timezone *)0);
 
     fprintf(stderr,
 	    " %10.2f MFlops\n",

benchmark/symv.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef SYMV
 
@@ -47,6 +53,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *x, *y;
@@ -63,6 +134,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -90,7 +162,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -105,7 +177,7 @@ int main(int argc, char *argv[]){
 
    for(j = 0; j < m; j++){
       		for(i = 0; i < m * COMPSIZE; i++){
-			a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+			a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       		}
    }
 
@@ -120,13 +192,13 @@ int main(int argc, char *argv[]){
    	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
 			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    	}
-    	begin();
+    	gettimeofday( &start, (struct timezone *)0);
 
     	SYMV (&uplo, &m, alpha, a, &m, x, &inc_x, beta, y, &inc_y );
 
-    	end();
+    	gettimeofday( &stop, (struct timezone *)0);
 
-    	time1 = getsec();
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
 	timeg += time1;
 

benchmark/syr.c

@@ -1,113 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-
-#undef SYR
-
-#ifdef DOUBLE
-#define SYR   BLASFUNC(dsyr)
-#else
-#define SYR   BLASFUNC(ssyr)
-#endif
-
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x,*a;
-  FLOAT alpha[] = {1.0, 1.0};
-  char *p;
-
-  char uplo='U';
-
-  if ((p = getenv("OPENBLAS_UPLO"))) uplo=*p;
-
-  blasint m, i, j;
-  blasint inc_x= 1;
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-  
-  double time1;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c Inc_x = %d\n", from, to, step,uplo,inc_x);
-
-
-  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to *  COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-   if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-    fprintf(stderr, " %6d : ", (int)m);
-	
-	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-	x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-	
-    for(j = 0; j < m; j++){
-      for(i = 0; i < m * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-      }
-    }
-
-    begin();
-
-    SYR (&uplo, &m, alpha, x, &inc_x, a, &m );
-
-    end();
-
-    time1 = getsec();
-
-    fprintf(stderr,
-	    " %10.2f MFlops\n",
-	    COMPSIZE * COMPSIZE * 1. * (double)m * (double)m / time1 * 1.e-6);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/syr2.c

@@ -1,127 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef SYR2
-
-
-#ifdef DOUBLE
-#define SYR2   BLASFUNC(dsyr2)
-#else
-#define SYR2   BLASFUNC(ssyr2)
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x, *y, *a;
-  FLOAT alpha[] = {1.0, 1.0};
-  char *p;
-
-  char uplo='U';
-
-  if ((p = getenv("OPENBLAS_UPLO"))) uplo=*p; 
-
-  blasint m, i, j, l;
-  blasint inc_x= 1;
-  blasint inc_y= 1;
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-  int loops =  1;
-
-  if ((p = getenv("OPENBLAS_LOOPS"))) loops=*p;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c Inc_x = %d Inc_y = %d\n", from, to, step,uplo,inc_x,inc_y);
-
-  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-   if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-  
-   if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-    timeg = 0.;	
-    fprintf(stderr, " %6d : ", (int)m);
-    for (l = 0; l < loops; l++) {
-	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-	x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-	
-	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
-	y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-    for(j = 0; j < m; j++){
-      for(i = 0; i < m * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-      }
-    }
-
-    begin();
-
-    SYR2 (&uplo, &m, alpha, x, &inc_x, y, &inc_y, a, &m );
-
-    end();
-
-    timeg += getsec();
-    } // loops
-
-    time1 = timeg/(double)loops;
-    fprintf(stderr,
-	    " %10.2f MFlops\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m * (double)m / time1 * 1.e-6);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/syr2k.c

@@ -25,7 +25,12 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
 
 
 #undef SYR2K
@@ -48,6 +53,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *b, *c;
@@ -67,6 +137,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1;
 
   argc--;argv++;
@@ -91,7 +162,7 @@ int main(int argc, char *argv[]){
 
 
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -104,19 +175,21 @@ int main(int argc, char *argv[]){
 
     for(j = 0; j < m; j++){
       for(i = 0; i < m * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-	b[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-	c[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	b[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	c[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       }
     }
 
-    begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     SYR2K (&uplo, &trans, &m, &m, alpha, a, &m, b, &m, beta, c, &m );
 
-    end();
+    gettimeofday( &stop, (struct timezone *)0);
 
-    time1 = getsec();
+    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
+    gettimeofday( &start, (struct timezone *)0);
 
     fprintf(stderr,
 	    " %10.2f MFlops\n",

benchmark/syrk.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef SYRK
 
@@ -47,6 +53,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *c;
@@ -56,20 +127,18 @@ int main(int argc, char *argv[]){
 
   char uplo='U';
   char trans='N';
-  
+
   if ((p = getenv("OPENBLAS_UPLO"))) uplo=*p;
   if ((p = getenv("OPENBLAS_TRANS"))) trans=*p;
 
-  blasint m, i, j, l;
+  blasint m, i, j;
 
   int from =   1;
   int to   = 200;
   int step =   1;
-  int loops =  1;
 
-  if ((p = getenv("OPENBLAS_LOOPS"))) loops=*p;
-
-  double time1,timeg;
+  struct timeval start, stop;
+  double time1;
 
   argc--;argv++;
 
@@ -90,7 +159,7 @@ int main(int argc, char *argv[]){
 
 
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -98,29 +167,26 @@ int main(int argc, char *argv[]){
 
   for(m = from; m <= to; m += step)
   {
-    timeg = 0.;
 
     fprintf(stderr, " %6d : ", (int)m);
 
-    for(l = 0; l < loops; l++) {
-
     for(j = 0; j < m; j++){
       for(i = 0; i < m * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-	c[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	c[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       }
     }
 
-    begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     SYRK (&uplo, &trans, &m, &m, alpha, a, &m, beta, c, &m );
 
-    end();
+    gettimeofday( &stop, (struct timezone *)0);
+
+    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
+    gettimeofday( &start, (struct timezone *)0);
 
-    timeg += getsec();
-    
-    } //loops
-    time1 = timeg / (double)loops;
     fprintf(stderr,
 	    " %10.2f MFlops\n",
 	    COMPSIZE * COMPSIZE * 1. * (double)m * (double)m * (double)m / time1 * 1.e-6);

benchmark/tpmv.c

@@ -1,132 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef TPMV
-
-#ifndef COMPLEX
-
-#ifdef DOUBLE
-#define TPMV   BLASFUNC(dtpmv)
-#else
-#define TPMV   BLASFUNC(stpmv)
-#endif
-
-#else
-
-#ifdef DOUBLE
-#define TPMV   BLASFUNC(ztpmv)
-#else
-#define TPMV   BLASFUNC(ctpmv)
-#endif
-
-#endif
-
-int main(int argc, char *argv[])
-{
-
-    FLOAT *a, *x;
-    char *p;
-
-    char uplo ='U';
-    char trans='N';
-    char diag ='U';
-
-    int loops = 1;
-    int l;
-    blasint inc_x=1;
-
-    if ((p = getenv("OPENBLAS_UPLO"))) uplo=*p;
-    if ((p = getenv("OPENBLAS_TRANS"))) trans=*p;
-    if ((p = getenv("OPENBLAS_DIAG"))) diag=*p;
-    if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-    if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-    blasint n, i, j;
-
-    int from =   1;
-    int to   = 200;
-    int step =   1;
-
-    double time1, timeg;
-
-    argc--;argv++;
-
-    if (argc > 0) { from     = atol(*argv);        argc--; argv++;}
-    if (argc > 0) { to       = MAX(atol(*argv), from);    argc--; argv++;}
-    if (argc > 0) { step     = atol(*argv);        argc--; argv++;}
-
-    fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c Trans = %c  Diag = %c Loops=%d Inc_x=%d\n", from,
-            to, step, uplo, trans, diag, loops, inc_x);
-
-    if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");exit(1);
-    }
-
-    if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-        fprintf(stderr,"Out of Memory!!\n");exit(1);
-    }
-
-#ifdef __linux
-    srandom(getpid());
-#endif
-
-    fprintf(stderr, "   SIZE       Flops\n");
-
-    for(n = from; n <= to; n += step) {
-        timeg=0;
-
-        fprintf(stderr, " %6d : ", (int)n);
-        for(j = 0; j < n; j++) {
-            for(i = 0; i < n * COMPSIZE; i++) {
-                a[(long)i + (long)j * (long)n * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-            }
-        }
-
-        for (i = 0; i < n * COMPSIZE * abs(inc_x); i++) {
-            x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        for (l = 0; l < loops; l++) {
-            begin();
-            TPMV (&uplo, &trans, &diag, &n, a, x, &inc_x);
-            end();
-
-            time1 = getsec();
-            timeg += time1;
-        }
-
-        timeg /= loops;
-        fprintf(stderr, " %10.2f MFlops %12.9f sec\n",
-                COMPSIZE * COMPSIZE * 1. * (double)n * (double)n / timeg / 1.e6, timeg);
-    }
-
-    return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/tpsv.c

@@ -1,132 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef TPSV
-
-#ifndef COMPLEX
-
-#ifdef DOUBLE
-#define TPSV   BLASFUNC(dtpsv)
-#else
-#define TPSV   BLASFUNC(stpsv)
-#endif
-
-#else
-
-#ifdef DOUBLE
-#define TPSV   BLASFUNC(ztpsv)
-#else
-#define TPSV   BLASFUNC(ctpsv)
-#endif
-
-#endif
-
-int main(int argc, char *argv[])
-{
-
-    FLOAT *a, *x;
-    char *p;
-
-    char uplo ='U';
-    char trans='N';
-    char diag ='U';
-
-    int loops = 1;
-    int l;
-    blasint inc_x=1;
-
-    if ((p = getenv("OPENBLAS_UPLO"))) uplo=*p;
-    if ((p = getenv("OPENBLAS_TRANS"))) trans=*p;
-    if ((p = getenv("OPENBLAS_DIAG"))) diag=*p;
-    if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-    if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-    blasint n, i, j;
-
-    int from =   1;
-    int to   = 200;
-    int step =   1;
-
-    double time1, timeg;
-
-    argc--;argv++;
-
-    if (argc > 0) { from     = atol(*argv);        argc--; argv++;}
-    if (argc > 0) { to       = MAX(atol(*argv), from);    argc--; argv++;}
-    if (argc > 0) { step     = atol(*argv);        argc--; argv++;}
-
-    fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c Trans = %c  Diag = %c Loops=%d Inc_x=%d\n", from,
-            to, step, uplo, trans, diag, loops, inc_x);
-
-    if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");exit(1);
-    }
-
-    if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-        fprintf(stderr,"Out of Memory!!\n");exit(1);
-    }
-
-#ifdef __linux
-    srandom(getpid());
-#endif
-
-    fprintf(stderr, "   SIZE       Flops\n");
-
-    for(n = from; n <= to; n += step) {
-        timeg=0;
-
-        fprintf(stderr, " %6d : ", (int)n);
-        for(j = 0; j < n; j++) {
-            for(i = 0; i < n * COMPSIZE; i++) {
-                a[(long)i + (long)j * (long)n * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-            }
-        }
-
-        for (i = 0; i < n * COMPSIZE * abs(inc_x); i++) {
-            x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        for (l = 0; l < loops; l++) {
-            begin();
-            TPSV (&uplo, &trans, &diag, &n, a, x, &inc_x);
-            end();
-
-            time1 = getsec();
-            timeg += time1;
-        }
-
-        timeg /= loops;
-        fprintf(stderr, " %10.2f MFlops %12.9f sec\n",
-                COMPSIZE * COMPSIZE * 1. * (double)n * (double)n / timeg / 1.e6, timeg);
-    }
-
-    return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/trmm.c

@@ -25,7 +25,12 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
 
 
 #undef TRMM
@@ -48,6 +53,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *b;
@@ -71,6 +141,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1;
 
   argc--;argv++;
@@ -91,7 +162,7 @@ int main(int argc, char *argv[]){
 
 
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -104,18 +175,20 @@ int main(int argc, char *argv[]){
 
     for(j = 0; j < m; j++){
       for(i = 0; i < m * COMPSIZE; i++){
-	a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-	b[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+	b[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       }
     }
 
-    begin();
+    gettimeofday( &start, (struct timezone *)0);
 
     TRMM (&side, &uplo, &trans, &diag, &m, &m, alpha, a, &m, b, &m);
 
-    end();
+    gettimeofday( &stop, (struct timezone *)0);
 
-    time1 = getsec();
+    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+
+    gettimeofday( &start, (struct timezone *)0);
 
     fprintf(stderr,
 	    " %10.2f MFlops  %10.6f sec\n",

benchmark/trmv.c

@@ -1,132 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef TRMV
-
-#ifndef COMPLEX
-
-#ifdef DOUBLE
-#define TRMV   BLASFUNC(dtrmv)
-#else
-#define TRMV   BLASFUNC(strmv)
-#endif
-
-#else
-
-#ifdef DOUBLE
-#define TRMV   BLASFUNC(ztrmv)
-#else
-#define TRMV   BLASFUNC(ctrmv)
-#endif
-
-#endif
-
-int main(int argc, char *argv[])
-{
-
-    FLOAT *a, *x;
-    char *p;
-
-    char uplo ='U';
-    char trans='N';
-    char diag ='U';
-
-    int loops = 1;
-    int l;
-    blasint inc_x=1;
-
-    if ((p = getenv("OPENBLAS_UPLO"))) uplo=*p;
-    if ((p = getenv("OPENBLAS_TRANS"))) trans=*p;
-    if ((p = getenv("OPENBLAS_DIAG"))) diag=*p;
-    if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-    if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-    blasint n, i, j;
-
-    int from =   1;
-    int to   = 200;
-    int step =   1;
-
-    double time1, timeg;
-
-    argc--;argv++;
-
-    if (argc > 0) { from     = atol(*argv);        argc--; argv++;}
-    if (argc > 0) { to       = MAX(atol(*argv), from);    argc--; argv++;}
-    if (argc > 0) { step     = atol(*argv);        argc--; argv++;}
-
-    fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c Trans = %c  Diag = %c Loops=%d Inc_x=%d\n", from,
-            to, step, uplo, trans, diag, loops, inc_x);
-
-    if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");exit(1);
-    }
-
-    if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-        fprintf(stderr,"Out of Memory!!\n");exit(1);
-    }
-
-#ifdef __linux
-    srandom(getpid());
-#endif
-
-    fprintf(stderr, "   SIZE       Flops\n");
-
-    for(n = from; n <= to; n += step) {
-        timeg=0;
-
-        fprintf(stderr, " %6d : ", (int)n);
-        for(j = 0; j < n; j++) {
-            for(i = 0; i < n * COMPSIZE; i++) {
-                a[(long)i + (long)j * (long)n * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-            }
-        }
-
-        for (i = 0; i < n * COMPSIZE * abs(inc_x); i++) {
-            x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        for (l = 0; l < loops; l++) {
-            begin();
-            TRMV (&uplo, &trans, &diag, &n, a, &n, x, &inc_x);
-            end();
-
-            time1 = getsec();
-            timeg += time1;
-        }
-
-        timeg /= loops;
-        fprintf(stderr, " %10.2f MFlops %12.9f sec\n",
-                COMPSIZE * COMPSIZE * 1. * (double)n * (double)n / timeg / 1.e6, timeg);
-    }
-
-    return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/trsm.c

@@ -25,7 +25,12 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
 
 
 #undef TRSM
@@ -48,6 +53,71 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #endif
 
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *a, *b;
@@ -81,6 +151,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1;
 
   argc--;argv++;
@@ -101,7 +172,7 @@ int main(int argc, char *argv[]){
 
 
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -120,18 +191,18 @@ int main(int argc, char *argv[]){
 
    		 for(j = 0; j < m; j++){
       			for(i = 0; i < m * COMPSIZE; i++){
-				a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-				b[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+				a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+				b[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       		 	}
     		 }
 
-    		begin();
+    		gettimeofday( &start, (struct timezone *)0);
 
     		TRSM (&side, &uplo, &trans, &diag, &m, &m, alpha, a, &m, b, &m);
 
-    		end();
+    		gettimeofday( &stop, (struct timezone *)0);
 
-    		time1 = getsec();
+    		time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
 		timeg += time1;
         }

benchmark/trsv.c

@@ -1,143 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.
-3. Neither the name of the OpenBLAS project nor the names of
-its contributors may be used to endorse or promote products
-derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef GEMV
-#undef TRSV
-
-#ifndef COMPLEX
-
-#ifdef DOUBLE
-#define TRSV   BLASFUNC(dtrsv)
-#else
-#define TRSV   BLASFUNC(strsv)
-#endif
-
-#else
-
-#ifdef DOUBLE
-#define TRSV   BLASFUNC(ztrsv)
-#else
-#define TRSV   BLASFUNC(ctrsv)
-#endif
-
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a, *x;
-  blasint n = 0, i, j;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  time_t seconds = 0;
-
-  double time1,timeg;
-  long long nanos = 0;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  char uplo ='L';
-  char transa = 'N';
-  char diag ='U';
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-  if ((p = getenv("OPENBLAS_TRANSA")))  transa=*p;
-  if ((p = getenv("OPENBLAS_DIAG")))  diag=*p;
-  if ((p = getenv("OPENBLAS_UPLO")))  uplo=*p;
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Transa = '%c' Inc_x = %d uplo=%c diag=%c loop = %d\n", from, to, step,transa,inc_x,
-          uplo,diag,loops);
-
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-  fprintf(stderr, "============================================\n");
-
-  for(n = from; n <= to; n += step)
-  {
-      timeg=0;
-      if (( a = (FLOAT *)malloc(sizeof(FLOAT) * n * n * COMPSIZE)) == NULL){
-          fprintf(stderr,"Out of Memory!!\n");exit(1);
-      }
-
-      if (( x = (FLOAT *)malloc(sizeof(FLOAT) * n * abs(inc_x) * COMPSIZE)) == NULL){
-          fprintf(stderr,"Out of Memory!!\n");exit(1);
-      }
-
-      for(j = 0; j < n; j++){
-          for(i = 0; i < n * COMPSIZE; i++){
-              a[i + j * n * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-          }
-      }
-
-      for(i = 0; i < n * COMPSIZE * abs(inc_x); i++){
-          x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-      }
-
-      for(l =0;l< loops;l++){
-
-          begin();
-          TRSV(&uplo,&transa,&diag,&n,a,&n,x,&inc_x);
-          end();
-          time1 = getsec();
-          timeg += time1;
-      }
-
-      timeg /= loops;
-      long long muls = n*(n+1)/2.0;
-      long long adds = (n - 1.0)*n/2.0;
-
-      fprintf(stderr, "%10d   %10.2f MFlops %10.6f sec\n", n,(muls+adds) / timeg * 1.e-6, timeg);
-      if(a != NULL){
-        free(a);
-      }
-
-      if( x != NULL){
-        free(x);
-      }
-
-  }
-
-  return 0;
-}
-

benchmark/zdot-intel.c

@@ -25,18 +25,90 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
-
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
 #define RETURN_BY_STACK 1
+#include "common.h"
+
 
 #undef DOT
 
+
 #ifdef DOUBLE
 #define DOT   BLASFUNC(zdotu)
 #else
 #define DOT   BLASFUNC(cdotu)
 #endif
 
+
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *x, *y;
@@ -51,6 +123,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -73,7 +146,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -97,13 +170,13 @@ int main(int argc, char *argv[]){
    	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
 			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    	}
-    	begin();
+    	gettimeofday( &start, (struct timezone *)0);
 
     	DOT (&result, &m, x, &inc_x, y, &inc_y );
 
-    	end();
+    	gettimeofday( &stop, (struct timezone *)0);
 
-    	time1 = getsec();
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
 	timeg += time1;
 

benchmark/zdot.c

@@ -25,7 +25,13 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
 
-#include "bench.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __CYGWIN32__
+#include <sys/time.h>
+#endif
+#include "common.h"
+
 
 #undef DOT
 
@@ -36,6 +42,72 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define DOT   BLASFUNC(cdotu)
 #endif
 
+
+#if defined(__WIN32__) || defined(__WIN64__)
+
+#ifndef DELTA_EPOCH_IN_MICROSECS
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+#endif
+
+int gettimeofday(struct timeval *tv, void *tz){
+
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+    {
+      GetSystemTimeAsFileTime(&ft);
+
+      tmpres |= ft.dwHighDateTime;
+      tmpres <<= 32;
+      tmpres |= ft.dwLowDateTime;
+
+      /*converting file time to unix epoch*/
+      tmpres /= 10;  /*convert into microseconds*/
+      tmpres -= DELTA_EPOCH_IN_MICROSECS;
+      tv->tv_sec = (long)(tmpres / 1000000UL);
+      tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+  return 0;
+}
+
+#endif
+
+#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
+
+static void *huge_malloc(BLASLONG size){
+  int shmid;
+  void *address;
+
+#ifndef SHM_HUGETLB
+#define SHM_HUGETLB 04000
+#endif
+
+  if ((shmid =shmget(IPC_PRIVATE,
+		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
+		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
+    printf( "Memory allocation failed(shmget).\n");
+    exit(1);
+  }
+
+  address = shmat(shmid, NULL, SHM_RND);
+
+  if ((BLASLONG)address == -1){
+    printf( "Memory allocation failed(shmat).\n");
+    exit(1);
+  }
+
+  shmctl(shmid, IPC_RMID, 0);
+
+  return address;
+}
+
+#define malloc huge_malloc
+
+#endif
+
 int main(int argc, char *argv[]){
 
   FLOAT *x, *y;
@@ -50,6 +122,7 @@ int main(int argc, char *argv[]){
   int to   = 200;
   int step =   1;
 
+  struct timeval start, stop;
   double time1,timeg;
 
   argc--;argv++;
@@ -72,7 +145,7 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-#ifdef __linux
+#ifdef linux
   srandom(getpid());
 #endif
 
@@ -96,15 +169,13 @@ int main(int argc, char *argv[]){
    	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
 			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    	}
-    	begin();
-#ifdef RETURN_BY_STACK
-    	DOT (&result , &m, x, &inc_x, y, &inc_y );
-#else
-    	result = DOT (&m, x, &inc_x, y, &inc_y );
-#endif
-    	end();
+    	gettimeofday( &start, (struct timezone *)0);
 
-    	time1 = getsec();
+    	result = DOT (&m, x, &inc_x, y, &inc_y );
+
+    	gettimeofday( &stop, (struct timezone *)0);
+
+    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
 	timeg += time1;
 

c_check

@@ -1,15 +1,13 @@
-#!/usr/bin/env perl
+#!/usr/bin/perl
 
 #use File::Basename;
 # use File::Temp qw(tempfile);
 
 # Checking cross compile
 $hostos   = `uname -s | sed -e s/\-.*//`;    chop($hostos);
-$hostarch = `uname -m | sed -e s/i.86/x86/`;
-$hostarch = `uname -p` if ($hostos eq "AIX" || $hostos eq "SunOS");
-chop($hostarch);
+$hostarch = `uname -m | sed -e s/i.86/x86/`;chop($hostarch);
 $hostarch = "x86_64" if ($hostarch eq "amd64");
-$hostarch = "arm" if ($hostarch ne "arm64" && $hostarch =~ /^arm.*/);
+$hostarch = "arm" if ($hostarch =~ /^arm.*/);
 $hostarch = "arm64" if ($hostarch eq "aarch64");
 $hostarch = "power" if ($hostarch =~ /^(powerpc|ppc).*/);
 $hostarch = "zarch" if ($hostarch eq "s390x");
@@ -20,12 +18,11 @@ $binary = $ENV{"BINARY"};
 $makefile = shift(@ARGV);
 $config   = shift(@ARGV);
 
-$compiler_name = shift(@ARGV);
-$flags = join(" ", @ARGV);
+$compiler_name = join(" ", @ARGV);
 
 # First, we need to know the target OS and compiler name
 
-$data = `$compiler_name $flags -E ctest.c`;
+$data = `$compiler_name -E ctest.c`;
 
 if ($?) {
     printf STDERR "C Compiler ($compiler_name) is something wrong.\n";
@@ -82,19 +79,17 @@ $os = Interix         if ($data =~ /OS_INTERIX/);
 $os = Android         if ($data =~ /OS_ANDROID/);
 $os = Haiku           if ($data =~ /OS_HAIKU/);
 
-$architecture = x86          if ($data =~ /ARCH_X86/);
-$architecture = x86_64       if ($data =~ /ARCH_X86_64/);
-$architecture = power        if ($data =~ /ARCH_POWER/);
-$architecture = mips         if ($data =~ /ARCH_MIPS/);
-$architecture = mips64       if ($data =~ /ARCH_MIPS64/);
-$architecture = alpha        if ($data =~ /ARCH_ALPHA/);
-$architecture = sparc        if ($data =~ /ARCH_SPARC/);
-$architecture = ia64         if ($data =~ /ARCH_IA64/);
-$architecture = arm          if ($data =~ /ARCH_ARM/);
-$architecture = arm64        if ($data =~ /ARCH_ARM64/);
-$architecture = zarch        if ($data =~ /ARCH_ZARCH/);
-$architecture = riscv64      if ($data =~ /ARCH_RISCV64/);
-$architecture = loongarch64  if ($data =~ /ARCH_LOONGARCH64/);
+$architecture = x86    if ($data =~ /ARCH_X86/);
+$architecture = x86_64 if ($data =~ /ARCH_X86_64/);
+$architecture = power  if ($data =~ /ARCH_POWER/);
+$architecture = mips   if ($data =~ /ARCH_MIPS/);
+$architecture = mips64 if ($data =~ /ARCH_MIPS64/);
+$architecture = alpha  if ($data =~ /ARCH_ALPHA/);
+$architecture = sparc  if ($data =~ /ARCH_SPARC/);
+$architecture = ia64   if ($data =~ /ARCH_IA64/);
+$architecture = arm    if ($data =~ /ARCH_ARM/);
+$architecture = arm64  if ($data =~ /ARCH_ARM64/);
+$architecture = zarch  if ($data =~ /ARCH_ZARCH/);
 
 $defined = 0;
 
@@ -139,16 +134,6 @@ if (($architecture eq "x86") && ($os ne Darwin) && ($os ne SunOS)) {
     $binary =32;
 }
 
-if ($architecture eq "riscv64") {
-    $defined = 1;
-    $binary = 64;
-}
-
-if ($architecture eq "loongarch64") {
-    $defined = 1;
-    $binary = 64;
-}
-
 if ($compiler eq "PGI") {
     $compiler_name .= " -tp p7"    if ($binary eq "32");
     $compiler_name .= " -tp p7-64" if ($binary eq "64");
@@ -190,7 +175,7 @@ if ($defined == 0) {
 
 # Do again
 
-$data = `$compiler_name $flags -E ctest.c`;
+$data = `$compiler_name -E ctest.c`;
 
 if ($?) {
     printf STDERR "C Compiler ($compiler_name) is something wrong.\n";
@@ -203,14 +188,14 @@ if (($architecture eq "mips") || ($architecture eq "mips64")) {
     if ($@){ 
 	warn "could not load PERL module File::Temp, so could not check MSA capatibility";
     } else {
-	$tmpf = new File::Temp( SUFFIX => '.c' , UNLINK => 1 );
+	$tmpf = new File::Temp( UNLINK => 1 );
 	$code = '"addvi.b $w0, $w1, 1"';
-	$msa_flags = "-mmsa -mfp64 -mload-store-pairs";
+	$msa_flags = "-mmsa -mfp64 -msched-weight -mload-store-pairs";
 	print $tmpf "#include <msa.h>\n\n";
 	print $tmpf "void main(void){ __asm__ volatile($code); }\n";
 
-	$args = "$msa_flags -o $tmpf.o $tmpf";
-	my @cmd = ("$compiler_name $flags $args >/dev/null 2>/dev/null");
+	$args = "$msa_flags -o $tmpf.o -x c $tmpf";
+	my @cmd = ("$compiler_name $args");
 	system(@cmd) == 0;
 	if ($? != 0) {
 	    $have_msa = 0;
@@ -221,18 +206,17 @@ if (($architecture eq "mips") || ($architecture eq "mips64")) {
     }
 }
 
-$architecture = x86          if ($data =~ /ARCH_X86/);
-$architecture = x86_64       if ($data =~ /ARCH_X86_64/);
-$architecture = power        if ($data =~ /ARCH_POWER/);
-$architecture = mips         if ($data =~ /ARCH_MIPS/);
-$architecture = mips64       if ($data =~ /ARCH_MIPS64/);
-$architecture = alpha        if ($data =~ /ARCH_ALPHA/);
-$architecture = sparc        if ($data =~ /ARCH_SPARC/);
-$architecture = ia64         if ($data =~ /ARCH_IA64/);
-$architecture = arm          if ($data =~ /ARCH_ARM/);
-$architecture = arm64        if ($data =~ /ARCH_ARM64/);
-$architecture = zarch        if ($data =~ /ARCH_ZARCH/);
-$architecture = loongarch64  if ($data =~ /ARCH_LOONGARCH64/);
+$architecture = x86    if ($data =~ /ARCH_X86/);
+$architecture = x86_64 if ($data =~ /ARCH_X86_64/);
+$architecture = power  if ($data =~ /ARCH_POWER/);
+$architecture = mips   if ($data =~ /ARCH_MIPS/);
+$architecture = mips64 if ($data =~ /ARCH_MIPS64/);
+$architecture = alpha  if ($data =~ /ARCH_ALPHA/);
+$architecture = sparc  if ($data =~ /ARCH_SPARC/);
+$architecture = ia64   if ($data =~ /ARCH_IA64/);
+$architecture = arm    if ($data =~ /ARCH_ARM/);
+$architecture = arm64  if ($data =~ /ARCH_ARM64/);
+$architecture = zarch  if ($data =~ /ARCH_ZARCH/);
 
 $binformat    = bin32;
 $binformat    = bin64  if ($data =~ /BINARY_64/);
@@ -245,14 +229,11 @@ if (($architecture eq "x86") || ($architecture eq "x86_64")) {
 	$no_avx512 = 0;
     } else {
 #	$tmpf = new File::Temp( UNLINK => 1 );
-	($fh,$tmpf) = tempfile( SUFFIX => '.c' , UNLINK => 1 );
+	($fh,$tmpf) = tempfile( UNLINK => 1 );
 	$code = '"vbroadcastss -4 * 4(%rsi), %zmm2"';
 	print $tmpf "#include <immintrin.h>\n\nint main(void){ __asm__ volatile($code); }\n";
-	$args = " -march=skylake-avx512 -c -o $tmpf.o $tmpf";
-	if ($compiler eq "PGI") {
-	    $args = " -tp skylake -c -o $tmpf.o $tmpf";
-	}
-	my @cmd = ("$compiler_name $flags $args >/dev/null 2>/dev/null");
+	$args = " -march=skylake-avx512 -c -o $tmpf.o -x c $tmpf";
+	my @cmd = ("$compiler_name $args >/dev/null 2>/dev/null");
 	system(@cmd) == 0;
 	if ($? != 0) {
 	    $no_avx512 = 1;
@@ -263,38 +244,7 @@ if (($architecture eq "x86") || ($architecture eq "x86_64")) {
     }
 }
 
-$c11_atomics = 0;
-if ($data =~ /HAVE_C11/) {
-    eval "use File::Temp qw(tempfile)";
-    if ($@){ 
-       warn "could not load PERL module File::Temp, so could not check compiler compatibility with C11";
-       $c11_atomics = 0;
-    } else {
-       ($fh,$tmpf) = tempfile( SUFFIX => '.c' , UNLINK => 1 );
-       print $tmpf "#include <stdatomic.h>\nint main(void){}\n";
-       $args = " -c -o $tmpf.o $tmpf";
-       my @cmd = ("$compiler_name $flags $args >/dev/null 2>/dev/null");
-       system(@cmd) == 0;
-       if ($? != 0) {
-           $c11_atomics = 0;
-       } else {
-           $c11_atomics = 1;
-       }
-       unlink("$tmpf.o");
-    }
-}
-
-if ($compiler eq "GCC" &&( ($architecture eq "x86") || ($architecture eq "x86_64"))) {
-	$no_avx2 = 0;
-	$oldgcc = 0;
-	$data = `$compiler_name -dumpversion`;
-	if ($data <= 4.6) {
-		$no_avx2 = 1;
-		$oldgcc = 1;
-	}
-}
-
-$data = `$compiler_name $flags -S ctest1.c && grep globl ctest1.s | head -n 1 && rm -f ctest1.s`;
+$data = `$compiler_name -S ctest1.c && grep globl ctest1.s | head -n 1 && rm -f ctest1.s`;
 
 $data =~ /globl\s([_\.]*)(.*)/;
 
@@ -317,7 +267,7 @@ $linker_l = "";
 $linker_a = "";
 
 {
-    $link = `$compiler_name $flags -c ctest2.c -o ctest2.o 2>&1 && $compiler_name $flags $openmp -v ctest2.o -o ctest2 2>&1 && rm -f ctest2.o ctest2 ctest2.exe`;
+    $link = `$compiler_name -c ctest2.c -o ctest2.o 2>&1 && $compiler_name $openmp -v ctest2.o -o ctest2 2>&1 && rm -f ctest2.o ctest2 ctest2.exe`;
 
     $link =~ s/\-Y\sP\,/\-Y/g;
 
@@ -355,8 +305,6 @@ $linker_a = "";
 	    && ($flags !~ /kernel32/)
 	    && ($flags !~ /advapi32/)
 	    && ($flags !~ /shell32/)
-	    && ($flags !~ /omp/)
-	    && ($flags !~ /[0-9]+/)
 	    ) {
 	    $linker_l .= $flags . " "
 	}
@@ -385,8 +333,6 @@ print MAKEFILE "CEXTRALIB=$linker_L $linker_l $linker_a\n";
 print MAKEFILE "HAVE_MSA=1\n" if $have_msa eq 1;
 print MAKEFILE "MSA_FLAGS=$msa_flags\n" if $have_msa eq 1;
 print MAKEFILE "NO_AVX512=1\n" if $no_avx512 eq 1;
-print MAKEFILE "NO_AVX2=1\n" if $no_avx2 eq 1;
-print MAKEFILE "OLDGCC=1\n" if $oldgcc eq 1;
 
 $os           =~ tr/[a-z]/[A-Z]/;
 $architecture =~ tr/[a-z]/[A-Z]/;
@@ -399,8 +345,6 @@ print CONFFILE "#define __32BIT__\t1\n"  if $binformat eq bin32;
 print CONFFILE "#define __64BIT__\t1\n"  if $binformat eq bin64;
 print CONFFILE "#define FUNDERSCORE\t$need_fu\n" if $need_fu ne "";
 print CONFFILE "#define HAVE_MSA\t1\n"  if $have_msa eq 1;
-print CONFFILE "#define HAVE_C11\t1\n" if $c11_atomics eq 1;
-
 
 if ($os eq "LINUX") {
 

cblas.h

@@ -25,11 +25,6 @@ char* openblas_get_config(void);
 /*Get the CPU corename on runtime.*/
 char* openblas_get_corename(void);
 
-#ifdef OPENBLAS_OS_LINUX
-/* Sets thread affinity for OpenBLAS threads. `thread_idx` is in [0, openblas_get_num_threads()-1]. */
-int openblas_setaffinity(int thread_idx, size_t cpusetsize, cpu_set_t* cpu_set);
-#endif
-
 /* Get the parallelization type which is used by OpenBLAS */
 int openblas_get_parallel(void);
 /* OpenBLAS is compiled for sequential use  */
@@ -125,14 +120,9 @@ void cblas_zswap(OPENBLAS_CONST blasint n, void *x, OPENBLAS_CONST blasint incx,
 
 void cblas_srot(OPENBLAS_CONST blasint N, float *X, OPENBLAS_CONST blasint incX, float *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST float c, OPENBLAS_CONST float s);
 void cblas_drot(OPENBLAS_CONST blasint N, double *X, OPENBLAS_CONST blasint incX, double *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST double c, OPENBLAS_CONST double  s);
-void cblas_csrot(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST float c, OPENBLAS_CONST float s);
-void cblas_zdrot(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST double c, OPENBLAS_CONST double s);
 
 void cblas_srotg(float *a, float *b, float *c, float *s);
 void cblas_drotg(double *a, double *b, double *c, double *s);
-void cblas_crotg(void *a, void *b, float *c, void *s);
-void cblas_zrotg(void *a, void *b, double *c, void *s);
-
 
 void cblas_srotm(OPENBLAS_CONST blasint N, float *X, OPENBLAS_CONST blasint incX, float *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST float *P);
 void cblas_drotm(OPENBLAS_CONST blasint N, double *X, OPENBLAS_CONST blasint incX, double *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST double *P);
@@ -387,21 +377,7 @@ void cblas_cgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST blasint
 void cblas_zgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double *calpha, double *a, OPENBLAS_CONST blasint clda, OPENBLAS_CONST double *cbeta, 
 		  double *c, OPENBLAS_CONST blasint cldc); 
 
-/*** BFLOAT16 and INT8 extensions ***/
-/* convert float array to BFLOAT16 array by rounding */
-void   cblas_sbstobf16(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *in, OPENBLAS_CONST blasint incin, bfloat16 *out, OPENBLAS_CONST blasint incout);
-/* convert double array to BFLOAT16 array by rounding */
-void   cblas_sbdtobf16(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *in, OPENBLAS_CONST blasint incin, bfloat16 *out, OPENBLAS_CONST blasint incout);
-/* convert BFLOAT16 array to float array */
-void   cblas_sbf16tos(OPENBLAS_CONST blasint n, OPENBLAS_CONST bfloat16 *in, OPENBLAS_CONST blasint incin, float  *out, OPENBLAS_CONST blasint incout);
-/* convert BFLOAT16 array to double array */
-void   cblas_dbf16tod(OPENBLAS_CONST blasint n, OPENBLAS_CONST bfloat16 *in, OPENBLAS_CONST blasint incin, double *out, OPENBLAS_CONST blasint incout);
-/* dot production of BFLOAT16 input arrays, and output as float */
-float  cblas_sbdot(OPENBLAS_CONST blasint n, OPENBLAS_CONST bfloat16 *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST bfloat16 *y, OPENBLAS_CONST blasint incy);
-void   cblas_sbgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST bfloat16 *a, OPENBLAS_CONST blasint lda, OPENBLAS_CONST bfloat16 *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float beta, float *y, OPENBLAS_CONST blasint incy);
 
-void   cblas_sbgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-		    OPENBLAS_CONST float alpha, OPENBLAS_CONST bfloat16 *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST bfloat16 *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
 #ifdef __cplusplus
 }
 #endif  /* __cplusplus */

cmake/arch.cmake

@@ -1,3 +1,4 @@
+##
 ## Author: Hank Anderson <hank@statease.com>
 ## Description: Ported from portion of OpenBLAS/Makefile.system
 ##              Sets various variables based on architecture.
@@ -44,15 +45,7 @@ endif ()
 
 if (DYNAMIC_ARCH)
   if (ARM64)
-	  set(DYNAMIC_CORE ARMV8 CORTEXA53 CORTEXA55 CORTEXA57 CORTEXA72 CORTEXA73 FALKOR THUNDERX THUNDERX2T99 TSV110 EMAG8180 NEOVERSEN1 NEOVERSEV1 NEOVERSEN2 THUNDERX3T110)
-    if (DYNAMIC_LIST)
-	    set(DYNAMIC_CORE ARMV8 ${DYNAMIC_LIST})
-    endif ()
-  endif ()
-  
-  if (POWER)
-	  set(DYNAMIC_CORE POWER6 POWER8 POWER9 POWER10)
-	  set(CCOMMON_OPT "${CCOMMON_OPT} -DHAVE_P10_SUPPORT")
+    set(DYNAMIC_CORE ARMV8 CORTEXA53 CORTEXA57 CORTEXA72 CORTEXA73 FALKOR THUNDERX THUNDERX2T99)
   endif ()
   
   if (X86)
@@ -79,18 +72,14 @@ if (DYNAMIC_ARCH)
       set(DYNAMIC_CORE ${DYNAMIC_CORE} HASWELL ZEN)
     endif ()
     if (NOT NO_AVX512)
-      set(DYNAMIC_CORE ${DYNAMIC_CORE} SKYLAKEX COOPERLAKE)
-      string(REGEX REPLACE "-march=native" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-    endif ()
+      set(DYNAMIC_CORE ${DYNAMIC_CORE} SKYLAKEX)
+      string(REGEX REPLACE "-march=native" "" CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
+   endif ()
     if (DYNAMIC_LIST)
-      set(DYNAMIC_CORE PRESCOTT ${DYNAMIC_LIST})
+	set(DYNAMIC_CORE PRESCOTT ${DYNAMIC_LIST})
     endif ()
   endif ()
 
-  if (EXISTS ${PROJECT_SOURCE_DIR}/config_kernel.h)
-	  message (FATAL_ERROR "Your build directory contains a file config_kernel.h, probably from a previous compilation with make. This will conflict with the cmake compilation and cause strange compiler errors - please remove the file before trying again")
-  endif ()
-
   if (NOT DYNAMIC_CORE)
     message (STATUS "DYNAMIC_ARCH is not supported on this architecture, removing from options")
     unset(DYNAMIC_ARCH CACHE)
@@ -109,11 +98,7 @@ if (${ARCH} STREQUAL "ia64")
   endif ()
 endif ()
 
-if (MIPS32 OR MIPS64)
-  set(NO_BINARY_MODE 1)
-endif ()
-
-if (LOONGARCH64)
+if (MIPS64)
   set(NO_BINARY_MODE 1)
 endif ()
 

cmake/cc.cmake

@@ -15,11 +15,6 @@ if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU" OR ${CMAKE_C_COMPILER_ID} STREQUAL "LS
 
   if (NO_BINARY_MODE)
 
-    if (MIPS32)
-        set(CCOMMON_OPT "${CCOMMON_OPT} -mabi=32")
-      set(BINARY_DEFINED 1)
-    endif ()
-
     if (MIPS64)
       if (BINARY64)
         set(CCOMMON_OPT "${CCOMMON_OPT} -mabi=64")
@@ -34,15 +29,6 @@ if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU" OR ${CMAKE_C_COMPILER_ID} STREQUAL "LS
       set(FCOMMON_OPT "${FCOMMON_OPT} -march=mips64")
     endif ()
 
-    if (LOONGARCH64)
-      if (BINARY64)
-        set(CCOMMON_OPT "${CCOMMON_OPT} -mabi=lp64")
-      else ()
-        set(CCOMMON_OPT "${CCOMMON_OPT} -mabi=lp32")
-      endif ()
-      set(BINARY_DEFINED 1)
-    endif ()
-
     if (CMAKE_SYSTEM_NAME STREQUAL "AIX")
       set(BINARY_DEFINED 1)
     endif ()
@@ -110,109 +96,3 @@ if (${CMAKE_C_COMPILER_ID} STREQUAL "SUN")
   endif ()
 endif ()
 
-if (${CORE} STREQUAL SKYLAKEX)
-  if (NOT DYNAMIC_ARCH)
-    if (NOT NO_AVX512)
-      set (CCOMMON_OPT "${CCOMMON_OPT} -march=skylake-avx512")
-    endif ()
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL COOPERLAKE)
-  if (NOT DYNAMIC_ARCH)
-    if (NOT NO_AVX512)
-      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-      if (${GCC_VERSION} VERSION_GREATER 10.1 OR ${GCC_VERSION} VERSION_EQUAL 10.1)
-        set (CCOMMON_OPT  "${CCOMMON_OPT} -march=cooperlake")
-      else ()
-        set (CCOMMON_OPT "${CCOMMON_OPT} -march=skylake-avx512")
-      endif()  
-    endif ()
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL SAPPHIRERAPIDS)
-  if (NOT DYNAMIC_ARCH)
-    if (NOT NO_AVX512)
-      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-      if (${GCC_VERSION} VERSION_GREATER 11.0 OR ${GCC_VERSION} VERSION_EQUAL 11.0)
-        set (CCOMMON_OPT  "${CCOMMON_OPT} -march=sapphirerapids")
-      else ()
-        set (CCOMMON_OPT "${CCOMMON_OPT} -march=skylake-avx512")
-      endif()  
-    endif ()
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL A64FX)
-  if (NOT DYNAMIC_ARCH)
-    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-    if (${GCC_VERSION} VERSION_GREATER 11.0 OR ${GCC_VERSION} VERSION_EQUAL 11.0)
-      set (CCOMMON_OPT  "${CCOMMON_OPT} -march=armv8.2-a+sve -mtune=a64fx")
-    else ()
-      set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.2-a+sve")
-    endif()
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL ARMV8SVE)
-  if (NOT DYNAMIC_ARCH)
-    set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8-a+sve")
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL POWER10)
-  if (NOT DYNAMIC_ARCH)
-    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-    if (${GCC_VERSION} VERSION_GREATER 10.2 OR ${GCC_VERSION} VERSION_EQUAL 10.2)
-      set (CCOMMON_OPT  "${CCOMMON_OPT} -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math")
-    else ()
-      message(FATAL_ERROR "Compiler GCC.${GCC_VERSION} does not support Power10." )
-    endif()
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL POWER9)
-  if (NOT DYNAMIC_ARCH)
-    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-    if (${GCC_VERSION} VERSION_GREATER 5.0 OR ${GCC_VERSION} VERSION_EQUAL 5.0)
-      set (CCOMMON_OPT  "${CCOMMON_OPT} -mcpu=power9 -mtune=power9 -mvsx -fno-fast-math")
-    else ()
-      set (CCOMMON_OPT  "${CCOMMON_OPT} -mcpu=power8 -mtune=power8 -mvsx -fno-fast-math")
-      message(WARNING "Compiler GCC.${GCC_VERSION} does not fully support Power9.")
-    endif ()
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL POWER8)
-  if (NOT DYNAMIC_ARCH)
-    set (CCOMMON_OPT  "${CCOMMON_OPT} -mcpu=power8 -mtune=power8 -mvsx -fno-fast-math")
-  endif ()
-endif ()
-
-if (NOT DYNAMIC_ARCH)
-	if (HAVE_AVX2)
-        set (CCOMMON_OPT  "${CCOMMON_OPT} -mavx2")
-	endif ()
-	if (HAVE_AVX)
-        set (CCOMMON_OPT  "${CCOMMON_OPT} -mavx")
-	endif ()
-	#	if (HAVE_FMA3)
-	#set (CCOMMON_OPT  "${CCOMMON_OPT} -mfma")
-	#endif ()
-	if (HAVE_SSE)
-	set (CCOMMON_OPT  "${CCOMMON_OPT} -msse")
-	endif ()
-	if (HAVE_SSE2)
-        set (CCOMMON_OPT  "${CCOMMON_OPT} -msse2")
-	endif ()
-	if (HAVE_SSE3)
-        set (CCOMMON_OPT  "${CCOMMON_OPT} -msse3")
-	endif ()
-	if (HAVE_SSSE3)
-        set (CCOMMON_OPT  "${CCOMMON_OPT} -mssse3")
-	endif ()
-	if (HAVE_SSE4_1)
-	set (CCOMMON_OPT  "${CCOMMON_OPT} -msse4.1")
-	endif ()
-endif()

cmake/f_check.cmake

@@ -20,16 +20,11 @@
 # NEEDBUNDERSCORE
 # NEED2UNDERSCORES
 
-include(CheckLanguage)
-check_language(Fortran)
-if(CMAKE_Fortran_COMPILER)
+if (NOT NO_LAPACK)
   enable_language(Fortran)
 else()
-  if (NOT NO_LAPACK)
-    message(STATUS "No Fortran compiler found, can build only BLAS but not LAPACK")
-  endif()
-  set (NOFORTRAN 1)
-  set (NO_LAPACK 1)
+  include(CMakeForceCompiler)
+  CMAKE_FORCE_Fortran_COMPILER(gfortran GNU)
 endif()
 
 if (NOT ONLY_CBLAS)

cmake/fc.cmake

@@ -3,6 +3,11 @@
 ## Description: Ported from portion of OpenBLAS/Makefile.system
 ##              Sets Fortran related variables.
 
+if (INTERFACE64)
+  set(SUFFIX64 64)
+  set(SUFFIX64_UNDERSCORE _64)
+endif()
+
 if (${F_COMPILER} STREQUAL "FLANG")
   set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_FLANG")
   if (BINARY64 AND INTERFACE64)
@@ -11,7 +16,6 @@ if (${F_COMPILER} STREQUAL "FLANG")
   if (USE_OPENMP)
     set(FCOMMON_OPT "${FCOMMON_OPT} -fopenmp")
   endif ()
-  set(FCOMMON_OPT "${FCOMMON_OPT} -Mrecursive -Kieee")
 endif ()
 
 if (${F_COMPILER} STREQUAL "G77")
@@ -56,13 +60,6 @@ if (${F_COMPILER} STREQUAL "GFORTRAN")
         set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=n32")
       endif ()
     endif ()
-    if (LOONGARCH64)
-      if (BINARY64)
-        set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=lp64")
-      else ()
-        set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=lp32")
-      endif ()
-    endif ()
   else ()
     if (BINARY64)
       set(FCOMMON_OPT "${FCOMMON_OPT} -m64")
@@ -84,7 +81,6 @@ if (${F_COMPILER} STREQUAL "INTEL")
   if (INTERFACE64)
     set(FCOMMON_OPT "${FCOMMON_OPT} -i8")
   endif ()
-  set(FCOMMON_OPT "${FCOMMON_OPT} -recursive")
   if (USE_OPENMP)
     set(FCOMMON_OPT "${FCOMMON_OPT} -openmp")
   endif ()
@@ -99,7 +95,7 @@ endif ()
 
 if (${F_COMPILER} STREQUAL "IBM")
   set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_IBM")
-  set(FCOMMON_OPT "${FCOMMON_OPT} -qrecur")
+  # FCOMMON_OPT	+= -qarch=440
   if (BINARY64)
     set(FCOMMON_OPT "${FCOMMON_OPT} -q64")
     if (INTERFACE64)
@@ -124,7 +120,6 @@ if (${F_COMPILER} STREQUAL "PGI")
   else ()
     set(FCOMMON_OPT "${FCOMMON_OPT} -tp p7")
   endif ()
-  set(FCOMMON_OPT "${FCOMMON_OPT} -Mrecursive")
   if (USE_OPENMP)
     set(FCOMMON_OPT "${FCOMMON_OPT} -mp")
   endif ()

cmake/kernel.cmake

@@ -1,218 +1,171 @@
 # helper functions for the kernel CMakeLists.txt
 
-function(SetFallback KERNEL SOURCE_PATH)
-  if (NOT (DEFINED ${KERNEL}))
-    set(${KERNEL} ${SOURCE_PATH} PARENT_SCOPE)
-  endif ()
-endfunction()
 
+# Set the default filenames for L1 objects. Most of these will be overridden by the appropriate KERNEL file.
 macro(SetDefaultL1)
-  SetFallback(SAMAXKERNEL amax.S)
-  SetFallback(DAMAXKERNEL amax.S)
-  SetFallback(QAMAXKERNEL amax.S)
-  SetFallback(CAMAXKERNEL zamax.S)
-  SetFallback(ZAMAXKERNEL zamax.S)
-  SetFallback(XAMAXKERNEL zamax.S)
-  SetFallback(SAMINKERNEL amin.S)
-  SetFallback(DAMINKERNEL amin.S)
-  SetFallback(QAMINKERNEL amin.S)
-  SetFallback(CAMINKERNEL zamin.S)
-  SetFallback(ZAMINKERNEL zamin.S)
-  SetFallback(XAMINKERNEL zamin.S)
-  SetFallback(SMAXKERNEL max.S)
-  SetFallback(DMAXKERNEL max.S)
-  SetFallback(QMAXKERNEL max.S)
-  SetFallback(SMINKERNEL min.S)
-  SetFallback(DMINKERNEL min.S)
-  SetFallback(QMINKERNEL min.S)
-  SetFallback(ISAMAXKERNEL iamax.S)
-  SetFallback(IDAMAXKERNEL iamax.S)
-  SetFallback(IQAMAXKERNEL iamax.S)
-  SetFallback(ICAMAXKERNEL izamax.S)
-  SetFallback(IZAMAXKERNEL izamax.S)
-  SetFallback(IXAMAXKERNEL izamax.S)
-  SetFallback(ISAMINKERNEL iamin.S)
-  SetFallback(IDAMINKERNEL iamin.S)
-  SetFallback(IQAMINKERNEL iamin.S)
-  SetFallback(ICAMINKERNEL izamin.S)
-  SetFallback(IZAMINKERNEL izamin.S)
-  SetFallback(IXAMINKERNEL izamin.S)
-  SetFallback(ISMAXKERNEL iamax.S)
-  SetFallback(IDMAXKERNEL iamax.S)
-  SetFallback(IQMAXKERNEL iamax.S)
-  SetFallback(ISMINKERNEL iamin.S)
-  SetFallback(IDMINKERNEL iamin.S)
-  SetFallback(IQMINKERNEL iamin.S)
-  SetFallback(SASUMKERNEL asum.S)
-  SetFallback(DASUMKERNEL asum.S)
-  SetFallback(CASUMKERNEL zasum.S)
-  SetFallback(ZASUMKERNEL zasum.S)
-  SetFallback(QASUMKERNEL asum.S)
-  SetFallback(XASUMKERNEL zasum.S)
-  SetFallback(SAXPYKERNEL axpy.S)
-  SetFallback(DAXPYKERNEL axpy.S)
-  SetFallback(CAXPYKERNEL zaxpy.S)
-  SetFallback(ZAXPYKERNEL zaxpy.S)
-  SetFallback(QAXPYKERNEL axpy.S)
-  SetFallback(XAXPYKERNEL zaxpy.S)
-  SetFallback(SCOPYKERNEL copy.S)
-  SetFallback(DCOPYKERNEL copy.S)
-  SetFallback(CCOPYKERNEL zcopy.S)
-  SetFallback(ZCOPYKERNEL zcopy.S)
-  SetFallback(QCOPYKERNEL copy.S)
-  SetFallback(XCOPYKERNEL zcopy.S)
-  SetFallback(SDOTKERNEL dot.S)
-  SetFallback(DDOTKERNEL dot.S)
-  SetFallback(CDOTKERNEL zdot.S)
-  SetFallback(ZDOTKERNEL zdot.S)
-  SetFallback(QDOTKERNEL dot.S)
-  SetFallback(XDOTKERNEL zdot.S)
-  SetFallback(SNRM2KERNEL nrm2.S)
-  SetFallback(DNRM2KERNEL nrm2.S)
-  SetFallback(QNRM2KERNEL nrm2.S)
-  SetFallback(CNRM2KERNEL znrm2.S)
-  SetFallback(ZNRM2KERNEL znrm2.S)
-  SetFallback(XNRM2KERNEL znrm2.S)
-  SetFallback(SROTKERNEL rot.S)
-  SetFallback(DROTKERNEL rot.S)
-  SetFallback(QROTKERNEL rot.S)
-  SetFallback(CROTKERNEL zrot.S)
-  SetFallback(ZROTKERNEL zrot.S)
-  SetFallback(XROTKERNEL zrot.S)
-  SetFallback(SSCALKERNEL scal.S)
-  SetFallback(DSCALKERNEL scal.S)
-  SetFallback(CSCALKERNEL zscal.S)
-  SetFallback(ZSCALKERNEL zscal.S)
-  SetFallback(QSCALKERNEL scal.S)
-  SetFallback(XSCALKERNEL zscal.S)
-  SetFallback(SSWAPKERNEL swap.S)
-  SetFallback(DSWAPKERNEL swap.S)
-  SetFallback(CSWAPKERNEL zswap.S)
-  SetFallback(ZSWAPKERNEL zswap.S)
-  SetFallback(QSWAPKERNEL swap.S)
-  SetFallback(XSWAPKERNEL zswap.S)
-  SetFallback(SGEMVNKERNEL gemv_n.S)
-  SetFallback(SGEMVTKERNEL gemv_t.S)
-  SetFallback(DGEMVNKERNEL gemv_n.S)
-  SetFallback(DGEMVTKERNEL gemv_t.S)
-  SetFallback(CGEMVNKERNEL zgemv_n.S)
-  SetFallback(CGEMVTKERNEL zgemv_t.S)
-  SetFallback(ZGEMVNKERNEL zgemv_n.S)
-  SetFallback(ZGEMVTKERNEL zgemv_t.S)
-  SetFallback(QGEMVNKERNEL gemv_n.S)
-  SetFallback(QGEMVTKERNEL gemv_t.S)
-  SetFallback(XGEMVNKERNEL zgemv_n.S)
-  SetFallback(XGEMVTKERNEL zgemv_t.S)
-  SetFallback(SCABS_KERNEL ../generic/cabs.c)
-  SetFallback(DCABS_KERNEL ../generic/cabs.c)
-  SetFallback(QCABS_KERNEL ../generic/cabs.c)
-  SetFallback(LSAME_KERNEL ../generic/lsame.c)
-  SetFallback(SAXPBYKERNEL ../arm/axpby.c)
-  SetFallback(DAXPBYKERNEL ../arm/axpby.c)
-  SetFallback(CAXPBYKERNEL ../arm/zaxpby.c)
-  SetFallback(ZAXPBYKERNEL ../arm/zaxpby.c)
-  SetFallback(SSUMKERNEL sum.S)
-  SetFallback(DSUMKERNEL sum.S)
-  SetFallback(CSUMKERNEL zsum.S)
-  SetFallback(ZSUMKERNEL zsum.S)
-  SetFallback(QSUMKERNEL sum.S)
-  SetFallback(XSUMKERNEL zsum.S)
-if (BUILD_BFLOAT16)
-  SetFallback(SHAMINKERNEL ../arm/amin.c)
-  SetFallback(SHAMAXKERNEL ../arm/amax.c)
-  SetFallback(SHMAXKERNEL ../arm/max.c)
-  SetFallback(SHMINKERNEL ../arm/min.c)
-  SetFallback(ISHAMAXKERNEL ../arm/iamax.c)
-  SetFallback(ISHAMINKERNEL ../arm/iamin.c)
-  SetFallback(ISHMAXKERNEL ../arm/imax.c)
-  SetFallback(ISHMINKERNEL ../arm/imin.c)
-  SetFallback(SHASUMKERNEL ../arm/asum.c)
-  SetFallback(SHAXPYKERNEL ../arm/axpy.c)
-  SetFallback(SHAXPBYKERNEL ../arm/axpby.c)
-  SetFallback(SHCOPYKERNEL ../arm/copy.c)
-  SetFallback(SBDOTKERNEL ../x86_64/sbdot.c)
-  SetFallback(SHROTKERNEL ../arm/rot.c)
-  SetFallback(SHSCALKERNEL ../arm/scal.c)
-  SetFallback(SHNRM2KERNEL ../arm/nrm2.c)
-  SetFallback(SHSUMKERNEL ../arm/sum.c)
-  SetFallback(SHSWAPKERNEL ../arm/swap.c)
-  SetFallback(TOBF16KERNEL ../x86_64/tobf16.c)
-  SetFallback(BF16TOKERNEL ../x86_64/bf16to.c)
-  SetFallback(SBGEMVNKERNEL ../x86_64/sbgemv_n.c)
-  SetFallback(SBGEMVTKERNEL ../x86_64/sbgemv_t.c)
-endif ()
+  set(SAMAXKERNEL amax.S)
+  set(DAMAXKERNEL amax.S)
+  set(QAMAXKERNEL amax.S)
+  set(CAMAXKERNEL zamax.S)
+  set(ZAMAXKERNEL zamax.S)
+  set(XAMAXKERNEL zamax.S)
+  set(SAMINKERNEL amin.S)
+  set(DAMINKERNEL amin.S)
+  set(QAMINKERNEL amin.S)
+  set(CAMINKERNEL zamin.S)
+  set(ZAMINKERNEL zamin.S)
+  set(XAMINKERNEL zamin.S)
+  set(SMAXKERNEL max.S)
+  set(DMAXKERNEL max.S)
+  set(QMAXKERNEL max.S)
+  set(SMINKERNEL min.S)
+  set(DMINKERNEL min.S)
+  set(QMINKERNEL min.S)
+  set(ISAMAXKERNEL iamax.S)
+  set(IDAMAXKERNEL iamax.S)
+  set(IQAMAXKERNEL iamax.S)
+  set(ICAMAXKERNEL izamax.S)
+  set(IZAMAXKERNEL izamax.S)
+  set(IXAMAXKERNEL izamax.S)
+  set(ISAMINKERNEL iamin.S)
+  set(IDAMINKERNEL iamin.S)
+  set(IQAMINKERNEL iamin.S)
+  set(ICAMINKERNEL izamin.S)
+  set(IZAMINKERNEL izamin.S)
+  set(IXAMINKERNEL izamin.S)
+  set(ISMAXKERNEL iamax.S)
+  set(IDMAXKERNEL iamax.S)
+  set(IQMAXKERNEL iamax.S)
+  set(ISMINKERNEL iamin.S)
+  set(IDMINKERNEL iamin.S)
+  set(IQMINKERNEL iamin.S)
+  set(SASUMKERNEL asum.S)
+  set(DASUMKERNEL asum.S)
+  set(CASUMKERNEL zasum.S)
+  set(ZASUMKERNEL zasum.S)
+  set(QASUMKERNEL asum.S)
+  set(XASUMKERNEL zasum.S)
+  set(SAXPYKERNEL axpy.S)
+  set(DAXPYKERNEL axpy.S)
+  set(CAXPYKERNEL zaxpy.S)
+  set(ZAXPYKERNEL zaxpy.S)
+  set(QAXPYKERNEL axpy.S)
+  set(XAXPYKERNEL zaxpy.S)
+  set(SCOPYKERNEL copy.S)
+  set(DCOPYKERNEL copy.S)
+  set(CCOPYKERNEL zcopy.S)
+  set(ZCOPYKERNEL zcopy.S)
+  set(QCOPYKERNEL copy.S)
+  set(XCOPYKERNEL zcopy.S)
+  set(SDOTKERNEL dot.S)
+  set(DDOTKERNEL dot.S)
+  set(CDOTKERNEL zdot.S)
+  set(ZDOTKERNEL zdot.S)
+  set(QDOTKERNEL dot.S)
+  set(XDOTKERNEL zdot.S)
+  set(SNRM2KERNEL nrm2.S)
+  set(DNRM2KERNEL nrm2.S)
+  set(QNRM2KERNEL nrm2.S)
+  set(CNRM2KERNEL znrm2.S)
+  set(ZNRM2KERNEL znrm2.S)
+  set(XNRM2KERNEL znrm2.S)
+  set(SROTKERNEL rot.S)
+  set(DROTKERNEL rot.S)
+  set(QROTKERNEL rot.S)
+  set(CROTKERNEL zrot.S)
+  set(ZROTKERNEL zrot.S)
+  set(XROTKERNEL zrot.S)
+  set(SSCALKERNEL scal.S)
+  set(DSCALKERNEL scal.S)
+  set(CSCALKERNEL zscal.S)
+  set(ZSCALKERNEL zscal.S)
+  set(QSCALKERNEL scal.S)
+  set(XSCALKERNEL zscal.S)
+  set(SSWAPKERNEL swap.S)
+  set(DSWAPKERNEL swap.S)
+  set(CSWAPKERNEL zswap.S)
+  set(ZSWAPKERNEL zswap.S)
+  set(QSWAPKERNEL swap.S)
+  set(XSWAPKERNEL zswap.S)
+  set(SGEMVNKERNEL gemv_n.S)
+  set(SGEMVTKERNEL gemv_t.S)
+  set(DGEMVNKERNEL gemv_n.S)
+  set(DGEMVTKERNEL gemv_t.S)
+  set(CGEMVNKERNEL zgemv_n.S)
+  set(CGEMVTKERNEL zgemv_t.S)
+  set(ZGEMVNKERNEL zgemv_n.S)
+  set(ZGEMVTKERNEL zgemv_t.S)
+  set(QGEMVNKERNEL gemv_n.S)
+  set(QGEMVTKERNEL gemv_t.S)
+  set(XGEMVNKERNEL zgemv_n.S)
+  set(XGEMVTKERNEL zgemv_t.S)
+  set(SCABS_KERNEL ../generic/cabs.c)
+  set(DCABS_KERNEL ../generic/cabs.c)
+  set(QCABS_KERNEL ../generic/cabs.c)
+  set(LSAME_KERNEL ../generic/lsame.c)
+  set(SAXPBYKERNEL ../arm/axpby.c)
+  set(DAXPBYKERNEL ../arm/axpby.c)
+  set(CAXPBYKERNEL ../arm/zaxpby.c)
+  set(ZAXPBYKERNEL ../arm/zaxpby.c)
+  set(SSUMKERNEL sum.S)
+  set(DSUMKERNEL sum.S)
+  set(CSUMKERNEL zsum.S)
+  set(ZSUMKERNEL zsum.S)
+  set(QSUMKERNEL sum.S)
+  set(XSUMKERNEL zsum.S)
 endmacro ()
 
 macro(SetDefaultL2)
-  SetFallback(SGEMVNKERNEL ../arm/gemv_n.c)
-  SetFallback(SGEMVTKERNEL ../arm/gemv_t.c)
-  SetFallback(DGEMVNKERNEL gemv_n.S)
-  SetFallback(DGEMVTKERNEL gemv_t.S)
-  SetFallback(CGEMVNKERNEL zgemv_n.S)
-  SetFallback(CGEMVTKERNEL zgemv_t.S)
-  SetFallback(ZGEMVNKERNEL zgemv_n.S)
-  SetFallback(ZGEMVTKERNEL zgemv_t.S)
-  SetFallback(QGEMVNKERNEL gemv_n.S)
-  SetFallback(QGEMVTKERNEL gemv_t.S)
-  SetFallback(XGEMVNKERNEL zgemv_n.S)
-  SetFallback(XGEMVTKERNEL zgemv_t.S)
-  SetFallback(SGERKERNEL ../generic/ger.c)
-  SetFallback(DGERKERNEL ../generic/ger.c)
-  SetFallback(QGERKERNEL ../generic/ger.c)
-  SetFallback(CGERUKERNEL ../generic/zger.c)
-  SetFallback(CGERCKERNEL ../generic/zger.c)
-  SetFallback(ZGERUKERNEL ../generic/zger.c)
-  SetFallback(ZGERCKERNEL ../generic/zger.c)
-  SetFallback(XGERUKERNEL ../generic/zger.c)
-  SetFallback(XGERCKERNEL ../generic/zger.c)
-  SetFallback(SSYMV_U_KERNEL ../generic/symv_k.c)
-  SetFallback(SSYMV_L_KERNEL ../generic/symv_k.c)
-  SetFallback(DSYMV_U_KERNEL ../generic/symv_k.c)
-  SetFallback(DSYMV_L_KERNEL ../generic/symv_k.c)
-  SetFallback(QSYMV_U_KERNEL ../generic/symv_k.c)
-  SetFallback(QSYMV_L_KERNEL ../generic/symv_k.c)
-  SetFallback(CSYMV_U_KERNEL ../generic/zsymv_k.c)
-  SetFallback(CSYMV_L_KERNEL ../generic/zsymv_k.c)
-  SetFallback(ZSYMV_U_KERNEL ../generic/zsymv_k.c)
-  SetFallback(ZSYMV_L_KERNEL ../generic/zsymv_k.c)
-  SetFallback(XSYMV_U_KERNEL ../generic/zsymv_k.c)
-  SetFallback(XSYMV_L_KERNEL ../generic/zsymv_k.c)
-  SetFallback(CHEMV_U_KERNEL ../generic/zhemv_k.c)
-  SetFallback(CHEMV_L_KERNEL ../generic/zhemv_k.c)
-  SetFallback(CHEMV_V_KERNEL ../generic/zhemv_k.c)
-  SetFallback(CHEMV_M_KERNEL ../generic/zhemv_k.c)
-  SetFallback(ZHEMV_U_KERNEL ../generic/zhemv_k.c)
-  SetFallback(ZHEMV_L_KERNEL ../generic/zhemv_k.c)
-  SetFallback(ZHEMV_V_KERNEL ../generic/zhemv_k.c)
-  SetFallback(ZHEMV_M_KERNEL ../generic/zhemv_k.c)
-  SetFallback(XHEMV_U_KERNEL ../generic/zhemv_k.c)
-  SetFallback(XHEMV_L_KERNEL ../generic/zhemv_k.c)
-  SetFallback(XHEMV_V_KERNEL ../generic/zhemv_k.c)
-  SetFallback(XHEMV_M_KERNEL ../generic/zhemv_k.c)
-if (BUILD_BFLOAT16)
-  SetFallback(SBGEMVNKERNEL ../x86_64/sbgemv_n.c)
-  SetFallback(SBGEMVTKERNEL ../x86_64/sbgemv_t.c)
-  SetFallback(SHGERKERNEL ../generic/ger.c)
-endif ()
+  set(SGEMVNKERNEL gemv_n.S)
+  set(SGEMVTKERNEL gemv_t.S)
+  set(DGEMVNKERNEL gemv_n.S)
+  set(DGEMVTKERNEL gemv_t.S)
+  set(CGEMVNKERNEL zgemv_n.S)
+  set(CGEMVTKERNEL zgemv_t.S)
+  set(ZGEMVNKERNEL zgemv_n.S)
+  set(ZGEMVTKERNEL zgemv_t.S)
+  set(QGEMVNKERNEL gemv_n.S)
+  set(QGEMVTKERNEL gemv_t.S)
+  set(XGEMVNKERNEL zgemv_n.S)
+  set(XGEMVTKERNEL zgemv_t.S)
+  set(SGERKERNEL ../generic/ger.c)
+  set(DGERKERNEL ../generic/ger.c)
+  set(QGERKERNEL ../generic/ger.c)
+  set(CGERUKERNEL ../generic/zger.c)
+  set(CGERCKERNEL ../generic/zger.c)
+  set(ZGERUKERNEL ../generic/zger.c)
+  set(ZGERCKERNEL ../generic/zger.c)
+  set(XGERUKERNEL ../generic/zger.c)
+  set(XGERCKERNEL ../generic/zger.c)
+  set(SSYMV_U_KERNEL ../generic/symv_k.c)
+  set(SSYMV_L_KERNEL ../generic/symv_k.c)
+  set(DSYMV_U_KERNEL ../generic/symv_k.c)
+  set(DSYMV_L_KERNEL ../generic/symv_k.c)
+  set(QSYMV_U_KERNEL ../generic/symv_k.c)
+  set(QSYMV_L_KERNEL ../generic/symv_k.c)
+  set(CSYMV_U_KERNEL ../generic/zsymv_k.c)
+  set(CSYMV_L_KERNEL ../generic/zsymv_k.c)
+  set(ZSYMV_U_KERNEL ../generic/zsymv_k.c)
+  set(ZSYMV_L_KERNEL ../generic/zsymv_k.c)
+  set(XSYMV_U_KERNEL ../generic/zsymv_k.c)
+  set(XSYMV_L_KERNEL ../generic/zsymv_k.c)
+  set(CHEMV_U_KERNEL ../generic/zhemv_k.c)
+  set(CHEMV_L_KERNEL ../generic/zhemv_k.c)
+  set(CHEMV_V_KERNEL ../generic/zhemv_k.c)
+  set(CHEMV_M_KERNEL ../generic/zhemv_k.c)
+  set(ZHEMV_U_KERNEL ../generic/zhemv_k.c)
+  set(ZHEMV_L_KERNEL ../generic/zhemv_k.c)
+  set(ZHEMV_V_KERNEL ../generic/zhemv_k.c)
+  set(ZHEMV_M_KERNEL ../generic/zhemv_k.c)
+  set(XHEMV_U_KERNEL ../generic/zhemv_k.c)
+  set(XHEMV_L_KERNEL ../generic/zhemv_k.c)
+  set(XHEMV_V_KERNEL ../generic/zhemv_k.c)
+  set(XHEMV_M_KERNEL ../generic/zhemv_k.c)
 endmacro ()
 
 macro(SetDefaultL3)
-  SetFallback(SGEADD_KERNEL ../generic/geadd.c)
-  SetFallback(DGEADD_KERNEL ../generic/geadd.c)
-  SetFallback(CGEADD_KERNEL ../generic/zgeadd.c)
-  SetFallback(ZGEADD_KERNEL ../generic/zgeadd.c)
-if (BUILD_BFLOAT16)
-  SetFallback(SHGEADD_KERNEL ../generic/geadd.c)
-  SetFallback(SBGEMMKERNEL ../generic/gemmkernel_2x2.c)
-  SetFallback(SBGEMM_BETA  ../generic/gemm_beta.c)
-  SetFallback(SBGEMMINCOPY ../generic/gemm_ncopy_2.c)
-  SetFallback(SBGEMMITCOPY ../generic/gemm_tcopy_2.c)
-  SetFallback(SBGEMMONCOPY ../generic/gemm_ncopy_2.c)
-  SetFallback(SBGEMMOTCOPY ../generic/gemm_tcopy_2.c)
-  SetFallback(SBGEMMINCOPYOBJ sbgemm_incopy.o)
-  SetFallback(SBGEMMITCOPYOBJ sbgemm_itcopy.o)
-  SetFallback(SBGEMMONCOPYOBJ sbgemm_oncopy.o)
-  SetFallback(SBGEMMOTCOPYOBJ sbgemm_otcopy.o)
-endif ()
-
+  set(SGEADD_KERNEL ../generic/geadd.c)
+  set(DGEADD_KERNEL ../generic/geadd.c)
+  set(CGEADD_KERNEL ../generic/zgeadd.c)
+  set(ZGEADD_KERNEL ../generic/zgeadd.c)
 endmacro ()

cmake/lapack.cmake

@@ -1,12 +1,11 @@
 # Sources for compiling lapack-netlib. Can't use CMakeLists.txt because lapack-netlib already has its own cmake files.
 
 set(ALLAUX ilaenv.f ilaenv2stage.f ieeeck.f lsamen.f iparmq.f iparam2stage.F
-   ilaprec.f ilatrans.f ilauplo.f iladiag.f chla_transtype.f dlaset.f
+   ilaprec.f ilatrans.f ilauplo.f iladiag.f chla_transtype.f
    ../INSTALL/ilaver.f xerbla_array.f
    ../INSTALL/slamch.f)
 
 set(SCLAUX
-	scombssq.f sbdsvdx.f sstevx.f sstein.f
    sbdsdc.f
    sbdsqr.f sdisna.f slabad.f slacpy.f sladiv.f slae2.f  slaebz.f
    slaed0.f slaed1.f slaed2.f slaed3.f slaed4.f slaed5.f slaed6.f
@@ -26,7 +25,6 @@ set(SCLAUX
 
 set(DZLAUX
    dbdsdc.f
-   dbdsvdx.f dstevx.f dstein.f
    dbdsqr.f ddisna.f dlabad.f dlacpy.f dladiv.f dlae2.f  dlaebz.f
    dlaed0.f dlaed1.f dlaed2.f dlaed3.f dlaed4.f dlaed5.f dlaed6.f
    dlaed7.f dlaed8.f dlaed9.f dlaeda.f dlaev2.f dlagtf.f
@@ -37,14 +35,14 @@ set(DZLAUX
    dlartg.f dlaruv.f dlas2.f  dlascl.f
    dlasd0.f dlasd1.f dlasd2.f dlasd3.f dlasd4.f dlasd5.f dlasd6.f
    dlasd7.f dlasd8.f dlasda.f dlasdq.f dlasdt.f
-   dlasq1.f dlasq2.f dlasq3.f dlasq4.f dlasq5.f dlasq6.f
+   dlaset.f dlasq1.f dlasq2.f dlasq3.f dlasq4.f dlasq5.f dlasq6.f
    dlasr.f  dlasrt.f dlassq.f dlasv2.f dpttrf.f dstebz.f dstedc.f
    dsteqr.f dsterf.f dlaisnan.f disnan.f
    dlartgp.f dlartgs.f
    ../INSTALL/dlamch.f ../INSTALL/dsecnd_${TIMER}.f)
 
 set(SLASRC
-   sgbbrd.f sgbcon.f sgbequ.f sgbrfs.f sgbsv.f
+   sbdsvdx.f sgbbrd.f sgbcon.f sgbequ.f sgbrfs.f sgbsv.f
    sgbsvx.f sgbtf2.f sgbtrf.f sgbtrs.f sgebak.f sgebal.f sgebd2.f
    sgebrd.f sgecon.f sgeequ.f sgees.f  sgeesx.f sgeev.f  sgeevx.f
    sgehd2.f sgehrd.f sgelq2.f sgelqf.f
@@ -66,7 +64,7 @@ set(SLASRC
    slaqgb.f slaqge.f slaqp2.f slaqps.f slaqsb.f slaqsp.f slaqsy.f
    slaqr0.f slaqr1.f slaqr2.f slaqr3.f slaqr4.f slaqr5.f
    slaqtr.f slar1v.f slar2v.f ilaslr.f ilaslc.f
-   slarf.f  slarfb.f slarfb_gett.f slarfg.f slarfgp.f slarft.f slarfx.f slarfy.f slargv.f
+   slarf.f  slarfb.f slarfg.f slarfgp.f slarft.f slarfx.f slarfy.f slargv.f
    slarrv.f slartv.f
    slarz.f  slarzb.f slarzt.f slasy2.f
    slasyf.f slasyf_rook.f slasyf_rk.f slasyf_aa.f
@@ -85,8 +83,8 @@ set(SLASRC
    ssbev.f  ssbevd.f ssbevx.f ssbgst.f ssbgv.f  ssbgvd.f ssbgvx.f
    ssbtrd.f sspcon.f sspev.f  sspevd.f sspevx.f sspgst.f
    sspgv.f  sspgvd.f sspgvx.f ssprfs.f sspsv.f  sspsvx.f ssptrd.f
-   ssptrf.f ssptri.f ssptrs.f sstegr.f sstev.f  sstevd.f sstevr.f
-   ssycon.f ssyev.f  ssyevd.f ssyevr.f ssyevx.f ssygs2.f
+   ssptrf.f ssptri.f ssptrs.f sstegr.f sstein.f sstev.f  sstevd.f sstevr.f
+   sstevx.f ssycon.f ssyev.f  ssyevd.f ssyevr.f ssyevx.f ssygs2.f
    ssygst.f ssygv.f  ssygvd.f ssygvx.f ssyrfs.f ssysv.f  ssysvx.f
    ssytd2.f ssytf2.f ssytrd.f ssytrf.f ssytri.f ssytri2.f ssytri2x.f
    ssyswapr.f ssytrs.f ssytrs2.f
@@ -112,14 +110,12 @@ set(SLASRC
    sgeqrt.f sgeqrt2.f sgeqrt3.f sgemqrt.f
    stpqrt.f stpqrt2.f stpmqrt.f stprfb.f
    sgelqt.f sgelqt3.f sgemlqt.f
-   sgetsls.f sgetsqrhrt.f sgeqr.f slatsqr.f slamtsqr.f sgemqr.f
+   sgetsls.f sgeqr.f slatsqr.f slamtsqr.f sgemqr.f
    sgelq.f slaswlq.f slamswlq.f sgemlq.f
    stplqt.f stplqt2.f stpmlqt.f
    ssytrd_2stage.f ssytrd_sy2sb.f ssytrd_sb2st.F ssb2st_kernels.f
    ssyevd_2stage.f ssyev_2stage.f ssyevx_2stage.f ssyevr_2stage.f
-   ssbev_2stage.f ssbevx_2stage.f ssbevd_2stage.f ssygv_2stage.f
-   sgesvdq.f slaorhr_col_getrfnp.f
-   slaorhr_col_getrfnp2.f sorgtsqr.f sorgtsqr_row.f sorhr_col.f )
+   ssbev_2stage.f ssbevx_2stage.f ssbevd_2stage.f ssygv_2stage.f)
 
 set(SXLASRC sgesvxx.f sgerfsx.f sla_gerfsx_extended.f sla_geamv.f
    sla_gercond.f sla_gerpvgrw.f ssysvxx.f ssyrfsx.f
@@ -171,7 +167,7 @@ set(CLASRC
    claqhb.f claqhe.f claqhp.f claqp2.f claqps.f claqsb.f
    claqr0.f claqr1.f claqr2.f claqr3.f claqr4.f claqr5.f
    claqsp.f claqsy.f clar1v.f clar2v.f ilaclr.f ilaclc.f
-   clarf.f  clarfb.f clarfb_gett.f clarfg.f clarfgp.f clarft.f
+   clarf.f  clarfb.f clarfg.f clarfgp.f clarft.f
    clarfx.f clarfy.f clargv.f clarnv.f clarrv.f clartg.f clartv.f
    clarz.f  clarzb.f clarzt.f clascl.f claset.f clasr.f  classq.f
    clasyf.f clasyf_rook.f clasyf_rk.f clasyf_aa.f
@@ -209,14 +205,12 @@ set(CLASRC
    cgeqrt.f cgeqrt2.f cgeqrt3.f cgemqrt.f
    ctpqrt.f ctpqrt2.f ctpmqrt.f ctprfb.f
    cgelqt.f cgelqt3.f cgemlqt.f
-   cgetsls.f cgetsqrhrt.f cgeqr.f clatsqr.f clamtsqr.f cgemqr.f
+   cgetsls.f cgeqr.f clatsqr.f clamtsqr.f cgemqr.f
    cgelq.f claswlq.f clamswlq.f cgemlq.f
    ctplqt.f ctplqt2.f ctpmlqt.f
    chetrd_2stage.f chetrd_he2hb.f chetrd_hb2st.F chb2st_kernels.f
    cheevd_2stage.f cheev_2stage.f cheevx_2stage.f cheevr_2stage.f
-   chbev_2stage.f chbevx_2stage.f chbevd_2stage.f chegv_2stage.f
-   cgesvdq.f claunhr_col_getrfnp.f claunhr_col_getrfnp2.f 
-   cungtsqr.f cungtsqr_row.f cunhr_col.f )
+   chbev_2stage.f chbevx_2stage.f chbevd_2stage.f chegv_2stage.f)
 
 set(CXLASRC cgesvxx.f cgerfsx.f cla_gerfsx_extended.f cla_geamv.f
    cla_gercond_c.f cla_gercond_x.f cla_gerpvgrw.f
@@ -231,7 +225,7 @@ set(CXLASRC cgesvxx.f cgerfsx.f cla_gerfsx_extended.f cla_geamv.f
    cla_lin_berr.f clarscl2.f clascl2.f cla_wwaddw.f)
 
 set(DLASRC
-   dgbbrd.f dgbcon.f dgbequ.f dgbrfs.f dgbsv.f
+   dbdsvdx.f dgbbrd.f dgbcon.f dgbequ.f dgbrfs.f dgbsv.f
    dgbsvx.f dgbtf2.f dgbtrf.f dgbtrs.f dgebak.f dgebal.f dgebd2.f
    dgebrd.f dgecon.f dgeequ.f dgees.f  dgeesx.f dgeev.f  dgeevx.f
    dgehd2.f dgehrd.f dgelq2.f dgelqf.f
@@ -253,7 +247,7 @@ set(DLASRC
    dlaqgb.f dlaqge.f dlaqp2.f dlaqps.f dlaqsb.f dlaqsp.f dlaqsy.f
    dlaqr0.f dlaqr1.f dlaqr2.f dlaqr3.f dlaqr4.f dlaqr5.f
    dlaqtr.f dlar1v.f dlar2v.f iladlr.f iladlc.f
-   dlarf.f  dlarfb.f dlarfb_gett.f dlarfg.f dlarfgp.f dlarft.f dlarfx.f dlarfy.f
+   dlarf.f  dlarfb.f dlarfg.f dlarfgp.f dlarft.f dlarfx.f dlarfy.f
    dlargv.f dlarrv.f dlartv.f
    dlarz.f  dlarzb.f dlarzt.f dlasy2.f
    dlasyf.f dlasyf_rook.f dlasyf_rk.f dlasyf_aa.f
@@ -272,8 +266,8 @@ set(DLASRC
    dsbev.f  dsbevd.f dsbevx.f dsbgst.f dsbgv.f  dsbgvd.f dsbgvx.f
    dsbtrd.f dspcon.f dspev.f  dspevd.f dspevx.f dspgst.f
    dspgv.f  dspgvd.f dspgvx.f dsprfs.f dspsv.f  dspsvx.f dsptrd.f
-   dsptrf.f dsptri.f dsptrs.f dstegr.f dstev.f  dstevd.f dstevr.f
-   dsycon.f dsyev.f  dsyevd.f dsyevr.f
+   dsptrf.f dsptri.f dsptrs.f dstegr.f dstein.f dstev.f  dstevd.f dstevr.f
+   dstevx.f dsycon.f dsyev.f  dsyevd.f dsyevr.f
    dsyevx.f dsygs2.f dsygst.f dsygv.f  dsygvd.f dsygvx.f dsyrfs.f
    dsysv.f  dsysvx.f
    dsytd2.f dsytf2.f dsytrd.f dsytrf.f dsytri.f dsytrs.f dsytrs2.f
@@ -300,14 +294,12 @@ set(DLASRC
    dgeqrt.f dgeqrt2.f dgeqrt3.f dgemqrt.f
    dtpqrt.f dtpqrt2.f dtpmqrt.f dtprfb.f
    dgelqt.f dgelqt3.f dgemlqt.f
-   dgetsls.f dgetsqrhrt.f dgeqr.f dlatsqr.f dlamtsqr.f dgemqr.f
+   dgetsls.f dgeqr.f dlatsqr.f dlamtsqr.f dgemqr.f
    dgelq.f dlaswlq.f dlamswlq.f dgemlq.f
    dtplqt.f dtplqt2.f dtpmlqt.f
    dsytrd_2stage.f dsytrd_sy2sb.f dsytrd_sb2st.F dsb2st_kernels.f
    dsyevd_2stage.f dsyev_2stage.f dsyevx_2stage.f dsyevr_2stage.f
-   dsbev_2stage.f dsbevx_2stage.f dsbevd_2stage.f dsygv_2stage.f
-   dcombssq.f dgesvdq.f dlaorhr_col_getrfnp.f
-   dlaorhr_col_getrfnp2.f dorgtsqr.f dorgtsqr_row.f dorhr_col.f )
+   dsbev_2stage.f dsbevx_2stage.f dsbevd_2stage.f dsygv_2stage.f)
 
 set(DXLASRC dgesvxx.f dgerfsx.f dla_gerfsx_extended.f dla_geamv.f
    dla_gercond.f dla_gerpvgrw.f dsysvxx.f dsyrfsx.f
@@ -360,7 +352,7 @@ set(ZLASRC
    zlaqhb.f zlaqhe.f zlaqhp.f zlaqp2.f zlaqps.f zlaqsb.f
    zlaqr0.f zlaqr1.f zlaqr2.f zlaqr3.f zlaqr4.f zlaqr5.f
    zlaqsp.f zlaqsy.f zlar1v.f zlar2v.f ilazlr.f ilazlc.f
-   zlarcm.f zlarf.f  zlarfb.f zlarfb_gett.f
+   zlarcm.f zlarf.f  zlarfb.f
    zlarfg.f zlarfgp.f zlarft.f
    zlarfx.f zlarfy.f zlargv.f zlarnv.f zlarrv.f zlartg.f zlartv.f
    zlarz.f  zlarzb.f zlarzt.f zlascl.f zlaset.f zlasr.f
@@ -402,13 +394,11 @@ set(ZLASRC
    ztpqrt.f ztpqrt2.f ztpmqrt.f ztprfb.f
    ztplqt.f ztplqt2.f ztpmlqt.f
    zgelqt.f zgelqt3.f zgemlqt.f
-   zgetsls.f zgetsqrhrt.f zgeqr.f zlatsqr.f zlamtsqr.f zgemqr.f
+   zgetsls.f zgeqr.f zlatsqr.f zlamtsqr.f zgemqr.f
    zgelq.f zlaswlq.f zlamswlq.f zgemlq.f
    zhetrd_2stage.f zhetrd_he2hb.f zhetrd_hb2st.F zhb2st_kernels.f
    zheevd_2stage.f zheev_2stage.f zheevx_2stage.f zheevr_2stage.f
-   zhbev_2stage.f zhbevx_2stage.f zhbevd_2stage.f zhegv_2stage.f
-   zgesvdq.f zlaunhr_col_getrfnp.f zlaunhr_col_getrfnp2.f
-   zungtsqr.f zungtsqr_row.f zunhr_col.f)
+   zhbev_2stage.f zhbevx_2stage.f zhbevd_2stage.f zhegv_2stage.f)
 
 set(ZXLASRC zgesvxx.f zgerfsx.f zla_gerfsx_extended.f zla_geamv.f
    zla_gercond_c.f zla_gercond_x.f zla_gerpvgrw.f zsysvxx.f zsyrfsx.f
@@ -476,16 +466,12 @@ endif()
 if(BUILD_COMPLEX)
   set(LA_REL_SRC ${LA_REL_SRC} ${CLASRC} ${ZCLASRC} ${ALLAUX} ${SCLAUX})
   SET(LA_GEN_SRC ${LA_GEN_SRC} ${CMATGEN} ${SCATGEN})
-  message(STATUS "Building Single Precision Complex")
+  message(STATUS "Building Complex Precision")
 endif()
 if(BUILD_COMPLEX16)
   set(LA_REL_SRC ${LA_REL_SRC} ${ZLASRC} ${ZCLASRC} ${ALLAUX} ${DZLAUX})
   SET(LA_GEN_SRC ${LA_GEN_SRC} ${ZMATGEN} ${DZATGEN})
-# for zlange/zlanhe
-  if (NOT BUILD_DOUBLE)
-    set (LA_REL_SRC ${LA_REL_SRC} dcombssq.f)
-  endif	()  
-  message(STATUS "Building Double Precision Complex")
+  message(STATUS "Building Double Complex Precision")
 endif()
 
 # add lapack-netlib folder to the sources

cmake/lapacke.cmake

@@ -114,8 +114,6 @@ set(CSRC
   lapacke_cgetrs_work.c
   lapacke_cgetsls.c
   lapacke_cgetsls_work.c
-  lapacke_cgetsqrhrt.c
-  lapacke_cgetsqrhrt_work.c 
   lapacke_cggbak.c
   lapacke_cggbak_work.c
   lapacke_cggbal.c
@@ -592,8 +590,6 @@ set(CSRC
   lapacke_cungrq_work.c
   lapacke_cungtr.c
   lapacke_cungtr_work.c
-  lapacke_cungtsqr_row.c
-  lapacke_cungtsqr_row_work.c
   lapacke_cunmbr.c
   lapacke_cunmbr_work.c
   lapacke_cunmhr.c
@@ -719,8 +715,6 @@ set(DSRC
   lapacke_dgesv_work.c
   lapacke_dgesvd.c
   lapacke_dgesvd_work.c
-  lapacke_dgesvdq.c
-  lapacke_dgesvdq_work.c
   lapacke_dgesvdx.c
   lapacke_dgesvdx_work.c
   lapacke_dgesvj.c
@@ -739,8 +733,6 @@ set(DSRC
   lapacke_dgetrs_work.c
   lapacke_dgetsls.c
   lapacke_dgetsls_work.c
-  lapacke_dgetsqrhrt.c
-  lapacke_dgetsqrhrt_work.c
   lapacke_dggbak.c
   lapacke_dggbak_work.c
   lapacke_dggbal.c
@@ -868,8 +860,6 @@ set(DSRC
   lapacke_dorgrq_work.c
   lapacke_dorgtr.c
   lapacke_dorgtr_work.c
-  lapacke_dorgtsqr_row.c
-  lapacke_dorgtsqr_row_work.c
   lapacke_dormbr.c
   lapacke_dormbr_work.c
   lapacke_dormhr.c
@@ -1297,8 +1287,6 @@ set(SSRC
   lapacke_sgesv_work.c
   lapacke_sgesvd.c
   lapacke_sgesvd_work.c
-  lapacke_sgesvdq.c
-  lapacke_sgesvdq_work.c
   lapacke_sgesvdx.c
   lapacke_sgesvdx_work.c
   lapacke_sgesvj.c
@@ -1317,8 +1305,6 @@ set(SSRC
   lapacke_sgetrs_work.c
   lapacke_sgetsls.c
   lapacke_sgetsls_work.c
-  lapacke_sgetsqrhrt.c
-  lapacke_sgetsqrhrt_work.c
   lapacke_sggbak.c
   lapacke_sggbak_work.c
   lapacke_sggbal.c
@@ -1445,8 +1431,6 @@ set(SSRC
   lapacke_sorgrq_work.c
   lapacke_sorgtr.c
   lapacke_sorgtr_work.c
-  lapacke_sorgtsqr_row.c
-  lapacke_sorgtsqr_row_work.c
   lapacke_sormbr.c
   lapacke_sormbr_work.c
   lapacke_sormhr.c
@@ -1869,8 +1853,6 @@ set(ZSRC
   lapacke_zgesv_work.c
   lapacke_zgesvd.c
   lapacke_zgesvd_work.c
-  lapacke_zgesvdq.c
-  lapacke_zgesvdq_work.c
   lapacke_zgesvdx.c
   lapacke_zgesvdx_work.c
   lapacke_zgesvj.c
@@ -1889,8 +1871,6 @@ set(ZSRC
   lapacke_zgetrs_work.c
   lapacke_zgetsls.c
   lapacke_zgetsls_work.c
-  lapacke_zgetsqrhrt.c
-  lapacke_zgetsqrhrt_work.c
   lapacke_zggbak.c
   lapacke_zggbak_work.c
   lapacke_zggbal.c
@@ -2365,8 +2345,6 @@ set(ZSRC
   lapacke_zungrq_work.c
   lapacke_zungtr.c
   lapacke_zungtr_work.c
-  lapacke_zungtsqr_row.c
-  lapacke_zungtsqr_row_work.c
   lapacke_zunmbr.c
   lapacke_zunmbr_work.c
   lapacke_zunmhr.c
@@ -2515,5 +2493,6 @@ foreach (Utils_FILE ${Utils_SRC})
 endforeach ()
 
 set(lapacke_include_dir "${NETLIB_LAPACK_DIR}/LAPACKE/include")
+configure_file("${lapacke_include_dir}/lapacke_mangling_with_flags.h.in" "${lapacke_include_dir}/lapacke_mangling.h" COPYONLY)
 include_directories(${lapacke_include_dir})
 set_source_files_properties(${LAPACKE_SOURCES} PROPERTIES COMPILE_FLAGS "${LAPACK_CFLAGS}")

cmake/openblas.pc.in

@@ -7,5 +7,5 @@ Name: OpenBLAS
 Description: OpenBLAS is an optimized BLAS library based on GotoBLAS2 1.13 BSD version
 Version: @OPENBLAS_VERSION@
 URL: https://github.com/xianyi/OpenBLAS
-Libs: @OpenMP_C_FLAGS@ -L${libdir} -lopenblas${libsuffix} 
+Libs: -L${libdir} -lopenblas${libsuffix}
 Cflags: -I${includedir}

cmake/os.cmake

@@ -8,7 +8,7 @@ if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
   set(NO_EXPRECISION 1)
 endif ()
 
-if (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD|OpenBSD|NetBSD|DragonFly|Darwin")
+if (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD|OpenBSD|NetBSD|DragonFly")
   set(EXTRALIB "${EXTRALIB} -lm")
   set(NO_EXPRECISION 1)
 endif ()
@@ -84,14 +84,6 @@ if (X86)
   set(NO_EXPRECISION 1)
 endif ()
 
-if (DYNAMIC_ARCH)
-if (TARGET)
-if (${TARGET} STREQUAL "GENERIC")
-  set(NO_EXPRECISION 1)
-endif ()
-endif ()
-endif ()
-
 if (UTEST_CHECK)
   set(CCOMMON_OPT "${CCOMMON_OPT} -DUTEST_CHECK")
   set(SANITY_CHECK 1)

cmake/prebuild.cmake

@@ -16,8 +16,6 @@
 # HAVE_SSE2
 # HAVE_SSE3
 # MAKE
-# SBGEMM_UNROLL_M
-# SBGEMM_UNROLL_N
 # SGEMM_UNROLL_M
 # SGEMM_UNROLL_N
 # DGEMM_UNROLL_M
@@ -127,10 +125,6 @@ if (DEFINED CORE AND CMAKE_CROSSCOMPILING AND NOT (${HOST_OS} STREQUAL "WINDOWSS
       "#define DLOCAL_BUFFER_SIZE\t16384\n"
       "#define CLOCAL_BUFFER_SIZE\t16384\n"
       "#define ZLOCAL_BUFFER_SIZE\t16384\n")
-      set(HAVE_SSE 1)
-      set(HAVE_SSE2 1)
-      set(HAVE_SSE3 1)
-      set(HAVE_SSSE3 1)
       set(SGEMM_UNROLL_M 8)
       set(SGEMM_UNROLL_N 4)
       set(DGEMM_UNROLL_M 4)
@@ -181,7 +175,7 @@ if (DEFINED CORE AND CMAKE_CROSSCOMPILING AND NOT (${HOST_OS} STREQUAL "WINDOWSS
     set(ZGEMM_UNROLL_M 4)
     set(ZGEMM_UNROLL_N 4)
     set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "CORTEXA57" OR "${TCORE}" STREQUAL "CORTEXA53" OR "${TCORE}" STREQUAL "CORTEXA55")
+  elseif ("${TCORE}" STREQUAL "CORTEXA57" OR "${TCORE}" STREQUAL "CORTEXA53")
     file(APPEND ${TARGET_CONF_TEMP}
       "#define L1_CODE_SIZE\t32768\n"
       "#define L1_CODE_LINESIZE\t64\n"
@@ -199,13 +193,8 @@ if (DEFINED CORE AND CMAKE_CROSSCOMPILING AND NOT (${HOST_OS} STREQUAL "WINDOWSS
       "#define HAVE_VFP\n"
       "#define HAVE_NEON\n"
       "#define ARMV8\n")
-if ("${TCORE}" STREQUAL "CORTEXA57")     
     set(SGEMM_UNROLL_M 16)
     set(SGEMM_UNROLL_N 4)
-else ()
-    set(SGEMM_UNROLL_M 8)
-    set(SGEMM_UNROLL_N 8) 
-endif ()
     set(DGEMM_UNROLL_M 8)
     set(DGEMM_UNROLL_N 4)
     set(CGEMM_UNROLL_M 8)
@@ -240,89 +229,6 @@ endif ()
     set(ZGEMM_UNROLL_M 4)
     set(ZGEMM_UNROLL_N 4)
     set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "NEOVERSEN1")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_CODE_SIZE\t65536\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t4\n"
-      "#define L1_DATA_SIZE\t65536\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L1_DATA_ASSOCIATIVE\t4\n"
-      "#define L2_SIZE\t1048576\n\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define L2_ASSOCIATIVE\t8\n"
-      "#define DTB_DEFAULT_ENTRIES\t48\n"
-      "#define DTB_SIZE\t4096\n"
-      "#define HAVE_VFPV4\n"
-      "#define HAVE_VFPV3\n"
-      "#define HAVE_VFP\n"
-      "#define HAVE_NEON\n"
-      "#define ARMV8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "NEOVERSEV1")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_CODE_SIZE\t65536\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t4\n"
-      "#define L1_DATA_SIZE\t65536\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L1_DATA_ASSOCIATIVE\t4\n"
-      "#define L2_SIZE\t1048576\n\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define L2_ASSOCIATIVE\t8\n"
-      "#define DTB_DEFAULT_ENTRIES\t48\n"
-      "#define DTB_SIZE\t4096\n"
-      "#define HAVE_VFPV4\n"
-      "#define HAVE_VFPV3\n"
-      "#define HAVE_VFP\n"
-      "#define HAVE_NEON\n"
-      "#define HAVE_SVE\n"
-      "#define ARMV8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "NEOVERSEN2")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_CODE_SIZE\t65536\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t4\n"
-      "#define L1_DATA_SIZE\t65536\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L1_DATA_ASSOCIATIVE\t2\n"
-      "#define L2_SIZE\t1048576\n\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define L2_ASSOCIATIVE\t8\n"
-      "#define DTB_DEFAULT_ENTRIES\t48\n"
-      "#define DTB_SIZE\t4096\n"
-      "#define HAVE_VFPV4\n"
-      "#define HAVE_VFPV3\n"
-      "#define HAVE_VFP\n"
-      "#define HAVE_NEON\n"
-      "#define HAVE_SVE\n"
-      "#define ARMV8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
   elseif ("${TCORE}" STREQUAL "FALKOR")
     file(APPEND ${TARGET_CONF_TEMP}
       "#define L1_CODE_SIZE\t65536\n"
@@ -403,187 +309,7 @@ endif ()
     set(ZGEMM_UNROLL_M 4)
     set(ZGEMM_UNROLL_N 4)
     set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "THUNDERX3T110")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define THUNDERX3T110\n"
-      "#define L1_CODE_SIZE\t65536\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t8\n"
-      "#define L1_DATA_SIZE\t65536\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L1_DATA_ASSOCIATIVE\t8\n"
-      "#define L2_SIZE\t524288\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define L2_ASSOCIATIVE\t8\n"
-      "#define L3_SIZE\t94371840\n"
-      "#define L3_LINESIZE\t64\n"
-      "#define L3_ASSOCIATIVE\t32\n"
-      "#define DTB_DEFAULT_ENTRIES\t64\n"
-      "#define DTB_SIZE\t4096\n"
-      "#define ARMV8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "TSV110")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define ARMV8\n"
-      "#define L1_CODE_SIZE\t65536\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t4\n"
-      "#define L1_DATA_SIZE\t65536\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L1_DATA_ASSOCIATIVE\t4\n"
-      "#define L2_SIZE\t524288\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define L2_ASSOCIATIVE\t8\n"
-      "#define DTB_DEFAULT_ENTRIES\t64\n"
-      "#define DTB_SIZE\t4096\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "EMAG8180")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define ARMV8\n"
-      "#define L1_CODE_SIZE\t32768\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t4\n"
-      "#define L1_DATA_SIZE\t32768\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L1_DATA_ASSOCIATIVE\t4\n"
-      "#define L2_SIZE\t5262144\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define L2_ASSOCIATIVE\t8\n"
-      "#define DTB_DEFAULT_ENTRIES\t64\n"
-      "#define DTB_SIZE\t4096\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "VORTEX")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define ARMV8\n"
-      "#define L1_CODE_SIZE\t32768\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t4\n"
-      "#define L1_DATA_SIZE\t32768\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L1_DATA_ASSOCIATIVE\t4\n"
-      "#define L2_SIZE\t5262144\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define L2_ASSOCIATIVE\t8\n"
-      "#define DTB_DEFAULT_ENTRIES\t64\n"
-      "#define DTB_SIZE\t4096\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "P5600")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L2_SIZE 1048576\n"
-      "#define DTB_SIZE 4096\n"
-      "#define DTB_DEFAULT_ENTRIES 64\n")
-    set(SGEMM_UNROLL_M 2)
-    set(SGEMM_UNROLL_N 2)
-    set(DGEMM_UNROLL_M 2)
-    set(DGEMM_UNROLL_N 2)
-    set(CGEMM_UNROLL_M 2)
-    set(CGEMM_UNROLL_N 2)
-    set(ZGEMM_UNROLL_M 2)
-    set(ZGEMM_UNROLL_N 2)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" MATCHES "MIPS")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L2_SIZE 262144\n"
-      "#define DTB_SIZE 4096\n"
-      "#define DTB_DEFAULT_ENTRIES 64\n")
-    set(SGEMM_UNROLL_M 2)
-    set(SGEMM_UNROLL_N 2)
-    set(DGEMM_UNROLL_M 2)
-    set(DGEMM_UNROLL_N 2)
-    set(CGEMM_UNROLL_M 2)
-    set(CGEMM_UNROLL_N 2)
-    set(ZGEMM_UNROLL_M 2)
-    set(ZGEMM_UNROLL_N 2)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "POWER6")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_DATA_SIZE 32768\n"
-      "#define L1_DATA_LINESIZE 128\n"
-      "#define L2_SIZE 524288\n"
-      "#define L2_LINESIZE 128 \n"
-      "#define DTB_DEFAULT_ENTRIES 128\n"
-      "#define DTB_SIZE 4096\n"
-      "#define L2_ASSOCIATIVE 8\n")
-    set(SGEMM_UNROLL_M 4)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 4)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 2)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 2)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 8)
-  elseif ("${TCORE}" STREQUAL "POWER8")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_DATA_SIZE 32768\n"
-      "#define L1_DATA_LINESIZE 128\n"
-      "#define L2_SIZE 524288\n"
-      "#define L2_LINESIZE 128 \n"
-      "#define DTB_DEFAULT_ENTRIES 128\n"
-      "#define DTB_SIZE 4096\n"
-      "#define L2_ASSOCIATIVE 8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 8)
-    set(DGEMM_UNROLL_M 16)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 8)
-    set(ZGEMM_UNROLL_N 2)
-    set(SYMV_P 8)
-  elseif ("${TCORE}" STREQUAL "POWER9" OR "${TCORE}" STREQUAL "POWER10")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_DATA_SIZE 32768\n"
-      "#define L1_DATA_LINESIZE 128\n"
-      "#define L2_SIZE 524288\n"
-      "#define L2_LINESIZE 128 \n"
-      "#define DTB_DEFAULT_ENTRIES 128\n"
-      "#define DTB_SIZE 4096\n"
-      "#define L2_ASSOCIATIVE 8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 8)
-    set(DGEMM_UNROLL_M 16)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 8)
-    set(ZGEMM_UNROLL_N 2)
-    set(SYMV_P 8)
   endif()
-  set(SBGEMM_UNROLL_M 8)
-  set(SBGEMM_UNROLL_N 4)
 
   # Or should this actually be NUM_CORES?
   if (${NUM_THREADS} GREATER 0)
@@ -635,7 +361,7 @@ else(NOT CMAKE_CROSSCOMPILING)
   if (NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "WindowsStore")
     try_compile(GETARCH_RESULT ${GETARCH_DIR}
       SOURCES ${GETARCH_SRC}
-    COMPILE_DEFINITIONS ${EXFLAGS} ${GETARCH_FLAGS} -I"${GETARCH_DIR}" -I"${PROJECT_SOURCE_DIR}" -I"${PROJECT_BINARY_DIR}"
+    COMPILE_DEFINITIONS ${EXFLAGS} ${GETARCH_FLAGS} -I${GETARCH_DIR} -I"${PROJECT_SOURCE_DIR}" -I"${PROJECT_BINARY_DIR}"
       OUTPUT_VARIABLE GETARCH_LOG
       COPY_FILE ${PROJECT_BINARY_DIR}/${GETARCH_BIN}
     )
@@ -644,21 +370,6 @@ else(NOT CMAKE_CROSSCOMPILING)
       MESSAGE(FATAL_ERROR "Compiling getarch failed ${GETARCH_LOG}")
     endif ()
   endif ()
-  unset (HAVE_AVX2)
-  unset (HAVE_AVX)
-  unset (HAVE_FMA3)
-  unset (HAVE_MMX)
-  unset (HAVE_SSE)
-  unset (HAVE_SSE2)
-  unset (HAVE_SSE3)
-  unset (HAVE_SSSE3)
-  unset (HAVE_SSE4A)
-  unset (HAVE_SSE4_1)
-  unset (HAVE_SSE4_2)
-  unset (HAVE_NEON)
-  unset (HAVE_VFP)
-  unset (HAVE_VFPV3)
-  unset (HAVE_VFPV4)
   message(STATUS "Running getarch")
 
   # use the cmake binary w/ the -E param to run a shell command in a cross-platform way
@@ -678,7 +389,7 @@ execute_process(COMMAND "${PROJECT_BINARY_DIR}/${GETARCH_BIN}" 1 OUTPUT_VARIABLE
   if (NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "WindowsStore")
     try_compile(GETARCH2_RESULT ${GETARCH2_DIR}
       SOURCES ${PROJECT_SOURCE_DIR}/getarch_2nd.c
-    COMPILE_DEFINITIONS ${EXFLAGS} ${GETARCH_FLAGS} ${GETARCH2_FLAGS} -I"${GETARCH2_DIR}" -I"${PROJECT_SOURCE_DIR}" -I"${PROJECT_BINARY_DIR}"
+    COMPILE_DEFINITIONS ${EXFLAGS} ${GETARCH_FLAGS} ${GETARCH2_FLAGS} -I${GETARCH2_DIR} -I"${PROJECT_SOURCE_DIR}" -I"${PROJECT_BINARY_DIR}"
       OUTPUT_VARIABLE GETARCH2_LOG
       COPY_FILE ${PROJECT_BINARY_DIR}/${GETARCH2_BIN}
     )

cmake/system.cmake

@@ -33,23 +33,34 @@ endif ()
 if (DEFINED BINARY AND DEFINED TARGET AND BINARY EQUAL 32)
   message(STATUS "Compiling a ${BINARY}-bit binary.")
   set(NO_AVX 1)
-  if (${TARGET} STREQUAL "HASWELL" OR ${TARGET} STREQUAL "SANDYBRIDGE" OR ${TARGET} STREQUAL "SKYLAKEX" OR ${TARGET} STREQUAL "COOPERLAKE" OR ${TARGET} STREQUAL "SAPPHIRERAPIDS")
+  if (${TARGET} STREQUAL "HASWELL" OR ${TARGET} STREQUAL "SANDYBRIDGE" OR ${TARGET} STREQUAL "SKYLAKEX")
     set(TARGET "NEHALEM")
   endif ()
   if (${TARGET} STREQUAL "BULLDOZER" OR ${TARGET} STREQUAL "PILEDRIVER" OR ${TARGET} STREQUAL "ZEN")
     set(TARGET "BARCELONA")
   endif ()
-  if (${TARGET} STREQUAL "ARMV8" OR ${TARGET} STREQUAL "CORTEXA57" OR ${TARGET} STREQUAL "CORTEXA53" OR ${TARGET} STREQUAL "CORTEXA55")
+  if (${TARGET} STREQUAL "ARMV8" OR ${TARGET} STREQUAL "CORTEXA57" OR ${TARGET} STREQUAL "CORTEXA53")
     set(TARGET "ARMV7")
   endif ()
-  if (${TARGET} STREQUAL "POWER8" OR ${TARGET} STREQUAL "POWER9" OR ${TARGET} STREQUAL "POWER10")
-    set(TARGET "POWER6")
-  endif ()
 endif ()
 
+if (DEFINED TARGET)
+  if (${TARGET} STREQUAL "SKYLAKEX" AND NOT NO_AVX512)
+    set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
+  endif()
+  if (${TARGET} STREQUAL "HASWELL" AND NOT NO_AVX2)
+    if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
+      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
+      if (${GCC_VERSION} VERSION_GREATER 4.7 OR ${GCC_VERSION} VERSION_EQUAL 4.7)
+        set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mavx2")
+      endif()
+    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "CLANG")
+      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mavx2")
+    endif()
+  endif()
+endif()
 
 if (DEFINED TARGET)
-  message(STATUS "-- -- -- -- -- -- -- -- -- -- -- -- --")
   message(STATUS "Targeting the ${TARGET} architecture.")
   set(GETARCH_FLAGS "-DFORCE_${TARGET}")
 endif ()
@@ -87,11 +98,6 @@ if (NO_AVX2)
   set(GETARCH_FLAGS "${GETARCH_FLAGS} -DNO_AVX2")
 endif ()
 
-if (NO_AVX512)
-  message(STATUS "Disabling Advanced Vector Extensions 512 (AVX512).")
-  set(GETARCH_FLAGS "${GETARCH_FLAGS} -DNO_AVX512")
-endif ()
-
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
   set(GETARCH_FLAGS "${GETARCH_FLAGS} ${CMAKE_C_FLAGS_DEBUG}")
 endif ()
@@ -105,18 +111,6 @@ if (CMAKE_C_COMPILER STREQUAL loongcc)
   set(GETARCH_FLAGS	"${GETARCH_FLAGS} -static")
 endif ()
 
-if (POWER)
-  set(NO_WARMUP 1)
-  set(HAVE_GAS 1)
-  if (CMAKE_ASM_COMPILER_ID STREQUAL "GNU")
-    set(HAVE_GAS 0)
-  elseif (CMAKE_ASM_COMPILER_ID STREQUAL "Clang")
-    set(CCOMMON_OPT "${CCOMMON_OPT} -fno-integrated-as")
-    set(HAVE_GAS 0)
-  endif ()
-  set(GETARCH_FLAGS "${GETARCH_FLAGS} -DHAVE_GAS=${HAVE_GAS}")
-endif ()
-
 #if don't use Fortran, it will only compile CBLAS.
 if (ONLY_CBLAS)
   set(NO_LAPACK 1)
@@ -161,104 +155,6 @@ else()
 endif ()
 
 include("${PROJECT_SOURCE_DIR}/cmake/prebuild.cmake")
-if (DEFINED TARGET)
-  if (${TARGET} STREQUAL COOPERLAKE AND NOT NO_AVX512)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
-      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-        if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 10.09)
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=cooperlake")
-        else()
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
-        endif()
-    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_C_COMPILER_ID} STREQUAL "AppleClang")
-         if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 8.99)
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=cooperlake")
-        else()
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
-        endif()
-    endif()    
-  endif()
-  if (${TARGET} STREQUAL SAPPHIRERAPIDS AND NOT NO_AVX512)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
-      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-        if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 11.0)
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=sapphirerapids")
-        else()
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
-        endif()
-    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_C_COMPILER_ID} STREQUAL "AppleClang")
-         if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 12.0)
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=sapphirerapids")
-        else()
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
-        endif()
-    endif()    
-  endif()
-  if (${TARGET} STREQUAL SKYLAKEX AND NOT NO_AVX512)
-    set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
-  endif()
-  if (${TARGET} STREQUAL HASWELL AND NOT NO_AVX2)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
-      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-      if (${GCC_VERSION} VERSION_GREATER 4.7 OR ${GCC_VERSION} VERSION_EQUAL 4.7)
-        set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mavx2")
-      endif()
-    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "CLANG")
-      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mavx2")
-    endif()
-  endif()
-  if (DEFINED HAVE_AVX)
-	if (NOT NO_AVX)
-    set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mavx")
-	endif()
-  endif()
-  if (DEFINED HAVE_AVX2)
-	if (NOT NO_AVX2)
-      	  set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mavx2")
-	endif()
-  endif()
-  #  if (DEFINED HAVE_FMA3)
-  #	if (NOT NO_AVX2)
-  #  set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mfma")
-  #	endif()
-  #  endif()
-    if (DEFINED HAVE_SSE)
-    set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -msse")
-  endif()
-  if (DEFINED HAVE_SSE2)
-    set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -msse2")
-  endif()
-  if (DEFINED HAVE_SSE3)
-    set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -msse3")
-  endif()
-    if (DEFINED HAVE_SSSE3)
-    set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mssse3")
-  endif()
-    if (DEFINED HAVE_SSE4_1)
-    set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -msse4.1")
-  endif()
-
-  if (${TARGET} STREQUAL POWER10)
-    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-    if (${GCC_VERSION} VERSION_GREATER 10.2 OR ${GCC_VERSION} VERSION_EQUAL 10.2)
-      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math")
-    else ()
-      message(FATAL_ERROR "Compiler GCC.${GCC_VERSION} does not support Power10.")
-    endif()
-  endif()
-  if (${TARGET} STREQUAL POWER9)
-    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-    if (${GCC_VERSION} VERSION_GREATER 5.0 OR ${GCC_VERSION} VERSION_EQUAL 5.0)
-      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -mcpu=power9 -mtune=power9 -mvsx -fno-fast-math")
-    else ()
-      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -mcpu=power8 -mtune=power8 -mvsx -fno-fast-math")
-      message(WARNING "Compiler GCC.${GCC_VERSION} does not support fully Power9.")
-    endif()
-  endif()
-  if (${TARGET} STREQUAL POWER8)
-    set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -mcpu=power8 -mtune=power8 -mvsx -fno-fast-math")
-  endif()
-endif()
 if (DEFINED BINARY)
   message(STATUS "Compiling a ${BINARY}-bit binary.")
 endif ()
@@ -275,11 +171,6 @@ include("${PROJECT_SOURCE_DIR}/cmake/arch.cmake")
 # C Compiler dependent settings
 include("${PROJECT_SOURCE_DIR}/cmake/cc.cmake")
 
-if (INTERFACE64)
-  set(SUFFIX64 64)
-  set(SUFFIX64_UNDERSCORE _64)
-endif()
-
 if (NOT NOFORTRAN)
   # Fortran Compiler dependent settings
   include("${PROJECT_SOURCE_DIR}/cmake/fc.cmake")
@@ -294,11 +185,6 @@ if (BINARY64)
   endif ()
 endif ()
 
-if(EMBEDDED)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DOS_EMBEDDED")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16")
-endif()
-
 if (NEED_PIC)
   if (${CMAKE_C_COMPILER} STREQUAL "IBM")
     set(CCOMMON_OPT "${CCOMMON_OPT} -qpic=large")
@@ -315,15 +201,8 @@ if (NEED_PIC)
   endif()
 endif ()
 
-if (X86_64 OR ${CORE} STREQUAL POWER10)
-  set(SMALL_MATRIX_OPT TRUE)
-endif ()
-if (SMALL_MATRIX_OPT)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DSMALL_MATRIX_OPT")
-endif ()
-
 if (DYNAMIC_ARCH)
-  if (X86 OR X86_64 OR ARM64 OR POWER)
+  if (X86 OR X86_64 OR ARM64 OR PPC)
     set(CCOMMON_OPT "${CCOMMON_OPT} -DDYNAMIC_ARCH")
     if (DYNAMIC_OLDER)
       set(CCOMMON_OPT "${CCOMMON_OPT} -DDYNAMIC_OLDER")
@@ -363,10 +242,6 @@ if (NO_AVX2)
   set(CCOMMON_OPT "${CCOMMON_OPT} -DNO_AVX2")
 endif ()
 
-if (NO_AVX512)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DNO_AVX512")
-endif ()
-
 if (USE_THREAD)
   # USE_SIMPLE_THREADED_LEVEL3 = 1
   # NO_AFFINITY = 1
@@ -414,30 +289,10 @@ set(CCOMMON_OPT "${CCOMMON_OPT} -DMAX_CPU_NUMBER=${NUM_THREADS}")
 
 set(CCOMMON_OPT "${CCOMMON_OPT} -DMAX_PARALLEL_NUMBER=${NUM_PARALLEL}")
 
-if (BUFFERSIZE)
-set(CCOMMON_OPT "${CCOMMON_OPT} -DBUFFERSIZE=${BUFFERSIZE}")
-endif ()
-
 if (USE_SIMPLE_THREADED_LEVEL3)
   set(CCOMMON_OPT "${CCOMMON_OPT} -DUSE_SIMPLE_THREADED_LEVEL3")
 endif ()
 
-if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-if (DEFINED MAX_STACK_ALLOC)
-if (NOT ${MAX_STACK_ALLOC} EQUAL 0)
-set(CCOMMON_OPT "${CCOMMON_OPT} -DMAX_STACK_ALLOC=${MAX_STACK_ALLOC}")
-endif ()
-else ()
-set(CCOMMON_OPT "${CCOMMON_OPT} -DMAX_STACK_ALLOC=2048")
-endif ()
-endif ()
-if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-if (DEFINED BLAS3_MEM_ALLOC_THRESHOLD)
-if (NOT ${BLAS3_MEM_ALLOC_THRESHOLD} EQUAL 32)
-set(CCOMMON_OPT "${CCOMMON_OPT} -DBLAS3_MEM_ALLOC_THRESHOLD=${BLAS3_MEM_ALLOC_THRESHOLD}")
-endif()
-endif()
-endif()
 if (DEFINED LIBNAMESUFFIX)
   set(LIBPREFIX "libopenblas_${LIBNAMESUFFIX}")
 else ()
@@ -507,28 +362,6 @@ set(REVISION "-r${OpenBLAS_VERSION}")
 set(MAJOR_VERSION ${OpenBLAS_MAJOR_VERSION})
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CCOMMON_OPT}")
-
-if (NOT BUILD_SINGLE AND NOT BUILD_DOUBLE AND NOT BUILD_COMPLEX AND NOT BUILD_COMPLEX16)
-	set (BUILD_SINGLE ON)
-	set (BUILD_DOUBLE ON)
-	set (BUILD_COMPLEX ON)
-	set (BUILD_COMPLEX16 ON)
-endif()
-if (BUILD_SINGLE)
-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DBUILD_SINGLE")
-endif()
-if (BUILD_DOUBLE)
-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DBUILD_DOUBLE")
-endif()
-if (BUILD_COMPLEX)
-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DBUILD_COMPLEX")
-endif()
-if (BUILD_COMPLEX16)
-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DBUILD_COMPLEX16")
-endif()
-if (BUILD_BFLOAT16)
-       set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DBUILD_BFLOAT16")
-endif()
 if(NOT MSVC)
 set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${CCOMMON_OPT}")
 endif()
@@ -570,14 +403,6 @@ if (${CMAKE_C_COMPILER} STREQUAL "LSB" OR ${CMAKE_SYSTEM_NAME} STREQUAL "Windows
   set(LAPACK_CFLAGS "${LAPACK_CFLAGS} -DLAPACK_COMPLEX_STRUCTURE")
 endif ()
 
-if ("${CMAKE_BUILD_TYPE}" STREQUAL "Release")
-if ("${F_COMPILER}" STREQUAL "FLANG")
-if (${CMAKE_Fortran_COMPILER_VERSION} VERSION_LESS_EQUAL 3)
-  set(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE} -fno-unroll-loops")
-endif ()
-endif ()
-endif ()
-
 if (NOT DEFINED SUFFIX)
   set(SUFFIX o)
 endif ()
@@ -701,8 +526,6 @@ endif ()
 #export FUNCTION_PROFILE
 #export TARGET_CORE
 #
-#export SBGEMM_UNROLL_M
-#export SBGEMM_UNROLL_N
 #export SGEMM_UNROLL_M
 #export SGEMM_UNROLL_N
 #export DGEMM_UNROLL_M

cmake/system_check.cmake

@@ -20,11 +20,11 @@ endif()
 
 
 
-if(MINGW)
+if(CMAKE_COMPILER_IS_GNUCC AND WIN32)
     execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpmachine
-              OUTPUT_VARIABLE OPENBLAS_MINGW_TARGET_MACHINE
+              OUTPUT_VARIABLE OPENBLAS_GCC_TARGET_MACHINE
               OUTPUT_STRIP_TRAILING_WHITESPACE)
-    if(OPENBLAS_MINGW_TARGET_MACHINE MATCHES "amd64|x86_64|AMD64")
+    if(OPENBLAS_GCC_TARGET_MACHINE MATCHES "amd64|x86_64|AMD64")
       set(MINGW64 1)
     endif()
 endif()
@@ -35,11 +35,9 @@ if(CMAKE_CL_64 OR MINGW64)
 elseif(MINGW OR (MSVC AND NOT CMAKE_CROSSCOMPILING))
   set(X86 1)
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc.*|power.*|Power.*")
-  set(POWER 1)
+  set(PPC 1)
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "mips64.*")
   set(MIPS64 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "loongarch64.*")
-  set(LOONGARCH64 1)
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*")
   if (NOT BINARY)
     if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
@@ -56,14 +54,14 @@ elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*")
   endif()
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "i686.*|i386.*|x86.*|amd64.*|AMD64.*")
   set(X86 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*|arm64.*|ARM64.*)")
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(arm.*|ARM.*)")
+  set(ARM 1)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*)")
   if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
     set(ARM64 1)
   else()
     set(ARM 1)
   endif()
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(arm.*|ARM.*)")
-  set(ARM 1)
 elseif (${CMAKE_CROSSCOMPILING})
    if (${TARGET} STREQUAL "CORE2")
     if (NOT BINARY)
@@ -73,8 +71,6 @@ elseif (${CMAKE_CROSSCOMPILING})
     else ()
        set(X86 1)
     endif()
-   elseif (${TARGET} STREQUAL "P5600" OR ${TARGET} MATCHES "MIPS.*")
-       set(MIPS32 1)
    elseif (${TARGET} STREQUAL "ARMV7")
        set(ARM 1)
    else()
@@ -88,12 +84,8 @@ if (X86_64)
   set(ARCH "x86_64")
 elseif(X86)
   set(ARCH "x86")
-elseif(POWER)
+elseif(PPC)
   set(ARCH "power")
-elseif(MIPS32)
-  set(ARCH "mips")
-elseif(MIPS64)
-  set(ARCH "mips64")
 elseif(ARM)
   set(ARCH "arm")
 elseif(ARM64)
@@ -103,7 +95,7 @@ else()
 endif ()
 
 if (NOT BINARY)
-  if (X86_64 OR ARM64 OR POWER OR MIPS64 OR LOONGARCH64)
+  if (X86_64 OR ARM64 OR PPC OR MIPS64)
     set(BINARY 64)
   else ()
     set(BINARY 32)
@@ -117,18 +109,10 @@ else()
 endif()
 
 if (X86_64 OR X86)
-if (NOT NO_AVX512)
-  file(WRITE ${PROJECT_BINARY_DIR}/avx512.c "#include <immintrin.h>\n\nint main(void){ __asm__ volatile(\"vbroadcastss -4 * 4(%rsi), %zmm2\"); }")
-execute_process(COMMAND ${CMAKE_C_COMPILER} -march=skylake-avx512 -c -v -o ${PROJECT_BINARY_DIR}/avx512.o ${PROJECT_BINARY_DIR}/avx512.c OUTPUT_QUIET ERROR_QUIET RESULT_VARIABLE NO_AVX512)
+  file(WRITE ${PROJECT_BINARY_DIR}/avx512.tmp "#include <immintrin.h>\n\nint main(void){ __asm__ volatile(\"vbroadcastss -4 * 4(%rsi), %zmm2\"); }")
+execute_process(COMMAND ${CMAKE_C_COMPILER} -march=skylake-avx512 -c -v -o ${PROJECT_BINARY_DIR}/avx512.o -x c ${PROJECT_BINARY_DIR}/avx512.tmp OUTPUT_QUIET ERROR_QUIET RESULT_VARIABLE NO_AVX512)
 if (NO_AVX512 EQUAL 1)
 set (CCOMMON_OPT "${CCOMMON_OPT} -DNO_AVX512")
 endif()
-  file(REMOVE "avx512.c" "avx512.o")
-endif()
-endif()
-
-include(CheckIncludeFile)
-CHECK_INCLUDE_FILE("stdatomic.h" HAVE_C11)
-if (HAVE_C11 EQUAL 1)
-set (CCOMMON_OPT "${CCOMMON_OPT} -DHAVE_C11")
+  file(REMOVE "avx512.tmp" "avx512.o")
 endif()

cmake/utils.cmake

@@ -15,84 +15,12 @@ endfunction ()
 # Reads a Makefile into CMake vars.
 macro(ParseMakefileVars MAKEFILE_IN)
   message(STATUS "Reading vars from ${MAKEFILE_IN}...")
-  set (C_COMPILER ${CMAKE_C_COMPILER_ID})
-  set (IfElse 0)
-  set (ElseSeen 0)
-  set (SkipIfs 0)
-  set (SkipElse 0)
   file(STRINGS ${MAKEFILE_IN} makefile_contents)
   foreach (makefile_line ${makefile_contents})
-    #message(STATUS "parsing ${makefile_line}")
-    # Skip the entire scope of the else statement given that the if statement that precedes it has the valid condition.
-    # The variable SkipIfs is used to identify which endif statement closes the scope of the else statement.
-    if (${SkipElse} EQUAL 1)
-      #message(STATUS "skipping ${makefile_line}")
-      string(REGEX MATCH "(ifeq|ifneq|ifdef|ifndef) .*$" line_match "${makefile_line}")
-      if (NOT "${line_match}" STREQUAL "")
-        MATH(EXPR SkipIfs "${SkipIfs}+1")
-      endif ()
-      string(REGEX MATCH "endif[ \t]*" line_match "${makefile_line}")
-      if (NOT "${line_match}" STREQUAL "")
-        if (${SkipIfs} EQUAL 0)
-          set (SkipElse 0)
-        else ()
-          MATH(EXPR SkipIfs "${SkipIfs}-1")
-        endif ()
-      endif ()
-      continue ()
-    endif ()
-    # The variable IfElse is greater than 0 if and only if the previously parsed line is an if statement.
-    if (${IfElse} GREATER 0)
-      # If the current scope is the one that has to be skipped, the if/endif/else statements
-      # along with it till the endif that closes the current scope have to be ignored as well.
-      string(REGEX MATCH "(ifeq|ifneq|ifdef|ifndef) .*$" line_match "${makefile_line}")
-      if (NOT "${line_match}" STREQUAL "")
-        if ((${IfElse} EQUAL 2 AND ${ElseSeen} EQUAL 0) OR (${IfElse} EQUAL 1 AND ${ElseSeen} EQUAL 1))
-          #message(STATUS "skipping ${makefile_line}")
-          MATH(EXPR SkipIfs "${SkipIfs}+1")
-          continue ()
-        endif ()
-      endif ()
-      string(REGEX MATCH "endif[ \t]*" line_match "${makefile_line}")
-      if (NOT "${line_match}" STREQUAL "")
-        if (${SkipIfs} EQUAL 0)
-          #message(STATUS "ENDIF ${makefile_line}")
-          set (IfElse 0)
-          set (ElseSeen 0)
-        else ()
-          #message(STATUS "skipping ${makefile_line}")
-          MATH(EXPR SkipIfs "${SkipIfs}-1")
-        endif ()
-        continue ()
-      endif ()
-      string(REGEX MATCH "else[ \t]*" line_match "${makefile_line}")
-      if (NOT "${line_match}" STREQUAL "") 
-        if (${SkipIfs} EQUAL 0)
-          #message(STATUS "ELSE ${makefile_line}")
-          set (ElseSeen 1)        
-        else ()
-          #message(STATUS "skipping ${makefile_line}")
-        endif ()
-        continue ()  
-      endif()
-      # Skip the lines that are not part of the path that has to be taken.
-      if ((${IfElse} EQUAL 2 AND ${ElseSeen} EQUAL 0) OR (${IfElse} EQUAL 1 AND ${ElseSeen} EQUAL 1) OR (${SkipIfs} GREATER 0))
-        #message(STATUS "skipping ${makefile_line}")
-        continue ()
-      endif ()    
-    endif ()
-    # Skip commented lines (the ones that start with '#')
-    string(REGEX MATCH "[ \t]*\\#.*$" line_match "${makefile_line}")
-    if (NOT "${line_match}" STREQUAL "")
-      #message(STATUS "skipping ${makefile_line}")
-      continue ()
-    endif ()
     string(REGEX MATCH "([0-9_a-zA-Z]+)[ \t]*=[ \t]*(.+)$" line_match "${makefile_line}")
     if (NOT "${line_match}" STREQUAL "")
-      #message(STATUS "match on ${line_match}")
       set(var_name ${CMAKE_MATCH_1})
-      #set(var_value ${CMAKE_MATCH_2})
-      string(STRIP ${CMAKE_MATCH_2} var_value)
+      set(var_value ${CMAKE_MATCH_2})
       # check for Makefile variables in the string, e.g. $(TSUFFIX)
       string(REGEX MATCHALL "\\$\\(([0-9_a-zA-Z]+)\\)" make_var_matches ${var_value})
       foreach (make_var ${make_var_matches})
@@ -102,93 +30,12 @@ macro(ParseMakefileVars MAKEFILE_IN)
         string(REPLACE "$(${make_var})" "${${make_var}}" var_value ${var_value})
       endforeach ()
       set(${var_name} ${var_value})
-      continue ()
-    endif ()
-    # Include a new file to be parsed
-    string(REGEX MATCH "include \\$\\(KERNELDIR\\)/(.+)$" line_match "${makefile_line}")
-    if (NOT "${line_match}" STREQUAL "")
-      #message(STATUS "match on include ${line_match}")
-      ParseMakefileVars(${KERNELDIR}/${CMAKE_MATCH_1})
-      continue ()
-    endif ()
-    # The if statement that precedes this else has the path taken
-    # Thus, this else statement has to be skipped.
-    string(REGEX MATCH "else[ \t]*" line_match "${makefile_line}")
-    if (NOT "${line_match}" STREQUAL "") 
-      #message(STATUS "skipping ${makefile_line}")
-      set (SkipElse 1)
-      continue()
-    endif()
-    # Example 1: ifdef HAVE_MSA
-    # Example 2: ifndef ZNRM2KERNEL
-    string(REGEX MATCH "(ifdef|ifndef) ([0-9_A-Z]+)" line_match "${makefile_line}")
-    if (NOT "${line_match}" STREQUAL "")
-      #message(STATUS "${CMAKE_MATCH_1} first: ${CMAKE_MATCH_2}")
-      set (ElseSeen 0)
-      if (${CMAKE_MATCH_2})
-        if (${CMAKE_MATCH_1} STREQUAL "ifdef")
-          #message (STATUS "condition is true")
-          set (IfElse 1)
-        else ()
-          set (IfElse 2)
-        endif ()
-      else ()
-        if (${CMAKE_MATCH_1} STREQUAL "ifdef")
-          set (IfElse 2)
-        else ()
-          #message (STATUS "condition is true")
-          set (IfElse 1)
-        endif ()
+    else ()
+      string(REGEX MATCH "include \\$\\(KERNELDIR\\)/(.+)$" line_match "${makefile_line}")
+      if (NOT "${line_match}" STREQUAL "")
+        ParseMakefileVars(${KERNELDIR}/${CMAKE_MATCH_1})
       endif ()
-      continue ()
     endif ()
-    # Example 1: ifeq ($(SGEMM_UNROLL_M), 16)
-    # Example 2: ifeq ($(SGEMM_UNROLL_M)x$(SGEMM_UNROLL_N), 8x8)
-    # Example 3: ifeq ($(__BYTE_ORDER__)$(ELF_VERSION),__ORDER_BIG_ENDIAN__2)
-    # Ignore the second group since (?:...) does not work on cmake
-    string(REGEX MATCH "ifeq \\(\\$\\(([0-9_A-Z]+)\\)(([0-9_A-Za-z]*)\\$\\(([0-9_A-Z]+)\\))?,[ \t]*([0-9_A-Za-z]+)\\)" line_match "${makefile_line}")
-    if (NOT "${line_match}" STREQUAL "")
-      #message(STATUS "IFEQ: ${line_match} first: ${CMAKE_MATCH_1} second: ${CMAKE_MATCH_3} third: ${CMAKE_MATCH_4} fourth: ${CMAKE_MATCH_5}")
-      if (DEFINED ${CMAKE_MATCH_1})
-        if (DEFINED ${CMAKE_MATCH_4})
-          set (STR ${${CMAKE_MATCH_1}}${CMAKE_MATCH_3}${${CMAKE_MATCH_4}})
-        else ()
-          set (STR ${${CMAKE_MATCH_1}})
-        endif ()
-        if (${STR} STREQUAL ${CMAKE_MATCH_5})
-          #message (STATUS "condition is true")
-          set (IfElse 1)
-          continue ()
-        endif ()
-      endif ()
-      set (IfElse 2)
-      continue ()
-    endif ()
-    # Example 1 (Group 3): ifneq ($(SGEMM_UNROLL_M), $(SGEMM_UNROLL_N))
-    # Example 2 (Group 4): ifneq ($(C_COMPILER), PGI)
-    string(REGEX MATCH "ifneq \\(\\$\\(([0-9_A-Z]+)\\),[ \t]*(\\$\\(([0-9_A-Z]+)\\)|([0-9_A-Z]+))\\)" line_match "${makefile_line}")
-    if (NOT "${line_match}" STREQUAL "")
-      #message(STATUS "IFNEQ: ${line_match} first: ${CMAKE_MATCH_1} second: ${CMAKE_MATCH_3} third: ${CMAKE_MATCH_4}")
-      set (ElseSeen 0)
-      set (HasValidGroup 0)
-      if (DEFINED ${CMAKE_MATCH_3})
-        set (HasValidGroup 1)
-        set (STR ${${CMAKE_MATCH_3}})
-      elseif (NOT ${CMAKE_MATCH_4} STREQUAL "")
-        set (HasValidGroup 1)
-        set (STR ${CMAKE_MATCH_4})
-      endif ()
-      if (DEFINED ${CMAKE_MATCH_1} AND ${HasValidGroup} EQUAL 1)
-        if (NOT (${${CMAKE_MATCH_1}} STREQUAL ${STR}))
-          #message (STATUS "condition is true")
-          set (IfElse 1)
-          continue ()
-        endif ()
-      endif ()
-      set (IfElse 2)
-      continue ()
-    endif ()
-    #message(STATUS "unmatched line ${line_match}")
   endforeach ()
 endmacro ()
 
@@ -259,31 +106,31 @@ endfunction ()
 #                               STRING - compiles only the given type (e.g. DOUBLE)
 function(GenerateNamedObjects sources_in)
 
-  if (${ARGC} GREATER 1)
+  if (DEFINED ARGV1)
     set(defines_in ${ARGV1})
   endif ()
 
-  if (${ARGC} GREATER 2 AND NOT "${ARGV2}" STREQUAL "")
+  if (DEFINED ARGV2 AND NOT "${ARGV2}" STREQUAL "")
     set(name_in ${ARGV2})
     # strip off extension for kernel files that pass in the object name.
     get_filename_component(name_in ${name_in} NAME_WE)
   endif ()
 
-  if (${ARGC} GREATER 3)
+  if (DEFINED ARGV3)
     set(use_cblas ${ARGV3})
   else ()
     set(use_cblas false)
   endif ()
 
-  if (${ARGC} GREATER 4)
+  if (DEFINED ARGV4)
     set(replace_last_with ${ARGV4})
   endif ()
 
-  if (${ARGC} GREATER 5)
+  if (DEFINED ARGV5)
     set(append_with ${ARGV5})
   endif ()
 
-  if (${ARGC} GREATER 6)
+  if (DEFINED ARGV6)
     set(no_float_type ${ARGV6})
   else ()
     set(no_float_type false)
@@ -298,7 +145,7 @@ function(GenerateNamedObjects sources_in)
   set(real_only false)
   set(complex_only false)
   set(mangle_complex_sources false)
-  if (${ARGC} GREATER 7 AND NOT "${ARGV7}" STREQUAL "")
+  if (DEFINED ARGV7 AND NOT "${ARGV7}" STREQUAL "")
     if (${ARGV7} EQUAL 1)
       set(real_only true)
     elseif (${ARGV7} EQUAL 2)
@@ -316,7 +163,6 @@ function(GenerateNamedObjects sources_in)
   if (complex_only)
     list(REMOVE_ITEM float_list "SINGLE")
     list(REMOVE_ITEM float_list "DOUBLE")
-    list(REMOVE_ITEM float_list "BFLOAT16")
   elseif (real_only)
     list(REMOVE_ITEM float_list "COMPLEX")
     list(REMOVE_ITEM float_list "ZCOMPLEX")
@@ -330,9 +176,6 @@ function(GenerateNamedObjects sources_in)
       if (NOT no_float_type)
         string(SUBSTRING ${float_type} 0 1 float_char)
         string(TOLOWER ${float_char} float_char)
-	if (${float_type} STREQUAL "BFLOAT16")
-		set (float_char "sb")
-	endif ()
       endif ()
 
       if (NOT name_in)
@@ -356,19 +199,6 @@ function(GenerateNamedObjects sources_in)
       # now add the object and set the defines
       set(obj_defines ${defines_in})
 
-      list(FIND obj_defines "RC" def_idx)
-      if (${def_idx} GREATER -1) 
-	      #	      list(REMOVE_AT ${obj_defines} ${def_idx})
-	      list (REMOVE_ITEM obj_defines "RC")
-	      list(APPEND obj_defines  "RC=RC")
-      endif ()
-      list(FIND obj_defines "CR" def_idx)
-      if (${def_idx} GREATER -1) 
-	      #	      list(REMOVE_AT ${obj_defines} ${def_idx})
-	      list (REMOVE_ITEM obj_defines "CR")
-	      list(APPEND obj_defines  "CR=CR")
-      endif ()
-
       if (use_cblas)
         set(obj_name "cblas_${obj_name}")
         list(APPEND obj_defines "CBLAS")
@@ -380,9 +210,6 @@ function(GenerateNamedObjects sources_in)
       if (${float_type} STREQUAL "DOUBLE" OR ${float_type} STREQUAL "ZCOMPLEX")
         list(APPEND obj_defines "DOUBLE")
       endif ()
-      if (${float_type} STREQUAL "BFLOAT16")
-        list(APPEND obj_defines "BFLOAT16")
-      endif ()
       if (${float_type} STREQUAL "COMPLEX" OR ${float_type} STREQUAL "ZCOMPLEX")
         list(APPEND obj_defines "COMPLEX")
         if (mangle_complex_sources)
@@ -413,15 +240,7 @@ function(GenerateNamedObjects sources_in)
       configure_file(${new_source_file}.tmp ${new_source_file} COPYONLY)
       file(REMOVE ${new_source_file}.tmp)
       list(APPEND SRC_LIST_OUT ${new_source_file})
-      message (STATUS ${new_source_file})
-      if (DEFINED HAVE_FMA3)
-        if ( ${new_source_file} MATCHES "(s|d?)rot_k.*c")
-		set_source_files_properties(${new_source_file} PROPERTIES COMPILE_OPTIONS "-mfma")
-        endif ()
-        if ( ${new_source_file} MATCHES "dgemv_t_k.*c")
-		set_source_files_properties(${new_source_file} PROPERTIES COMPILE_OPTIONS "-mfma")
-        endif ()
-      endif ()
+
     endforeach ()
   endforeach ()
 
@@ -444,17 +263,17 @@ endfunction ()
 function(GenerateCombinationObjects sources_in defines_in absent_codes_in all_defines_in replace_scheme)
 
   set(alternate_name_in "")
-  if (${ARGC} GREATER 5)
+  if (DEFINED ARGV5)
     set(alternate_name_in ${ARGV5})
   endif ()
 
   set(no_float_type false)
-  if (${ARGC} GREATER 6)
+  if (DEFINED ARGV6)
     set(no_float_type ${ARGV6})
   endif ()
 
   set(complex_filename_scheme "")
-  if (${ARGC} GREATER 7)
+  if (DEFINED ARGV7)
     set(complex_filename_scheme ${ARGV7})
   endif ()
 

common.h

@@ -122,7 +122,7 @@ extern "C" {
 #define ATOM GOTO_ATOM
 #undef  GOTO_ATOM
 #endif
-#elif !defined(OS_EMBEDDED)
+#else
 #include <sys/mman.h>
 #ifndef NO_SYSV_IPC
 #include <sys/shm.h>
@@ -134,9 +134,6 @@ extern "C" {
 #if defined(SMP) || defined(USE_LOCKING)
 #include <pthread.h>
 #endif
-#else
-#include <time.h>
-#include <math.h>
 #endif
 
 #if defined(OS_SUNOS)
@@ -260,12 +257,6 @@ typedef long BLASLONG;
 typedef unsigned long BLASULONG;
 #endif
 
-#ifndef bfloat16
-#include <stdint.h>
-typedef uint16_t bfloat16;
-#define BFLOAT16CONVERSION 1
-#endif
-
 #ifdef USE64BITINT
 typedef BLASLONG blasint;
 #if defined(OS_WINDOWS) && defined(__64BIT__)
@@ -306,13 +297,6 @@ typedef int blasint;
 #define SIZE	8
 #define  BASE_SHIFT 3
 #define ZBASE_SHIFT 4
-#elif defined(BFLOAT16)
-#define IFLOAT	bfloat16
-#define XFLOAT IFLOAT
-#define FLOAT	float
-#define SIZE   2
-#define BASE_SHIFT 1
-#define ZBASE_SHIFT 2
 #else
 #define FLOAT	float
 #define SIZE    4
@@ -324,10 +308,6 @@ typedef int blasint;
 #define XFLOAT	FLOAT
 #endif
 
-#ifndef IFLOAT
-#define IFLOAT	FLOAT
-#endif
-
 #ifndef COMPLEX
 #define COMPSIZE  1
 #else
@@ -355,7 +335,7 @@ typedef int blasint;
 #endif
 
 #if defined(ARMV7) || defined(ARMV6) || defined(ARMV8) || defined(ARMV5)
-#define YIELDING        __asm__ __volatile__ ("nop;nop;nop;nop;nop;nop;nop;nop; \n");
+#define YIELDING        asm volatile ("nop;nop;nop;nop;nop;nop;nop;nop; \n");
 #endif
 
 #ifdef BULLDOZER
@@ -364,8 +344,13 @@ typedef int blasint;
 #endif
 #endif
 
+#ifdef POWER8
+#ifndef YIELDING
+#define YIELDING        __asm__ __volatile__ ("nop;nop;nop;nop;nop;nop;nop;nop;\n");
+#endif
+#endif
 
-#if defined(POWER8) || defined(POWER9) || defined(POWER10)
+#ifdef POWER9
 #ifndef YIELDING
 #define YIELDING        __asm__ __volatile__ ("nop;nop;nop;nop;nop;nop;nop;nop;\n");
 #endif
@@ -405,7 +390,7 @@ please https://github.com/xianyi/OpenBLAS/issues/246
 #endif
 
 #ifndef BLAS3_MEM_ALLOC_THRESHOLD
-#define BLAS3_MEM_ALLOC_THRESHOLD 32 
+#define BLAS3_MEM_ALLOC_THRESHOLD 160
 #endif
 
 #ifdef QUAD_PRECISION
@@ -416,15 +401,6 @@ please https://github.com/xianyi/OpenBLAS/issues/246
 #include "common_alpha.h"
 #endif
 
-#if (defined(ARCH_X86) || defined(ARCH_X86_64)) && defined(__CET__) && defined(__has_include)
-#if __has_include(<cet.h>)
-#include <cet.h>
-#endif
-#endif
-#ifndef _CET_ENDBR
-#define _CET_ENDBR
-#endif
-
 #ifdef ARCH_X86
 #include "common_x86.h"
 #endif
@@ -449,11 +425,6 @@ please https://github.com/xianyi/OpenBLAS/issues/246
 #include "common_mips.h"
 #endif
 
-
-#ifdef ARCH_RISCV64
-#include "common_riscv64.h"
-#endif
-
 #ifdef ARCH_MIPS64
 #include "common_mips64.h"
 #endif
@@ -470,10 +441,6 @@ please https://github.com/xianyi/OpenBLAS/issues/246
 #include "common_zarch.h"
 #endif
 
-#ifdef ARCH_LOONGARCH64
-#include "common_loongarch64.h"
-#endif
-
 #ifndef ASSEMBLER
 #ifdef OS_WINDOWSSTORE
 typedef char env_var_t[MAX_PATH];
@@ -504,12 +471,10 @@ static inline unsigned long long rpcc(void){
   struct timespec ts;
   clock_gettime(CLOCK_MONOTONIC, &ts);
   return (unsigned long long)ts.tv_sec * 1000000000ull + ts.tv_nsec;
-#elif !defined(OS_EMBEDDED)
+#else
   struct timeval tv;
   gettimeofday(&tv,NULL);
   return (unsigned long long)tv.tv_sec * 1000000000ull + tv.tv_usec * 1000;
-#else
-  return 0;
 #endif
 }
 #define RPCC_DEFINED
@@ -539,10 +504,6 @@ static void __inline blas_lock(volatile BLASULONG *address){
 #include "common_linux.h"
 #endif
 
-#ifdef OS_EMBEDDED
-#define DTB_DEFAULT_ENTRIES 64
-#endif
-
 #define MMAP_ACCESS (PROT_READ | PROT_WRITE)
 
 #ifdef __NetBSD__
@@ -696,8 +657,6 @@ void gotoblas_dynamic_init(void);
 void gotoblas_dynamic_quit(void);
 void gotoblas_profile_init(void);
 void gotoblas_profile_quit(void);
-	
-int support_avx512(void);	
 
 #ifdef USE_OPENMP
 
@@ -709,7 +668,7 @@ __declspec(dllimport) int __cdecl omp_in_parallel(void);
 __declspec(dllimport) int __cdecl omp_get_num_procs(void);
 #endif
 
-#ifdef HAVE_C11
+#if (__STDC_VERSION__ >= 201112L)
 #if defined(C_GCC) && ( __GNUC__ < 7) 
 // workaround for GCC bug 65467
 #ifndef _Atomic

common_alpha.h

@@ -43,7 +43,6 @@
 
 #define MB  asm("mb")
 #define WMB asm("wmb")
-#define RMB asm("rmb")
 
 static void __inline blas_lock(unsigned long *address){
 #ifndef __DECC