deploy: 65382d22d4

.drone.yml

@@ -1,216 +0,0 @@
----
-kind: pipeline
-name: arm64_gcc_make
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: gcc
-    COMMON_FLAGS: 'DYNAMIC_ARCH=1 TARGET=ARMV8 NUM_THREADS=32'
-  commands:
-    - echo "MAKE_FLAGS:= $COMMON_FLAGS"
-    - apt-get update -y
-    - apt-get install -y make $CC gfortran perl
-    - $CC --version
-    - make QUIET_MAKE=1 $COMMON_FLAGS
-    - make -C test $COMMON_FLAGS
-    - make -C ctest $COMMON_FLAGS
-    - make -C utest $COMMON_FLAGS
-
----
-kind: pipeline
-name: arm32_gcc_make
-
-platform:
-  os: linux
-  arch: arm
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: gcc
-    COMMON_FLAGS: 'DYNAMIC_ARCH=1 TARGET=ARMV6 NUM_THREADS=32'
-  commands:
-    - echo "MAKE_FLAGS:= $COMMON_FLAGS"
-    - apt-get update -y
-    - apt-get install -y make $CC gfortran perl
-    - $CC --version
-    - make QUIET_MAKE=1 $COMMON_FLAGS
-    - make -C test $COMMON_FLAGS
-    - make -C ctest $COMMON_FLAGS
-    - make -C utest $COMMON_FLAGS
-
----
-kind: pipeline
-name: arm64_clang_make
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    COMMON_FLAGS: 'DYNAMIC_ARCH=1 TARGET=ARMV8 NUM_THREADS=32'
-  commands:
-    - echo "MAKE_FLAGS:= $COMMON_FLAGS"
-    - apt-get update -y
-    - apt-get install -y make $CC gfortran perl
-    - $CC --version
-    - make QUIET_MAKE=1 $COMMON_FLAGS
-    - make -C test $COMMON_FLAGS
-    - make -C ctest $COMMON_FLAGS
-    - make -C utest $COMMON_FLAGS
-
----
-kind: pipeline
-name: arm32_clang_cmake
-
-platform:
-  os: linux
-  arch: arm
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CMAKE_FLAGS: '-DDYNAMIC_ARCH=1 -DTARGET=ARMV6 -DNUM_THREADS=32 -DNOFORTRAN=ON -DBUILD_WITHOUT_LAPACK=ON'
-  commands:
-    - echo "CMAKE_FLAGS:= $CMAKE_FLAGS"
-    - apt-get update -y
-    - apt-get install -y make $CC g++ perl cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest -V
-
----
-kind: pipeline
-name: arm64_gcc_cmake
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: gcc
-    CMAKE_FLAGS: '-DDYNAMIC_ARCH=1 -DTARGET=ARMV8 -DNUM_THREADS=32 -DNOFORTRAN=ON -DBUILD_WITHOUT_LAPACK=ON'
-  commands:
-    - echo "CMAKE_FLAGS:= $CMAKE_FLAGS"
-    - apt-get update -y
-    - apt-get install -y make $CC g++ perl cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest -V
-
----
-kind: pipeline
-name: arm64_clang_cmake
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CMAKE_FLAGS: '-DDYNAMIC_ARCH=1 -DTARGET=ARMV8 -DNUM_THREADS=32 -DNOFORTRAN=ON -DBUILD_WITHOUT_LAPACK=ON'
-  commands:
-    - echo "CMAKE_FLAGS:= $CMAKE_FLAGS"
-    - apt-get update -y
-    - apt-get install -y make $CC g++ perl cmake
-    - $CC --version
-    - 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
-    

.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,84 +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: unlink installed gcc to allow updating
-        run: |
-          brew unlink gcc@8
-          brew unlink gcc@9
-          
-      - 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

@@ -1,95 +0,0 @@
-*.obj
-*.lib
-*.dll
-*.dylib
-*.def
-*.o
-*.out
-*.tmp
-lapack-3.1.1
-lapack-3.1.1.tgz
-lapack-3.4.1
-lapack-3.4.1.tgz
-lapack-3.4.2
-lapack-3.4.2.tgz
-lapack-netlib/make.inc
-lapack-netlib/lapacke/include/lapacke_mangling.h
-lapack-netlib/TESTING/testing_results.txt
-lapack-netlib/INSTALL/test*
-lapack-netlib/TESTING/xeigtstc
-lapack-netlib/TESTING/xeigtstd
-lapack-netlib/TESTING/xeigtsts
-lapack-netlib/TESTING/xeigtstz
-lapack-netlib/TESTING/xlintstc
-lapack-netlib/TESTING/xlintstd
-lapack-netlib/TESTING/xlintstds
-lapack-netlib/TESTING/xlintstrfc
-lapack-netlib/TESTING/xlintstrfd
-lapack-netlib/TESTING/xlintstrfs
-lapack-netlib/TESTING/xlintstrfz
-lapack-netlib/TESTING/xlintsts
-lapack-netlib/TESTING/xlintstz
-lapack-netlib/TESTING/xlintstzc
-*.so
-*.so.*
-*.a
-.svn
-*~
-lib.grd
-nohup.out
-config.h
-config_kernel.h
-Makefile.conf
-Makefile.conf_last
-Makefile_kernel.conf
-config_last.h
-getarch
-getarch_2nd
-utest/openblas_utest
-ctest/xccblat1
-ctest/xccblat2
-ctest/xccblat3
-ctest/xdcblat1
-ctest/xdcblat2
-ctest/xdcblat3
-ctest/xscblat1
-ctest/xscblat2
-ctest/xscblat3
-ctest/xzcblat1
-ctest/xzcblat2
-ctest/xzcblat3
-exports/linktest.c
-exports/linux.def
-kernel/setparam_*.c
-kernel/kernel_*.h
-test/CBLAT2.SUMM
-test/CBLAT3.SUMM
-test/DBLAT2.SUMM
-test/DBLAT3.SUMM
-test/SBLAT2.SUMM
-test/SBLAT3.SUMM
-test/ZBLAT2.SUMM
-test/ZBLAT3.SUMM
-test/SHBLAT3.SUMM
-test/cblat1
-test/cblat2
-test/cblat3
-test/dblat1
-test/dblat2
-test/dblat3
-test/sblat1
-test/sblat2
-test/sblat3
-test/test_shgemm
-test/zblat1
-test/zblat2
-test/zblat3
-build
-build.*
-*.swp
-benchmark/*.goto
-benchmark/smallscaling
-.vscode
-CMakeCache.txt
-CMakeFiles/*
-.vscode

.travis.yml

@@ -1,293 +0,0 @@
-# XXX: Precise is already deprecated, new default is Trusty.
-# https://blog.travis-ci.com/2017-07-11-trusty-as-default-linux-is-coming
-dist: precise
-sudo: true
-language: c
-
-matrix:
-  include:
-    - &test-ubuntu
-      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_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
-        - BTYPE="BINARY=64 USE_OPENMP=1"
-
-    - <<: *test-ubuntu
-      os: linux
-      dist: focal
-      arch: s390x
-      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"
-
-    - <<: *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 
-      env:
-        # for matrix annotation only
-        - TARGET_BOX=PPC64LE_LINUX_P9
-
-    - 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  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 
-      env:
-        # for matrix annotation only
-        - TARGET_BOX=PPC64LE_LINUX_P9
-
-    - 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"
-
-    # XXX: This job segfaults in TESTS OF THE COMPLEX LEVEL 3 BLAS,
-    # but only on Travis CI, cannot reproduce it elsewhere.
-    #- &test-alpine-openmp
-    #  <<: *test-alpine
-    #  env:
-    #    - 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-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
-
-    - &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
-      os: linux
-      arch: arm64-graviton2
-      dist: focal
-      group: edge
-      virt: lxd
-      compiler: gcc
-      addons:
-        apt:
-          packages:
-            - gfortran
-      script:
-        - travis_wait 45 make && make lapack-test
-        
-# whitelist
-branches:
-  only:
-    - master
-    - develop
-
-notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/8a6e4470a0cebd090344
-    on_success: change  # options: [always|never|change] default: always
-    on_failure: always  # options: [always|never|change] default: always
-    on_start: never     # options: [always|never|change] default: always

BACKERS.md

@@ -1,39 +0,0 @@
-Thank you for the support.
-
-### [2013.8] [Testbed for OpenBLAS project](https://www.bountysource.com/fundraisers/443-testbed-for-openblas-project)
-
-https://www.bountysource.com/fundraisers/443-testbed-for-openblas-project/pledges
-
-In chronological order:
-
-* aeberspaecher
-* fmolina
-* saullocastro
-* xianyi
-* cuda
-* carter
-* StefanKarpinski
-* staticfloat
-* sebastien-villemot
-* JeffBezanson
-* ihnorton
-* simonp0420
-* andrioni
-* Tim Holy
-* ivarne
-* johnmyleswhite
-* traz
-* Jean-Francis Roy
-* bkalpert
-* Anirban
-* pgermain
-* alexandre.lacoste.18
-* foges
-* ssam
-* WestleyArgentum
-* daniebmariani
-* pjpuglia
-* albarrentine
-* Alexander Vogt
-
-

CMakeLists.txt

@@ -1,422 +0,0 @@
-##
-## Author: Hank Anderson <hank@statease.com>
-##
-
-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 14.dev)
-set(OpenBLAS_VERSION "${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}.${OpenBLAS_PATCH_VERSION}")
-
-# Adhere to GNU filesystem layout conventions
-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)
-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)
-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)
-
-# 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)
-endif()
-
-if(BUILD_WITHOUT_CBLAS)
-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()
-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.")
-
-include("${PROJECT_SOURCE_DIR}/cmake/utils.cmake")
-include("${PROJECT_SOURCE_DIR}/cmake/system.cmake")
-
-set(OpenBLAS_LIBNAME openblas${SUFFIX64_UNDERSCORE})
-
-set(BLASDIRS interface driver/level2 driver/level3 driver/others)
-
-if (NOT DYNAMIC_ARCH)
-  list(APPEND BLASDIRS kernel)
-endif ()
-
-if (DEFINED SANITY_CHECK)
-  list(APPEND BLASDIRS reference)
-endif ()
-
-set(SUBDIRS	${BLASDIRS})
-if (NOT NO_LAPACK)
-  if(BUILD_RELAPACK)
-    list(APPEND SUBDIRS relapack/src)
-  endif()
-  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)
-  set(BUILD_COMPLEX16 true)
-endif ()
-
-if (NOT DEFINED BUILD_MATGEN)
-  set(BUILD_MATGEN true)
-endif()
-
-set(FLOAT_TYPES "")
-if (BUILD_SINGLE)
-  message(STATUS "Building Single Precision")
-  list(APPEND FLOAT_TYPES "SINGLE") # defines nothing
-endif ()
-
-if (BUILD_DOUBLE)
-  message(STATUS "Building Double Precision")
-  list(APPEND FLOAT_TYPES "DOUBLE") # defines DOUBLE
-endif ()
-
-if (BUILD_COMPLEX)
-  message(STATUS "Building Complex Precision")
-  list(APPEND FLOAT_TYPES "COMPLEX") # defines COMPLEX
-endif ()
-
-if (BUILD_COMPLEX16)
-  message(STATUS "Building Double Complex Precision")
-  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 ()
-
-#Set default output directory
-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)
-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})
-  add_subdirectory(${SUBDIR})
-  string(REPLACE "/" "_" subdir_obj ${SUBDIR})
-  list(APPEND TARGET_OBJS "$<TARGET_OBJECTS:${subdir_obj}>")
-endforeach ()
-
-# netlib:
-
-# Can't just use lapack-netlib's CMake files, since they are set up to search for BLAS, build and install a binary. We just want to build a couple of lib files out of lapack and lapacke.
-# Not using add_subdirectory here because lapack-netlib already has its own CMakeLists.txt. Instead include a cmake script with the sources we want.
-if (NOT NOFORTRAN AND NOT NO_LAPACK)
-  include("${PROJECT_SOURCE_DIR}/cmake/lapack.cmake")
-  if (NOT NO_LAPACKE)
-    include("${PROJECT_SOURCE_DIR}/cmake/lapacke.cmake")
-  endif ()
-endif ()
-
-# Only generate .def for dll on MSVC and always produce pdb files for debug and release
-if(MSVC)
-  if (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} VERSION_LESS 3.4)
-    set(OpenBLAS_DEF_FILE "${PROJECT_BINARY_DIR}/openblas.def")
-  endif()
-  set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Zi")
-  set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
-endif()
-
-if (${DYNAMIC_ARCH})
-  add_subdirectory(kernel)
-  foreach(TARGET_CORE ${DYNAMIC_CORE})
-    message("${TARGET_CORE}")
-    list(APPEND TARGET_OBJS "$<TARGET_OBJECTS:kernel_${TARGET_CORE}>")
-  endforeach()
-endif ()
-
-# add objects to the openblas lib
-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)
-  target_link_libraries(${OpenBLAS_LIBNAME} m)
-endif()
-
-# Handle MSVC exports
-if(MSVC AND BUILD_SHARED_LIBS)
-  if (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} VERSION_LESS 3.4)
-    include("${PROJECT_SOURCE_DIR}/cmake/export.cmake")
-  else()
-    # Creates verbose .def file (51KB vs 18KB)
-    set_target_properties(${OpenBLAS_LIBNAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS true)
-  endif()
-endif()
-
-# Set output for libopenblas
-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_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()
-
-if (USE_THREAD)
-  # Add threading library to linker
-  find_package(Threads)
-  if (THREADS_HAVE_PTHREAD_ARG)
-    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)
-if (NOT NO_CBLAS)
-  # Broken without fortran on unix
-  add_subdirectory(utest)
-endif()
-
-if (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_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} "-Wl,-allow-multiple-definition")
-  else()
-   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /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 (${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 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_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 ONLY_CBLAS)
-  set(ONLY_CBLAS_IN 0)
-else()
-  set(ONLY_CBLAS_IN ${ONLY_CBLAS})
-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} 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
-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})
-set(CMAKE_INSTALL_FULL_INCLUDEDIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR})
-
-message(STATUS "Generating openblas_config.h in ${CMAKE_INSTALL_INCLUDEDIR}")
-
-set(OPENBLAS_CONFIG_H ${CMAKE_BINARY_DIR}/openblas_config.h)
-file(WRITE  ${OPENBLAS_CONFIG_H} "#ifndef OPENBLAS_CONFIG_H\n")
-file(APPEND ${OPENBLAS_CONFIG_H} "#define OPENBLAS_CONFIG_H\n")
-file(STRINGS ${PROJECT_BINARY_DIR}/config.h __lines)
-foreach(line ${__lines})
-  string(REPLACE "#define " "" line ${line})
-  file(APPEND ${OPENBLAS_CONFIG_H} "#define OPENBLAS_${line}\n")
-endforeach()
-file(APPEND ${OPENBLAS_CONFIG_H} "#define OPENBLAS_VERSION \"OpenBLAS ${OpenBLAS_VERSION}\"\n")
-file(READ   ${CMAKE_CURRENT_SOURCE_DIR}/openblas_config_template.h OPENBLAS_CONFIG_TEMPLATE_H_CONTENTS)
-file(APPEND ${OPENBLAS_CONFIG_H} "${OPENBLAS_CONFIG_TEMPLATE_H_CONTENTS}\n")
-file(APPEND ${OPENBLAS_CONFIG_H} "#endif /* OPENBLAS_CONFIG_H */\n")
-install (FILES ${OPENBLAS_CONFIG_H} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-
-if(NOT NOFORTRAN)
-  message(STATUS "Generating f77blas.h in ${CMAKE_INSTALL_INCLUDEDIR}")
-
-  set(F77BLAS_H ${CMAKE_BINARY_DIR}/generated/f77blas.h)
-  file(WRITE  ${F77BLAS_H} "#ifndef OPENBLAS_F77BLAS_H\n")
-  file(APPEND ${F77BLAS_H} "#define OPENBLAS_F77BLAS_H\n")
-  file(APPEND ${F77BLAS_H} "#include \"openblas_config.h\"\n")
-  file(READ ${CMAKE_CURRENT_SOURCE_DIR}/common_interface.h COMMON_INTERFACE_H_CONTENTS)
-  file(APPEND ${F77BLAS_H} "${COMMON_INTERFACE_H_CONTENTS}\n")
-  file(APPEND ${F77BLAS_H} "#endif")
-  install (FILES ${F77BLAS_H} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-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})
-endif()
-
-if(NOT NO_LAPACKE)
-	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})
-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/)
-
-
-# GNUInstallDirs "DATADIR" wrong here; CMake search path wants "share".
-set(PN OpenBLAS)
-set(CMAKECONFIG_INSTALL_DIR "share/cmake/${PN}${SUFFIX64}")
-configure_package_config_file(cmake/${PN}Config.cmake.in
-                              "${CMAKE_CURRENT_BINARY_DIR}/${PN}${SUFFIX64}Config.cmake"
-                              INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR})
-write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PN}ConfigVersion.cmake
-                                 VERSION ${${PN}_VERSION}
-                                 COMPATIBILITY AnyNewerVersion)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PN}${SUFFIX64}Config.cmake
-        DESTINATION ${CMAKECONFIG_INSTALL_DIR})
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PN}ConfigVersion.cmake
-        RENAME ${PN}${SUFFIX64}ConfigVersion.cmake
-        DESTINATION ${CMAKECONFIG_INSTALL_DIR})
-install(EXPORT "${PN}${SUFFIX64}Targets"
-        NAMESPACE "${PN}${SUFFIX64}::"
-        DESTINATION ${CMAKECONFIG_INSTALL_DIR})
-

CNAME

@@ -0,0 +1 @@
+openmathlib.org

CONTRIBUTORS.md

@@ -1,196 +0,0 @@
-# Contributions to the OpenBLAS project
-
-## Creator & Maintainer
-
-* Zhang Xianyi <traits.zhang@gmail.com>
-
-## Active Developers
-
-* Wang Qian <traz0824@gmail.com>
-  * Optimize BLAS3 on ICT Loongson 3A.
-  * Optimize BLAS3 on Intel Sandy Bridge.
-
-* Werner Saar <wernsaar@googlemail.com>
-  * [2013-03-04] Optimize AVX and FMA4 DGEMM on AMD Bulldozer
-  * [2013-04-27] Optimize AVX and FMA4 TRSM on AMD Bulldozer
-  * [2013-06-09] Optimize AVX and FMA4 SGEMM on AMD Bulldozer
-  * [2013-06-11] Optimize AVX and FMA4 ZGEMM on AMD Bulldozer
-  * [2013-06-12] Optimize AVX and FMA4 CGEMM on AMD Bulldozer
-  * [2013-06-16] Optimize dgemv_n kernel on AMD Bulldozer
-  * [2013-06-20] Optimize ddot, daxpy kernel on AMD Bulldozer
-  * [2013-06-21] Optimize dcopy kernel on AMD Bulldozer
-  * Porting and Optimization on ARM Cortex-A9
-  * Optimization on AMD Piledriver
-  * Optimization on Intel Haswell
-
-## Previous Developers
-
-* Zaheer Chothia <zaheer.chothia@gmail.com>
-  * Improve the compatibility about complex number
-  * Build LAPACKE: C interface to LAPACK
-  * Improve the windows build.
-
-* Chen Shaohu <huhumartinwar@gmail.com>
-  * Optimize GEMV on the Loongson 3A processor.
-
-* Luo Wen
-  * Intern. Test Level-2 BLAS.
-
-## Contributors
-
-In chronological order:
-
-* pipping <http://page.mi.fu-berlin.de/pipping>
-  * [2011-06-11] Make USE_OPENMP=0 disable openmp.
-
-* Stefan Karpinski <stefan@karpinski.org>
-  * [2011-12-28] Fix a bug about SystemStubs on Mac OS X.
-
-* Alexander Eberspächer <https://github.com/aeberspaecher>
-  * [2012-05-02] Add note on patch for segfaults on Linux kernel 2.6.32.
-
-* Mike Nolta <mike@nolta.net>
-  * [2012-05-19] Fix building bug on FreeBSD and NetBSD.
-
-* Sylvestre Ledru <https://github.com/sylvestre>
-  * [2012-07-01] Improve the detection of sparc. Fix building bug under
-    Hurd and kfreebsd.
-
-* Jameson Nash <https://github.com/vtjnash>
-  * [2012-08-20] Provide support for passing CFLAGS, FFLAGS, PFLAGS, FPFLAGS to
-    make on the command line.
-
-* Alexander Nasonov <alnsn@yandex.ru>
-  * [2012-11-10] Fix NetBSD build.
-
-* Sébastien Villemot <sebastien@debian.org>
-  * [2012-11-14] Fix compilation with TARGET=GENERIC. Patch applied to Debian package.
-  * [2013-08-28] Avoid failure on qemu guests declaring an Athlon CPU without 3dnow!
-
-* Kang-Che Sung <Explorer09@gmail.com>
-  * [2013-05-17] Fix typo in the document. Re-order the architecture list in getarch.c.
-
-* Kenneth Hoste <kenneth.hoste@gmail.com>
-  * [2013-05-22] Adjust Makefile about downloading LAPACK source files.
-
-* Lei WANG <https://github.com/wlbksy>
-  * [2013-05-22] Fix a bug about wget.
-
-* Dan Luu <http://www.linkedin.com/in/danluu>
-  * [2013-06-30] Add Intel Haswell support (using sandybridge optimizations).
-
-* grisuthedragon <https://github.com/grisuthedragon>
-  * [2013-07-11] create openblas_get_parallel to retrieve information which parallelization
-    model is used by OpenBLAS.
-
-* Elliot Saba <staticfloat@gmail.com>
-  * [2013-07-22] Add in return value for `interface/trtri.c`
-
-* Sébastien Fabbro <bicatali@gentoo.org>
-  * [2013-07-24] Modify makefile to respect user's LDFLAGS
-  * [2013-07-24] Add stack markings for GNU as arch-independent for assembler files
-
-* Viral B. Shah <viral@mayin.org>
-  * [2013-08-21] Patch LAPACK XLASD4.f as discussed in JuliaLang/julia#2340
-
-* Lars Buitinck <https://github.com/larsmans>
-  * [2013-08-28] get rid of the generated cblas_noconst.h file
-  * [2013-08-28] Missing threshold in gemm.c
-  * [2013-08-28] fix default prefix handling in makefiles
-
-* yieldthought <https://github.com/yieldthought>
-  * [2013-10-08] Remove -Wl,--retain-symbols-file from dynamic link line to fix tool support
-
-* Keno Fischer <https://github.com/loladiro>
-  * [2013-10-23] Use FC instead of CC to link the dynamic library on OS X
-
-* Christopher Meng <cickumqt@gmail.com>
-  * [2013-12-09] Add DESTDIR support for easier building on RPM based distros.
-                 Use install command instead of cp to install files with permissions control.
-
-* Lucas Beyer <lucasb.eyer.be@gmail.com>
-  * [2013-12-10] Added support for NO_SHARED in make install.
-
-* carlkl <https://github.com/carlkl>
-  * [2013-12-13] Fixed LAPACKE building bug on Windows
-
-* Isaac Dunham <https://github.com/idunham>
-  * [2014-08-03] Fixed link error on Linux/musl
-
-* Dave Nuechterlein
-  * [2014-10-10] trmm and sgemm kernels (optimized for APM's X-Gene 1).
-                 ARMv8 support.
-
-* Jerome Robert <jeromerobert@gmx.com>
-  * [2015-01-01] Speed-up small `ger` and `gemv` using stack allocation (bug #478)
-  * [2015-12-23] `stack_check` in `gemv.c` (bug #722)
-  * [2015-12-28] Allow to force the number of parallel make job
-  * [2015-12-28] Fix detection of AMD E2-3200 detection
-  * [2015-12-31] Let `make MAX_STACK_ALLOC=0` do what expected
-  * [2016-01-19] Disable multi-threading in `ger` and `swap` for small matrices (bug #731)
-  * [2016-01-24] Use `GEMM_MULTITHREAD_THRESHOLD` as a number of ops (bug #742)
-  * [2016-01-26] Let `openblas_get_num_threads` return the number of active threads (bug #760)
-  * [2016-01-30] Speed-up small `zger`, `zgemv`, `ztrmv` using stack allocation (bug #727)
-
-* Dan Kortschak
-  * [2015-01-07] Added test for drotmg bug #484.
-
-* Ton van den Heuvel <https://github.com/ton>
-  * [2015-03-18] Fix race condition during shutdown causing a crash in gotoblas_set_affinity().
-
-* Martin Koehler <https://github.com/grisuthedragon/>
-  * [2015-09-07] Improved imatcopy
-
-* Ashwin Sekhar T K <https://github.com/ashwinyes/>
-  * [2015-11-09] Assembly kernels for Cortex-A57 (ARMv8)
-  * [2015-11-20] lapack-test fixes for Cortex-A57
-  * [2016-03-14] Additional functional Assembly Kernels for Cortex-A57
-  * [2016-03-14] Optimize Dgemm 4x4 for Cortex-A57
-
-* theoractice <https://github.com/theoractice/>
-  * [2016-03-20] Fix compiler error in VisualStudio with CMake
-  * [2016-03-22] Fix access violation on Windows while static linking
-
-* Paul Mustière <https://github.com/buffer51/>
-  * [2016-02-04] Fix Android build on ARMV7
-  * [2016-04-26] Android build with LAPACK for ARMV7 & ARMV8
-
-* Shivraj Patil <https://github.com/sva-img/>
-  * [2016-05-03] DGEMM optimization for MIPS P5600 and I6400 using MSA
-
-* Kaustubh Raste <https://github.com/ksraste/>
-  * [2016-05-09] DTRSM optimization for MIPS P5600 and I6400 using MSA
-  * [2016-05-20] STRSM optimization for MIPS P5600 and I6400 using MSA
-
-* Abdelrauf  <https://github.com/quickwritereader>
-  * [2017-01-01] dgemm and dtrmm kernels for IBM z13
-  * [2017-02-26] ztrmm kernel for IBM z13
-  * [2017-03-13] strmm and ctrmm kernel for IBM z13
-  * [2017-09-01] initial Blas Level-1,2 (double precision) for IBM z13
-  * [2018-03-07] added missing Blas Level 1-2  (double precision) simd codes
-  * [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

GotoBLAS_00License.txt

@@ -1,32 +0,0 @@
-
-Copyright 2009, 2010 The University of Texas at Austin.
-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.
-
-THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY OF TEXAS AT AUSTIN ``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 UNIVERSITY  OF TEXAS AT
-AUSTIN 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.
-
-The views and conclusions contained in the software and documentation
-are those of the authors and should not be interpreted as representing
-official policies, either expressed or implied, of The University of
-Texas at Austin.

GotoBLAS_01Readme.txt

@@ -1,93 +0,0 @@
-              Optimized GotoBLAS2 libraries version 1.13
-
-                       By Kazushige Goto <kgoto@tacc.utexas.edu>
-
-# This is the last update and done on 5th Feb. 2010.
-
-0. License
-
-   See 00TACC_Research_License.txt.
-
-1. Supported OS
-
-     Linux
-     FreeBSD(Also it may work on NetBSD)
-     OSX
-     Soralis
-     Windows 2k, XP, Server 2003 and 2008(both 32bit and 64bit)
-     AIX
-     Tru64 UNIX
-
-2. Supported Architecture
-
-    X86  : Pentium3 Katmai
-                    Coppermine
-           Athlon  (not well optimized, though)
-           PentiumM Banias, Yonah
-           Pentium4 Northwood
-                    Nocona (Prescott)
-	   Core 2   Woodcrest
-	   Core 2   Penryn
-           Nehalem-EP  Corei{3,5,7}
-	   Atom
-           AMD Opteron
-	   AMD Barlcelona, Shanghai, Istanbul
-	   VIA NANO
-
-   X86_64: Pentium4 Nocona
-	   Core 2   Woodcrest
-	   Core 2   Penryn
-           Nehalem
-	   Atom
-           AMD Opteron
-	   AMD Barlcelona, Shanghai, Istanbul
-	   VIA NANO
-
-   IA64  : Itanium2
-
-   Alpha : EV4, EV5, EV6
-
-   POWER : POWER4
-           PPC970/PPC970FX
-           PPC970MP
-	   CELL (PPU only)
-           POWER5
-           PPC440   (QCDOC)
-           PPC440FP2(BG/L)
-	   POWERPC G4(PPC7450)
-           POWER6
-
-   SPARC : SPARC IV
-           SPARC VI, VII (Fujitsu chip)
-
-   MIPS64/32: Sicortex
-
-3. Supported compiler
-
-   C compiler       : GNU CC
-                      Cygwin, MinGW
-                      Other commercial compiler(especially for x86/x86_64)
-
-   Fortran Compiler : GNU G77, GFORTRAN
-		      G95
-		      Open64
-                      Compaq
-                      F2C
-                      IBM
-                      Intel
-                      PathScale
-                      PGI
-                      SUN
-                      Fujitsu
-
-4. Suported precision
-
- Now x86/x86_64 version support 80bit FP precision in addition to
-normal double presicion and single precision. Currently only
-gfortran supports 80bit FP with "REAL*10".
-
-
-5. How to build library?
-
- Please see 02QuickInstall.txt or just type "make".
-

GotoBLAS_02QuickInstall.txt

@@ -1,118 +0,0 @@
-                Quick installation for GotoBLAS2
-
-***************************************************************************
-***************************************************************************
-**                                                                       **
-**                                                                       **
-**                    Just type "make" <<return>>.                       **
-**                                                                       **
-**           If you're not satisfied with this library,                  **
-**           please read following instruction and customize it.         **
-**                                                                       **
-**                                                                       **
-***************************************************************************
-***************************************************************************
-
-
-1. REALLY REALLY quick way to build library
-
-    Type "make" or "gmake".
-
-   $shell> make
-
-   The script will detect Fortran compiler, number of cores and
-   architecture which you're using. If default gcc binary type is
-   64bit, 64 bit library will be created. Otherwise 32 bit library
-   will be created.
-
-   After finishing compile, you'll find various information about
-   generated library.
-
- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
- GotoBLAS2 build complete.
-
-  OS               ... Linux
-  Architecture     ... x86_64
-  BINARY           ... 64bit
-  C compiler       ... GCC  (command line : gcc)
-  Fortran compiler ... PATHSCALE  (command line : pathf90)
-  Library Name     ... libgoto_barcelonap-r1.27.a (Multi threaded; Max
-  num-threads is 16)
-
- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
-
-2. Specifying 32bit or 64bit library
-
-   If you need 32bit binary,
-
-   $shell> make BINARY=32
-
-   If you need 64bit binary,
-
-   $shell> make BINARY=64
-
-
-3. Specifying target architecture
-
-   If you need library for different architecture, you can use TARGET
-   option. You can find current available options in top of getarch.c.
-   For example, if you need library for Intel core2 architecture,
-   you'll find FORCE_CORE2 option in getarch.c. Therefore you can
-   specify TARGET=CORE2 (get rid of FORCE_) with make.
-
-   $shell> make TARGET=CORE2
-
-   Also if you want GotoBLAS2 to support multiple architecture,
-
-   $shell> make DYNAMIC_ARCH=1
-
-   All kernel will be included in the library and dynamically switched
-   the best architecutre at run time.
-
-
-4. Specifying for enabling multi-threaded
-
-   Script will detect number of cores and will enable multi threaded
-   library if number of cores is more than two. If you still want to
-   create single threaded library,
-
-   $shell> make USE_THREAD=0
-
-   Or if you need threaded library by force,
-
-   $shell> make USE_THREAD=1
-
-
-5. Specifying target OS
-
-   Target architecture will be determined by the CC. If you
-   specify cross compiler for MIPS, you can create library for
-   MIPS architecture.
-
-   $shell> make CC=mips64el-linux-gcc TARGET=SICORTEX
-
-   Or you can specify your favorite C compiler with absolute path.
-
-   $shell> make CC=/opt/intel/cc/32/10.0.026/bin/icc TARGET=BARCELONA
-
-   Binary type (32bit/64bit) is determined by checking CC, you
-   can control binary type with this option.
-
-   $shell> make CC="pathcc -m32"
-
-   In this case, 32bit library will be created.
-
-
-6. Specifying Fortran compiler
-
-   If you need to support other Fortran compiler, you can specify with
-   FC option.
-
-   $shell> make FC=gfortran
-
-
-7. Other useful options
-
-   You'll find other useful options in Makefile.rule.

GotoBLAS_03FAQ.txt

@@ -1,128 +0,0 @@
-	GotoBLAS2 FAQ
-
-1. General
-
-1.1  Q Can I find useful paper about GotoBLAS2?
-
-     A You may check following URL.
-
-     http://www.cs.utexas.edu/users/flame/Publications/index.htm
-
-    11. Kazushige Goto and Robert A. van de Geijn, " Anatomy of
-	High-Performance Matrix Multiplication," ACM Transactions on
-	Mathematical Software, accepted.
-
-    15. Kazushige Goto and Robert van de Geijn, "High-Performance
-        Implementation of the Level-3 BLAS." ACM Transactions on
-        Mathematical Software, submitted.
-
-
-1.2  Q Does GotoBLAS2 work with Hyperthread (SMT)?
-
-     A Yes, it will work. GotoBLAS2 detects Hyperthread and
-       avoid scheduling on the same core.
-
-
-1.3  Q When I type "make", following error occured. What's wrong?
-
-	$shell> make
-	"./Makefile.rule", line 58: Missing dependency operator
-	"./Makefile.rule", line 61: Need an operator
-	...
-
-     A This error occurs because you didn't use GNU make. Some binary
-       packages install GNU make as "gmake" and it's worth to try.
-
-
-1.4  Q Function "xxx" is slow. Why?
-
-     A Generally GotoBLAS2 has many well optimized functions, but it's
-       far and far from perfect. Especially Level 1/2 function
-       performance depends on how you call BLAS. You should understand
-       what happends between your function and GotoBLAS2 by using profile
-       enabled version or hardware performance counter. Again, please
-       don't regard GotoBLAS2 as a black box.
-
-
-1.5  Q I have a commercial C compiler and want to compile GotoBLAS2 with
-       it. Is it possible?
-
-     A All function that affects performance is written in assembler
-       and C code is just used for wrapper of assembler functions or
-       complicated functions. Also I use many inline assembler functions,
-       unfortunately most of commercial compiler can't handle inline
-       assembler. Therefore you should use gcc.
-
-
-1.6  Q I use OpenMP compiler. How can I use GotoBLAS2 with it?
-
-     A Please understand that OpenMP is a compromised method to use
-       thread. If you want to use OpenMP based code with GotoBLAS2, you
-       should enable "USE_OPENMP=1" in Makefile.rule.
-
-
-1.7  Q Could you tell me how to use profiled library?
-
-     A You need to build and link your application with -pg
-       option. After executing your application, "gmon.out" is
-       generated in your current directory.
-
-       $shell> gprof <your application name> gmon.out
-
-       Each sample counts as 0.01 seconds.
-	 %   cumulative   self              self     total
-	time   seconds   seconds    calls  Ks/call  Ks/call  name
-	89.86    975.02   975.02    79317     0.00     0.00  .dgemm_kernel
-	 4.19   1020.47    45.45       40     0.00     0.00  .dlaswp00N
-	 2.28   1045.16    24.69     2539     0.00     0.00  .dtrsm_kernel_LT
-	 1.19   1058.03    12.87    79317     0.00     0.00  .dgemm_otcopy
-	 1.05   1069.40    11.37     4999     0.00     0.00  .dgemm_oncopy
-       ....
-
-       I think profiled BLAS library is really useful for your
-       research. Please find bottleneck of your application and
-       improve it.
-
-1.8  Q Is number of thread limited?
-
-     A Basically, there is no limitation about number of threads. You
-       can specify number of threads as many as you want, but larger
-       number of threads will consume extra resource. I recommend you to
-       specify minimum number of threads.
-
-1.9  Q I have segfaults when I compile with USE_OPENMP=1. What's wrong?
-
-     A This may be related to a bug in the Linux kernel 2.6.32. Try applying
-     the patch segaults.patch using
-
-     patch < segfaults.patch
-
-     and see if the crashes persist. Note that this patch will lead to many
-     compiler warnings.
-
-2. Architecture Specific issue or Implementation
-
-2.1 Q GotoBLAS2 seems to support any combination with OS and
-      architecture. Is it possible?
-
-    A Combination is limited by current OS and architecture. For
-      examble, the combination OSX with SPARC is impossible. But it
-      will be possible with slight modification if these combination
-      appears in front of us.
-
-
-2.2 Q I have POWER architecture systems. Do I need extra work?
-
-    A Although POWER architecture defined special instruction
-      like CPUID to detect correct architecture, it's privileged
-      and can't be accessed by user process. So you have to set
-      the architecture that you have manually in getarch.c.
-
-
-2.3 Q I can't create DLL on Cygwin (Error 53). What's wrong?
-
-    A You have to make sure if lib.exe and mspdb80.dll are in Microsoft
-      Studio PATH. The easiest way is to use 'which' command.
-
-    $shell> which lib.exe
-    /cygdrive/c/Program Files/Microsoft Visual Studio/VC98/bin/lib.exe

GotoBLAS_04FAQ.txt

@@ -1,13 +0,0 @@
-
-Quick guide to build library for Windows 64bit.
-
-1. What you need
-
- a. Windows Server 2003 or later
- b. Cygwin environment(make, gcc, g77, perl, sed, wget)
- c. MinGW64 compiler
- d. Microsoft Visual Studio (lib.exe and mspdb80.dll are required to create dll)
-
-2. Do ./quickbuild.win64
-
-Good luck

GotoBLAS_05LargePage.txt

@@ -1,53 +0,0 @@
- To enhance perfomance, I'd recommend you to enable large page on
- your OS (root account is required).
-
-  A) Linux
-
-    x86   32bit    ... (number of core) * 4 pages
-    x86   64bit    ... (number of core) * 8 pages
-    POWER 32/64bit ... (number of core) * 1 pages
-
-    If you want to allocate 64 large pages,
-
-    $shell> echo  0 > /proc/sys/vm/nr_hugepages		# need to be reset
-    $shell> echo 65 > /proc/sys/vm/nr_hugepages		# add 1 extra page
-    $shell> echo 3355443200 > /proc/sys/kernel/shmmax   # just large number
-    $shell> echo 3355443200 > /proc/sys/kernel/shmall
-
-    Also may add a few lines into /etc/security/limits.conf file.
-
-    *       hard    memlock          unlimited
-    *       soft    memlock          unlimited
-
-    Then restart sshd (/etc/init.d/sshd restart).
-
-  B) Solaris
-
-    You don't have to set up.
-
-  C) Windows (Windows Server 2003 or later, XP 64bit)
-
-    You have to assign memory lock operation to your account.
-
-     Control Panel -> Administrative Tools -> Local Security Policy ->
-     Local Policies -> User Rights Assignment -> Lock pages in memory
-
-  D) AIX
-
-    Ask your administrator
-
-  E) Tru64 UNIX
-
-    Assign shared memory at boot time.
-
-  F) Other aarchitecture which doesn't have Large TLB enhancement
-
-   If you have root permission, please install device driver which
-   located in drivers/mapper.
-
-   $shell> cd drivers/mapper
-   $shell> make
-   $shell> insmod mapper.ko
-   $shell> ./device_setup
-
-   Then enable DEVICEDRIVER_ALLOCATION = 1 in Makefile.rule.

GotoBLAS_06WeirdPerformance.txt

@@ -1,22 +0,0 @@
-        Weird Performance
-
-1. If you see serious performance loss (extremely low performance),
-   probably you created too many threads or process. Basically GotoBLAS
-   assumes that available cores that you specify are exclusively for
-   BLAS computation. Even one small thread/process conflicts with BLAS
-   threads, performance will become worse.
-
-   The best solution is to reduce your number of threads or insert
-   some synchronization mechanism and suspend your threads until BLAS
-   operation is finished.
-
-
-2. Simlar problem may happen under virtual machine. If supervisor
-   allocates different cores for each scheduling, BLAS performnace
-   will be bad. This is because BLAS also utilizes all cache,
-   unexpected re-schedule for different core may result of heavy
-   performance loss.
-
-
-Anyway, if you see any weird performance loss, it means your code or
-algorithm is not optimal.

Jenkinsfile

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

LICENSE

@@ -1,29 +0,0 @@
-Copyright (c) 2011-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 COPYRIGHT OWNER 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.

Makefile

@@ -1,402 +0,0 @@
-TOPDIR	= .
-include ./Makefile.system
-
-BLASDIRS = interface driver/level2 driver/level3 driver/others
-
-ifneq ($(DYNAMIC_ARCH), 1)
-BLASDIRS += kernel
-endif
-
-ifdef SANITY_CHECK
-BLASDIRS += reference
-endif
-
-SUBDIRS	= $(BLASDIRS)
-ifneq ($(NO_LAPACK), 1)
-SUBDIRS	+= lapack
-endif
-
-RELA =
-ifeq ($(BUILD_RELAPACK), 1)
-RELA = re_lapack
-endif
-
-ifeq ($(NO_FORTRAN), 1)
-define NOFORTRAN
-1
-endef
-define NO_LAPACK
-1
-endef
-export NOFORTRAN
-export NO_LAPACK
-endif
-
-LAPACK_NOOPT := $(filter-out -O0 -O1 -O2 -O3 -Ofast,$(LAPACK_FFLAGS))
-
-SUBDIRS_ALL = $(SUBDIRS) test ctest utest exports benchmark ../laswp ../bench cpp_thread_test
-
-.PHONY : all libs netlib $(RELA) test ctest shared install
-.NOTPARALLEL : all libs $(RELA) prof lapack-test install blas-test
-
-all :: libs netlib $(RELA) tests shared
-	@echo
-	@echo " OpenBLAS build complete. ($(LIB_COMPONENTS))"
-	@echo
-	@echo "  OS               ... $(OSNAME)             "
-	@echo "  Architecture     ... $(ARCH)               "
-ifndef BINARY64
-	@echo "  BINARY           ... 32bit                 "
-else
-	@echo "  BINARY           ... 64bit                 "
-endif
-
-ifdef INTERFACE64
-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
-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
-endif
-ifneq ($(OSNAME), AIX)
-	@echo -n "  Library Name     ... $(LIBNAME)"
-else
-	@echo "  Library Name     ... $(LIBNAME)"
-endif
-
-ifndef SMP
-	@echo " (Single-threading)  "
-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)"
-endif
-
-ifeq ($(USE_OPENMP), 1)
-	@echo
-	@echo " Use OpenMP in the multithreading. Because of ignoring OPENBLAS_NUM_THREADS and GOTO_NUM_THREADS flags, "
-	@echo " you should use OMP_NUM_THREADS environment variable to control the number of threads."
-	@echo
-endif
-
-ifeq ($(OSNAME), Darwin)
-	@echo "WARNING: If you plan to use the dynamic library $(LIBDYNNAME), you must run:"
-	@echo
-	@echo "\"make PREFIX=/your_installation_path/ install\"."
-	@echo
-	@echo "(or set PREFIX in Makefile.rule and run make install."
-	@echo "If you want to move the .dylib to a new location later, make sure you change"
-	@echo "the internal name of the dylib with:"
-	@echo
-	@echo "install_name_tool -id /new/absolute/path/to/$(LIBDYNNAME) $(LIBDYNNAME)"
-endif
-	@echo
-	@echo "To install the library, you can run \"make PREFIX=/path/to/your/installation install\"."
-	@echo
-
-shared :
-ifneq ($(NO_SHARED), 1)
-ifeq ($(OSNAME), $(filter $(OSNAME),Linux SunOS Android Haiku FreeBSD DragonFly))
-	@$(MAKE) -C exports so
-	@ln -fs $(LIBSONAME) $(LIBPREFIX).so
-	@ln -fs $(LIBSONAME) $(LIBPREFIX).so.$(MAJOR_VERSION)
-endif
-ifeq ($(OSNAME), $(filter $(OSNAME),OpenBSD NetBSD))
-	@$(MAKE) -C exports so
-	@ln -fs $(LIBSONAME) $(LIBPREFIX).so
-endif
-ifeq ($(OSNAME), Darwin)
-	@$(MAKE) -C exports dyn
-	@ln -fs $(LIBDYNNAME) $(LIBPREFIX).dylib
-	@ln -fs $(LIBDYNNAME) $(LIBPREFIX).$(MAJOR_VERSION).dylib
-endif
-ifeq ($(OSNAME), WINNT)
-	@$(MAKE) -C exports dll
-endif
-ifeq ($(OSNAME), CYGWIN_NT)
-	@$(MAKE) -C exports dll
-endif
-endif
-
-tests :
-ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
-	touch $(LIBNAME)
-ifndef NO_FBLAS
-	$(MAKE) -C test all
-endif
-	$(MAKE) -C utest all
-ifneq ($(NO_CBLAS), 1)
-	$(MAKE) -C ctest all
-ifeq ($(CPP_THREAD_SAFETY_TEST), 1)
-	$(MAKE) -C cpp_thread_test all
-endif
-endif
-endif
-
-libs :
-ifeq ($(CORE), UNKNOWN)
-	$(error OpenBLAS: Detecting CPU failed. Please set TARGET explicitly, e.g. make TARGET=your_cpu_target. Please read README for the detail.)
-endif
-ifeq ($(NOFORTRAN), 1)
-	$(info OpenBLAS: Detecting fortran compiler failed. Cannot compile LAPACK. Only compile BLAS.)
-endif
-ifeq ($(NO_STATIC), 1)
-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 ; \
-	fi; \
-	done
-#Save the config files for installation
-	@cp Makefile.conf Makefile.conf_last
-	@cp config.h config_last.h
-ifdef QUAD_PRECISION
-	@echo "#define QUAD_PRECISION">> config_last.h
-endif
-ifeq ($(EXPRECISION), 1)
-	@echo "#define EXPRECISION">> config_last.h
-endif
-##
-ifeq ($(DYNAMIC_ARCH), 1)
-	@$(MAKE) -C kernel commonlibs || exit 1
-	@for d in $(DYNAMIC_CORE) ; \
-	do  $(MAKE) GOTOBLAS_MAKEFILE= -C kernel TARGET_CORE=$$d kernel || exit 1 ;\
-	done
-	@echo DYNAMIC_ARCH=1 >> Makefile.conf_last
-ifeq ($(DYNAMIC_OLDER), 1)
-	@echo DYNAMIC_OLDER=1 >> Makefile.conf_last
-endif	
-endif
-ifdef USE_THREAD
-	@echo USE_THREAD=$(USE_THREAD) >>  Makefile.conf_last
-endif
-	@touch lib.grd
-
-prof : prof_blas prof_lapack
-
-prof_blas :
-	ln -fs $(LIBNAME_P) $(LIBPREFIX)_p.$(LIBSUFFIX)
-	for d in $(SUBDIRS) ; \
-	do if test -d $$d; then \
-	  $(MAKE) -C $$d prof || exit 1 ; \
-	fi; \
-	done
-ifeq ($(DYNAMIC_ARCH), 1)
-	  $(MAKE) -C kernel commonprof || exit 1
-endif
-
-blas :
-	ln -fs $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
-	for d in $(BLASDIRS) ; \
-	do if test -d $$d; then \
-	  $(MAKE) -C $$d libs || exit 1 ; \
-	fi; \
-	done
-
-hpl :
-	ln -fs $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
-	for d in $(BLASDIRS) ../laswp exports ; \
-	do if test -d $$d; then \
-	  $(MAKE) -C $$d $(@F) || exit 1 ; \
-	fi; \
-	done
-ifeq ($(DYNAMIC_ARCH), 1)
-	  $(MAKE) -C kernel commonlibs || exit 1
-	for d in $(DYNAMIC_CORE) ; \
-	do  $(MAKE) GOTOBLAS_MAKEFILE= -C kernel TARGET_CORE=$$d kernel || exit 1 ;\
-	done
-endif
-
-hpl_p :
-	ln -fs $(LIBNAME_P) $(LIBPREFIX)_p.$(LIBSUFFIX)
-	for d in $(SUBDIRS) ../laswp exports ; \
-	do if test -d $$d; then \
-	  $(MAKE) -C $$d $(@F) || exit 1 ; \
-	fi; \
-	done
-
-ifeq ($(NO_LAPACK), 1)
-netlib :
-
-else
-netlib : lapack_prebuild
-ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
-	@$(MAKE) -C $(NETLIB_LAPACK_DIR) lapacklib
-	@$(MAKE) -C $(NETLIB_LAPACK_DIR) tmglib
-endif
-ifneq ($(NO_LAPACKE), 1)
-	@$(MAKE) -C $(NETLIB_LAPACK_DIR) lapackelib
-endif
-endif
-
-ifeq ($(NO_LAPACK), 1)
-re_lapack :
-
-else
-re_lapack :
-	@$(MAKE) -C relapack
-endif
-
-prof_lapack : lapack_prebuild
-	@$(MAKE) -C $(NETLIB_LAPACK_DIR) lapack_prof
-
-lapack_prebuild :
-ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
-	-@echo "FC          = $(FC)" > $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "FFLAGS      = $(LAPACK_FFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "FFLAGS_DRV  = $(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 "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 "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 "RANLIB      = $(RANLIB)" >> $(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 "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
-	-@echo "CEXTRALIB   = $(EXTRALIB)" >> $(NETLIB_LAPACK_DIR)/make.inc
-ifeq ($(F_COMPILER), GFORTRAN)
-	-@echo "TIMER       = INT_ETIME" >> $(NETLIB_LAPACK_DIR)/make.inc
-ifdef SMP
-ifeq ($(OSNAME), WINNT)
-	-@echo "LOADER      = $(FC)" >> $(NETLIB_LAPACK_DIR)/make.inc
-else ifeq ($(OSNAME), Haiku)
-	-@echo "LOADER      = $(FC)" >> $(NETLIB_LAPACK_DIR)/make.inc
-else
-	-@echo "LOADER      = $(FC) -pthread" >> $(NETLIB_LAPACK_DIR)/make.inc
-endif
-else
-	-@echo "LOADER      = $(FC)" >> $(NETLIB_LAPACK_DIR)/make.inc
-endif
-else
-	-@echo "TIMER       = NONE" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "LOADER      = $(FC)" >> $(NETLIB_LAPACK_DIR)/make.inc
-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
-endif
-
-large.tgz :
-ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
-	if [ ! -a $< ]; then
-	-wget http://www.netlib.org/lapack/timing/large.tgz;
-	fi
-endif
-
-timing.tgz :
-ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
-	if [ ! -a $< ]; then
-	-wget http://www.netlib.org/lapack/timing/timing.tgz;
-	fi
-endif
-
-lapack-timing : large.tgz timing.tgz
-ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
-	(cd $(NETLIB_LAPACK_DIR); $(TAR) zxf ../timing.tgz TIMING)
-	(cd $(NETLIB_LAPACK_DIR)/TIMING; $(TAR) zxf ../../large.tgz )
-	$(MAKE) -C $(NETLIB_LAPACK_DIR)/TIMING
-endif
-
-
-lapack-test :
-	(cd $(NETLIB_LAPACK_DIR)/TESTING && rm -f x* *.out)
-	$(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; \
-        ./testsecond; ./testdsecnd; ./testieee; ./testversion )
-	(cd $(NETLIB_LAPACK_DIR); ./lapack_testing.py -r -b TESTING)
-endif
-
-lapack-runtest:
-	( cd $(NETLIB_LAPACK_DIR)/INSTALL; ./testlsame; ./testslamch; ./testdlamch; \
-        ./testsecond; ./testdsecnd; ./testieee; ./testversion )
-	(cd $(NETLIB_LAPACK_DIR); ./lapack_testing.py -r )
-
-
-blas-test:
-	(cd $(NETLIB_LAPACK_DIR)/BLAS/TESTING && rm -f x* *.out)
-	$(MAKE) -j 1 -C $(NETLIB_LAPACK_DIR) blas_testing
-	(cd $(NETLIB_LAPACK_DIR)/BLAS/TESTING && cat *.out)
-
-
-dummy :
-
-install :
-	$(MAKE) -f Makefile.install install
-
-clean ::
-	@for d in $(SUBDIRS_ALL) ; \
-	do if test -d $$d; then \
-	  $(MAKE) -C $$d $(@F) || exit 1 ; \
-	fi; \
-	done
-#ifdef DYNAMIC_ARCH
-	@$(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
-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
-	@$(MAKE) -C relapack clean
-	@rm -f *.grd Makefile.conf_last config_last.h
-	@(cd $(NETLIB_LAPACK_DIR)/TESTING && rm -f x* *.out testing_results.txt)
-	@echo Done.

Makefile.alpha

@@ -1,57 +0,0 @@
-CPP	= $(CC) -E
-RANLIB  = ranlib
-
-ifeq ($(LIBSUBARCH), EV4)
-LIBNAME		= $(LIBPREFIX)_ev4.a
-LIBNAME_P	= $(LIBPREFIX)_ev4_p.a
-endif
-
-ifeq ($(LIBSUBARCH), EV5)
-LIBNAME		= $(LIBPREFIX)_ev5.a
-LIBNAME_P	= $(LIBPREFIX)_ev5_p.a
-endif
-
-ifeq ($(LIBSUBARCH), EV6)
-LIBNAME		= $(LIBPREFIX)_ev6.a
-LIBNAME_P	= $(LIBPREFIX)_ev6_p.a
-endif
-
-ifneq ($(COMPILER), NATIVE)
-# GCC User
-ifeq ($(LIBSUBARCH), EV4)
-OPTION += -DEV4 -mcpu=ev4
-endif
-ifeq ($(LIBSUBARCH), EV5)
-OPTION += -DEV5 -mcpu=ev5
-endif
-ifeq ($(LIBSUBARCH), EV6)
-OPTION += -DEV6 -mcpu=ev6
-endif
-else
-# Compaq Compiler User
-ifeq ($(LIBSUBARCH), EV4)
-OPTION += -DEV4 -tune ev4 -arch ev4
-endif
-ifeq ($(LIBSUBARCH), EV5)
-OPTION += -DEV5 -tune ev5 -arch ev5
-endif
-ifeq ($(LIBSUBARCH), EV6)
-OPTION += -DEV6 -tune ev6 -arch ev6
-endif
-endif
-
-ifeq ($(F_COMPILER), GFORTRAN)
-FCOMMON_OPT	+= -mieee
-endif
-
-ifeq ($(F_COMPILER), G77)
-FCOMMON_OPT	+= -mieee
-endif
-
-ifndef SMP
-LIBCXML		= -lcxml  -lots -lm
-LIBATLAS	= -L/usr/lib/atlas3.7.8 -lf77blas -latlas -lm
-else
-LIBCXML		= -lcxmlp -lots -lm
-LIBATLAS	= -L/usr/lib/atlas3.7.8p -llapack -lptcblas -lptf77blas -latlas -lpthread -lm
-endif

Makefile.arm

@@ -1,19 +0,0 @@
-ifeq ($(CORE), $(filter $(CORE),ARMV7 CORTEXA9 CORTEXA15))
-ifeq ($(OSNAME), Android)
-CCOMMON_OPT += -mfpu=neon -march=armv7-a
-FCOMMON_OPT += -mfpu=neon -march=armv7-a
-else
-CCOMMON_OPT += -mfpu=vfpv3 -march=armv7-a
-FCOMMON_OPT += -mfpu=vfpv3 -march=armv7-a
-endif
-endif
-
-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,110 +0,0 @@
-ifneq ($(C_COMPILER), PGI)
-ifeq ($(CORE), ARMV8)
-CCOMMON_OPT += -march=armv8-a
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8-a
-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 ($(GCCVERSIONGTEQ7), 1)
-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
-
-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 ($(GCCVERSIONGTEQ9), 1)
-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
-endif

Makefile.generic

@@ -1 +0,0 @@
-COPT	= -Wall -O2 # -DGEMMTEST

Makefile.ia64

@@ -1,22 +0,0 @@
-CCOMMON_COPT += # -DUSE64BITINT  # -DGEMMTEST
-
-# CCOMMON_OPT	 += -DPARAMTEST
-FLAMEPATH	= $(HOME)/flame/lib/ia64
-
-ifndef SMP
-LIBMKL		= -L$(MKLPATH)/64 -Wl,-rpath,$(MKLPATH)/64 -lmkl_intel_lp64 -lmkl_sequential -lmkl_core -lguide -lpthread -lm
-else
-LIBMKL		= -L$(MKLPATH)/64 -Wl,-rpath,$(MKLPATH)/64 -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -lguide -lpthread -lm
-endif
-
-LIBFLAME	= -L$(FLAMEPATH) -llapack2flame -lflame $(TOPDIR)/$(LIBNAME) -lgfortran -lpthread -lm
-
-LIBMLIB		= ../../level1/others/libmisc.a -L/opt/intel/fc/ia64/9.1.040/lib -L/opt/mlib/lib \
-		 -llapack -lguide -lifcore -lm -lpthread
-LIBSCSL		= -L/opt/scsl/1.4.1.0/lib -Wl,-rpath,/opt/scsl/1.4.1.0/lib -lscs
-
-ifndef SMP
-LIBATLAS	= -L/usr/lib/atlas3.6.0 -lf77blas -latlas -lm
-else
-LIBATLAS	= -L$(HOME)/misc/lib -L/usr/lib/atlas3.6.0p -llapack -lptcblas -lptf77blas -latlas -lpthread -lm
-endif

Makefile.install

@@ -1,193 +0,0 @@
-TOPDIR	= .
-export GOTOBLAS_MAKEFILE = 1
--include $(TOPDIR)/Makefile.conf_last
-include ./Makefile.system
-
-PREFIX ?= /opt/OpenBLAS
-
-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_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
-
-lib.grd :
-	$(error OpenBLAS: Please run "make" firstly)
-
-install : 	lib.grd
-	@-mkdir -p "$(DESTDIR)$(PREFIX)"
-	@-mkdir -p "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)"
-	@-mkdir -p "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
-	@-mkdir -p "$(DESTDIR)$(OPENBLAS_BINARY_DIR)"
-	@-mkdir -p "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)"
-	@-mkdir -p "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)"
-	@echo Generating openblas_config.h in $(DESTDIR)$(OPENBLAS_INCLUDE_DIR)
-#for inc
-	@echo \#ifndef OPENBLAS_CONFIG_H > "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/openblas_config.h"
-	@echo \#define OPENBLAS_CONFIG_H >> "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/openblas_config.h"
-	@$(AWK) 'NF {print $$1, "OPENBLAS_"$$2, $$3}' config_last.h >> "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/openblas_config.h"
-	@echo \#define OPENBLAS_VERSION \" OpenBLAS $(VERSION) \" >> "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/openblas_config.h"
-	@cat openblas_config_template.h >> "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/openblas_config.h"
-	@echo \#endif  \/\* OPENBLAS_CONFIG_H \*\/ >> "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/openblas_config.h"
-
-	@echo Generating f77blas.h in $(DESTDIR)$(OPENBLAS_INCLUDE_DIR)
-	@echo \#ifndef OPENBLAS_F77BLAS_H > "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/f77blas.h"
-	@echo \#define OPENBLAS_F77BLAS_H >> "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/f77blas.h"
-	@echo \#include \"openblas_config.h\" >> "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/f77blas.h"
-	@cat common_interface.h >> "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/f77blas.h"
-	@echo \#endif >> "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/f77blas.h"
-
-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"
-endif
-
-ifneq ($(OSNAME), AIX)
-ifndef NO_LAPACKE
-	@echo Copying LAPACKE header files to $(DESTDIR)$(OPENBLAS_INCLUDE_DIR)
-	@-install -pm644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapack.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapack.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 -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 -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))
-	@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)"
-	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
-	ln -fs $(LIBDYNNAME) $(LIBPREFIX).dylib ; \
-	ln -fs $(LIBDYNNAME) $(LIBPREFIX).$(MAJOR_VERSION).dylib
-endif
-ifeq ($(OSNAME), WINNT)
-	@-cp $(LIBDLLNAME) "$(DESTDIR)$(OPENBLAS_BINARY_DIR)"
-	@-cp $(IMPLIBNAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
-endif
-ifeq ($(OSNAME), CYGWIN_NT)
-	@-cp $(LIBDLLNAME) "$(DESTDIR)$(OPENBLAS_BINARY_DIR)"
-	@-cp $(IMPLIBNAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
-endif
-endif
-
-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"
-	@-installbsd -c -m 644 $(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)
-	@installbsd -c -m 644 $(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)
-	@installbsd -c -m 755 $(LIBSONAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
-	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
-	ln -fs $(LIBSONAME) $(LIBPREFIX).so ; \
-	ln -fs $(LIBSONAME) $(LIBPREFIX).so.$(MAJOR_VERSION)
-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"
-
-
-#Generating OpenBLASConfig.cmake
-	@echo Generating $(OPENBLAS_CMAKE_CONFIG) in $(DESTDIR)$(OPENBLAS_CMAKE_DIR)
-	@echo "SET(OpenBLAS_VERSION \"${VERSION}\")" > "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-	@echo "SET(OpenBLAS_INCLUDE_DIRS ${OPENBLAS_INCLUDE_DIR})" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-
-ifneq ($(NO_SHARED),1)
-#ifeq logical or
-ifeq ($(OSNAME), $(filter $(OSNAME),Linux FreeBSD NetBSD OpenBSD DragonFly))
-	@echo "SET(OpenBLAS_LIBRARIES ${OPENBLAS_LIBRARY_DIR}/$(LIBPREFIX).so)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-endif
-ifeq ($(OSNAME), $(filter $(OSNAME),WINNT CYGWIN_NT))
-	@echo "SET(OpenBLAS_LIBRARIES ${OPENBLAS_BINARY_DIR}/$(LIBDLLNAME))" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-endif
-ifeq ($(OSNAME), Darwin)
-	@echo "SET(OpenBLAS_LIBRARIES ${OPENBLAS_LIBRARY_DIR}/$(LIBPREFIX).dylib)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-endif
-else
-#only static
-	@echo "SET(OpenBLAS_LIBRARIES ${OPENBLAS_LIBRARY_DIR}/$(LIBPREFIX).$(LIBSUFFIX))" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-endif
-#Generating OpenBLASConfigVersion.cmake
-	@echo Generating $(OPENBLAS_CMAKE_CONFIG_VERSION) in $(DESTDIR)$(OPENBLAS_CMAKE_DIR)
-	@echo "set (PACKAGE_VERSION \"${VERSION}\")" > "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
-	@echo "if (PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
-	@echo "  set (PACKAGE_VERSION_COMPATIBLE FALSE)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
-	@echo "else ()" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
-	@echo "  set (PACKAGE_VERSION_COMPATIBLE TRUE)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
-	@echo "  if (PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
-	@echo "    set (PACKAGE_VERSION_EXACT TRUE)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
-	@echo "  endif ()" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
-	@echo "endif ()" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
-	@echo Install OK!

Makefile.mips

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

Makefile.mips64

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

Makefile.power

@@ -1,179 +0,0 @@
-
-ifdef USE_THREAD
-ifeq ($(USE_THREAD), 0)
-USE_OPENMP = 0
-else
-USE_OPENMP = 1
-endif
-else
-USE_OPENMP = 1
-endif
-
-ifeq ($(CORE), POWER10)
-ifneq ($(C_COMPILER), PGI)
-CCOMMON_OPT += -Ofast -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math
-FCOMMON_OPT += -O2 -frecursive -mcpu=power10 -mtune=power10  -fno-fast-math
-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 
-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)
-FCOMMON_OPT += -O2 -frecursive -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)
-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
-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)
-FCOMMON_OPT += -O1 -frecursive -mcpu=power8 -mtune=power8  -fno-fast-math 
-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
-else
-CCOMMON_OPT += -DUSE_OPENMP -mp
-endif
-ifneq ($(F_COMPILER), PGI)
-FCOMMON_OPT += -DUSE_OPENMP -fopenmp
-else
-FCOMMON_OPT += -DUSE_OPENMP -mp
-endif
-endif
-
-# workaround for C->FORTRAN ABI violation in LAPACKE
-ifeq ($(F_COMPILER), GFORTRAN)
-FCOMMON_OPT += -fno-optimize-sibling-calls
-endif
-
-FLAMEPATH	= $(HOME)/flame/lib
-
-#ifeq ($(CORE), CELL)
-#CELL_SDK_ROOT = /opt/IBM/cell-sdk-1.1/sysroot/usr
-#SPU_CC	         = spu-gcc
-#EXTRALIB	+= -lspe
-#endif
-
-ifeq ($(OSNAME), Linux)
-ifdef BINARY64
-# COMPILER_PREFIX = powerpc64-linux-
-else
-# COMPILER_PREFIX = powerpc-linux-
-endif
-endif
-
-#Either uncomment below line or run make with `USE_MASS=1` to enable support of MASS library
-#USE_MASS = 1
-
-ifeq ($(USE_MASS), 1)
-# Path to MASS libs, change it if the libs are installed at any other location
-MASSPATH        = /opt/ibm/xlmass/8.1.5/lib
-COMMON_OPT     += -mveclibabi=mass -ftree-vectorize -funsafe-math-optimizations -DUSE_MASS
-EXTRALIB       += -L$(MASSPATH) -lmass -lmassvp8 -lmass_simdp8
-endif
-
-ifdef BINARY64
-
-
-ifeq ($(OSNAME), AIX)
-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
-ARFLAGS		= -X 64
-ASFLAGS		= -a64
-endif
-else
-ifeq ($(OSNAME), AIX)
-CCOMMON_OPT	+= -Wa,-a32
-ARFLAGS		= -X 32
-ASFLAGS		= -a32
-endif
-endif
-
-# CCOMMON_OPT	+= -maltivec -mabi=altivec
-
-LIBFLAME	= -L$(FLAMEPATH) -llapack2flame -lflame-lapack -lflame-base $(LIBS)
-
-ifeq ($(OSNAME), Darwin)
-CCOMMON_OPT	+= -force_cpusubtype_ALL
-endif
-
-
-ifndef BINARY64
-ifeq ($(OSNAME), Linux)
-ESSLPATH = -L/opt/ibmcmp/lib -L/opt/ibmcmp/xlf/11.1/lib -Wl,-rpath,/opt/ibmcmp/lib -Wl,-rpath,/opt/ibmcmp/xlf/11.1/lib -lxlf90_r -lxlomp_ser -lxlfmath -lxl -lpthread
-else
-ESSLPATH = -lxlf90_r
-endif
-
-
-LIBVECLIB	= -framework VecLib
-ifndef SMP
-LIBATLAS	= -L/usr/lib/atlas3.7.11 -lf77blas -latlas -lg2c -lm
-LIBESSL		= -lessl $(ESSLPATH) ../../level1/others/libmisc.a -lm
-else
-LIBATLAS	= -L/usr/lib/atlas3.7.11p -lptf77blas -latlas -lm -lpthread
-LIBESSL		= -lesslsmp $(ESSLPATH)  ../../level1/others/libmisc.a -lm
-endif
-else
-ifeq ($(OSNAME), Linux)
-ESSLPATH = -L/opt/ibmcmp/lib64 -Wl,-rpath,/opt/ibmcmp/lib64 -L/opt/ibmcmp/xlf/11.1/lib64 -Wl,-rpath,/opt/ibmcmp/xlf/11.1/lib64 -lxlf90_r -lxlomp_ser
-else
-ESSLPATH = -lxlf90_r
-endif
-
-LIBVECLIB	= /System/Library/Frameworks/vecLib.framework/Versions/Current/vecLib
-
-ifndef SMP
-LIBATLAS	= -L/usr/lib64/atlas3.7.11  -lf77blas -latlas -lg2c -lm
-LIBESSL		= -lessl $(ESSLPATH) -lm
-else
-LIBATLAS	= -L/usr/lib64/atlas3.7.11p -lptf77blas -latlas -lm -lpthread
-LIBESSL		= -lesslsmp $(ESSLPATH) -lxlsmp -lm
-endif
-endif

Makefile.prebuild

@@ -1,79 +0,0 @@
-# This is triggered by Makefile.system and runs before any of the code is built.
-
-export BINARY
-export USE_OPENMP
-
-ifdef TARGET_CORE
-TARGET_MAKE = Makefile_kernel.conf
-TARGET_CONF = config_kernel.h
-else
-TARGET_MAKE = Makefile.conf
-TARGET_CONF = config.h
-endif
-
-# CPUIDEMU = ../../cpuid/table.o
-
-ifdef CPUIDEMU
-EXFLAGS = -DCPUIDEMU -DVENDOR=99
-endif
-
-ifeq ($(TARGET), MIPS24K)
-TARGET_FLAGS = -mips32r2
-endif
-
-ifeq ($(TARGET), MIPS1004K)
-TARGET_FLAGS = -mips32r2
-endif
-
-ifeq ($(TARGET), P5600)
-TARGET_FLAGS = -mips32r5
-endif
-
-ifeq ($(TARGET), I6400)
-TARGET_FLAGS = -mips64r6
-endif
-
-ifeq ($(TARGET), P6600)
-TARGET_FLAGS = -mips64r6
-endif
-
-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)
-ifneq ($(ONLY_CBLAS), 1)
-	perl ./f_check $(TARGET_MAKE) $(TARGET_CONF) $(FC) $(TARGET_FLAGS)
-else
-#When we only build CBLAS, we set NOFORTRAN=2
-	echo "NOFORTRAN=2" >> $(TARGET_MAKE)
-	echo "NO_FBLAS=1" >> $(TARGET_MAKE)
-	echo "F_COMPILER=GFORTRAN"  >> $(TARGET_MAKE)
-	echo "BU=_"  >> $(TARGET_MAKE)
-	echo "#define BUNDERSCORE _" >> $(TARGET_CONF)
-	echo "#define NEEDBUNDERSCORE 1" >> $(TARGET_CONF)
-endif
-	./getarch 0 >> $(TARGET_MAKE)
-	./getarch 1 >> $(TARGET_CONF)
-
-
-getarch : getarch.c cpuid.S dummy $(CPUIDEMU)
-	$(HOSTCC) $(HOST_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
-else
-	$(HOSTCC) -I. $(HOST_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

@@ -1,307 +0,0 @@
-#
-#  Beginning of user configuration
-#
-
-# This library's version
-VERSION = 0.3.14.dev
-
-# If you set the suffix, the library name will be libopenblas_$(LIBNAMESUFFIX).a
-# and libopenblas_$(LIBNAMESUFFIX).so. Meanwhile, the soname in shared library
-# is libopenblas_$(LIBNAMESUFFIX).so.0.
-# LIBNAMESUFFIX = omp
-
-# You can specify the target architecture, otherwise it's
-# automatically detected.
-# TARGET = PENRYN
-
-# If you want to support multiple architecture in one binary
-# DYNAMIC_ARCH = 1
-
-# If you want the full list of x86_64 architectures supported in DYNAMIC_ARCH
-# mode (including individual optimizied codes for PENRYN, DUNNINGTON, OPTERON,
-# OPTERON_SSE3, ATOM and NANO rather than fallbacks to older architectures)
-# DYNAMIC_OLDER = 1
-
-# C compiler including binary type(32bit / 64bit). Default is gcc.
-# Don't use Intel Compiler or PGI, it won't generate right codes as I expect.
-# CC = gcc
-
-# Fortran compiler. Default is g77.
-# FC = gfortran
-
-# Even you can specify cross compiler. Meanwhile, please set HOSTCC.
-
-# cross compiler for Windows
-# CC = x86_64-w64-mingw32-gcc
-# FC = x86_64-w64-mingw32-gfortran
-
-# cross compiler for 32bit ARM
-# CC = arm-linux-gnueabihf-gcc
-# FC = arm-linux-gnueabihf-gfortran
-
-# cross compiler for 64bit ARM
-# CC = aarch64-linux-gnu-gcc
-# FC = aarch64-linux-gnu-gfortran
-
-
-# If you use the cross compiler, please set this host compiler.
-# HOSTCC = gcc
-
-# If you need 32bit binary, define BINARY=32, otherwise define BINARY=64
-# Please note that AVX is not available on 32-bit.
-# Setting BINARY=32 disables AVX/AVX2/AVX-512.
-# BINARY=64
-
-# About threaded BLAS. It will be automatically detected if you don't
-# specify it.
-# For force setting for single threaded, specify USE_THREAD = 0
-# For force setting for multi  threaded, specify USE_THREAD = 1
-# USE_THREAD = 0
-
-# If you want to build a single-threaded OpenBLAS, but expect to call this
-# from several concurrent threads in some other program, comment this in for
-# thread safety. (This is done automatically for USE_THREAD=1 , and should not
-# be necessary when USE_OPENMP=1)
-# USE_LOCKING = 1
-
-# If you're going to use this library with OpenMP, please comment it in.
-# This flag is always set for POWER8. Don't set USE_OPENMP = 0 if you're targeting POWER8.
-# USE_OPENMP = 1
-
-# The OpenMP scheduler to use - by default this is "static" and you
-# will normally not want to change this unless you know that your main
-# workload will involve tasks that have highly unbalanced running times
-# for individual threads. Changing away from "static" may also adversely
-# affect memory access locality in NUMA systems. Setting to "runtime" will
-# allow you to select the scheduler from the environment variable OMP_SCHEDULE
-# CCOMMON_OPT += -DOMP_SCHED=dynamic
-
-# You can define the maximum number of threads. Basically it should be less
-# than or equal to the number of CPU threads. If you don't specify one, it's
-# automatically detected by the build system.
-# If SMT (aka. HT) is enabled on the system, it may or may not be beneficial to 
-# restrict NUM_THREADS to the number of physical cores. By default, the automatic 
-# detection includes logical CPUs, thus allowing the use of SMT.
-# Users may opt at runtime to use less than NUM_THREADS threads.
-#
-# Note for package maintainers: you can build OpenBLAS with a large NUM_THREADS
-# value (eg. 32-256) if you expect your users to use that many threads. Due to the way
-# some internal structures are allocated, using a large NUM_THREADS value has a RAM
-# footprint penalty, even if users reduce the actual number of threads at runtime.
-# NUM_THREADS = 24
-
-# If you have enabled USE_OPENMP and your application would call
-# OpenBLAS's calculation API from multiple threads, please comment this in.
-# This flag defines how many instances of OpenBLAS's calculation API can actually
-# run in parallel. If more than NUM_PARALLEL threads call OpenBLAS's calculation API,
-# 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
-
-# If you don't need to generate the shared library, please comment this in.
-# NO_SHARED = 1
-
-# If you don't need the CBLAS interface, please comment this in.
-# NO_CBLAS = 1
-
-# If you only want the CBLAS interface without installing a Fortran compiler,
-# please comment this in.
-# ONLY_CBLAS = 1
-
-# If you don't need LAPACK, please comment this in.
-# If you set NO_LAPACK=1, the build system automatically sets NO_LAPACKE=1.
-# NO_LAPACK = 1
-
-# If you don't need LAPACKE (C Interface to LAPACK), please comment this in.
-# NO_LAPACKE = 1
-
-# Build LAPACK Deprecated functions since LAPACK 3.6.0
-BUILD_LAPACK_DEPRECATED = 1
-
-# Build RecursiveLAPACK on top of LAPACK
-# BUILD_RELAPACK = 1
-
-# If you want to use the legacy threaded Level 3 implementation.
-# USE_SIMPLE_THREADED_LEVEL3 = 1
-
-# If you want to use the new, still somewhat experimental code that uses
-# thread-local storage instead of a central memory buffer in memory.c
-# Note that if your system uses GLIBC, it needs to have at least glibc 2.21
-# for this to work.
-# USE_TLS = 1
-
-# If you want to drive whole 64bit region by BLAS. Not all Fortran
-# compilers support this. It's safe to keep this commented out if you
-# are not sure. (This is equivalent to the "-i8" ifort option).
-# INTERFACE64 = 1
-
-# Unfortunately most of kernel won't give us high quality buffer.
-# BLAS tries to find the best region before entering main function,
-# but it will consume time. If you don't like it, you can disable one.
-NO_WARMUP = 1
-
-# Comment this in if you want to disable OpenBLAS's CPU/Memory affinity handling.
-# This feature is only implemented on Linux, and is always disabled on other platforms.
-# Enabling affinity handling may improve performance, especially on NUMA systems, but 
-# it may conflict with certain applications that also try to manage affinity.
-# This conflict can result in threads of the application calling OpenBLAS ending up locked
-# to the same core(s) as OpenBLAS, possibly binding all threads to a single core.
-# For this reason, affinity handling is disabled by default. Can be safely enabled if nothing
-# else modifies affinity settings.
-# Note: enabling affinity has been known to cause problems with NumPy and R
-NO_AFFINITY = 1
-
-# If you are compiling for Linux and you have more than 16 numa nodes or more than 256 cpus
-# BIGNUMA = 1
-
-# Don't use AVX kernel on Sandy Bridge. It is compatible with old compilers
-# and OS. However, the performance is low.
-# NO_AVX = 1
-
-# Don't use Haswell optimizations if binutils is too old (e.g. RHEL6)
-# NO_AVX2 = 1
-
-# Don't use SkylakeX optimizations if binutils or compiler are too old (the build
-# system will try to determine this automatically)
-# NO_AVX512 = 1
-
-# Don't use parallel make.
-# NO_PARALLEL_MAKE = 1
-
-# Force number of make jobs. The default is the number of logical CPU of the host.
-# This is particularly useful when using distcc.
-# A negative value will disable adding a -j flag to make, allowing to use a parent
-# make -j value. This is useful to call OpenBLAS make from an other project
-# makefile
-# MAKE_NB_JOBS = 2
-
-# If you would like to know minute performance report of GotoBLAS.
-# FUNCTION_PROFILE = 1
-
-# Support for IEEE quad precision(it's *real* REAL*16)( under testing)
-# This option should not be used - it is a holdover from unfinished code present
-# in the original GotoBLAS2 library that may be usable as a starting point but
-# is not even expected to compile in its present form.
-# QUAD_PRECISION = 1
-
-# Theads are still working for a while after finishing BLAS operation
-# to reduce thread activate/deactivate overhead. You can determine
-# time out to improve performance. This number should be from 4 to 30
-# which corresponds to (1 << n) cycles. For example, if you set to 26,
-# thread will be running for (1 << 26) cycles(about 25ms on 3.0GHz
-# system). Also you can control this number by THREAD_TIMEOUT
-# CCOMMON_OPT	+= -DTHREAD_TIMEOUT=26
-
-# Using special device driver for mapping physically contiguous memory
-# to the user space. If bigphysarea is enabled, it will use it.
-# DEVICEDRIVER_ALLOCATION = 1
-
-# If you need to synchronize FP CSR between threads (for x86/x86_64 only).
-# CONSISTENT_FPCSR = 1
-
-# If any gemm argument m, n or k is less or equal this threshold, gemm will be execute
-# with single thread. (Actually in recent versions this is a factor proportional to the
-# number of floating point operations necessary for the given problem size, no longer
-# an individual dimension). You can use this setting to avoid the overhead of multi-
-# threading in small matrix sizes. The default value is 4, but values as high as 50 have 
-# been reported to be optimal for certain workloads (50 is the recommended value for Julia).
-# GEMM_MULTITHREAD_THRESHOLD = 4
-
-# If you need sanity check by comparing results to reference BLAS. It'll be very
-# slow (Not implemented yet).
-# SANITY_CHECK = 1
-
-# The installation directory.
-# PREFIX = /opt/OpenBLAS
-
-# Common Optimization Flag;
-# The default -O2 is enough.
-# Flags for POWER8 are defined in Makefile.power. Don't modify COMMON_OPT
-# COMMON_OPT = -O2
-
-# gfortran option for LAPACK to improve thread-safety
-# It is enabled by default in Makefile.system for gfortran
-# Flags for POWER8 are defined in Makefile.power. Don't modify FCOMMON_OPT
-# FCOMMON_OPT = -frecursive
-
-# Profiling flags
-COMMON_PROF = -pg
-
-# Build Debug version
-# DEBUG = 1
-
-# Set maximum stack allocation.
-# The default value is 2048. 0 disable stack allocation a may reduce GER and GEMV
-# performance. For details, https://github.com/xianyi/OpenBLAS/pull/482
-#
-# MAX_STACK_ALLOC = 0
-
-# Add a prefix or suffix to all exported symbol names in the shared library.
-# Avoid conflicts with other BLAS libraries, especially when using
-# 64 bit integer interfaces in OpenBLAS.
-# For details, https://github.com/xianyi/OpenBLAS/pull/459
-#
-# The same prefix and suffix are also added to the library name,
-# i.e. you get lib$(SYMBOLPREFIX)openblas$(SYMBOLSUFFIX) rather than libopenblas
-#
-# SYMBOLPREFIX=
-# SYMBOLSUFFIX=
-
-# Run a C++ based thread safety tester after the build is done.
-# This is mostly intended as a developer feature to spot regressions, but users and
-# package maintainers can enable this if they have doubts about the thread safety of
-# the library, given the configuration in this file.
-# By default, the thread safety tester launches 52 concurrent calculations at the same
-# time.
-#
-# Please note that the test uses ~1300 MiB of RAM for the DGEMM test.
-#
-# The test requires CBLAS to be built, a C++11 capable compiler and the presence of
-# an OpenMP implementation. If you are cross-compiling this test will probably not
-# 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

@@ -1,48 +0,0 @@
-CPP	= $(CC) -E
-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
-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)
-FCOMMON_OPT += -xarch=v8plusb
-endif
-
-endif
-
-LIBNAME		= $(LIBPREFIX).a
-
-ifndef SMP
-LIBCXML		= -L/opt/SUNWspro/lib/v9
-LIBATLAS	= -L$(HOME)/misc/lib -lf77blas -latlas -lm
-else
-LIBCXML		= -lcxmlp -lots -lm
-endif
-ifdef BINARY64
-LIBSUNPERF	= -L/opt/SUNWspro/lib/v9 -L/opt/SUNWspro/prod/lib/v9 \
-		-Wl,-R,/opt/SUNWspro/lib/v9 -lsunperf -lompstubs -lfui -lfsu -lsunmath
-else
-LIBSUNPERF	= -L/opt/SUNWspro/lib -L/opt/SUNWspro/prod/lib \
-		-Wl,-R,/opt/SUNWspro/lib -lsunperf -lompstubs -lfui -lfsu -lsunmath
-endif

Makefile.tail

@@ -1,624 +0,0 @@
-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)
-
-ifdef EXPRECISION
-BLASOBJS   += $(QBLASOBJS)   $(XBLASOBJS)
-BLASOBJS_P += $(QBLASOBJS_P) $(XBLASOBJS_P)
-endif
-
-ifdef QUAD_PRECISION
-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) $^
-
-prof    :: $(BLASOBJS_P) $(COMMONOBJS_P)
-	$(AR) $(ARFLAGS) -ru $(TOPDIR)/$(LIBNAME_P) $^
-
-hpl	:: $(HPLOBJS) $(COMMONOBJS)
-	$(AR) $(ARFLAGS) -ru $(TOPDIR)/$(LIBNAME) $^
-
-hpl_p	:: $(HPLOBJS_P) $(COMMONOBJS_P)
-	$(AR) $(ARFLAGS) -ru $(TOPDIR)/$(LIBNAME_P) $^
-
-kernel :: $(BLASOBJS)
-	$(AR) $(ARFLAGS) -ru $(TOPDIR)/$(LIBNAME) $^
-
-commonlibs :: $(COMMONOBJS)
-	$(AR) $(ARFLAGS) -ru $(TOPDIR)/$(LIBNAME) $^
-
-commonprof :: $(COMMONOBJS_P)
-	$(AR) $(ARFLAGS) -ru $(TOPDIR)/$(LIBNAME_P) $^
-
-quick :
-	  $(MAKE) -C $(TOPDIR) libs
-
-bms.$(SUFFIX):bm.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -UDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-bmd.$(SUFFIX):bm.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-bmd-k.$(SUFFIX):bm-k.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-ifdef QUAD_PRECISION
-bmq.$(SUFFIX):bmq.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DXDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-bmx.$(SUFFIX):bmx.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DXDOUBLE -DCOMPLEX -c $< -o $(@F)
-else
-bmq.$(SUFFIX):bm.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DXDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-bmx.$(SUFFIX):bmz.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DXDOUBLE -DCOMPLEX -c $< -o $(@F)
-endif
-
-bmc.$(SUFFIX):bmz.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -UDOUBLE -DCOMPLEX -c $< -o $(@F)
-
-bmz.$(SUFFIX):bmz.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DDOUBLE -DCOMPLEX -c $< -o $(@F)
-
-bmd_nn.$(SUFFIX):bm_special.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DDOUBLE -UCOMPLEX -DNN -c $< -o $(@F)
-
-bmd_nt.$(SUFFIX):bm_special.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DDOUBLE -UCOMPLEX -DNT -c $< -o $(@F)
-
-bmd_tn.$(SUFFIX):bm_special.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DDOUBLE -UCOMPLEX -DTN -c $< -o $(@F)
-
-bmd_tt.$(SUFFIX):bm_special.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DDOUBLE -UCOMPLEX -DTT -c $< -o $(@F)
-
-bm-phy.$(SUFFIX):bm-phy.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-bms.$(PSUFFIX):bm.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(PFLAGS) -UDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-bmd.$(PSUFFIX):bm.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(PFLAGS) -DDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-ifdef QUAD_PRECISION
-bmq.$(PSUFFIX):bmq.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(PFLAGS) -DXDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-bmx.$(PSUFFIX):bmx.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(PFLAGS) -DXDOUBLE -DCOMPLEX -c $< -o $(@F)
-else
-bmq.$(PSUFFIX):bm.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(PFLAGS) -DXDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-bmx.$(PSUFFIX):bmz.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(PFLAGS) -DXDOUBLE -DCOMPLEX -c $< -o $(@F)
-endif
-
-bmc.$(PSUFFIX):bmz.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(PFLAGS) -UDOUBLE -DCOMPLEX -c $< -o $(@F)
-
-bmz.$(PSUFFIX):bmz.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(PFLAGS) -DDOUBLE -DCOMPLEX -c $< -o $(@F)
-
-bms : bms.$(SUFFIX) $(SBLASOBJS) $(COMMONOBJS) $(SOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmd : bmd.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(DOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB) -lm
-
-bmd-k : bmd-k.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(DOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB) -lm
-
-bmq : bmq.$(SUFFIX) $(QBLASOBJS) $(COMMONOBJS) $(QOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmc : bmc.$(SUFFIX) $(CBLASOBJS) $(COMMONOBJS) $(COBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB) $(FEXTRALIB)
-
-bmz : bmz.$(SUFFIX) $(ZBLASOBJS) $(COMMONOBJS) $(ZOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmx : bmx.$(SUFFIX) $(XBLASOBJS) $(COMMONOBJS) $(XOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmd_nn : bmd_nn.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(DOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmd_nt : bmd_nt.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(DOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmd_tn : bmd_tn.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(DOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmd_tt : bmd_tt.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(DOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bm-phy:bm-phy.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(DOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmcc	: bmcc.$(SUFFIX) $(CBLASOBJS) $(COMMONOBJS) $(COBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmzc	: bmzc.$(SUFFIX) $(ZBLASOBJS) $(COMMONOBJS) $(ZOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bms.prof : bms.$(PSUFFIX) $(SBLASOBJS_P) $(COMMONOBJS_P) $(SOBJS) $(OBJS) $(LIBS_P)
-	$(CC) -o $(@F) $(PFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmd.prof : bmd.$(PSUFFIX) $(DBLASOBJS_P) $(COMMONOBJS_P) $(DOBJS) $(OBJS) $(LIBS_P)
-	$(CC) -o $(@F) $(PFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmq.prof : bmq.$(PSUFFIX) $(QBLASOBJS_P) $(COMMONOBJS_P) $(QOBJS) $(OBJS) $(LIBS_P)
-	$(CC) -o $(@F) $(PFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmc.prof : bmc.$(PSUFFIX) $(CBLASOBJS_P) $(COMMONOBJS) $(COBJS) $(OBJS) $(LIBS_P)
-	$(CC) -o $(@F) $(PFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmz.prof : bmz.$(PSUFFIX) $(ZBLASOBJS_P) $(COMMONOBJS) $(ZOBJS) $(OBJS) $(LIBS_P)
-	$(CC) -o $(@F) $(PFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bmx.prof : bmz.$(PSUFFIX) $(XBLASOBJS_P) $(COMMONOBJS) $(XOBJS) $(OBJS) $(LIBS_P)
-	$(CC) -o $(@F) $(PFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-bms.cxml : bms.$(SUFFIX) $(SOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBCXML)
-
-bmd.cxml : bmd.$(SUFFIX) $(DOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBCXML)
-
-bmc.cxml : bmc.$(SUFFIX) $(COBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBCXML)
-
-bmz.cxml : bmz.$(SUFFIX) $(ZOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBCXML)
-
-bms.scsl : bms.$(SUFFIX) $(SOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBSCSL)
-
-bmd.scsl : bmd.$(SUFFIX) $(DOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBSCSL)
-
-bmc.scsl : bmc.$(SUFFIX) $(COBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBSCSL)
-
-bmz.scsl : bmz.$(SUFFIX) $(ZOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBSCSL)
-
-bms.acml : bms.$(SUFFIX) $(SOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBACML)
-
-bmd.acml : bmd.$(SUFFIX) $(DOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBACML)
-
-bmc.acml : bmc.$(SUFFIX) $(COBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBACML)
-
-bmz.acml : bmz.$(SUFFIX) $(ZOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBACML)
-
-bms.sun : bms.$(SUFFIX) $(SOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBSUNPERF) $(EXTRALIB) $(CEXTRALIB)
-
-bmd.sun : bmd.$(SUFFIX) $(DOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBSUNPERF) $(EXTRALIB) $(CEXTRALIB)
-
-bmc.sun : bmc.$(SUFFIX) $(COBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBSUNPERF) $(EXTRALIB) $(CEXTRALIB)
-
-bmz.sun : bmz.$(SUFFIX) $(ZOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBSUNPERF) $(EXTRALIB) $(CEXTRALIB)
-
-bms.atlas : bms.$(SUFFIX) $(SOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBATLAS)
-
-bmd.atlas : bmd.$(SUFFIX) $(DOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBATLAS)
-
-bmc.atlas : bmc.$(SUFFIX) $(COBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBATLAS)
-
-bmz.atlas : bmz.$(SUFFIX) $(ZOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBATLAS)
-
-bms.essl : bms.$(SUFFIX) $(SOBJS) $(OBJS)
-	$(CC) $(FCOMMON_OPT) -o $(@F) $^  $(LIBESSL)
-
-bmd.essl : bmd.$(SUFFIX) $(DOBJS) $(OBJS)
-	$(CC) $(CCOMMON_OPT) -o $(@F) $^  $(LIBESSL)
-
-bmc.essl : bmc.$(SUFFIX) $(COBJS) $(OBJS)
-	$(F77) $(CCOMMON_OPT) -o $(@F) $^  $(LIBESSL)
-
-bmz.essl : bmz.$(SUFFIX) $(ZOBJS) $(OBJS)
-	$(CC) $(CCOMMON_OPT) -o $(@F) $^  $(LIBESSL)
-
-bms.flame : bms.$(SUFFIX) $(SOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBFLAME)
-
-bmd.flame : bmd.$(SUFFIX) $(DOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBFLAME)
-
-bmc.flame : bmc.$(SUFFIX) $(COBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBFLAME)
-
-bmz.flame : bmz.$(SUFFIX) $(ZOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBFLAME)
-
-bms.flame.prof : bms.$(SUFFIX) $(SOBJS) $(OBJS_P)
-	$(F77) -o $(@F) $(PFLAGS) $^  $(LIBFLAME)
-
-bmd.flame.prof : bmd.$(SUFFIX) $(DOBJS) $(OBJS_P)
-	$(F77) -o $(@F) $(PFLAGS) $^  $(LIBFLAME)
-
-bmc.flame.prof : bmc.$(SUFFIX) $(COBJS) $(OBJS_P)
-	$(F77) -o $(@F) $(PFLAGS) $^  $(LIBFLAME)
-
-bmz.flame.prof : bmz.$(SUFFIX) $(ZOBJS) $(OBJS_P)
-	$(F77) -o $(@F) $(PFLAGS) $^  $(LIBFLAME)
-
-bms.mkl : bms.$(SUFFIX) $(SOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBMKL) $(EXTRALIB) $(CEXTRALIB)
-
-bmd.mkl : bmd.$(SUFFIX) $(DOBJS) $(OBJS)
-	$(CC) -static -o $(@F) $(CFLAGS) $^  $(LIBMKL) $(EXTRALIB) $(CEXTRALIB)
-
-bmc.mkl : bmc.$(SUFFIX) $(COBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBMKL) $(EXTRALIB) $(CEXTRALIB)
-
-bmz.mkl : bmz.$(SUFFIX) $(ZOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBMKL) $(EXTRALIB) $(CEXTRALIB)
-
-bmq.mkl : bmq.$(SUFFIX) $(QOBJS) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBMKL)  $(EXTRALIB) $(CEXTRALIB)
-
-bms.mkl.prof : bms.$(PSUFFIX) $(SOBJS) $(OBJS)
-	$(CC) -o $(@F) $(PFLAGS) $^  $(LIBMKL)
-
-bmd.mkl.prof : bmd.$(PSUFFIX) $(DOBJS) $(OBJS)
-	$(CC) -o $(@F) $(PFLAGS) $^  $(LIBMKL)
-
-bmc.mkl.prof : bmc.$(PSUFFIX) $(COBJS) $(OBJS)
-	$(CC) -o $(@F) $(PFLAGS) $^  $(LIBMKL)
-
-bmz.mkl.prof : bmz.$(PSUFFIX) $(ZOBJS) $(OBJS)
-	$(CC) -o $(@F) $(PFLAGS) $^  $(LIBMKL)
-
-bms.mlib : bms.$(SUFFIX) $(SOBJS) $(OBJS)
-	$(F77) -o $(@F) $(CFLAGS) $^  $(LIBMLIB)
-
-bmd.mlib : bmd.$(SUFFIX) $(DOBJS) $(OBJS)
-	$(F77) -o $(@F) $(CFLAGS) $^  $(LIBMLIB)
-
-bmc.mlib : bmc.$(SUFFIX) $(COBJS) $(OBJS)
-	$(F77) -o $(@F) $(CFLAGS) $^  $(LIBMLIB)
-
-bmz.mlib : bmz.$(SUFFIX) $(ZOBJS) $(OBJS)
-	$(F77) -o $(@F) $(CFLAGS) $^  $(LIBMLIB)
-
-bms.veclib : bms.$(SUFFIX) $(SOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBVECLIB)
-
-bmd.veclib : bmd.$(SUFFIX) $(DOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBVECLIB)
-
-bmc.veclib : bmc.$(SUFFIX) $(COBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBVECLIB)
-
-bmz.veclib : bmz.$(SUFFIX) $(ZOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBVECLIB)
-
-bms.fuji : bms.$(SUFFIX) $(SOBJS)
-ifndef SMP
-	fcc -KV9FMADD -SSL2 -o $(@F) $^
-else
-	fcc -KV9FMADD -SSL2BLAMP -o $(@F) $^
-endif
-
-bmd.fuji : bmd.$(SUFFIX) $(DOBJS)
-ifndef SMP
-	fcc -KV9FMADD -SSL2 -o $(@F) $^
-else
-	fcc -KV9FMADD -SSL2BLAMP -o $(@F) $^
-endif
-
-bmc.fuji : bmc.$(SUFFIX) $(COBJS)
-ifndef SMP
-	fcc -KV9FMADD -SSL2 -o $(@F) $^
-else
-	fcc -KV9FMADD -SSL2BLAMP -o $(@F) $^
-endif
-
-bmz.fuji : bmz.$(SUFFIX) $(ZOBJS)
-ifndef SMP
-	fcc -KV9FMADD -SSL2 -o $(@F) $^
-else
-	fcc -KV9FMADD -SSL2BLAMP -o $(@F) $^
-endif
-
-bench: bench.$(SUFFIX)  $(BLASOBJS) $(COMMONOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(EXTRALIB) $(CEXTRALIB)
-
-bench.$(SUFFIX): bench.c
-	$(CC) -c -o $(@F) $(CFLAGS) $^
-
-bench_old: bench_old.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(EXTRALIB) $(CEXTRALIB)
-
-kbench: kbench.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(EXTRALIB) $(CEXTRALIB)
-
-prebench: prebench.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(EXTRALIB) $(CEXTRALIB)
-
-kbench_rank_k: kbench_rank_k.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(EXTRALIB) $(CEXTRALIB)
-
-smallbench: smallbench.$(SUFFIX)  $(BLASOBJS) $(COMMONOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(EXTRALIB) $(CEXTRALIB)
-
-smallbench.mkl: smallbench.$(SUFFIX)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBMKL) $(EXTRALIB) $(CEXTRALIB)
-
-bench.sun: bench.$(SUFFIX) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBSUNPERF) $(EXTRALIB) $(CEXTRALIB)
-
-bench.cxml: bench.$(SUFFIX) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBCXML)
-
-bench.atlas: bench.$(SUFFIX) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBATLAS)
-
-bench.essl: bench.$(SUFFIX) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBESSL) ../../level1/others/libmisc.$(LIBSUFFIX)
-
-bench.scsl: bench.$(SUFFIX) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBSCSL)  $(EXTRALIB) $(CEXTRALIB)
-
-bench.acml: bench.$(SUFFIX) $(OBJS)
-	$(CC) -static -o $(@F) $(CFLAGS) $^  $(LIBACML)  $(EXTRALIB) $(CEXTRALIB)
-
-bench.flame: bench.$(SUFFIX) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBFLAME)  $(EXTRALIB) $(CEXTRALIB)
-
-kbench.mkl: kbench.$(SUFFIX) $(OBJS)
-	$(CC) -static -o $(@F) $(CFLAGS) $^  $(LIBMKL) $(EXTRALIB) $(CEXTRALIB)
-
-bench.mkl: bench.$(SUFFIX) $(OBJS)
-	$(CC) -static -o $(@F) $(CFLAGS) $^  $(LIBMKL) $(EXTRALIB) $(CEXTRALIB)
-
-bench_old.mkl: bench_old.$(SUFFIX) $(OBJS)
-	$(CC) -static -o $(@F) $(CFLAGS) $^  $(LIBMKL) $(EXTRALIB) $(CEXTRALIB)
-
-bench.mlib: bench.$(SUFFIX) $(OBJS)
-	$(F77) -o $(@F) $(CFLAGS) $^  $(LIBMLIB)
-
-bench.veclib: bench.$(SUFFIX) $(OBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^  $(LIBVECLIB)
-
-params : params.$(SUFFIX) $(SBLASOBJS) $(COMMONOBJS) $(SOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-paramd : paramd.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(DOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-paramq : paramq.$(SUFFIX) $(QBLASOBJS) $(COMMONOBJS) $(QOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-paramc : paramc.$(SUFFIX) $(CBLASOBJS) $(COMMONOBJS) $(COBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-paramz : paramz.$(SUFFIX) $(ZBLASOBJS) $(COMMONOBJS) $(ZOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-paramx : paramx.$(SUFFIX) $(XBLASOBJS) $(COMMONOBJS) $(XOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-params-ex : params-ex.$(SUFFIX) $(SBLASOBJS) $(COMMONOBJS) $(SOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-paramd-ex : paramd-ex.$(SUFFIX) $(DBLASOBJS) $(COMMONOBJS) $(DOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-paramq-ex : paramq-ex.$(SUFFIX) $(QBLASOBJS) $(COMMONOBJS) $(QOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-paramc-ex : paramc-ex.$(SUFFIX) $(CBLASOBJS) $(COMMONOBJS) $(COBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-paramz-ex : paramz-ex.$(SUFFIX) $(ZBLASOBJS) $(COMMONOBJS) $(ZOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-paramx-ex : paramx-ex.$(SUFFIX) $(XBLASOBJS) $(COMMONOBJS) $(XOBJS) $(OBJS) $(LIBS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(EXTRALIB) $(CEXTRALIB)
-
-params.atlas : params.$(SUFFIX) $(OBJS) $(SOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBATLAS)
-
-paramd.atlas : paramd.$(SUFFIX) $(OBJS) $(DOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBATLAS)
-
-paramc.atlas : paramc.$(SUFFIX) $(OBJS) $(COBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBATLAS)
-
-paramz.atlas : paramz.$(SUFFIX) $(OBJS) $(ZOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBATLAS)
-
-params.sun : params.$(SUFFIX) $(OBJS) $(SOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBSUNPERF)
-
-paramd.sun : paramd.$(SUFFIX) $(OBJS) $(DOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBSUNPERF)
-
-paramc.sun : paramc.$(SUFFIX) $(OBJS) $(COBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBSUNPERF)
-
-paramz.sun : paramz.$(SUFFIX) $(OBJS) $(ZOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBSUNPERF)
-
-params.essl : params.$(SUFFIX) $(OBJS) $(SOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBESSL)
-
-paramd.essl : paramd.$(SUFFIX) $(OBJS) $(DOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBESSL)
-
-paramc.essl : paramc.$(SUFFIX) $(OBJS) $(COBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBESSL)
-
-paramz.essl : paramz.$(SUFFIX) $(OBJS) $(ZOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBESSL)
-
-params.mkl : params.$(SUFFIX) $(OBJS) $(SOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBMKL)
-
-paramd.mkl : paramd.$(SUFFIX) $(OBJS) $(DOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBMKL)
-
-paramc.mkl : paramc.$(SUFFIX) $(OBJS) $(COBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBMKL)
-
-paramz.mkl : paramz.$(SUFFIX) $(OBJS) $(ZOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBMKL)
-
-params.acml : params.$(SUFFIX) $(OBJS) $(SOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBACML)
-
-paramd.acml : paramd.$(SUFFIX) $(OBJS) $(DOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBACML)
-
-paramc.acml : paramc.$(SUFFIX) $(OBJS) $(COBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBACML)
-
-paramz.acml : paramz.$(SUFFIX) $(OBJS) $(ZOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBACML)
-
-params.flame : params.$(SUFFIX) $(OBJS) $(SOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBFLAME) $(EXTRALIB) $(CEXTRALIB)
-
-paramd.flame : paramd.$(SUFFIX) $(OBJS) $(DOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBFLAME) $(EXTRALIB) $(CEXTRALIB)
-
-paramc.flame : paramc.$(SUFFIX) $(OBJS) $(COBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBFLAME) $(EXTRALIB) $(CEXTRALIB)
-
-paramz.flame : paramz.$(SUFFIX) $(OBJS) $(ZOBJS)
-	$(CC) -o $(@F) $(CFLAGS) $^ $(LIBFLAME) $(EXTRALIB) $(CEXTRALIB)
-
-params.$(SUFFIX):param.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -UDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-paramd.$(SUFFIX):param.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-paramq.$(SUFFIX):param.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DXDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-paramc.$(SUFFIX):paramz.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -UDOUBLE -DCOMPLEX -c $< -o $(@F)
-
-paramz.$(SUFFIX):paramz.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DDOUBLE -DCOMPLEX -c $< -o $(@F)
-
-paramx.$(SUFFIX):paramz.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DXDOUBLE -DCOMPLEX -c $< -o $(@F)
-
-params-ex.$(SUFFIX):param-ex.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -UDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-paramd-ex.$(SUFFIX):param-ex.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-paramq-ex.$(SUFFIX):param-ex.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DXDOUBLE -UCOMPLEX -c $< -o $(@F)
-
-paramc-ex.$(SUFFIX):paramz-ex.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -UDOUBLE -DCOMPLEX -c $< -o $(@F)
-
-paramz-ex.$(SUFFIX):paramz-ex.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DDOUBLE -DCOMPLEX -c $< -o $(@F)
-
-paramx-ex.$(SUFFIX):paramz-ex.c $(TOPDIR)/../bench/bmcommon.h
-	$(CC) $(CFLAGS) -DXDOUBLE -DCOMPLEX -c $< -o $(@F)
-
-gen_insn_flash.c :
-	echo '#include <stdio.h>'			>  gen_insn_flash.c
-	echo '#include <stdlib.h>'			>> gen_insn_flash.c
-	echo '#define ICACHE_SIZE ( 256 << 10)'		>> gen_insn_flash.c
-	echo 'int main(void){'				>> gen_insn_flash.c
-	echo 'int i;'					>> gen_insn_flash.c
-	echo '#ifdef __alpha'				>> gen_insn_flash.c
-	echo 'printf(".set noat;.set noreorder;\n");'	>> gen_insn_flash.c
-	echo 'printf(".arch ev6;.text;.align 5\n");'	>> gen_insn_flash.c
-	echo 'printf(".globl insn_flash\n");'		>> gen_insn_flash.c
-	echo 'printf(".ent insn_flash\n");'		>> gen_insn_flash.c
-	echo 'printf("insn_flash:\n");'			>> gen_insn_flash.c
-	echo 'for (i = 0; i < ICACHE_SIZE / 4; i++)'	>> gen_insn_flash.c
-	echo 'printf("br 1f\n 1:\n");'			>> gen_insn_flash.c
-	echo 'printf(".align 5;ret;.end insn_flash\n");'>> gen_insn_flash.c
-	echo '#else'					>> gen_insn_flash.c
-	echo 'printf(".text;.align 32\n");'		>> gen_insn_flash.c
-	echo 'printf(".globl insn_flash\n");'		>> gen_insn_flash.c
-	echo 'printf("insn_flash:\n");'			>> gen_insn_flash.c
-	echo 'for (i = 0; i < ICACHE_SIZE / 2; i++)'	>> gen_insn_flash.c
-	echo 'printf("jmp 1f\n 1:\n");'			>> gen_insn_flash.c
-	echo 'printf(".align 32;ret\n");'		>> gen_insn_flash.c
-	echo '#endif'					>> gen_insn_flash.c
-	echo 'return 0;'				>> gen_insn_flash.c
-	echo '}'					>> gen_insn_flash.c
-
-insn_flash.$(SUFFIX) : gen_insn_flash
-	./gen_insn_flash > temp.s
-	$(AS) -o $(@F) temp.s
-	rm -f temp.s
-
-dummy :
-
-clean ::
-	@if test -d $(ARCH); then \
-	(cd $(ARCH) && $(MAKE) clean) \
-	fi
-	@find . -name '*.o' | xargs rm -rf
-	@rm -rf *.a *.s *.po *.obj *.i *.so core core.* gmon.out *.cso \
-	*.csx *.is *~ *.exe *.flame *.pdb *.dwf \
-	gen_insn_flash.c gen_insn_flash *.stackdump *.dll *.exp *.lib \
-	*.pc *.pcl *.def *.i *.prof linktest.c \
-	bms bmd bmc bmz bmq bmx \
-	params paramd paramc paramz paramq paramx \
-	params-ex paramd-ex paramc-ex paramz-ex paramq-ex paramx-ex \
-	bench tpp kbench kbench2 \
-	*.mkl *.sun *.acml *.cxml *.essl *.atlas *.scsl *.mlib *.veclib *.fuji

Makefile.x86

@@ -1,78 +0,0 @@
-# COMPILER_PREFIX = mingw32-
-
-ifdef HAVE_SSE
-CCOMMON_OPT += -msse
-FCOMMON_OPT += -msse
-endif
-
-
-ifeq ($(OSNAME), Interix)
-ARFLAGS		= -m x86
-endif
-
-ifndef SMP
-LIBMKL		= -L$(MKLPATH)/32 -Wl,-rpath,$(MKLPATH)/32 -lmkl_intel -lmkl_sequential -lmkl_core -lguide -lpthread -lm
-else
-LIBMKL		= -L$(MKLPATH)/32 -Wl,-rpath,$(MKLPATH)/32 -lmkl_intel -lmkl_intel_thread -lmkl_core -lguide -lpthread -lm
-endif
-
-# LIBMKL		= -L$(MKLPATH)/32 -lmkl_lapack -lmkl_ia32 -lguide -lpthread -lm
-
-ifndef SMP
-LIBATLAS	= -L$(ATLAS) -lf77blas -latlas -lg2c -lm
-else
-LIBATLAS	= -L$(ATLAS) -lptf77blas -latlas -lpthread -lg2c -lm
-endif
-
-ifeq ($(COMPILER_F77), g77)
-LIBACML		= -L$(ACMLPATH)/gnu32/lib -Wl,-rpath,$(ACMLPATH)/gnu32/lib -lacml -lg2c
-endif
-
-LIBFLAME	= -L$(FLAMEPATH) -llapack2flame -lflame-lapack -lflame-base $(LIBS)
-
-ifeq ($(F_COMPILER), GFORTRAN)
-ifndef SMP
-LIBACML		= -L$(ACMLPATH)/gfortran32/lib -Wl,-rpath,$(ACMLPATH)/gfortran32/lib -lacml -lgfortran -lm
-else
-LIBACML		= -L$(ACMLPATH)/gfortran32_mp/lib -Wl,-rpath,$(ACMLPATH)/gfortran32_mp/lib -lacml_mp -lgfortran -lgomp -lm
-endif
-endif
-
-ifeq ($(COMPILER_F77), pgf77)
-LIBACML		= -L$(ACMLPATH)/pgi32/lib -lacml -L/opt/pgi/linux86-64/5.2/lib -lpgftnrtl -lnspgc -lpgc
-endif
-
-ifeq ($(F_COMPILER), PATHSCALE)
-ifndef SMP
-LIBACML		= -L$(ACMLPATH)/pathscale32/lib -Wl,-rpath,$(ACMLPATH)/pathscale32/lib -lacml -Wl,-rpath,$(PATHSCALEPATH) -L$(PATHSCALEPATH) -lpathfortran -lm
-else
-LIBACML		= -L$(ACMLPATH)/pathscale32_mp/lib -Wl,-rpath,$(ACMLPATH)/pathscale32_mp/lib -lacml_mp -Wl,-rpath,$(PATHSCALEPATH) -L$(PATHSCALEPATH) -lopenmp -lpathfortran -lm
-endif
-endif
-
-LIBSUNPERF	= -L/opt/SUNWspro/lib/sse2 -Wl,-R,/opt/SUNWspro/lib/sse2 -lsunperf
-
-LIBVECLIB	= /System/Library/Frameworks/vecLib.framework/Versions/Current/vecLib
-
-ifndef SMP
-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

@@ -1,203 +0,0 @@
-# CCOMMON_OPT	+= -DFASTCPU
-
-ifeq ($(OSNAME), SunOS)
-ifdef BINARY64
-ifeq ($(F_COMPILER), SUN)
-FCOMMON_OPT += -m64
-endif
-endif
-endif
-
-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 DYNAMIC_ARCH
-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
-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
-endif
-
-ifdef HAVE_AVX2
-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
-
-
-
-ifeq ($(OSNAME), Interix)
-ARFLAGS		= -m x64
-endif
-
-ifeq ($(OSNAME), Darwin)
-ifndef SMP
-LIBMKL		= -L$(MKLPATH)/em64t -Wl,-rpath,$(MKLPATH)/em64t -lmkl_intel_lp64 -lmkl_sequential -lmkl_core -lguide -lpthread -lm
-else
-LIBMKL		= -L$(MKLPATH)/em64t -Wl,-rpath,$(MKLPATH)/em64t -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -lguide -lpthread -lm
-endif
-else
-ifndef SMP
-LIBMKL		= -L$(MKLPATH)/em64t -Wl,-rpath,$(MKLPATH)/em64t -Wl,--start-group -lmkl_intel_lp64 -lmkl_sequential -lmkl_core -Wl,--end-group -lguide -lpthread -lm
-else
-LIBMKL		= -L$(MKLPATH)/em64t -Wl,-rpath,$(MKLPATH)/em64t -Wl,--start-group -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -Wl,--end-group -lguide -lpthread -lm
-endif
-endif
-
-
-ifndef SMP
-LIBATLAS	= -L$(ATLASPATH)64 -llapack -lcblas -lf77blas -latlas -lm
-else
-LIBATLAS	= -L$(ATLASPATH)64 -llapack -lptcblas -lptf77blas -latlas -lpthread -lm
-endif
-
-LIBFLAME	= -L$(FLAMEPATH) -llapack2flame -lflame $(TOPDIR)/$(LIBNAME) -lgfortran -lpthread -lm
-
-
-ifeq ($(F_COMPILER), g77)
-LIBACML		= -L$(ACMLPATH)/gnu64/lib -Wl,-rpath,$(ACMLPATH)/gnu64/lib -lacml -lacml_mv -lg2c -lm
-endif
-
-ifeq ($(F_COMPILER), GFORTRAN)
-ifndef SMP
-LIBACML		= -L$(ACMLPATH)/gfortran64/lib -Wl,-rpath,$(ACMLPATH)/gfortran64/lib -lacml -lacml_mv -lgfortran -lm
-else
-LIBACML		= -L$(ACMLPATH)/gfortran64_mp/lib -Wl,-rpath,$(ACMLPATH)/gfortran64_mp/lib -lacml_mp -lacml_mv -lgfortran -lgomp -lm
-endif
-endif
-
-ifeq ($(F_COMPILER), INTEL)
-ifndef SMP
-LIBACML		= -L$(ACMLPATH)/ifort64/lib -Wl,-rpath,$(ACMLPATH)/ifort64/lib -lacml -lacml_mv -lifcoremt_pic -lirc -lm -lpthread -ldl
-else
-LIBACML		= -L$(ACMLPATH)/ifort64_mp/lib -Wl,-rpath,$(ACMLPATH)/ifort64_mp/lib -lacml_mp -lacml_mv -lifcoremt_pic -liomp5 -lirc -lm -lpthread -ldl
-endif
-endif
-
-ifeq ($(F_COMPILER), OPEN64)
-ifndef SMP
-LIBACML		= -L$(ACMLPATH)/open64/lib -Wl,-rpath,$(ACMLPATH)/open64/lib -lacml -lacml_mv -lm
-else
-LIBACML		= -L$(ACMLPATH)/open64_mp/lib -Wl,-rpath,$(ACMLPATH)/open64_mp/lib -lacml_mp -lacml_mv -lm -lpthread
-endif
-endif
-
-ifeq ($(F_COMPILER), pgf77)
-ifndef SMP
-LIBACML		= -L$(ACMLPATH)/pgi64/lib    -Wl,-rpath,$(ACMLPATH)/pgi64/lib    -lacml -lacml_mv -L$(PGIPATH) -Wl,-rpath,$(PGIPATH) -lpgftnrtl -lnspgc -lpgmp -lpgc
-else
-LIBACML		= -L$(ACMLPATH)/pgi64_mp/lib -Wl,-rpath,$(ACMLPATH)/pgi64_mp/lib -lacml -lacml_mv -L$(PGIPATH) -Wl,-rpath,$(PGIPATH) -lpgftnrtl -lnspgc -lpgmp -lpgc
-endif
-endif
-
-ifeq ($(F_COMPILER), PATHSCALE)
-ifndef SMP
-LIBACML		= -L$(ACMLPATH)/pathscale64/lib -Wl,-rpath,$(ACMLPATH)/pathscale64/lib -lacml -lacml_mv -Wl,-rpath,$(PATHSCALEPATH) -L$(PATHSCALEPATH) -lpathfortran -lm
-else
-LIBACML		= -L$(ACMLPATH)/pathscale64_mp/lib -Wl,-rpath,$(ACMLPATH)/pathscale64_mp/lib -lacml_mp -lacml_mv -Wl,-rpath,$(PATHSCALEPATH) -L$(PATHSCALEPATH) -lopenmp -lpathfortran -lm
-endif
-endif
-
-ifeq ($(F_COMPILER), f90)
-LIBACML		= -L$(ACMLPATH)/sun64/lib -Wl,-R,$(ACMLPATH)/sun64/lib -L$(SUNPATH)/lib/amd64 -Wl,-R,$(SUNPATH)/lib/amd64 -lacml -lacml_mv -lfsu
-endif
-
-LIBSUNPERF	= -L$(SUNPATH)/lib/amd64 -L$(SUNPATH)/rtlibs/amd64 -Wl,-R,$(SUNPATH)/lib/amd64  -Wl,-R,$(SUNPATH)/rtlibs/amd64 -lsunperf -lfui -lfsu -lmtsk
-
-LIBVECLIB	= /System/Library/Frameworks/vecLib.framework/Versions/Current/vecLib

Makefile.zarch

@@ -1,16 +0,0 @@
-
-ifeq ($(CORE), Z13)
-CCOMMON_OPT += -march=z13 -mzvector
-FCOMMON_OPT += -march=z13 -mzvector
-endif
-
-ifeq ($(CORE), Z14)
-CCOMMON_OPT += -march=z14 -mzvector -O3
-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

@@ -1,292 +0,0 @@
-# OpenBLAS
-
-[![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.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.
-
-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/).
-
-## 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.
-
-### Dependencies
-
-Building OpenBLAS requires the following to be installed:
-
-* GNU Make
-* A C compiler, e.g. GCC or Clang
-* A Fortran compiler (optional, for LAPACK)
-* IBM MASS (optional, see below)
-
-### Normal compile
-
-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.
-
-### Cross compile
-
-Set `CC` and `FC` to point to the cross toolchains, and set `HOSTCC` to your host C compiler.
-The target must be specified explicitly when cross compiling.
-
-Examples:
-
-* On an x86 box, compile this library for a loongson3a CPU:
-  ```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
-  make CC=loongcc FC=loongf95 HOSTCC=gcc TARGET=LOONGSON3A CROSS=1 CROSS_SUFFIX=mips64el-st-linux-gnu-   NO_LAPACKE=1 NO_SHARED=1 BINARY=32
-  ```
-
-### Debug version
-
-A debug version can be built using `make DEBUG=1`.
-
-### Compile with MASS support on Power CPU (optional)
-
-The [IBM MASS](https://www.ibm.com/support/home/product/W511326D80541V01/other_software/mathematical_acceleration_subsystem) library consists of a set of mathematical functions for C, C++, and Fortran applications that are tuned for optimum performance on POWER architectures.
-OpenBLAS with MASS requires a 64-bit, little-endian OS on POWER.
-The library can be installed as shown:
-
-* On Ubuntu:
-  ```sh
-  wget -q http://public.dhe.ibm.com/software/server/POWER/Linux/xl-compiler/eval/ppc64le/ubuntu/public.gpg -O- | sudo apt-key add -
-  echo "deb http://public.dhe.ibm.com/software/server/POWER/Linux/xl-compiler/eval/ppc64le/ubuntu/ trusty main" | sudo tee /etc/apt/sources.list.d/ibm-xl-compiler-eval.list
-  sudo apt-get update
-  sudo apt-get install libxlmass-devel.8.1.5
-  ```
-
-* On RHEL/CentOS:
-  ```sh
-  wget http://public.dhe.ibm.com/software/server/POWER/Linux/xl-compiler/eval/ppc64le/rhel7/repodata/repomd.xml.key
-  sudo rpm --import repomd.xml.key
-  wget http://public.dhe.ibm.com/software/server/POWER/Linux/xl-compiler/eval/ppc64le/rhel7/ibm-xl-compiler-eval.repo
-  sudo cp ibm-xl-compiler-eval.repo /etc/yum.repos.d/
-  sudo yum install libxlmass-devel.8.1.5
-  ```
-
-After installing the MASS library, compile OpenBLAS with `USE_MASS=1`.
-For example, to compile on Power8 with MASS support: `make USE_MASS=1 TARGET=POWER8`.
-
-### Install to a specific directory (optional)
-
-Use `PREFIX=` when invoking `make`, for example
-
-```sh
-make install PREFIX=your_installation_directory
-```
-
-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.
-
-### Additional supported CPUs
-
-#### x86/x86-64
-
-- **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.
-- **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.
-- **ICT Loongson 3B**: Experimental
-
-#### ARM
-
-- **ARMv6**: Optimized BLAS for vfpv2 and vfpv3-d16 (e.g. BCM2835, Cortex M0+)
-- **ARMv7**: Optimized BLAS for vfpv3-d32 (e.g. Cortex A8, A9 and A15)
-
-#### ARM64
-
-- **ARMv8**: Basic ARMV8 with small caches, optimized Level-3 and Level-2 BLAS
-- **Cortex-A53**: 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
-
-#### 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 Leve-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
-  ```
-
-### 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.
-
-### 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.
-- **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
-
-Statically link with `libopenblas.a` or dynamically link with `-lopenblas` if OpenBLAS was
-compiled as a shared library.
-
-### Setting the number of threads using environment variables
-
-Environment variables are used to specify a maximum number of threads.
-For example,
-
-```sh
-export OPENBLAS_NUM_THREADS=4
-export GOTO_NUM_THREADS=4
-export OMP_NUM_THREADS=4
-```
-
-The priorities are `OPENBLAS_NUM_THREADS` > `GOTO_NUM_THREADS` > `OMP_NUM_THREADS`.
-
-If you compile this library with `USE_OPENMP=1`, you should set the `OMP_NUM_THREADS`
-environment variable; OpenBLAS ignores `OPENBLAS_NUM_THREADS` and `GOTO_NUM_THREADS` when
-compiled with `USE_OPENMP=1`.
-
-### Setting the number of threads at runtime
-
-We provide the following functions to control the number of threads at runtime:
-
-```c
-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
-
-Please submit an issue in https://github.com/xianyi/OpenBLAS/issues.
-
-## Contact
-
-* OpenBLAS users mailing list: https://groups.google.com/forum/#!forum/openblas-users
-* OpenBLAS developers mailing list: https://groups.google.com/forum/#!forum/openblas-dev
-
-## Change log
-
-Please see Changelog.txt to view the differences between OpenBLAS and GotoBLAS2 1.13 BSD version.
-
-## Troubleshooting
-
-* Please read the [FAQ](https://github.com/xianyi/OpenBLAS/wiki/Faq) first.
-* Please use GCC version 4.6 and above to compile Sandy Bridge AVX kernels on Linux/MinGW/BSD.
-* 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`),
-  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.
-  On Linux, you can enable processor affinity by commenting out the line `NO_AFFINITY=1` in
-  Makefile.rule. However, note that this may cause
-  [a conflict with R parallel](https://stat.ethz.ch/pipermail/r-sig-hpc/2012-April/001348.html).
-* On Loongson 3A, `make test` may fail with a `pthread_create` error (`EAGAIN`).
-  However, it will be okay when you run the same test case on the shell.
-
-## Contributing
-
-1. [Check for open issues](https://github.com/xianyi/OpenBLAS/issues) or open a fresh issue
-   to start a discussion around a feature idea or a bug.
-2. Fork the [OpenBLAS](https://github.com/xianyi/OpenBLAS) repository to start making your changes.
-3. Write a test which shows that the bug was fixed or that the feature works as expected.
-4. Send a pull request. Make sure to add yourself to `CONTRIBUTORS.md`.
-
-## Donation
-
-Please read [this wiki page](https://github.com/xianyi/OpenBLAS/wiki/Donation).

TargetList.txt

@@ -1,111 +0,0 @@
-Force Target Examples:
-
-make TARGET=NEHALEM
-make TARGET=LOONGSON3A BINARY=64
-make TARGET=ISTANBUL
-
-Supported List:
-1.X86/X86_64
-a)Intel CPU:
-P2
-KATMAI
-COPPERMINE
-NORTHWOOD
-PRESCOTT
-BANIAS
-YONAH
-CORE2
-PENRYN
-DUNNINGTON
-NEHALEM
-SANDYBRIDGE
-HASWELL
-SKYLAKEX
-ATOM
-COOPERLAKE
-
-b)AMD CPU:
-ATHLON
-OPTERON
-OPTERON_SSE3
-BARCELONA
-SHANGHAI
-ISTANBUL
-BOBCAT
-BULLDOZER
-PILEDRIVER
-STEAMROLLER
-EXCAVATOR
-ZEN
-
-c)VIA CPU:
-SSE_GENERIC
-VIAC3
-NANO
-
-2.Power CPU:
-POWER4
-POWER5
-POWER6
-POWER7
-POWER8
-POWER9
-POWER10
-PPCG4
-PPC970
-PPC970MP
-PPC440
-PPC440FP2
-CELL
-
-3.MIPS CPU:
-P5600
-MIPS1004K
-MIPS24K
-
-4.MIPS64 CPU:
-SICORTEX
-LOONGSON3A
-LOONGSON3B
-I6400
-P6600
-I6500
-
-5.IA64 CPU:
-ITANIUM2
-
-6.SPARC CPU:
-SPARC
-SPARCV7
-
-7.ARM CPU:
-CORTEXA15
-CORTEXA9
-ARMV7
-ARMV6
-ARMV5
-
-8.ARM 64-bit CPU:
-ARMV8
-CORTEXA53
-CORTEXA57
-CORTEXA72
-CORTEXA73
-NEOVERSEN1
-EMAG8180
-FALKOR
-THUNDERX
-THUNDERX2T99
-TSV110
-THUNDERX3T110
-VORTEX
-
-9.System Z:
-ZARCH_GENERIC
-Z13
-Z14
-
-10.RISC-V 64:
-RISCV64_GENERIC
-C910V
-

USAGE.md

@@ -1,213 +0,0 @@
-# Notes on OpenBLAS usage
-## Usage
-
-#### Program is Terminated. Because you tried to allocate too many memory regions
-
-In OpenBLAS, we mange a pool of memory buffers and allocate the number of
-buffers as the following.
-```
-#define NUM_BUFFERS (MAX_CPU_NUMBER * 2)
-```
-This error indicates that the program exceeded the number of buffers.
-
-Please build OpenBLAS with larger `NUM_THREADS`. For example, `make
-NUM_THREADS=32` or `make NUM_THREADS=64`.  In `Makefile.system`, we will set
-`MAX_CPU_NUMBER=NUM_THREADS`.
-
-Despite its name, and due to the use of memory buffers in functions like SGEMM,
-the setting of NUM_THREADS can be relevant even for a single-threaded build 
-of OpenBLAS, if such functions get called by multiple threads of a program
-that uses OpenBLAS. In some cases, the affected code may simply crash or throw 
-a segmentation fault without displaying the above warning first.
-
-Note that the number of threads used at runtime can be altered to differ from the
-value NUM_THREADS was set to at build time. At runtime, the actual number of
-threads can be set anywhere from 1 to the build's NUM_THREADS (note however,
-that this does not change the number of memory buffers that will be allocated,
-which is set at build time). The number of threads for a process can be set by
-using the mechanisms described below.
-
-
-#### How can I use OpenBLAS in multi-threaded applications?
-
-If your application is already multi-threaded, it will conflict with OpenBLAS
-multi-threading. Thus, you must set OpenBLAS to use single thread in any of the
-following ways:
-
-* `export OPENBLAS_NUM_THREADS=1` in the environment variables.
-* Call `openblas_set_num_threads(1)` in the application on runtime.
-* Build OpenBLAS single thread version, e.g. `make USE_THREAD=0`
-
-If the application is parallelized by OpenMP, please use OpenBLAS built with
-`USE_OPENMP=1`
-
-#### How to choose TARGET manually at runtime when compiled with DYNAMIC_ARCH
-
-The environment variable which control the kernel selection is
-`OPENBLAS_CORETYPE` (see `driver/others/dynamic.c`) e.g. `export
-OPENBLAS_CORETYPE=Haswell` and the function `char* openblas_get_corename()`
-returns the used target.
-
-#### How could I disable OpenBLAS threading affinity on runtime?
-
-You can define the `OPENBLAS_MAIN_FREE` or `GOTOBLAS_MAIN_FREE` environment
-variable to disable threading affinity on runtime. For example, before the
-running,
-```
-export OPENBLAS_MAIN_FREE=1
-```
-
-Alternatively, you can disable affinity feature with enabling `NO_AFFINITY=1`
-in `Makefile.rule`.
-
-## Linking with the library
-
-* Link with shared library
-
-`gcc -o test test.c -I /your_path/OpenBLAS/include/ -L/your_path/OpenBLAS/lib -lopenblas`
-
-If the library is multithreaded, please add `-lpthread`. If the library
-contains LAPACK functions, please add `-lgfortran` or other Fortran libs.
-
-* Link with static library
-
-`gcc -o test test.c /your/path/libopenblas.a`
-
-You can download `test.c` from https://gist.github.com/xianyi/5780018
-
-On Linux, if OpenBLAS was compiled with threading support (`USE_THREAD=1` by
-default), custom programs statically linked against `libopenblas.a` should also
-link with the pthread library e.g.:
-
-```
-gcc -static -I/opt/OpenBLAS/include -L/opt/OpenBLAS/lib -o my_program my_program.c -lopenblas -lpthread
-```
-
-Failing to add the `-lpthread` flag will cause errors such as:
-
-```
-/opt/OpenBLAS/libopenblas.a(memory.o): In function `_touch_memory':
-memory.c:(.text+0x15): undefined reference to `pthread_mutex_lock'
-memory.c:(.text+0x41): undefined reference to `pthread_mutex_unlock'
-...
-```
-
-## Code examples
-
-#### Call CBLAS interface
-This example shows calling cblas_dgemm in C. https://gist.github.com/xianyi/6930656
-```
-#include <cblas.h>
-#include <stdio.h>
-
-void main()
-{
-  int i=0;
-  double A[6] = {1.0,2.0,1.0,-3.0,4.0,-1.0};
-  double B[6] = {1.0,2.0,1.0,-3.0,4.0,-1.0};
-  double C[9] = {.5,.5,.5,.5,.5,.5,.5,.5,.5};
-  cblas_dgemm(CblasColMajor, CblasNoTrans, CblasTrans,3,3,2,1,A, 3, B, 3,2,C,3);
-
-  for(i=0; i<9; i++)
-    printf("%lf ", C[i]);
-  printf("\n");
-}
-```
-`gcc -o test_cblas_open test_cblas_dgemm.c -I /your_path/OpenBLAS/include/ -L/your_path/OpenBLAS/lib -lopenblas -lpthread -lgfortran`
-
-#### Call BLAS Fortran interface
-
-This example shows calling dgemm Fortran interface in C. https://gist.github.com/xianyi/5780018
-
-```
-#include "stdio.h"
-#include "stdlib.h"
-#include "sys/time.h"
-#include "time.h"
-
-extern void dgemm_(char*, char*, int*, int*,int*, double*, double*, int*, double*, int*, double*, double*, int*);
-
-int main(int argc, char* argv[])
-{
-  int i;
-  printf("test!\n");
-  if(argc<4){
-    printf("Input Error\n");
-    return 1;
-  }
-
-  int m = atoi(argv[1]);
-  int n = atoi(argv[2]);
-  int k = atoi(argv[3]);
-  int sizeofa = m * k;
-  int sizeofb = k * n;
-  int sizeofc = m * n;
-  char ta = 'N';
-  char tb = 'N';
-  double alpha = 1.2;
-  double beta = 0.001;
-
-  struct timeval start,finish;
-  double duration;
-
-  double* A = (double*)malloc(sizeof(double) * sizeofa);
-  double* B = (double*)malloc(sizeof(double) * sizeofb);
-  double* C = (double*)malloc(sizeof(double) * sizeofc);
-
-  srand((unsigned)time(NULL));
-
-  for (i=0; i<sizeofa; i++)
-    A[i] = i%3+1;//(rand()%100)/10.0;
-
-  for (i=0; i<sizeofb; i++)
-    B[i] = i%3+1;//(rand()%100)/10.0;
-
-  for (i=0; i<sizeofc; i++)
-    C[i] = i%3+1;//(rand()%100)/10.0;
-  //#if 0
-  printf("m=%d,n=%d,k=%d,alpha=%lf,beta=%lf,sizeofc=%d\n",m,n,k,alpha,beta,sizeofc);
-  gettimeofday(&start, NULL);
-  dgemm_(&ta, &tb, &m, &n, &k, &alpha, A, &m, B, &k, &beta, C, &m);
-  gettimeofday(&finish, NULL);
-
-  duration = ((double)(finish.tv_sec-start.tv_sec)*1000000 + (double)(finish.tv_usec-start.tv_usec)) / 1000000;
-  double gflops = 2.0 * m *n*k;
-  gflops = gflops/duration*1.0e-6;
-
-  FILE *fp;
-  fp = fopen("timeDGEMM.txt", "a");
-  fprintf(fp, "%dx%dx%d\t%lf s\t%lf MFLOPS\n", m, n, k, duration, gflops);
-  fclose(fp);
-
-  free(A);
-  free(B);
-  free(C);
-  return 0;
-}
-```
-
-` gcc -o time_dgemm time_dgemm.c /your/path/libopenblas.a`
-
-` ./time_dgemm <m> <n> <k> `
-
-## Troubleshooting
-* Please read [Faq](https://github.com/xianyi/OpenBLAS/wiki/Faq) at first.
-* Please use gcc version 4.6 and above to compile Sandy Bridge AVX kernels on Linux/MingW/BSD.
-* Please use Clang version 3.1 and above to compile the library on Sandy Bridge microarchitecture. The Clang 3.0 will generate the wrong AVX binary code.
-* 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. On Linux, you can enable processor affinity by commenting the line NO_AFFINITY=1 in Makefile.rule. But this may cause [the conflict with R parallel](https://stat.ethz.ch/pipermail/r-sig-hpc/2012-April/001348.html).
-* On Loongson 3A. make test would be failed because of pthread_create error. The error code is EAGAIN. However, it will be OK when you run the same testcase on shell.
-
-## BLAS reference manual
-If you want to understand every BLAS function and definition, please read
-[Intel MKL reference manual](https://software.intel.com/sites/products/documentation/doclib/iss/2013/mkl/mklman/GUID-F7ED9FB8-6663-4F44-A62B-61B63C4F0491.htm)
-or [netlib.org](http://netlib.org/blas/)
-
-Here are [OpenBLAS extension functions](https://github.com/xianyi/OpenBLAS/wiki/OpenBLAS-Extensions)
-
-## How to reference OpenBLAS.
-
-You can reference our [papers](https://github.com/xianyi/OpenBLAS/wiki/publications).
-
-Alternatively, you can cite the OpenBLAS homepage http://www.openblas.net directly.
-

appveyor.yml

@@ -1,76 +0,0 @@
-version: 0.2.19.{build}
-
-#environment:
-
-platform: 
-  - x64
-
-os: Visual Studio 2017
-
-configuration: Release
-
-clone_folder: c:\projects\OpenBLAS
-
-init:
-  - git config --global core.autocrlf input
-
-clone_depth: 5
-
-skip_tags: true
-
-matrix:
-  fast_finish: false
-
-skip_commits:
-# Add [av skip] to commit messages
-  message: /\[av skip\]/
-
-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
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      COMPILER: MinGW-gcc-6.3.0-32   
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      COMPILER: MinGW-gcc-5.3.0
-      WITH_FORTRAN: ignore
-    
-install:
-  - if [%COMPILER%]==[clang-cl] call %CONDA_INSTALL_LOCN%\Scripts\activate.bat
-  - if [%COMPILER%]==[clang-cl] conda config --add channels conda-forge --force
-  - if [%COMPILER%]==[clang-cl] conda install --yes --quiet clangdev cmake ninja flang=11.0.1
-  - 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%"
-
-before_build:
-  - ps: if (-Not (Test-Path .\build)) { mkdir build }
-  - cd build
-  - set PATH=%PATH:C:\Program Files\Git\usr\bin;=%
-  - if [%COMPILER%]==[MinGW-gcc-5.3.0] set PATH=C:\MinGW\bin;C:\msys64\usr\bin;C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
-  - if [%COMPILER%]==[MinGW64-gcc-7.2.0-mingw] set PATH=C:\MinGW\bin;C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
-  - if [%COMPILER%]==[MinGW-gcc-6.3.0-32] set PATH=C:\msys64\usr\bin;C:\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw64\bin;%PATH%
-  - if [%COMPILER%]==[cl] cmake -G "Visual Studio 15 2017 Win64" ..
-  - 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 -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 -DBUILD_WITHOUT_LAPACK=no -DNOFORTRAN=0 ..
-  - if [%USE_OPENMP%]==[ON] cmake -DUSE_OPENMP=ON ..
-  - if [%DYNAMIC_ARCH%]==[ON] cmake -DDYNAMIC_ARCH=ON -DDYNAMIC_LIST='CORE2;NEHALEM;SANDYBRIDGE;BULLDOZER;HASWELL' ..
-
-build_script:
-  - cmake --build .
-
-test_script:
-  - ctest -j2
-  

azure-pipelines.yml

@@ -1,80 +0,0 @@
-trigger:
-  # start a new build for every push
-  batch: False
-  branches:
-    include:
-      - develop
-
-jobs:
-# manylinux1 is useful to test because the
-# standard Docker container uses an old version
-# of gcc / glibc
-- job: manylinux1_gcc
-  pool:
-    vmImage: 'ubuntu-16.04'
-  steps:
-  - script: |
-      echo "FROM quay.io/pypa/manylinux1_x86_64
-        COPY . /tmp/openblas
-        RUN cd /tmp/openblas                                      &&  \
-            COMMON_FLAGS='DYNAMIC_ARCH=1 TARGET=NEHALEM NUM_THREADS=32' && \
-            BTYPE='BINARY=64' CC=gcc && \
-            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" > Dockerfile
-      docker build .
-    displayName: Run manylinux1 docker build
-- job: Intel_SDE_skx
-  pool:
-    vmImage: 'ubuntu-16.04'
-  steps:
-  - script: |
-      # at the time of writing the available Azure Ubuntu vm image
-      # does not support AVX512VL, so use more recent LTS version
-      echo "FROM ubuntu:bionic
-      COPY . /tmp/openblas
-      RUN apt-get -y update && apt-get -y install \\
-          cmake \\
-          gfortran \\
-          make \\
-          wget
-      RUN mkdir /tmp/SDE && cd /tmp/SDE && \\
-          mkdir sde-external-8.35.0-2019-03-11-lin && \\
-          wget --quiet -O sde-external-8.35.0-2019-03-11-lin.tar.bz2 https://www.dropbox.com/s/fopsnzj67572sj5/sde-external-8.35.0-2019-03-11-lin.tar.bz2?dl=0 && \\
-          tar -xjvf sde-external-8.35.0-2019-03-11-lin.tar.bz2 -C /tmp/SDE/sde-external-8.35.0-2019-03-11-lin --strip-components=1
-      RUN cd /tmp/openblas && CC=gcc make QUIET_MAKE=1 DYNAMIC_ARCH=1 NUM_THREADS=32 BINARY=64
-      CMD cd /tmp/openblas && echo 0 > /proc/sys/kernel/yama/ptrace_scope && CC=gcc OPENBLAS_VERBOSE=2 /tmp/SDE/sde-external-8.35.0-2019-03-11-lin/sde64 -cpuid_in /tmp/SDE/sde-external-8.35.0-2019-03-11-lin/misc/cpuid/skx/cpuid.def -- make -C utest DYNAMIC_ARCH=1 NUM_THREADS=32 BINARY=64" > Dockerfile
-      docker build -t intel_sde .
-      # 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: OSX_OpenMP
-  pool:
-     vmImage: 'macOS-10.15'
-  steps:   
-  - script: |
-      brew update
-      make TARGET=CORE2 DYNAMIC_ARCH=1 USE_OPENMP=1 CC=gcc-10 FC=gfortran-10
-      
-      
-       

benchmark/Make_exe.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-
-for f in *.goto *.acml *.mkl *.atlas
-do
-	if [ -f "$f" ]; then
-		mv $f `echo $f|tr '.' '_'`.exe
-	fi
-done
-

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

@@ -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 ASUM
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define ASUM BLASFUNC(dzasum)
-#else
-#define ASUM BLASFUNC(scasum)
-#endif
-#else
-#ifdef DOUBLE
-#define ASUM BLASFUNC(dasum)
-#else
-#define ASUM BLASFUNC(sasum)
-#endif
-#endif
-
-int main(int argc, char *argv[])
-{
-
-  FLOAT *x;
-  FLOAT result;
-  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();
-      result = ASUM(&m, x, &inc_x);
-      end();
-      timeg += getsec();
-    }
-    if (loops > 1)
-      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;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

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

@@ -1,128 +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 AXPY
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define AXPY   BLASFUNC(zaxpy)
-#else
-#define AXPY   BLASFUNC(caxpy)
-#endif
-#else
-#ifdef DOUBLE
-#define AXPY   BLASFUNC(daxpy)
-#else
-#define AXPY   BLASFUNC(saxpy)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x, *y;
-  FLOAT alpha[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 (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();
-
-    	AXPY (&m, alpha, x, &inc_x, y, &inc_y );
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.9f sec\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m / timeg * 1.e-6, timeg);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

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

@@ -1,247 +0,0 @@
-/*********************************************************************/
-/* Copyright 2009, 2010 The University of Texas at Austin.           */
-/* 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.                              */
-/*                                                                   */
-/*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */
-/*    AUSTIN  ``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 UNIVERSITY  OF TEXAS AT    */
-/*    AUSTIN 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.                                    */
-/*                                                                   */
-/* The views and conclusions contained in the software and           */
-/* documentation are those of the authors and should not be          */
-/* interpreted as representing official policies, either expressed   */
-/* or implied, of The University of Texas at Austin.                 */
-/*********************************************************************/
-
-#include "bench.h"
-
-double fabs(double);
-
-#undef POTRF
-
-#ifndef COMPLEX
-#ifdef XDOUBLE
-#define POTRF   BLASFUNC(qpotrf)
-#define SYRK    BLASFUNC(qsyrk)
-#elif defined(DOUBLE)
-#define POTRF   BLASFUNC(dpotrf)
-#define SYRK    BLASFUNC(dsyrk)
-#else
-#define POTRF   BLASFUNC(spotrf)
-#define SYRK    BLASFUNC(ssyrk)
-#endif
-#else
-#ifdef XDOUBLE
-#define POTRF   BLASFUNC(xpotrf)
-#define SYRK    BLASFUNC(xherk)
-#elif defined(DOUBLE)
-#define POTRF   BLASFUNC(zpotrf)
-#define SYRK    BLASFUNC(zherk)
-#else
-#define POTRF   BLASFUNC(cpotrf)
-#define SYRK    BLASFUNC(cherk)
-#endif
-#endif
-
-static __inline double getmflops(int ratio, int m, double secs){
-
-  double mm = (double)m;
-  double mulflops, addflops;
-
-  if (secs==0.) return 0.;
-
-  mulflops = mm * (1./3. + mm * (1./2. + mm * 1./6.));
-  addflops = 1./6. * mm * (mm * mm - 1);
-
-  if (ratio == 1) {
-    return (mulflops + addflops) / secs * 1.e-6;
-  } else {
-    return (2. * mulflops + 6. * addflops) / secs * 1.e-6;
-  }
-}
-
-
-int main(int argc, char *argv[]){
-
-#ifndef COMPLEX
-  char *trans[] = {"T", "N"};
-#else
-  char *trans[] = {"C", "N"};
-#endif
-  char *uplo[]  = {"U", "L"};
-  FLOAT alpha[] = {1.0, 0.0};
-  FLOAT beta [] = {0.0, 0.0};
-
-  FLOAT *a, *b;
-
-  blasint m, i, j, info, uplos;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  FLOAT maxerr;
-
-  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\n", from, to, step);
-
-  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 * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  for(m = from; m <= to; m += step){
-
-    fprintf(stderr, "M = %6d : ", (int)m);
-
-    for (uplos = 0; uplos < 2; uplos ++) {
-
-#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;
-	}
-      } 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.;
-	}
-      }
-#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[((long)j + (long)j * (long)m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
-	  a[((long)j + (long)j * (long)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;
-	  }
-	}
-      } 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[((long)j + (long)j * (long)m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
-	  a[((long)j + (long)j * (long)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.;
-	  }
-	}
-      }
-#endif
-
-      SYRK(uplo[uplos], trans[uplos], &m, &m, alpha, a, &m, beta, b, &m);
-
-      begin();
-
-      POTRF(uplo[uplos], &m, b, &m, &info);
-
-      end();
-
-      if (info != 0) {
-	fprintf(stderr, "Info = %d\n", info);
-	exit(1);
-      }
-
-     time1 = getsec();
-
-
-      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]);
-#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]);
-#endif
-	  }
-	}
-      } else {
-	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]);
-#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]);
-#endif
-	  }
-	}
-      }
-
-      fprintf(stderr,
-#ifdef XDOUBLE
-	      "  %Le  %10.3f MFlops", maxerr,
-#else
-	      "  %e  %10.3f MFlops", maxerr,
-#endif
-	      getmflops(COMPSIZE * COMPSIZE, m, time1));
-
-      if (maxerr > 1.e-3) {
-	fprintf(stderr, "Hmm, probably it has bug.\n");
-	exit(1);
-      }
-
-    }
-    fprintf(stderr, "\n");
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/copy.c

@@ -1,123 +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 COPY
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define COPY   BLASFUNC(zcopy)
-#else
-#define COPY   BLASFUNC(ccopy)
-#endif
-#else
-#ifdef DOUBLE
-#define COPY   BLASFUNC(dcopy)
-#else
-#define COPY   BLASFUNC(scopy)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x, *y;
-  FLOAT alpha[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 = 0.0, timeg = 0.0;
-  long nanos = 0;
-  time_t seconds = 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++;}
-
-  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();
-       COPY (&m, x, &inc_x, y, &inc_y );
-       end();
-       timeg += getsec();
-   }
-
-      timeg /= loops;
-
-      fprintf(stderr,
-	    " %10.2f MBytes %12.9f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg / 1.e6, timeg);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/cula_wrapper.c

@@ -1,28 +0,0 @@
-#include <stdio.h>
-#include "culapack.h"
-
-static int initialized = 0;
-
-int sgetrf_(int *m, int *n, float  *a, int *lda, int *ipiv, int *info) {
-
-  if (!initialized)  {
-    culaInitialize();
-    initialized = 1;
-  }
-
-  *info = culaSgetrf(*m, *m, a, *lda, ipiv);
-
-  return 0;
-}
-
-int cgetrf_(int *m, int *n, float  *a, int *lda, int *ipiv, int *info) {
-
-  if (!initialized)  {
-    culaInitialize();
-    initialized = 1;
-  }
-
-  *info = culaCgetrf(*m, *m, (culaFloatComplex *)a, *lda, ipiv);
-
-  return 0;
-}

benchmark/dot.c

@@ -1,118 +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 DOT
-
-#ifdef DOUBLE
-#define DOT   BLASFUNC(ddot)
-#else
-#define DOT   BLASFUNC(sdot)
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x, *y;
-  FLOAT result;
-  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 (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();
-
-    	result = DOT (&m, x, &inc_x, y, &inc_y );
-
-    	end();
-	    timeg += getsec();
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m / timeg * 1.e-6, timeg);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/geev.c

@@ -1,189 +0,0 @@
-/*********************************************************************/
-/* Copyright 2009, 2010 The University of Texas at Austin.           */
-/* 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.                              */
-/*                                                                   */
-/*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */
-/*    AUSTIN  ``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 UNIVERSITY  OF TEXAS AT    */
-/*    AUSTIN 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.                                    */
-/*                                                                   */
-/* The views and conclusions contained in the software and           */
-/* documentation are those of the authors and should not be          */
-/* interpreted as representing official policies, either expressed   */
-/* or implied, of The University of Texas at Austin.                 */
-/*********************************************************************/
-
-#include "bench.h"
-
-#undef GEEV
-
-#ifndef COMPLEX
-#ifdef XDOUBLE
-#define GEEV   BLASFUNC(qgeev)
-#elif defined(DOUBLE)
-#define GEEV   BLASFUNC(dgeev)
-#else
-#define GEEV   BLASFUNC(sgeev)
-#endif
-#else
-#ifdef XDOUBLE
-#define GEEV   BLASFUNC(xgeev)
-#elif defined(DOUBLE)
-#define GEEV   BLASFUNC(zgeev)
-#else
-#define GEEV   BLASFUNC(cgeev)
-#endif
-#endif
-
-#ifndef COMPLEX
-extern void GEEV( char* jobvl, char* jobvr, blasint* n, FLOAT* a,
-                blasint* lda, FLOAT* wr, FLOAT* wi, FLOAT* vl, blasint* ldvl,
-                FLOAT* vr, blasint* ldvr, FLOAT* work, blasint* lwork, blasint* info );
-#else
-extern void GEEV( char* jobvl, char* jobvr, blasint* n, FLOAT* a,
-                blasint* lda, FLOAT* wr, FLOAT* vl, blasint* ldvl,
-                FLOAT* vr, blasint* ldvr, FLOAT* work, blasint* lwork, FLOAT *rwork, blasint* info );
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a,*vl,*vr,*wi,*wr,*work,*rwork;
-  FLOAT wkopt[4];
-  char job='V';
-  char jobr='N';
-  char *p;
-
-  blasint m, i, j, info,lwork;
-  double factor = 26.33;
-
-  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++;}
-
-  if ((p = getenv("OPENBLAS_JOB")))  job=*p;
-
-  if ( job == 'N' ) factor = 10.0;
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Job=%c\n", from, to, step,job);
-
-  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( vl = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( vr = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( wr = (FLOAT *)malloc(sizeof(FLOAT) * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( wi = (FLOAT *)malloc(sizeof(FLOAT) * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( rwork = (FLOAT *)malloc(sizeof(FLOAT) * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-    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;
-      }
-    }
-
-
-    lwork = -1;
-    m=to;
-#ifndef COMPLEX
-    GEEV (&job, &jobr, &m, a, &m, wr, wi, vl, &m, vr, &m, wkopt, &lwork, &info);
-#else
-    GEEV (&job, &jobr, &m, a, &m, wr, vl, &m, vr, &m, wkopt, &lwork,rwork, &info);
-#endif
-
-  lwork = (blasint)wkopt[0];
-  if (( work = (FLOAT *)malloc(sizeof(FLOAT) * lwork * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE           FLops           Time          Lwork\n");
-
-  for(m = from; m <= to; m += step){
-
-    fprintf(stderr, " %6d : ", (int)m);
-    begin();
-
-    lwork = -1;
-#ifndef COMPLEX
-    GEEV (&job, &jobr, &m, a, &m, wr, wi, vl, &m, vr, &m, wkopt, &lwork, &info);
-#else
-    GEEV (&job, &jobr, &m, a, &m, wr, vl, &m, vr, &m, wkopt, &lwork,rwork, &info);
-#endif
-
-    lwork = (blasint)wkopt[0];
-#ifndef COMPLEX
-    GEEV (&job, &jobr, &m, a, &m, wr, wi, vl, &m, vr, &m, work, &lwork, &info);
-#else
-    GEEV (&job, &jobr, &m, a, &m, wr, vl, &m, vr, &m, work, &lwork,rwork, &info);
-#endif
-
-    end();
-
-    if (info) {
-      fprintf(stderr, "failed to compute eigenvalues .. %d\n", info);
-      exit(1);
-    }
-
-    time1 = getsec();
-
-    fprintf(stderr,
-	    " %10.2f MFlops : %10.2f Sec : %d\n",
-	    COMPSIZE * COMPSIZE * factor * (double)m * (double)m * (double)m / time1 * 1.e-6,time1,lwork);
-
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/gemm.c

@@ -1,178 +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 GEMM
-
-#ifndef COMPLEX
-
-#ifdef DOUBLE
-#define GEMM   BLASFUNC(dgemm)
-#elif defined(HALF)
-#define GEMM   BLASFUNC(sbgemm)
-#else
-#define GEMM   BLASFUNC(sgemm)
-#endif
-
-#else
-
-#ifdef DOUBLE
-#define GEMM   BLASFUNC(zgemm)
-#else
-#define GEMM   BLASFUNC(cgemm)
-#endif
-
-#endif
-
-int main(int argc, char *argv[]){
-
-  IFLOAT *a, *b;
-  FLOAT *c;
-  FLOAT alpha[] = {1.0, 0.0};
-  FLOAT beta [] = {0.0, 0.0};
-  char transa = 'N';
-  char transb = 'N';
-  blasint m, n, k, i, j, lda, ldb, ldc;
-  int loops = 1;
-  int has_param_m = 0;
-  int has_param_n = 0;
-  int has_param_k = 0;
-  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_TRANS"))) {
-    transa=*p;
-    transb=*p;
-  }
-  if ((p = getenv("OPENBLAS_TRANSA"))) {
-    transa=*p;
-  }
-  if ((p = getenv("OPENBLAS_TRANSB"))) {
-    transb=*p;
-  }
-  TOUPPER(transa);
-  TOUPPER(transb);
-
-  fprintf(stderr, "From : %3d  To : %3d Step=%d : Transa=%c : Transb=%c\n", from, to, step, transa, transb);
-
-  p = getenv("OPENBLAS_LOOPS");
-  if ( p != NULL ) {
-    loops = atoi(p);
-  }
-
-  if ((p = getenv("OPENBLAS_PARAM_M"))) {
-    m = atoi(p);
-    has_param_m=1;
-  } else {
-    m = to;
-  }
-  if ((p = getenv("OPENBLAS_PARAM_N"))) {
-    n = atoi(p);
-    has_param_n=1;
-  } else {
-    n = to;
-  }
-  if ((p = getenv("OPENBLAS_PARAM_K"))) {
-    k = atoi(p);
-    has_param_k=1;
-  } else {
-    k = to;
-  }
-
-  if (( a = (IFLOAT *)malloc(sizeof(IFLOAT) * m * k * COMPSIZE)) == NULL) {
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-  if (( b = (IFLOAT *)malloc(sizeof(IFLOAT) * 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
-  srandom(getpid());
-#endif
-
-  for (i = 0; i < m * k * COMPSIZE; i++) {
-    a[i] = ((IFLOAT) rand() / (IFLOAT) RAND_MAX) - 0.5;
-  }
-  for (i = 0; i < k * n * COMPSIZE; i++) {
-    b[i] = ((IFLOAT) rand() / (IFLOAT) RAND_MAX) - 0.5;
-  }
-  for (i = 0; i < m * n * COMPSIZE; i++) {
-    c[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-  }
-
-  fprintf(stderr, "          SIZE                   Flops             Time\n");
-
-  for (i = from; i <= to; i += step) {
-    
-    timeg=0;
-
-    if (!has_param_m) { m = i; }
-    if (!has_param_n) { n = i; }
-    if (!has_param_k) { k = i; }
-
-    if (transa == 'N') { lda = m; }
-    else { lda = k; }
-    if (transb == 'N') { ldb = k; }
-    else { ldb = n; }
-    ldc = m;
-
-    fprintf(stderr, " M=%4d, N=%4d, K=%4d : ", (int)m, (int)n, (int)k);
-    begin();
-
-    for (j=0; j<loops; j++) {
-      GEMM (&transa, &transb, &m, &n, &k, alpha, a, &lda, b, &ldb, beta, c, &ldc);
-    }
-
-    end();
-    time1 = getsec();
-
-    timeg = time1/loops;
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)k * (double)m * (double)n / timeg * 1.e-6, time1);
-    
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/gemm3m.c

@@ -1,136 +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 GEMM
-
-#ifndef COMPLEX
-
-#ifdef DOUBLE
-#define GEMM   BLASFUNC(dgemm)
-#else
-#define GEMM   BLASFUNC(sgemm)
-#endif
-
-#else
-
-#ifdef DOUBLE
-#define GEMM   BLASFUNC(zgemm3m)
-#else
-#define GEMM   BLASFUNC(cgemm3m)
-#endif
-
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a, *b, *c;
-  FLOAT alpha[] = {1.0, 1.0};
-  FLOAT beta [] = {1.0, 1.0};
-  char trans='N';
-  blasint m, i, j;
-  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_TRANS")))  trans=*p;
-
-  fprintf(stderr, "From : %3d  To : %3d Step=%d : Trans=%c\n", from, to, step, trans);
-
-  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 * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( c = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  p = getenv("OPENBLAS_LOOPS");
-  if ( p != NULL )
-	loops = atoi(p);
-
-
-#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(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;
-      		}
-    	}
-
-    	begin();
-
-    	GEMM (&trans, &trans, &m, &m, &m, alpha, a, &m, b, &m, beta, c, &m );
-
-    	end();
-	    timeg += getsec();
-    }
-
-    timeg /= loops;
-    fprintf(stderr,
-	    " %10.2f MFlops\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m * (double)m * (double)m / timeg * 1.e-6);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/gemv.c

@@ -1,197 +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
-
-#ifndef COMPLEX
-
-#ifdef DOUBLE
-#define GEMV   BLASFUNC(dgemv)
-#else
-#define GEMV   BLASFUNC(sgemv)
-#endif
-
-#else
-
-#ifdef DOUBLE
-#define GEMV   BLASFUNC(zgemv)
-#else
-#define GEMV   BLASFUNC(cgemv)
-#endif
-
-#endif
-int main(int argc, char *argv[]){
-
-  FLOAT *a, *x, *y;
-  FLOAT alpha[] = {1.0, 1.0};
-  FLOAT beta [] = {1.0, 0.0};
-  char trans='N';
-  blasint m, i, j;
-  blasint inc_x=1,inc_y=1;
-  blasint n=0;
-  int has_param_n = 0;
-  int has_param_m = 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++;}
-
-
-  int tomax = to;
-
-  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_TRANS")))  trans=*p;
-  if ((p = getenv("OPENBLAS_PARAM_N"))) {
-	  n = atoi(p);
-	  if ((n>0)) has_param_n = 1;
-  	  if ( n > tomax ) tomax = n;
-  }
-  if ( has_param_n == 0 )
-  	if ((p = getenv("OPENBLAS_PARAM_M"))) {
-		  m = atoi(p);
-		  if ((m>0)) has_param_m = 1;
-  	  	  if ( m > tomax ) tomax = m;
-  	}
-
-
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Trans = '%c' Inc_x = %d Inc_y = %d Loops = %d\n", from, to, step,trans,inc_x,inc_y,loops);
-
-  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * tomax * tomax * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * tomax * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( y = (FLOAT *)malloc(sizeof(FLOAT) * tomax * abs(inc_y) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  if (has_param_m == 0)
-  {
-
-  	for(m = from; m <= to; m += step)
-  	{
-   		timeg=0;
-   		if ( has_param_n == 0 ) n = m;
-   		fprintf(stderr, " %6dx%d : ", (int)m,(int)n);
-   		for(j = 0; j < m; j++){
-      			for(i = 0; i < n * COMPSIZE; i++){
-				a[(long)j + (long)i * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-      			}
-   		}
-
-    		for (l=0; l<loops; l++)
-    		{
-
-   			for(i = 0; i < n * 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();
-    			GEMV (&trans, &m, &n, alpha, a, &m, x, &inc_x, beta, y, &inc_y );
-    			end();
-    			time1 = getsec();
-			timeg += time1;
-
-    		}
-
-    		timeg /= loops;
-
-    		fprintf(stderr, " %10.2f MFlops %10.6f sec\n", COMPSIZE * COMPSIZE * 2. * (double)m * (double)n / timeg * 1.e-6, timeg);
-
-  	}
-  }
-  else
-  {
-
-  	for(n = from; n <= to; n += step)
-  	{
-   		timeg=0;
-   		fprintf(stderr, " %6dx%d : ", (int)m,(int)n);
-   		for(j = 0; j < m; j++){
-      			for(i = 0; i < n * COMPSIZE; i++){
-				a[(long)j + (long)i * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-      			}
-   		}
-
-    		for (l=0; l<loops; l++)
-    		{
-
-   			for(i = 0; i < n * 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();
-    			GEMV (&trans, &m, &n, alpha, a, &m, x, &inc_x, beta, y, &inc_y );
-    			end();
-    			time1 = getsec();
-			timeg += time1;
-
-    		}
-
-    		timeg /= loops;
-
-    		fprintf(stderr, " %10.2f MFlops %10.6f sec\n", COMPSIZE * COMPSIZE * 2. * (double)m * (double)n / timeg * 1.e-6, timeg);
-
-  	}
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/ger.c

@@ -1,149 +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 GER
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define GER   BLASFUNC(zgeru)
-#else
-#define GER   BLASFUNC(cgeru)
-#endif
-#else
-#ifdef DOUBLE
-#define GER   BLASFUNC(dger)
-#else
-#define GER   BLASFUNC(sger)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a, *x, *y;
-  FLOAT alpha[] = {1.0, 1.0};
-  blasint m, i, j;
-  blasint inc_x=1,inc_y=1;
-  blasint n=0;
-  int has_param_n = 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);
-  if ((p = getenv("OPENBLAS_PARAM_N"))) {
-	  n = atoi(p);
-	  if ((n>0) && (n<=to)) has_param_n = 1;
-  }
-
-  if ( has_param_n == 1 )
-    fprintf(stderr, "From : %3d  To : %3d Step = %3d N = %d Inc_x = %d Inc_y = %d Loops = %d\n", from, to, step,n,inc_x,inc_y,loops);
-  else
-    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 (( 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;
-
-   if ( has_param_n == 0 ) n = m;
-
-   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;
-      		}
-   }
-
-
-   for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   }
-
-   for(i = 0; i < n * COMPSIZE * abs(inc_y); i++){
-			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   }
-
-    for (l=0; l<loops; l++)
-    {
-
-    	begin();
-
-    	GER (&m, &n, alpha, x, &inc_x, y, &inc_y, a , &m);
-
-    	end();
-      
-      timeg += getsec();
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m * (double)n / timeg * 1.e-6);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));
-

benchmark/gesv.c

@@ -1,143 +0,0 @@
-/*********************************************************************/
-/* Copyright 2009, 2010 The University of Texas at Austin.           */
-/* 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.                              */
-/*                                                                   */
-/*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */
-/*    AUSTIN  ``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 UNIVERSITY  OF TEXAS AT    */
-/*    AUSTIN 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.                                    */
-/*                                                                   */
-/* The views and conclusions contained in the software and           */
-/* documentation are those of the authors and should not be          */
-/* interpreted as representing official policies, either expressed   */
-/* or implied, of The University of Texas at Austin.                 */
-/*********************************************************************/
-
-#include "bench.h"
-
-double fabs(double);
-
-#undef GESV
-#undef GETRS
-
-#ifndef COMPLEX
-#ifdef XDOUBLE
-#define GESV   BLASFUNC(qgesv)
-#elif defined(DOUBLE)
-#define GESV   BLASFUNC(dgesv)
-#else
-#define GESV   BLASFUNC(sgesv)
-#endif
-#else
-#ifdef XDOUBLE
-#define GESV   BLASFUNC(xgesv)
-#elif defined(DOUBLE)
-#define GESV   BLASFUNC(zgesv)
-#else
-#define GESV   BLASFUNC(cgesv)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a, *b;
-  blasint *ipiv;
-
-  blasint m, i, j, info;
-
-  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\n", from, to, step);
-
-  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 * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( ipiv = (blasint *)malloc(sizeof(blasint) * to * 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){
-
-    fprintf(stderr, " %dx%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(j = 0; j < m; j++){
-      for(i = 0; i < m * COMPSIZE; i++){
-	b[(long)i + (long)j * (long)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];
-      }
-    }
-
-    begin();
-
-    GESV (&m, &m, a, &m, ipiv, b, &m,  &info);
-
-    end();
-
-    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;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/getri.c

@@ -1,163 +0,0 @@
-/*********************************************************************/
-/* Copyright 2009, 2010 The University of Texas at Austin.           */
-/* 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.                              */
-/*                                                                   */
-/*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */
-/*    AUSTIN  ``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 UNIVERSITY  OF TEXAS AT    */
-/*    AUSTIN 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.                                    */
-/*                                                                   */
-/* The views and conclusions contained in the software and           */
-/* documentation are those of the authors and should not be          */
-/* interpreted as representing official policies, either expressed   */
-/* or implied, of The University of Texas at Austin.                 */
-/*********************************************************************/
-
-#include "bench.h"
-
-#undef GETRF
-#undef GETRI
-
-#ifndef COMPLEX
-#ifdef XDOUBLE
-#define GETRF   BLASFUNC(qgetrf)
-#define GETRI   BLASFUNC(qgetri)
-#elif defined(DOUBLE)
-#define GETRF   BLASFUNC(dgetrf)
-#define GETRI   BLASFUNC(dgetri)
-#else
-#define GETRF   BLASFUNC(sgetrf)
-#define GETRI   BLASFUNC(sgetri)
-#endif
-#else
-#ifdef XDOUBLE
-#define GETRF   BLASFUNC(xgetrf)
-#define GETRI   BLASFUNC(xgetri)
-#elif defined(DOUBLE)
-#define GETRF   BLASFUNC(zgetrf)
-#define GETRI   BLASFUNC(zgetri)
-#else
-#define GETRF   BLASFUNC(cgetrf)
-#define GETRI   BLASFUNC(cgetri)
-#endif
-#endif
-
-extern void GETRI(blasint *m, FLOAT *a, blasint *lda, blasint *ipiv, FLOAT *work, blasint *lwork, blasint *info);
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a,*work;
-  FLOAT wkopt[4];
-  blasint *ipiv;
-  blasint m, i, j, info,lwork;
-
-  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\n", from, to, step);
-
-  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( ipiv = (blasint *)malloc(sizeof(blasint) * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-
-
-    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;
-      }
-    }
-
-
-    lwork = -1;
-    m=to;
-
-  GETRI(&m, a, &m, ipiv, wkopt, &lwork, &info);
-
-  lwork = (blasint)wkopt[0];
-  if (( work = (FLOAT *)malloc(sizeof(FLOAT) * lwork * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE           FLops           Time          Lwork\n");
-
-  for(m = from; m <= to; m += step){
-
-    fprintf(stderr, " %6d : ", (int)m);
-
-    GETRF (&m, &m, a, &m, ipiv, &info);
-
-    if (info) {
-      fprintf(stderr, "Matrix is not singular .. %d\n", info);
-      exit(1);
-    }
-
-    begin();
-
-    lwork = -1;
-    GETRI(&m, a, &m, ipiv, wkopt, &lwork, &info);
-
-    lwork = (blasint)wkopt[0];
-    GETRI(&m, a, &m, ipiv, work, &lwork, &info);
-    end();
-
-    if (info) {
-      fprintf(stderr, "failed compute inverse matrix .. %d\n", info);
-      exit(1);
-    }
-
-    time1 = getsec();
-
-    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);
-
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

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

@@ -1,117 +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 HEMM
-
-#ifdef DOUBLE
-#define HEMM   BLASFUNC(zhemm)
-#else
-#define HEMM   BLASFUNC(chemm)
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a, *b, *c;
-  FLOAT alpha[] = {1.0, 1.0};
-  FLOAT beta [] = {1.0, 1.0};
-  char *p;
-
-  char side='L';
-  char uplo='U';
-
-  if ((p = getenv("OPENBLAS_SIDE"))) side=*p; 
-  if ((p = getenv("OPENBLAS_UPLO"))) uplo=*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 Side = %c Uplo = %c\n", from, to, step,side,uplo);
-
-  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 * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( c = (FLOAT *)malloc(sizeof(FLOAT) * to * 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;
-	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;
-      }
-    }
-
-    begin();
-
-    HEMM (&side, &uplo, &m, &m, alpha, a, &m, b, &m, beta, c, &m );
-
-    end();
-
-    time1 = getsec();
-
-    fprintf(stderr,
-	    " %10.2f MFlops\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m * (double)m * (double)m / time1 * 1.e-6);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/hemv.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 HEMV
-
-#ifdef DOUBLE
-#define HEMV   BLASFUNC(zhemv)
-#else
-#define HEMV   BLASFUNC(chemv)
-#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();
-
-    	HEMV (&uplo, &m, alpha, a, &m, 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/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

@@ -1,116 +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 HER2K
-#ifdef DOUBLE
-#define HER2K   BLASFUNC(zher2k)
-#else
-#define HER2K   BLASFUNC(cher2k)
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a, *b, *c;
-  FLOAT alpha[] = {1.0, 1.0};
-  FLOAT beta [] = {1.0, 1.0};
-  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 (( b = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( c = (FLOAT *)malloc(sizeof(FLOAT) * to * 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;
-	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;
-      }
-    }
-
-    begin();
-
-    HER2K (&uplo, &trans, &m, &m, alpha, a, &m, b, &m, beta, c, &m );
-
-    end();
-
-    time1 = getsec();
-
-    fprintf(stderr,
-	    " %10.2f MFlops\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m * (double)m * (double)m / time1 * 1.e-6);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/herk.c

@@ -1,112 +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 HERK
-
-#ifdef DOUBLE
-#define HERK   BLASFUNC(zherk)
-#else
-#define HERK   BLASFUNC(cherk)
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a, *c;
-  FLOAT alpha[] = {1.0, 1.0};
-  FLOAT beta [] = {1.0, 1.0};
-  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 (( c = (FLOAT *)malloc(sizeof(FLOAT) * to * 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;
-	c[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-      }
-    }
-
-    begin();
-
-    HERK (&uplo, &trans, &m, &m, alpha, a, &m, beta, c, &m );
-
-    end();
-
-    time1 = getsec();
-
-    fprintf(stderr,
-	    " %10.2f MFlops\n",
-	    COMPSIZE * COMPSIZE * 1. * (double)m * (double)m * (double)m / time1 * 1.e-6);
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

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

@@ -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 IAMAX
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define IAMAX   BLASFUNC(izamax)
-#else
-#define IAMAX   BLASFUNC(icamax)
-#endif
-#else
-#ifdef DOUBLE
-#define IAMAX   BLASFUNC(idamax)
-#else
-#define IAMAX   BLASFUNC(isamax)
-#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();
-
-    	IAMAX (&m, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MBytes %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/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

@@ -1,202 +0,0 @@
-/*********************************************************************/
-/* Copyright 2009, 2010 The University of Texas at Austin.           */
-/* 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.                              */
-/*                                                                   */
-/*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */
-/*    AUSTIN  ``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 UNIVERSITY  OF TEXAS AT    */
-/*    AUSTIN 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.                                    */
-/*                                                                   */
-/* The views and conclusions contained in the software and           */
-/* documentation are those of the authors and should not be          */
-/* interpreted as representing official policies, either expressed   */
-/* or implied, of The University of Texas at Austin.                 */
-/*********************************************************************/
-
-#include "bench.h"
-
-double fabs(double);
-
-#undef GETRF
-#undef GETRS
-
-#ifndef COMPLEX
-#ifdef XDOUBLE
-#define GETRF   BLASFUNC(qgetrf)
-#define GETRS   BLASFUNC(qgetrs)
-#elif defined(DOUBLE)
-#define GETRF   BLASFUNC(dgetrf)
-#define GETRS   BLASFUNC(dgetrs)
-#else
-#define GETRF   BLASFUNC(sgetrf)
-#define GETRS   BLASFUNC(sgetrs)
-#endif
-#else
-#ifdef XDOUBLE
-#define GETRF   BLASFUNC(xgetrf)
-#define GETRS   BLASFUNC(xgetrs)
-#elif defined(DOUBLE)
-#define GETRF   BLASFUNC(zgetrf)
-#define GETRS   BLASFUNC(zgetrs)
-#else
-#define GETRF   BLASFUNC(cgetrf)
-#define GETRS   BLASFUNC(cgetrs)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a, *b;
-  blasint *ipiv;
-
-  blasint m, i, j, info;
-  blasint unit =   1;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  FLOAT maxerr;
-
-  double time1, time2;
-
-  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\n", from, to, step);
-
-  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 * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( ipiv = (blasint *)malloc(sizeof(blasint) * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Residual     Decompose            Solve           Total\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;
-      }
-    }
-
-    for (i = 0; i < m * COMPSIZE; ++i) b[i] = 0.;
-
-    for (j = 0; j < m; ++j) {
-      for (i = 0; i < m * COMPSIZE; ++i) {
-	b[i] += a[(long)i + (long)j * (long)m * COMPSIZE];
-      }
-    }
-
-    begin();
-
-    GETRF (&m, &m, a, &m, ipiv, &info);
-
-    end();
-
-    if (info) {
-      fprintf(stderr, "Matrix is not singular .. %d\n", info);
-      exit(1);
-    }
-
-    time1 = getsec();
-
-    begin();
-
-    GETRS("N", &m, &unit, a, &m, ipiv, b, &m, &info);
-
-    end();
-
-    if (info) {
-      fprintf(stderr, "Matrix is not singular .. %d\n", info);
-      exit(1);
-    }
-
-    time2 = getsec();
-
-    maxerr = 0.;
-
-    for(i = 0; i < m; i++){
-#ifndef XDOUBLE
-      if (maxerr < fabs(b[i * COMPSIZE] - 1.0)) maxerr = fabs(b[i * COMPSIZE] - 1.0);
-#ifdef COMPLEX
-      if (maxerr < fabs(b[i * COMPSIZE] + 1)) maxerr = fabs(b[i * COMPSIZE + 1]);
-#endif
-#else
-      if (maxerr < fabsl(b[i * COMPSIZE] - 1.0L)) maxerr = fabsl(b[i * COMPSIZE] - 1.0L);
-#ifdef COMPLEX
-      if (maxerr < fabsl(b[i * COMPSIZE] + 1)) maxerr = fabsl(b[i * COMPSIZE + 1]);
-#endif
-#endif
-    }
-
-#ifdef XDOUBLE
-    fprintf(stderr,"  %Le ", maxerr);
-#else
-    fprintf(stderr,"  %e ", maxerr);
-#endif
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.2f MFlops %10.2f MFlops\n",
-	    COMPSIZE * COMPSIZE * 2. / 3. * (double)m * (double)m * (double)m / time1 * 1.e-6,
-	    COMPSIZE * COMPSIZE * 2.      * (double)m * (double)m             / time2 * 1.e-6,
-	    COMPSIZE * COMPSIZE * (2. / 3. * (double)m * (double)m * (double)m + 2. * (double)m * (double)m) / (time1 + time2) * 1.e-6);
-
-#if 0
-    if (
-#ifdef DOUBLE
-	maxerr > 1.e-8
-#else
-	maxerr > 1.e-1
-#endif
-	) {
-      fprintf(stderr, "Error is too large.\n");
-      exit(1);
-    }
-#endif
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

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

@@ -1,121 +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 NRM2
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define NRM2   BLASFUNC(dznrm2)
-#else
-#define NRM2   BLASFUNC(scnrm2)
-#endif
-#else
-#ifdef DOUBLE
-#define NRM2   BLASFUNC(dnrm2)
-#else
-#define NRM2   BLASFUNC(snrm2)
-#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();
-
-    	NRM2 (&m, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m / timeg * 1.e-6, timeg);
-
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/plot-filter.sh

@@ -1,65 +0,0 @@
-#!/bin/sh
-# **********************************************************************************
-# 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.
-# **********************************************************************************
-
-# ************************************************************************
-# sample filter for data output from benchmark programs
-#
-# usage example: 
-#   ./dgemm.goto 2>&1|./plotfilter.sh >OpenBLAS
-# ************************************************************************
-
-if [ $# -eq 1 ]
-then
-	arg1=$1
-else
-	arg1=0
-fi
-
-case $arg1 in
-
-L)
-	# Linpack Benchmark
-	awk '/MFlops/ { print $1,int($8) }'|tail --lines=+2
-	;;
-
-C)
-	# Cholesky Benchmark
-	awk '/MFlops/ { print $3,int($9) }'|tail --lines=+2
-	;;
-
-B)
-	# Copy Benchmark	
-	awk '/MBytes/ { print $1,int($3) }'|tail --lines=+2
-	;;
-
-
-*)
-	awk '/MFlops/ { print $1,int($3) }'|tail --lines=+2
-	;;
-esac
-

benchmark/plot-header

@@ -1,42 +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.
-# **********************************************************************************
-
-set term x11 font sans;
-set ylabel "MFlops";
-set xlabel "Size";
-set grid xtics;
-set grid ytics;
-set key left;
-set timestamp "generated on %Y-%m-%d by `whoami`"
-set title "Dtrsm\nUPLO=U TRANS=N SIDE=L\nBulldozer 1 Thread"
-plot 'OpenBLAS' smooth bezier, 'ACML' smooth bezier, 'MKL' smooth bezier;
-set output "print.png";
-show title;
-show plot;
-show output;
-
-

benchmark/potrf.c

@@ -1,250 +0,0 @@
-/*********************************************************************/
-/* Copyright 2009, 2010 The University of Texas at Austin.           */
-/* 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.                              */
-/*                                                                   */
-/*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */
-/*    AUSTIN  ``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 UNIVERSITY  OF TEXAS AT    */
-/*    AUSTIN 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.                                    */
-/*                                                                   */
-/* The views and conclusions contained in the software and           */
-/* documentation are those of the authors and should not be          */
-/* interpreted as representing official policies, either expressed   */
-/* or implied, of The University of Texas at Austin.                 */
-/*********************************************************************/
-
-#include "bench.h"
-
-double fabs(double);
-
-#undef POTRF
-
-#ifndef COMPLEX
-#ifdef XDOUBLE
-#define POTRF   BLASFUNC(qpotrf)
-#define POTRS   BLASFUNC(qpotrs)
-#define POTRI   BLASFUNC(qpotri)
-#define SYRK    BLASFUNC(qsyrk)
-#elif defined(DOUBLE)
-#define POTRF   BLASFUNC(dpotrf)
-#define POTRS   BLASFUNC(dpotrs)
-#define POTRI   BLASFUNC(dpotri)
-#define SYRK    BLASFUNC(dsyrk)
-#else
-#define POTRF   BLASFUNC(spotrf)
-#define POTRS   BLASFUNC(spotrs)
-#define POTRI   BLASFUNC(spotri)
-#define SYRK    BLASFUNC(ssyrk)
-#endif
-#else
-#ifdef XDOUBLE
-#define POTRF   BLASFUNC(xpotrf)
-#define POTRS   BLASFUNC(xpotrs)
-#define POTRI   BLASFUNC(xpotri)
-#define SYRK    BLASFUNC(xherk)
-#elif defined(DOUBLE)
-#define POTRF   BLASFUNC(zpotrf)
-#define POTRS   BLASFUNC(zpotrs)
-#define POTRI   BLASFUNC(zpotri)
-#define SYRK    BLASFUNC(zherk)
-#else
-#define POTRF   BLASFUNC(cpotrf)
-#define POTRS   BLASFUNC(cpotrs)
-#define POTRI   BLASFUNC(cpotri)
-#define SYRK    BLASFUNC(cherk)
-#endif
-#endif
-
-// 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);
-
-
-
-int main(int argc, char *argv[]){
-
-#ifndef COMPLEX
-  char *trans[] = {"T", "N"};
-#else
-  char *trans[] = {"C", "N"};
-#endif
-  char *uplo[]  = {"U", "L"};
-  FLOAT alpha[] = {1.0, 0.0};
-  FLOAT beta [] = {0.0, 0.0};
-
-  FLOAT *a, *b;
-
-  char *p;
-  char btest = 'F';
-
-  blasint m, i, j, info, uplos=0;
-  double flops;
-
-  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++;}
-
-  if ((p = getenv("OPENBLAS_UPLO")))
-	if (*p == 'L') uplos=1;
-
-  if ((p = getenv("OPENBLAS_TEST"))) btest=*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){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( b    = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  for(m = from; m <= to; m += step){
-
-#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;
-	}
-      } 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.;
-	}
-      }
-#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[((long)j + (long)j * (long)m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
-	  a[((long)j + (long)j * (long)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;
-	  }
-	}
-      } 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[((long)j + (long)j * (long)m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
-	  a[((long)j + (long)j * (long)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.;
-	  }
-	}
-      }
-#endif
-
-      SYRK(uplo[uplos], trans[uplos], &m, &m, alpha, a, &m, beta, b, &m);
-
-      begin();
-
-      POTRF(uplo[uplos], &m, b, &m, &info);
-
-      end();
-
-      if (info != 0) {
-	fprintf(stderr, "Potrf info = %d\n", info);
-	exit(1);
-      }
-
-      time1 = getsec();
-      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' )
-      {
-	
- 	for(j = 0; j < to; j++){
-      		for(i = 0; i < to * COMPSIZE; i++){
-        		a[i + j * to * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-      		}
-    	}
-
-      	begin();
-
-      	POTRS(uplo[uplos], &m, &m, b, &m, a, &m,  &info);
-
-      	end();
-
-      	if (info != 0) {
-		fprintf(stderr, "Potrs info = %d\n", info);
-		exit(1);
-        }
-        time1 = getsec();
-        flops = COMPSIZE * COMPSIZE * (2.0 * (double)m * (double)m *(double)m ) / time1 * 1.e-6;
-
-      }
-	
-      if ( btest == 'I' )
-      {
-	
-      	begin();
-
-      	POTRI(uplo[uplos], &m, b, &m, &info);
-
-      	end();
-
-      	if (info != 0) {
-		fprintf(stderr, "Potri info = %d\n", info);
-		exit(1);
-        }
-
-        time1 = getsec();
-        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);
-
-
-  }
-
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));
-

benchmark/rot.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 ROT
-
-#ifndef COMPLEX
-
-#ifdef DOUBLE
-#define ROT   BLASFUNC(drot)
-#else
-#define ROT   BLASFUNC(srot)
-#endif
-
-#else
-
-#ifdef DOUBLE
-#define ROT   BLASFUNC(zdrot)
-#else
-#define ROT   BLASFUNC(csrot)
-#endif
-
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x, *y;
-  // FLOAT result;
-  blasint m, i;
-  blasint inc_x=1,inc_y=1;
-  FLOAT c[1] = { 2.0 };
-  FLOAT s[1] = { 2.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();
-
-    	ROT (&m, x, &inc_x, y, &inc_y, c, s);
-
-    	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;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

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

@@ -1,130 +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 SCAL
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define SCAL   BLASFUNC(zscal)
-#else
-#define SCAL   BLASFUNC(cscal)
-#endif
-#else
-#ifdef DOUBLE
-#define SCAL   BLASFUNC(dscal)
-#else
-#define SCAL   BLASFUNC(sscal)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x, *y;
-  FLOAT alpha[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);
-
-  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 (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();
-
-    	SCAL (&m, alpha, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-#ifdef COMPLEX
-    fprintf(stderr, " %10.2f MFlops %10.6f sec\n", 6. * (double)m / timeg * 1.e-6, timeg);
-#else
-    fprintf(stderr, " %10.2f MFlops %10.6f sec\n", 1. * (double)m / timeg * 1.e-6, timeg);
-#endif
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/scripts/NUMPY/cgemm.py

@@ -1,56 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-
-def run_cgemm(N,l):
-
-	A = randn(N,N).astype('float32') + randn(N,N).astype('float32') * 1j;
-	B = randn(N,N).astype('float32') + randn(N,N).astype('float32') * 1j;
-
-	start = time.time();
-	for i in range(0,l):
-		ref = numpy.dot(A,B)
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 8*N*N*N) *l / timediff
-	mflops *= 1e-6
-
-	size = "%dx%d" % (N,N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_cgemm(i,LOOPS)
-

benchmark/scripts/NUMPY/cgemv.py

@@ -1,56 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-
-def run_cgemv(N,l):
-
-	A = randn(N,N).astype('float32') + randn(N,N).astype('float32') * 1j;
-	B = randn(N).astype('float32') + randn(N).astype('float32') * 1j;
-
-	start = time.time();
-	for i in range(0,l):
-		ref = numpy.dot(A,B)
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 8*N*N) *l / timediff
-	mflops *= 1e-6
-
-	size = "%dx%d" % (N,N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_cgemv(i,LOOPS)
-

benchmark/scripts/NUMPY/daxpy.py

@@ -1,58 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-from scipy.linalg.blas import daxpy
-
-
-def run_daxpy(N,l):
-
-	x = randn(N).astype('float64')
-	y = randn(N).astype('float64')
-
-	start = time.time();
-	for i in range(0,l):
-		y = daxpy(x,y, a=2.0 )
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 2*N ) *l / timediff
-	mflops *= 1e-6
-
-	size = "%d" % (N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_daxpy(i,LOOPS)
-

benchmark/scripts/NUMPY/ddot.py

@@ -1,56 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-
-def run_ddot(N,l):
-
-	A = randn(N).astype('float64')
-	B = randn(N).astype('float64')
-
-	start = time.time();
-	for i in range(0,l):
-		ref = numpy.dot(A,B)
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 2*N ) *l / timediff
-	mflops *= 1e-6
-
-	size = "%d" % (N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_ddot(i,LOOPS)
-

benchmark/scripts/NUMPY/deig.py

@@ -1,55 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-
-def run_deig(N,l):
-
-	A = randn(N,N).astype('float64')
-
-	start = time.time();
-	for i in range(0,l):
-		la,v = numpy.linalg.eig(A)
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 26.33 *N*N*N) *l / timediff
-	mflops *= 1e-6
-
-	size = "%dx%d" % (N,N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_deig(i,LOOPS)
-

benchmark/scripts/NUMPY/dgemm.py

@@ -1,56 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-
-def run_dgemm(N,l):
-
-	A = randn(N,N).astype('float64')
-	B = randn(N,N).astype('float64')
-
-	start = time.time();
-	for i in range(0,l):
-		ref = numpy.dot(A,B)
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 2*N*N*N) *l / timediff
-	mflops *= 1e-6
-
-	size = "%dx%d" % (N,N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_dgemm(i,LOOPS)
-

benchmark/scripts/NUMPY/dgemv.py

@@ -1,56 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-
-def run_dgemv(N,l):
-
-	A = randn(N,N).astype('float64')
-	B = randn(N).astype('float64')
-
-	start = time.time();
-	for i in range(0,l):
-		ref = numpy.dot(A,B)
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 2*N*N) *l / timediff
-	mflops *= 1e-6
-
-	size = "%dx%d" % (N,N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_dgemv(i,LOOPS)
-

benchmark/scripts/NUMPY/dgesv.py

@@ -1,58 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-from scipy.linalg.lapack import dgesv
-
-def run_dgesv(N,l):
-
-	a = randn(N,N).astype('float64')
-	b = randn(N,N).astype('float64')
-
-	start = time.time();
-	for i in range(0,l):
-		dgesv(a,b,1,1)
-	end = time.time()
-	
-	timediff = (end -start) 
-
-	mflops = ( 2.0/3.0 *N*N*N + 2.0*N*N*N) *l / timediff
-	mflops *= 1e-6
-
-	size = "%dx%d" % (N,N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_dgesv(i,LOOPS)
-

benchmark/scripts/NUMPY/dsolve.py

@@ -1,56 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-
-def run_dsolve(N,l):
-
-	A = randn(N,N).astype('float64')
-	B = randn(N,N).astype('float64')
-
-	start = time.time();
-	for i in range(0,l):
-		ref = numpy.linalg.solve(A,B)
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 2.0/3.0 *N*N*N + 2.0*N*N*N) *l / timediff
-	mflops *= 1e-6
-
-	size = "%dx%d" % (N,N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_dsolve(i,LOOPS)
-

benchmark/scripts/NUMPY/sdot.py

@@ -1,56 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-
-def run_sdot(N,l):
-
-	A = randn(N).astype('float32')
-	B = randn(N).astype('float32')
-
-	start = time.time();
-	for i in range(0,l):
-		ref = numpy.dot(A,B)
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 2*N ) *l / timediff
-	mflops *= 1e-6
-
-	size = "%d" % (N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_sdot(i,LOOPS)
-

benchmark/scripts/NUMPY/sgemm.py

@@ -1,56 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-
-def run_sgemm(N,l):
-
-	A = randn(N,N).astype('float32')
-	B = randn(N,N).astype('float32')
-
-	start = time.time();
-	for i in range(0,l):
-		ref = numpy.dot(A,B)
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 2*N*N*N) *l / timediff
-	mflops *= 1e-6
-
-	size = "%dx%d" % (N,N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_sgemm(i,LOOPS)
-

benchmark/scripts/NUMPY/sgemv.py

@@ -1,56 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-
-def run_sgemv(N,l):
-
-	A = randn(N,N).astype('float32')
-	B = randn(N).astype('float32')
-
-	start = time.time();
-	for i in range(0,l):
-		ref = numpy.dot(A,B)
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 2*N*N) *l / timediff
-	mflops *= 1e-6
-
-	size = "%dx%d" % (N,N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_sgemv(i,LOOPS)
-

benchmark/scripts/NUMPY/zgemm.py

@@ -1,56 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-
-def run_zgemm(N,l):
-
-	A = randn(N,N).astype('float64') + randn(N,N).astype('float64') * 1j;
-	B = randn(N,N).astype('float64') + randn(N,N).astype('float64') * 1j;
-
-	start = time.time();
-	for i in range(0,l):
-		ref = numpy.dot(A,B)
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 8*N*N*N) *l / timediff
-	mflops *= 1e-6
-
-	size = "%dx%d" % (N,N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_zgemm(i,LOOPS)
-

benchmark/scripts/NUMPY/zgemv.py

@@ -1,56 +0,0 @@
-#!/usr/bin/python
-
-import os
-import sys
-import time
-import numpy
-from numpy.random import randn
-
-def run_zgemv(N,l):
-
-	A = randn(N,N).astype('float64') + randn(N,N).astype('float64') * 1j;
-	B = randn(N).astype('float64') + randn(N).astype('float64') * 1j;
-
-	start = time.time();
-	for i in range(0,l):
-		ref = numpy.dot(A,B)
-	end = time.time()
-	
-	timediff = (end -start) 
-	mflops = ( 8*N*N) *l / timediff
-	mflops *= 1e-6
-
-	size = "%dx%d" % (N,N)
-	print("%14s :\t%20f MFlops\t%20f sec" % (size,mflops,timediff))
-
-
-if __name__ == "__main__":
-	N=128
-	NMAX=2048
-	NINC=128
-	LOOPS=1
-
-	z=0
-	for arg in sys.argv:
-		if z == 1:
-			N = int(arg)
-		elif z == 2:
-			NMAX = int(arg)
-		elif z == 3:
-			NINC = int(arg)
-		elif z == 4:
-			LOOPS = int(arg)
-
-		z = z + 1
-
-	if 'OPENBLAS_LOOPS' in os.environ:
-		p = os.environ['OPENBLAS_LOOPS']
-		if p:
-			LOOPS = int(p);
-
-	print("From: %d To: %d Step=%d Loops=%d" % (N, NMAX, NINC, LOOPS))
-	print("\tSIZE\t\t\tFlops\t\t\t\t\tTime")
-
-	for i in range (N,NMAX+NINC,NINC):
-		run_zgemv(i,LOOPS)
-

benchmark/scripts/OCTAVE/cgemm.m

@@ -1,56 +0,0 @@
-#!/usr/bin/octave --silent 
-
-nfrom = 128 ;
-nto   = 2048;
-nstep = 128;
-loops = 1;
-
-
-arg_list = argv();
-for i = 1:nargin
-
-	switch(i)
-		case 1
-			nfrom = str2num(arg_list{i});
-		case 2
-			nto   = str2num(arg_list{i});
-		case 3
-			nstep = str2num(arg_list{i});
-		case 4
-			loops = str2num(arg_list{i});
-
-	endswitch
-
-endfor
-
-p = getenv("OPENBLAS_LOOPS");
-if p 
-	loops = str2num(p);
-endif
-
-printf("From %d To %d Step=%d Loops=%d\n",nfrom, nto, nstep, loops);
-printf("        SIZE             FLOPS             TIME\n");
-
-n = nfrom;
-while n <= nto
-
-	A = single(rand(n,n)) + single(rand(n,n)) * 1i;
-	B = single(rand(n,n)) + single(rand(n,n)) * 1i;
-	start = clock();
-
-	l=0;
-	while l < loops
-
-		C = A * B;
-		l = l + 1;
-
-	endwhile
-
-	timeg = etime(clock(), start);
-	mflops = ( 4.0 * 2.0*n*n*n *loops ) / ( timeg * 1.0e6 );
-
-	st1 = sprintf("%dx%d : ", n,n);
-	printf("%20s %10.2f MFlops %10.6f sec\n", st1, mflops, timeg);
-	n = n + nstep;
-
-endwhile