Provide iaxpy and cblas_iaxpy for integer vectors. make INTEGER_PRECISION=1

.drone.yml

@@ -1,143 +0,0 @@
----
-kind: pipeline
-name: arm64_gcc_make
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: ubuntu:19.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:19.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
-
----
-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
-
----
-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

.gitignore

@@ -5,7 +5,6 @@
 *.def
 *.o
 *.out
-*.tmp
 lapack-3.1.1
 lapack-3.1.1.tgz
 lapack-3.4.1
@@ -15,23 +14,7 @@ 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
 *~
@@ -82,9 +65,3 @@ test/sblat3
 test/zblat1
 test/zblat2
 test/zblat3
-build
-build.*
-*.swp
-benchmark/*.goto
-benchmark/smallscaling
-

.travis.yml

@@ -1,195 +1,24 @@
-# 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
+compiler:
+  - gcc
 
-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:
-        - set -e
-        - 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"
+env:
+  - TARGET_BOX=LINUX64 BTYPE="BINARY=64"
+  - TARGET_BOX=LINUX64 BTYPE="BINARY=64 USE_OPENMP=1"
+  - TARGET_BOX=LINUX64 BTYPE="BINARY=64 INTERFACE64=1"
+  - TARGET_BOX=LINUX32 BTYPE="BINARY=32"
+  - TARGET_BOX=WIN64 BTYPE="BINARY=64 HOSTCC=gcc CC=x86_64-w64-mingw32-gcc FC=x86_64-w64-mingw32-gfortran"
 
-    - <<: *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"
+before_install:
+ - sudo apt-get update -qq
+ - sudo apt-get install -qq gfortran
+ - if [[ "$TARGET_BOX" == "WIN64" ]]; then sudo apt-get install -qq binutils-mingw-w64-x86-64 gcc-mingw-w64-x86-64 gfortran-mingw-w64-x86-64; fi
+ - if [[ "$TARGET_BOX" == "LINUX32" ]]; then sudo apt-get install -qq  gcc-multilib gfortran-multilib; fi
 
-    - <<: *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
-      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:
-        - set -e
-        # XXX: Disable some warnings for now to avoid exceeding Travis limit for log size.
-        - alpine make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
-              CFLAGS="-Wno-misleading-indentation -Wno-sign-conversion -Wno-incompatible-pointer-types"
-        - alpine make -C test $COMMON_FLAGS $BTYPE
-        - alpine make -C ctest $COMMON_FLAGS $BTYPE
-        - alpine make -C utest $COMMON_FLAGS $BTYPE
-      env:
-        - TARGET_BOX=LINUX64_MUSL
-        - BTYPE="BINARY=64"
-
-    # XXX: This job segfaults in TESTS OF THE COMPLEX LEVEL 3 BLAS,
-    # but only on Travis CI, cannot reproduce it elsewhere.
-    #- &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:
-        - set -e
-        - mkdir build
-        - CONFIG=Release
-        - cmake -Bbuild -H. $CMAKE_ARGS $COMMON_ARGS -DCMAKE_BUILD_TYPE=$CONFIG
-        - cmake --build build --config $CONFIG -- -j2
-      env:
-        - CMAKE=1
-    - <<: *test-cmake
-      env:
-        - CMAKE=1 CMAKE_ARGS="-DNOFORTRAN=1"
-    - <<: *test-cmake
-      compiler: gcc
-      env:
-        - CMAKE=1
-
-    - &test-macos
-      os: osx
-      osx_image: xcode10.1
-      before_script:
-        - COMMON_FLAGS="DYNAMIC_ARCH=1 NUM_THREADS=32"
-        - brew update
-        - brew install gcc@8 # for gfortran
-      script:
-        - travis_wait 45 make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
-      env:
-        - BTYPE="TARGET=NEHALEM BINARY=64 INTERFACE64=1 FC=gfortran-8"
-
-    - <<: *test-macos
-      osx_image: xcode10.0
-      env:
-        - BTYPE="TARGET=NEHALEM BINARY=32 NOFORTRAN=1"
-
-    - <<: *test-macos
-      osx_image: xcode10.1
-      env:
-        - CC="/Applications/Xcode-10.1.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang -isysroot /Applications/Xcode-10.1.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS12.1.sdk"
-        - 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"
-        - BTYPE="TARGET=ARMV8 BINARY=64 HOSTCC=clang NOFORTRAN=1"
+script: make QUIET_MAKE=1 DYNAMIC_ARCH=1 TARGET=NEHALEM NUM_THREADS=32 $BTYPE
 
 # 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
+    - develop

CMakeLists.txt

@@ -1,394 +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 8)
-set(OpenBLAS_VERSION "${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}.${OpenBLAS_PATCH_VERSION}")
-
-# Adhere to GNU filesystem layout conventions
-include(GNUInstallDirs)
-
-include(CMakePackageConfigHelpers)
-
-
-#######
-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)
-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()
-
-# 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 ()
-
-# 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_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 (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 MSVC AND NOT NOFORTRAN)
-  # Build test and ctest
-  add_subdirectory(test)
-  if(NOT NO_CBLAS)
-    add_subdirectory(ctest)
-  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()
-    target_link_libraries(${OpenBLAS_LIBNAME} "/FORCE:MULTIPLE")
-  endif()
-endif()
-
-if (BUILD_SHARED_LIBS AND NOT ${SYMBOLPREFIX}${SYMBOLSUFIX} STREQUAL "")
-if (NOT DEFINED ARCH)
-  set(ARCH_IN "x86_64")
-else()
-  set(ARCH_IN ${ARCH})
-endif()
-
-if (${CORE} STREQUAL "generic")
-  set(ARCH_IN "GENERIC")
-endif ()
-
-if (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}")
-	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()
-
-include(FindPkgConfig QUIET)
-if(PKG_CONFIG_FOUND)
-	configure_file(${PROJECT_SOURCE_DIR}/cmake/openblas.pc.in ${PROJECT_BINARY_DIR}/openblas${SUFFIX64}.pc @ONLY)
-	install (FILES ${PROJECT_BINARY_DIR}/openblas${SUFFIX64}.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig/)
-endif()
-
-
-# GNUInstallDirs "DATADIR" wrong here; CMake search path wants "share".
-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})
-

CONTRIBUTORS.md

@@ -121,62 +121,11 @@ In chronological order:
   * [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
+* [Your name or handle] <[email or website]>
+  * [Date] [Brief summary of your changes]

Changelog.txt

@@ -1,611 +1,4 @@
 OpenBLAS ChangeLog
-====================================================================
-Version 0.3.8
- 9-Feb-2020
-
-common: 
-`	* LAPACK has been updated to 3.9.0 (plus patches up to 
-	  January 2nd, 2020)
-	* CMAKE support has been improved in several areas including
-	  cross-compilation
-	* a thread race condition in the GEMM3M kernels was resolved
-	* the "generic" (plain C) gemm beta kernel used by many targets
-	  has been sped up
-	* an optimized version of the LAPACK trtrs functions has been added
-	* an incompatibilty between the LAPACK tests and the OpenBLAS
-	  implementation of XERBLA was resolved, removing the numerous
-	  warnings about wrong error exits in the former 
-	* support for NetBSD has been added
-	* support for compilation with g95 and non-GNU versions of ld
-	  has been improved
-	* support for compilation with (upcoming) gcc 10 has been added
-
-POWER:
-	* worked around miscompilation of several POWER8 and POWER9 
-	  kernels by older versions of gcc
-	* added support for big-endian POWER8 and for compilation on AIX
-	* corrected bugs in the big-endian support for PPC440 and PPC970
-	* DYNAMIC_ARCH support is now available in CMAKE builds as well
-
-ARMV8:
-	* performance of DGEMM_BETA and SGEMM_NCOPY has been improved
-	* compilation for 32bit works again 
-	* performance of the RPCC function has been improved
-	* improved performance on small systems
-	* DYNAMIC_ARCH support is now available in CMAKE builds as well
-	* cross-compilation from OSX to IOS was simplified
- 
-x86_64:
-	* a new AVX512 DGEMM kernel was added and the AVX512 SGEMM kernel
-	  was significantly improved
-	* optimized AVX512 kernels for CGEMM and ZGEMM have been added
-	* AVX2 kernels for STRMM, SGEMM, and CGEMM have been significantly
-	  sped up and optimized CGEMM3M and ZGEMM3M kernels have been added 
-	* added support for QEMU virtual cpus
-	* a compilation problem with PGI and SUN compilers was fixed
-	* Intel "Goldmont plus" is now autodetected
-	* a potential crash on program exit on MS Windows has been fixed
-
-x86:
-	* an unwanted case sensitivity in the implementation of LSAME
-  	  on older 32bit AMD cpus was fixed
-
-zarch:
-	* Z15 is now supported as Z14
-	* DYNAMIC_ARCH is now available on ZARCH as well
-
-====================================================================
-Version 0.3.7
-11-Aug 2019
-
-common:
-  * having the gmake special variables TARGET_ARCH or TARGET_MACH
-    defined no longer causes build failures in ctest or utest
-  * defining NO_AFFINITY or USE_TLS to 0 in gmake builds no longer
-    has the same effect as setting them to 1
-  * a new test program was added to allow checking the library for
-    thread safety
-  * a new option USE_LOCKING was added to ensure thread safety when
-    OpenBLAS itself is built without multithreading but will be 
-    called from multiple threads.
-  * a build failure on Linux with glibc versions earlier than 2.5
-    was fixed
-  * a runtime error with CPU enumeration (and NO_AFFINITY not set)
-    on glibc 2.6 was fixed
-  * NO_AFFINITY was added to the CMAKE options (and defaults to being
-    active on Linux, as in the gmake builds)
-
-x86_64:
-  * the build-time logic for detection of AVX512 availability in
-    the processor and compiler was fixed
-  * gmake builds on OSX now set the internal name of the library to 
-    libopenblas.0.dylib (consistent with CMAKE)
-  * the Haswell DGEMM kernel received a significant speedup through
-    improved prefetch and load instructions
-  * performance of DGEMM, DTRMM, DTRSM and ZDOT on Zen/Zen2 was markedly
-    increased by avoiding vpermpd instructions
-  * the SKYLAKEX (AVX512) DGEMM helper functions have now been disabled
-    to fix remaining errors in DGEMM, DSYMM and DTRMM
-
-POWER:
-  * added support for building on FreeBSD/powerpc64 and FreeBSD/ppc970
-  * added optimized kernels for POWER9 SGEMM and STRMM
-
-ARMV7:
-  * fixed the softfp implementations of xAMAX and IxAMAX
-  * removed the predefined -march= flags on both ARMV5 and ARMV6 as
-    they were appropriate for only a subset of platforms
-
-====================================================================
-Version 0.3.6
-29-Apr-2019
-
-common:
-	* the build tools now check that a given cpu TARGET is actually valid
-	* the build-time check of system features (c_check) has been made
-  	  less dependent on particular perl features (this should mainly
-  	  benefit building on Windows)
-	* several problem with the ReLAPACK integration were fixed,
-	  including INTERFACE64 support and building a shared library
-	* building with CMAKE on BSD systems was improved
-	* a non-absolute SUM function was added based on the
-  	  existing optimized code for ASUM
-	* CBLAS interfaces to the IxMIN and IxMAX functions were added
-	* a name clash between LAPACKE and BOOST headers was resolved
-	* CMAKE builds with OpenMP failed to include the appropriate getrf_parallel
-	  kernels
-	* a crash on thread (key) deletion with the USE_TLS=1 memory management
-	  option was fixed
-	* restored several earlier fixes, in particular for OpenMP performance,
-  	  building on BSD, and calling fork on CYGWIN, which had inadvertently
-  	  been dropped in the 0.3.3 rewrite of the memory management code.
-
-x86_64:
-	* the AVX512 DGEMM kernel has been disabled again due to unsolved problems
-	* building with old versions of MSVC was fixed
-	* it is now possible to build a static library on Windows with CMAKE
-	* accessing environment variables on CYGWIN at run time was fixed
-	* the CMAKE build system now recognizes 32bit userspace on 64bit hardware
-	* Intel "Denverton" atom and Hygon "Dhyana" zen CPUs are now autodetected
-	* building for DYNAMIC_ARCH with a DYNAMIC_LIST of targets is now supported
-  	  with CMAKE as well
-	* building for DYNAMIC_ARCH with GENERIC as the default target is now supported
-	* a buffer overflow in the SSE GEMM kernel for Intel Nano targets was fixed
-	* assembly bugs involving undeclared modification of input operands were fixed
-  	  in the AXPY, DOT, GEMV, GER, SCAL, SYMV and TRSM microkernels for Nehalem,
-	  Sandybridge, Haswell, Bulldozer and Piledriver. These would typically cause
-	  test failures or segfaults when compiled with recent versions of gcc from 8 onward.
-	* a similar bug was fixed in the blas_quickdivide code used to split workloads
-	  in most functions
-	* a bug in the IxMIN implementation for the GENERIC target made it return the result of IxMAX
-	* fixed building on SkylakeX systems when either the compiler or the (emulated) operating
-	  environment does not support AVX512
-	* improved GEMM performance on ZEN targets
-
-x86:
-	* build failures caused by the recently added checks for AVX512 were fixed
-	* an inline assembly bug involving undeclared modification of an input argument was
-  	  fixed in the blas_quickdivide code used to split workloads in most functions
-	* a bug in the IMIN implementation for the GENERIC target made it return the result of IMAX
-
-MIPS32:
-	* a bug in the IMIN implementation made it return the result of IMAX
-
-POWER:
-	* single precision BLAS1/2 functions have received optimized POWER8 kernels
-	* POWER9 is now a separate target, with an optimized DGEMM/DTRMM kernel
-	* building on PPC970 systems under OSX Leopard or Tiger is now supported
-	* out-of-bounds memory accesses in the gemm_beta microkernels were fixed
-	* building a shared library on AIX is now supported for POWER6
-	* DYNAMIC_ARCH support has been added for POWER6 and newer
-
-ARMv7:
-	* corrected xDOT behaviour with zero INC_X or INC_Y
-	* a bug in the IMIN implementation made it return the result of IMAX
-
-ARMv8:
-	* added support for HiSilicon TSV110 cpus
-	* the CMAKE build system now recognizes 32bit userspace on 64bit hardware
-	* cross-compilation with CMAKE now works again
-	* a bug in the IMIN implementation made it return the result of IMAX
-	* ARMV8 builds with the BINARY=32 option are now automatically handled as ARMV7
-
-IBM Z:
-	* optimized microkernels for single precicion BLAS1/2 functions have been added
-	  for both Z13 and Z14
-
-====================================================================
-Version 0.3.5
-31-Dec-2018
-
-common:
-	* loop unrolling in TRMV has been enabled again.
-	* A domain error in the thread workload distribution for SYRK
-	  has been fixed.
-	* gmake builds will now automatically add -fPIC to the build
-	  options if the platform requires it.
-	* a pthreads key leakage (and associate crash on dlclose) in
-	  the USE_TLS codepath was fixed.
-	* building of the utest cases on systems that do not provide
-	  an implementation of complex.h was fixed.
-	  
-x86_64:
-	* the SkylakeX code was changed to compile on OSX.
-	* unwanted application of the -march=skylake-avx512 option
-	  to the common code parts of a DYNAMIC_ARCH build was fixed.
-	* improved performance of SGEMM for small workloads on Skylake X.
-	* performance of SGEMM and DGEMM was improved on Haswell.
-
-ARMV8:
-	* a configuration error that broke the CNRM2 kernel was corrected.
-	* compilation of the GEMM kernels with CMAKE was fixed.
-	* DYNAMIC_ARCH builds are now available with CMAKE as well.
-	* using CMAKE for cross-compilation to the new cpu TARGETs
-	  introduced in 0.3.4 now works.
-	  
-POWER:
-	* a problem in cpu autodetection for AIX has been corrected.
-	
-====================================================================
-Version 0.3.4
-02-Dec-2018
-
-common:
-	* the new, experimental thread-local memory allocation had 
-	  inadvertently been left enabled for gmake builds in 0.3.3
-	  despite the announcement. It is now disabled by default, and
-	  single-threaded builds will keep using the old allocator even
-	  if the USE_TLS option is turned on.
-	* OpenBLAS will now provide enough buffer space for at least 50
-	  threads by default.
-	* The output of openblas_get_config() now contains the version
-	  number.
-	* A serious thread safety bug in GEMV operation with small M and
-	  large N size has been fixed.
-	* The code will now automatically call blas_thread_init after a
-	  fork if needed before handling a call to openblas_set_num_threads
-	* Accesses to parallelized level3 functions from multiple callers
-	  are now serialized to avoid thread races (unless using OpenMP).
-	  This should provide better performance than the known-threadsafe
-	  (but non-default) USE_SIMPLE_THREADED_LEVEL3 option.
-	* When building LAPACK with gfortran, -frecursive is now (again)
-	  enabled by default to ensure correct behaviour.
-        * The OpenBLAS version cblas.h now supports both CBLAS_ORDER and
-	  CBLAS_LAYOUT as the name of the matrix row/column order option.
-	* Externally set LDFLAGS are now passed through to the final compile/link
-	  steps to facilitate setting platform-specific linker flags.
-	* A potential race condition during the build of LAPACK (that would 
-	  usually manifest itself as a failure to build TESTING/MATGEN) has been 
-	  fixed.
-	* xHEMV has been changed to stay single-threaded for small input sizes
-	  where the overhead of multithreading exceeds any possible gains
-	* CSWAP and ZSWAP have been limited to a single thread except on ARMV8 or
-	  ThunderX hardware with sizable input.
-	* Linker flags for the PGI compiler have been updated
-	* Behaviour of AXPY with zero increments is now handled in the C interface,
-	  correcting the result on at least Intel Atom.
-	* The result matrix from calling SGELSS with an all-zero input matrix is 
-	  now zeroed completely.
-	  
-x86_64:
-	* Autodetection of AMD Ryzen2 has been fixed (again).
-        * CMAKE builds now support labeling of an INTERFACE64=1 build of
-	  the library with the _64 suffix.
-	* AVX512 version of DGEMM has been added and the AVX512 SGEMM kernel
-	  has been sped up by rewriting with C intrinsics
-	* Fixed compilation on RHEL5/CENTOS5 (issue with typename __WAIT_STATUS)
-	
-POWER:
-	* added support for building on AIX (with gcc and GNU tools from AIX Toolbox).
-	* CPU type detection has been implemented for AIX.
-	* CPU type detection has been fixed for NETBSD.
-	
-MIPS64:
-	* AXPY on LOONGSON3A has been corrected to pass "zero increment" utest.
-	* DSDOT on LOONGSON3A has been fixed.
-	* the SGEMM microkernel has been hardened against potential data loss.
-	
-ARMV8:
-	* DYNAMic_ARCH support is now available for 64bit ARM
-	* cross-compiling for ARMV8 under iOS now works.
-	* cpu-specific code has been rearranged to make better use of both
-	  hardware commonalities and model-specific compiler optimizations.
-	* XGENE1 has been removed as a TARGET, superseded by the improved generic
-	  ARMV8 support.
-	
-ARMV7:
-	* Older assembly mnemonics have been converted to UAL form to allow
-	  building with clang 7.0
-	* Cross compiling LAPACKE for Android has been fixed again (broken by
-	  update to LAPACK 3.7.0 some while ago).  
-	  
-====================================================================
-Version 0.3.3
-31-Aug-2018
-
-common:
-	* thread memory allocation has been switched back to the method
-	  used before version 0.3.1 due to unexpected problems caused by
-	  the new code under some circumstances. A new compile-time option
-	  USE_TLS has been added to enable the new code, and it is hoped
-	  that this can become the default again in the next version.
-	* LAPAck PR272 has been integrated, which fixes spurious errors
-	  in DSYEVR and related functions caused by missing conversion 
-	  from ILAENV to ILAENV_2STAGE in several _2stage routines.
-	* the cmake-generated OpenBLASConfig.cmake now uses correct case
-	  for the name of the library
-	* added support for Haiku OS  
-
-x86_64:
-	* added AVX512 implementations of SDOT, DDOT, SAXPY, DAXPY,
-	  DSCAL, DGEMVN and DSYMVL 
-	* added a workaround for a cygwin issue that prevented compilation
-	  of AVX512 code
-	  
-IBM Z:
-	* added autodetection of Z14
-	* fixed TRMM errors in the generic target
-	
-====================================================================
-Version 0.3.2
-30-Jul-2018
-
-common:
-	* fixes for regressions caused by the rewrite of the thread
-	  initialization code in 0.3.1
-
-POWER:
-	* fixed cpu autodetection for the BSDs
-
-MIPS64:
-	* fixed utest errors in AXPY, DSDOT, ROT and SWAP
-
-x86_64:
-	* added autodetection of AMD Ryzen 2
-	* fixed build with older versions of MSVC
-
-====================================================================
-Version 0.3.1
-01-Jul-2018
-
-common:
-	* rewritten thread initialization code with significantly reduced overhead
-	* added CBLAS interfaces to the IxAMIN BLAS extension functions
-	* fixed the lapack-test target
-	* CMAKE builds now create an OpenBLASConfig.cmake file
-	* ZAXPY now uses a single thread for small input sizes
-	* the LAPACK code was updated from Reference-LAPACK/lapack#253
-          (fixing LAPACKE interfaces to Aasen's functions)
-
-POWER:
-	* corrected CROT and ZROT behaviour with zero INC_X
-
-ARMV7:
-	* corrected xDOT behaviour with zero INC_X or INC_Y
-
-x86_64:
-	* retired some older targets of DYNAMIC_ARCH builds to a new option DYNAMIC_OLDER,
-	  this affects PENRYN,DUNNINGTON,OPTERON,OPTERON_SSE3,BOBCAT,ATOM and NANO
-	  (which will still be supported via the slower PRESCOTT kernels when this option is not set)
-	* added an option DYNAMIC_LIST that (used in conjunction with DYNAMIC_ARCH) allows to 
-	  specify the list of x86_64 targets to include. Any target not on the list will be supported 
-	  by the Sandybridge or Nehalem kernels if available, or by Prescott.
-	* improved SWITCH_RATIO on Haswell for increased GEMM throughput
-	* added initial support for Intel Skylake X, including an AVX512 SGEMM kernel
-	* added autodetection of Intel Cannon Lake series as Skylake X
-	* added a default L2 cache size for hypervisors that return zero here (Chromebook)
-	* fixed a name clash with recent Windows10 headers that broke the build with (at least)
-	  recent mingw from MSYS2
-	* fixed a link error in mixed clang/gfortran builds with OpenMP
-	* updated the OSX deployment target to 10.8
-	* switched on parallel make for builds on MS Windows by default
-
-x86:
-	* fixed SSWAP and DSWAP behaviour with zero INC_X and INC_Y
-
-====================================================================
-Version 0.3.0
-23-May-2108
-
-common:
-	* fixed some more thread race and locking bugs
-	* added preliminary support for calling an OpenMP build of the library from multiple threads
-	* removed performance impact of thread locks added in 0.2.20 on OpenMP code
-	* general code cleanup 
-	* optimized DSDOT implementation
-	* improved thread distribution for GEMM
-	* corrected IMATCOPY/OMATCOPY implementation
-	* fixed out-of-bounds accesses in the multithreaded xBMV/xPMV and SYMV implementations
-	* cmake build improvements
-	* pkgconfig file now contains build options
-	* openblas_get_config() now reports USE_OPENMP and NUM_THREADS settings used for the build
-	* corrections and improvements for systems with more than 64 cpus
-	* LAPACK code updated to 3.8.0 including later fixes
-	* added ReLAPACK, a recursive implementation of several LAPACK functions
-	* Rewrote ROTMG to handle cases that the netlib code failed to address
-	* Disabled (broken) multithreading code for xTRMV
-	* corrected prototypes of complex CBLAS functions to make our cblas.h match the generally accepted standard
-	* shared memory access failures on startup are now handled more gracefully
-	* restored utests from earlier releases (and made them pass on all affected systems)
-
-SPARC:
-	* several fixes for cpu autodetection
-
-POWER:
-	* corrected vector register overwriting in several Power8 kernels
-	* optimized additional BLAS functions
-
-ARM:
-	* added support for CortexA53 and A72 
-	* added autodetection for ThunderX2T99
-	* made most optimized kernels the default for generic ARMv8 targets 
-
-x86_64:
-	* parallelized DDOT kernel for Haswell
-	* changed alignment directives in assembly kernels to boost performance on OSX
-	* fixed register handling in the GEMV microkernels (bug exposed by gcc7)
-	* added support for building on OpenBSD and Dragonfly 
-	* updated compiler options to work with Intel release 2018
-	* support fully optimized build with clang/flang on Microsoft Windows
-	* fixed building on AIX
-
-IBM Z:
-	* added optimized BLAS 1/2 functions
-
-MIPS:
-	* fixed cpu autodetection helper code
-	* added mips32 1004K cpu (Mediatek MT7621 and similar SoC)
-	* added mips64 I6500 cpu
-
-====================================================================
-Version 0.2.20
-24-Jul-2017
-
-common:
-        * Improved CMake support
-        * Fixed several thread race and locking bugs
-        * Fixed default LAPACK optimization level
-        * Updated LAPACK to 3.7.0
-        * Added ReLAPACK (https://github.com/HPAC/ReLAPACK, make BUILD_RELAPACK=1)
-
-POWER:
-        * Optimizations for Power9
-        * Fixed several Power8 assembly bugs
-
-ARM:
-        * New optimized Vulcan and ThunderX2T99 targets
-        * Support for ARMV7 SOFT_FP ABI (make ARM_SOFTFP_ABI=1)
-        * Detect all cpu cores including offline ones
-        * Fix compilation with CLANG
-        * Support building a shared library for Android
-
-MIPS:
-        * Fixed several threading issues
-        * Fix compilation with CLANG
-
-x86_64:
-        * Detect Intel Bay Trail and Apollo Lake
-        * Detect Intel Sky Lake and Kaby Lake
-        * Detect Intel Knights Landing
-        * Detect AMD A8, A10, A12 and Ryzen
-        * Support 64bit builds with Visual Studio
-        * Fix building with Intel and PGI compilers
-        * Fix building with MINGW and TDM-GCC
-        * Fix cmake builds for Haswell and related cpus
-        * Fix building for Sandybridge with CLANG 3.9
-	* Add support for the FLANG compiler
-
-IBM Z:
-        * New target z13 with BLAS3 optimizations
-
-====================================================================
-Version 0.2.19
-1-Sep-2016
-common:
-	* Improved cross compiling.
-	* Fix the bug on musl libc.
-
-POWER:
-	* Optimize BLAS on Power8
-	* Fixed Julia+OpenBLAS bugs on Power8
-
-MIPS:
-	* Optimize BLAS on MIPS P5600 and I6400 (Thanks, Shivraj Patil, Kaustubh Raste)
-
-ARM:
-	* Improved on ARM Cortex-A57. (Thanks, Ashwin Sekhar T K)
-
-
-====================================================================
-Version 0.2.18
-12-Apr-2016
-common:
-	* If you set MAKE_NB_JOBS flag less or equal than zero,
-	  make will be without -j.
-
-x86/x86_64:
-	* Support building Visual Studio static library. (#813, Thanks, theoractice)
-	* Fix bugs to pass buidbot CI tests (http://build.openblas.net)
-
-ARM:
-	* Provide DGEMM 8x4 kernel for Cortex-A57 (Thanks, Ashwin Sekhar T K)
-
-POWER:
-	* Optimize S and C BLAS3 on Power8
-	* Optimize BLAS2/1 on Power8
-
-====================================================================
-Version 0.2.17
-20-Mar-2016
-common:
-	* Enable BUILD_LAPACK_DEPRECATED=1 by default.
-
-====================================================================
-Version 0.2.16
-15-Mar-2016
-common:
-	* Avoid potential getenv segfault. (#716)
-	* Import LAPACK svn bugfix #142-#147,#150-#155
-
-x86/x86_64:
-	* Optimize c/zgemv for AMD Bulldozer, Piledriver, Steamroller
-	* Fix bug with scipy linalg test.
-
-ARM:
-	* Improve DGEMM for ARM Cortex-A57. (Thanks, Ashwin Sekhar T K)
-
-POWER:
-	* Optimize D and Z BLAS3 functions for Power8.
-
-====================================================================
-Version 0.2.16.rc1
-23-Feb-2016
-common:
-	* Upgrade LAPACK to 3.6.0 version.
-	  Add BUILD_LAPACK_DEPRECATED option in Makefile.rule to build
-	  LAPACK deprecated functions.
-	* Add MAKE_NB_JOBS option in Makefile.
-	  Force number of make jobs.This is particularly
-	  useful when using distcc. (#735. Thanks, Jerome Robert.)
-	* Redesign unit test. Run unit/regression test at every build (Travis-CI and Appveyor).
-	* Disable multi-threading for small size swap and ger. (#744. Thanks, Jerome Robert)
-	* Improve small zger, zgemv, ztrmv using stack alloction (#727. Thanks, Jerome Robert)
-	* Let openblas_get_num_threads return the number of active threads. 
-	  (#760. Thanks, Jerome Robert)
-	* Support illumos(OmniOS). (#749. Thanks, Lauri Tirkkonen)
-	* Fix LAPACK Dormbr, Dormlq bug. (#711, #713. Thanks, Brendan Tracey)
-	* Update scipy benchmark script. (#745. Thanks, John Kirkham)
-
-x86/x86_64:
-	* Optimize trsm kernels for AMD Bulldozer, Piledriver, Steamroller.
-	* Detect Intel Avoton.
-	* Detect AMD Trinity, Richland, E2-3200.
-	* Fix gemv performance bug on Mac OSX Intel Haswell.
-	* Fix some bugs with CMake and Visual Studio
-
-ARM:
-	* Support and optimize Cortex-A57 AArch64.
-	  (#686. Thanks, Ashwin Sekhar TK)
-	* Fix Android build on ARMV7 (#778. Thanks, Paul Mustiere)
-	* Update ARMV6 kernels.
-
-POWER:
-	* Fix detection of POWER architecture
-	  (#684. Thanks, Sebastien Villemot)
-
-====================================================================
-Version 0.2.15
-27-Oct-2015
-common:
-	* Support cmake on x86/x86-64. Natively compiling on MS Visual Studio.
-	  (experimental. Thank Hank Anderson for the initial cmake porting work.)
-	  
-	  On Linux and Mac OSX, OpenBLAS cmake supports assembly kernels.
-	  e.g. cmake .
-	       make
-	       make test (Optional)
-
-	  On Windows MS Visual Studio, OpenBLAS cmake only support C kernels.
-	  (OpenBLAS uses AT&T style assembly, which is not supported by MSVC.)
-	  e.g. cmake -G "Visual Studio 12 Win64" .
-	       Open OpenBLAS.sln and build.
-	  
-	* Enable MAX_STACK_ALLOC flags by default.
-	  Improve ger and gemv for small matrices.
-	* Improve gemv parallel with small m and large n case.
-	* Improve ?imatcopy when lda==ldb (#633. Thanks, Martin Koehler)
-	* Add vecLib benchmarks (#565. Thanks, Andreas Noack.)
-	* Fix LAPACK lantr for row major matrices (#634. Thanks, Dan Kortschak)
-	* Fix LAPACKE lansy (#640. Thanks, Dan Kortschak)
-	* Import bug fixes for LAPACKE s/dormlq, c/zunmlq 
-	* Raise the signal when pthread_create fails (#668. Thanks, James K. Lowden)
-	* Remove g77 from compiler list.
-	* Enable AppVeyor Windows CI.
-
-x86/x86-64:
-	* Support pure C generic kernels for x86/x86-64.
-	* Support Intel Boardwell and Skylake by Haswell kernels.
-	* Support AMD Excavator by Steamroller kernels.
-	* Optimize s/d/c/zdot for Intel SandyBridge and Haswell.
-	* Optimize s/d/c/zdot for AMD Piledriver and Steamroller.
-	* Optimize s/d/c/zapxy for Intel SandyBridge and Haswell.
-	* Optimize s/d/c/zapxy for AMD Piledriver and Steamroller.
-	* Optimize d/c/zscal for Intel Haswell, dscal for Intel SandyBridge.
-	* Optimize d/c/zscal for AMD Bulldozer, Piledriver and Steamroller.
-	* Optimize s/dger for Intel SandyBridge.
-	* Optimize s/dsymv for Intel SandyBridge.
-	* Optimize ssymv for Intel Haswell.
-	* Optimize dgemv for Intel Nehalem and Haswell.
-	* Optimize dtrmm for Intel Haswell.
-
-ARM:
-	* Support Android NDK armeabi-v7a-hard ABI (-mfloat-abi=hard)
-	  e.g. make HOSTCC=gcc CC=arm-linux-androideabi-gcc NO_LAPACK=1 TARGET=ARMV7
-	* Fix lock, rpcc bugs (#616, #617. Thanks, Grazvydas Ignotas)
-POWER:
-	* Support ppc64le platform (ELF ABI v2. #612. Thanks, Matthew Brandyberry.)
-	* Support POWER7/8 by POWER6 kernels. (#612. Thanks, Fábio Perez.)
-
 ====================================================================
 Version 0.2.14
 24-Mar-2015

Makefile

@@ -7,6 +7,10 @@ ifneq ($(DYNAMIC_ARCH), 1)
 BLASDIRS += kernel
 endif
 
+ifdef UTEST_CHECK
+SANITY_CHECK = 1
+endif
+
 ifdef SANITY_CHECK
 BLASDIRS += reference
 endif
@@ -16,30 +20,14 @@ 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
+SUBDIRS_ALL = $(SUBDIRS) test ctest utest exports benchmark ../laswp ../bench
 
-.PHONY : all libs netlib $(RELA) test ctest shared install
-.NOTPARALLEL : all libs $(RELA) prof lapack-test install blas-test
+.PHONY : all libs netlib test ctest shared install
+.NOTPARALLEL : all libs prof lapack-test install blas-test
 
-all :: libs netlib $(RELA) tests shared
+all :: libs netlib tests shared
 	@echo
 	@echo " OpenBLAS build complete. ($(LIB_COMPONENTS))"
 	@echo
@@ -58,7 +46,7 @@ endif
 endif
 
 	@echo "  C compiler       ... $(C_COMPILER)  (command line : $(CC))"
-ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
+ifndef NOFORTRAN
 	@echo "  Fortran compiler ... $(F_COMPILER)  (command line : $(FC))"
 endif
 ifneq ($(OSNAME), AIX)
@@ -96,20 +84,23 @@ endif
 	@echo
 
 shared :
-ifneq ($(NO_SHARED), 1)
-ifeq ($(OSNAME), $(filter $(OSNAME),Linux SunOS Android Haiku))
+ifndef NO_SHARED
+ifeq ($(OSNAME), Linux)
 	@$(MAKE) -C exports so
-	@ln -fs $(LIBSONAME) $(LIBPREFIX).so
-	@ln -fs $(LIBSONAME) $(LIBPREFIX).so.$(MAJOR_VERSION)
+	@-ln -fs $(LIBSONAME) $(LIBPREFIX).so
+	@-ln -fs $(LIBSONAME) $(LIBPREFIX).so.$(MAJOR_VERSION)
 endif
-ifeq ($(OSNAME), $(filter $(OSNAME),FreeBSD OpenBSD NetBSD DragonFly))
+ifeq ($(OSNAME), FreeBSD)
 	@$(MAKE) -C exports so
-	@ln -fs $(LIBSONAME) $(LIBPREFIX).so
+	@-ln -fs $(LIBSONAME) $(LIBPREFIX).so
+endif
+ifeq ($(OSNAME), 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
+	@-ln -fs $(LIBDYNNAME) $(LIBPREFIX).dylib
 endif
 ifeq ($(OSNAME), WINNT)
 	@$(MAKE) -C exports dll
@@ -120,22 +111,25 @@ endif
 endif
 
 tests :
-ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
+ifndef NOFORTRAN
+ifndef TARGET
+ifndef CROSS
 	touch $(LIBNAME)
 ifndef NO_FBLAS
 	$(MAKE) -C test all
-endif
+ifdef UTEST_CHECK
 	$(MAKE) -C utest all
+endif
+endif
 ifndef NO_CBLAS
 	$(MAKE) -C ctest all
-ifeq ($(CPP_THREAD_SAFETY_TEST), 1)
-	$(MAKE) -C cpp_thread_test all
+endif
 endif
 endif
 endif
 
 libs :
-ifeq ($(CORE), UNKNOWN)
+ifeq ($(CORE), UNKOWN)
 	$(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)
@@ -168,9 +162,6 @@ ifeq ($(DYNAMIC_ARCH), 1)
 	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
@@ -225,7 +216,7 @@ netlib :
 
 else
 netlib : lapack_prebuild
-ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
+ifndef NOFORTRAN
 	@$(MAKE) -C $(NETLIB_LAPACK_DIR) lapacklib
 	@$(MAKE) -C $(NETLIB_LAPACK_DIR) tmglib
 endif
@@ -234,48 +225,34 @@ ifndef NO_LAPACKE
 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
+ifndef NOFORTRAN
+	-@echo "FORTRAN     = $(FC)" > $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "OPTS        = $(LAPACK_FFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "POPTS       = $(LAPACK_FPFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "FFLAGS_NOOPT       = -O0 $(LAPACK_NOOPT)" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "NOOPT       = -O0 $(LAPACK_NOOPT)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "PNOOPT      = $(LAPACK_FPFLAGS) -O0" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "LDFLAGS     = $(FFLAGS) $(EXTRALIB)" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "LOADOPTS    = $(FFLAGS) $(EXTRALIB)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "CC          = $(CC)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "override CFLAGS      = $(LAPACK_CFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "AR          = $(AR)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "ARFLAGS     = $(ARFLAGS) -ru" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "ARCH        = $(AR)" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "ARCHFLAGS   = -ru" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "RANLIB      = $(RANLIB)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "LAPACKLIB   = ../../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "TMGLIB      = ../../../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "LAPACKLIB   = ../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "TMGLIB      = ../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "BLASLIB     = ../../../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
-	-@echo "LAPACKELIB  = ../../../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
+	-@echo "LAPACKELIB  = ../$(LIBNAME)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "LAPACKLIB_P = ../$(LIBNAME_P)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "SUFFIX      = $(SUFFIX)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "PSUFFIX     = $(PSUFFIX)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "CEXTRALIB   = $(EXTRALIB)" >> $(NETLIB_LAPACK_DIR)/make.inc
-ifeq ($(F_COMPILER), GFORTRAN)
+ifeq ($(FC), 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
@@ -283,55 +260,40 @@ 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
-	-@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)))
+ifndef NOFORTRAN
 	if [ ! -a $< ]; then
 	-wget http://www.netlib.org/lapack/timing/large.tgz;
 	fi
 endif
 
 timing.tgz :
-ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
+ifndef 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)))
+ifndef 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
+	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 )
+	make -j 1 -C $(NETLIB_LAPACK_DIR)/TESTING xeigtstc  xeigtstd  xeigtsts  xeigtstz  xlintstc  xlintstd  xlintstds  xlintstrfd  xlintstrfz  xlintsts  xlintstz  xlintstzc xlintstrfs xlintstrfc
 	(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)
+	(cd $(NETLIB_LAPACK_DIR)/BLAS && rm -f x* *.out)
+	make -j 1 -C $(NETLIB_LAPACK_DIR) blas_testing
+	(cd $(NETLIB_LAPACK_DIR)/BLAS && cat *.out)
 
 
 dummy :
@@ -357,7 +319,6 @@ endif
 	@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.arm

@@ -1,14 +1,33 @@
-ifeq ($(CORE), $(filter $(CORE),ARMV7 CORTEXA9 CORTEXA15))
+# ifeq logical or
+ifeq ($(CORE), $(filter $(CORE),CORTEXA9 CORTEXA15))
 ifeq ($(OSNAME), Android)
-CCOMMON_OPT += -mfpu=neon
-FCOMMON_OPT += -mfpu=neon
+CCOMMON_OPT += -marm -mfpu=neon  -mfloat-abi=hard -march=armv7-a
+FCOMMON_OPT += -marm -mfpu=neon  -mfloat-abi=hard -march=armv7-a
 else
-CCOMMON_OPT += -mfpu=vfpv3 -march=armv7-a
-FCOMMON_OPT += -mfpu=vfpv3 -march=armv7-a
+CCOMMON_OPT += -marm -mfpu=vfpv3  -mfloat-abi=hard -march=armv7-a
+FCOMMON_OPT += -marm -mfpu=vfpv3  -mfloat-abi=hard -march=armv7-a
+endif
+endif
+
+ifeq ($(CORE), ARMV7)
+ifeq ($(OSNAME), Android)
+CCOMMON_OPT += -marm -mfpu=neon  -mfloat-abi=hard -march=armv7-a
+FCOMMON_OPT += -marm -mfpu=neon  -mfloat-abi=hard -march=armv7-a
+else
+CCOMMON_OPT += -marm -mfpu=vfpv3  -mfloat-abi=hard -march=armv7-a
+FCOMMON_OPT += -marm -mfpu=vfpv3  -mfloat-abi=hard -march=armv7-a
 endif
 endif
 
 ifeq ($(CORE), ARMV6)
-CCOMMON_OPT += -mfpu=vfp
-FCOMMON_OPT += -mfpu=vfp
+CCOMMON_OPT += -marm -mfpu=vfp -mfloat-abi=hard  -march=armv6
+FCOMMON_OPT += -marm -mfpu=vfp -mfloat-abi=hard  -march=armv6
 endif
+
+
+ifeq ($(CORE), ARMV5)
+CCOMMON_OPT += -marm -mfpu=vfp -mfloat-abi=hard  -march=armv6
+FCOMMON_OPT += -marm -mfpu=vfp -mfloat-abi=hard  -march=armv6
+endif
+
+

Makefile.arm64

@@ -4,45 +4,4 @@ CCOMMON_OPT += -march=armv8-a
 FCOMMON_OPT += -march=armv8-a
 endif
 
-ifeq ($(CORE), CORTEXA53)
-CCOMMON_OPT += -march=armv8-a -mtune=cortex-a53
-FCOMMON_OPT += -march=armv8-a -mtune=cortex-a53
-endif
-
-ifeq ($(CORE), CORTEXA57)
-CCOMMON_OPT += -march=armv8-a -mtune=cortex-a57
-FCOMMON_OPT += -march=armv8-a -mtune=cortex-a57
-endif
-
-ifeq ($(CORE), CORTEXA72)
-CCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
-FCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
-endif
-
-ifeq ($(CORE), CORTEXA73)
-CCOMMON_OPT += -march=armv8-a -mtune=cortex-a73
-FCOMMON_OPT += -march=armv8-a -mtune=cortex-a73
-endif
-
-ifeq ($(CORE), THUNDERX)
-CCOMMON_OPT += -march=armv8-a -mtune=thunderx
-FCOMMON_OPT += -march=armv8-a -mtune=thunderx
-endif
-
-ifeq ($(CORE), FALKOR)
-CCOMMON_OPT += -march=armv8-a -mtune=falkor
-FCOMMON_OPT += -march=armv8-a -mtune=falkor
-endif
-
-ifeq ($(CORE), THUNDERX2T99)
-CCOMMON_OPT += -march=armv8.1-a -mtune=thunderx2t99
-FCOMMON_OPT += -march=armv8.1-a -mtune=thunderx2t99
-endif
-
-ifeq ($(GCCVERSIONGTEQ9), 1)
-ifeq ($(CORE), TSV110)
-CCOMMON_OPT += -march=armv8.2-a -mtune=tsv110
-FCOMMON_OPT += -march=armv8.2-a -mtune=tsv110
-endif
-endif
 

Makefile.install

@@ -11,8 +11,6 @@ OPENBLAS_BINARY_DIR := $(PREFIX)/bin
 OPENBLAS_BUILD_DIR := $(CURDIR)
 OPENBLAS_CMAKE_DIR := $(OPENBLAS_LIBRARY_DIR)/cmake/openblas
 OPENBLAS_CMAKE_CONFIG := OpenBLASConfig.cmake
-OPENBLAS_CMAKE_CONFIG_VERSION := OpenBLASConfigVersion.cmake
-OPENBLAS_PKGCONFIG_DIR := $(OPENBLAS_LIBRARY_DIR)/pkgconfig
 
 .PHONY : install
 .NOTPARALLEL : install
@@ -21,151 +19,98 @@ 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)"
+	@-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)
 	@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 \#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"
+	@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)
-	@sed 's/common/openblas_config/g' cblas.h > "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/cblas.h"
+	@sed 's/common/openblas_config/g' cblas.h > $(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/cblas.h
 endif
 
-ifneq ($(OSNAME), AIX)
 ifndef NO_LAPACKE
 	@echo Copying LAPACKE header files to $(DESTDIR)$(OPENBLAS_INCLUDE_DIR)
-	@-install -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"
+	@-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 $(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)
+ifndef NO_STATIC
 	@echo Copying the static library to $(DESTDIR)$(OPENBLAS_LIBRARY_DIR)
-	@install -pm644 $(LIBNAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
-	@cd "$(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)
+ifndef NO_SHARED
 	@echo Copying the shared library to $(DESTDIR)$(OPENBLAS_LIBRARY_DIR)
-ifeq ($(OSNAME), $(filter $(OSNAME),Linux SunOS Android Haiku))
-	@install -pm755 $(LIBSONAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
-	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
+ifeq ($(OSNAME), Linux)
+	@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),FreeBSD OpenBSD NetBSD DragonFly))
-	@cp $(LIBSONAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
-	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
+ifeq ($(OSNAME), FreeBSD)
+	@cp $(LIBSONAME) $(DESTDIR)$(OPENBLAS_LIBRARY_DIR)
+	@cd $(DESTDIR)$(OPENBLAS_LIBRARY_DIR) ; \
+	ln -fs $(LIBSONAME) $(LIBPREFIX).so
+endif
+ifeq ($(OSNAME), 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 "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)/$(LIBDYNNAME)" "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)/$(LIBDYNNAME)"
-	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
-	ln -fs $(LIBDYNNAME) $(LIBPREFIX).dylib ; \
-	ln -fs $(LIBDYNNAME) $(LIBPREFIX).$(MAJOR_VERSION).dylib
+	@-cp $(LIBDYNNAME) $(DESTDIR)$(OPENBLAS_LIBRARY_DIR)
+	@-install_name_tool -id $(DESTDIR)$(OPENBLAS_LIBRARY_DIR)/$(LIBDYNNAME) $(DESTDIR)$(OPENBLAS_LIBRARY_DIR)/$(LIBDYNNAME)
+	@cd $(DESTDIR)$(OPENBLAS_LIBRARY_DIR) ; \
+	ln -fs $(LIBDYNNAME) $(LIBPREFIX).dylib
 endif
 ifeq ($(OSNAME), WINNT)
-	@-cp $(LIBDLLNAME) "$(DESTDIR)$(OPENBLAS_BINARY_DIR)"
-	@-cp $(IMPLIBNAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
+	@-cp $(LIBDLLNAME) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@-cp $(LIBDLLNAME).a $(DESTDIR)$(OPENBLAS_LIBRARY_DIR)
 endif
 ifeq ($(OSNAME), CYGWIN_NT)
-	@-cp $(LIBDLLNAME) "$(DESTDIR)$(OPENBLAS_BINARY_DIR)"
-	@-cp $(IMPLIBNAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
+	@-cp $(LIBDLLNAME) $(OPENBLAS_BINARY_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 openblas.pc in "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)"
-	@echo 'libdir='$(OPENBLAS_LIBRARY_DIR) > "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/openblas.pc"
-	@echo 'includedir='$(OPENBLAS_INCLUDE_DIR) >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/openblas.pc"
-	@echo 'openblas_config= USE_64BITINT='$(USE_64BITINT) 'DYNAMIC_ARCH='$(DYNAMIC_ARCH) 'DYNAMIC_OLDER='$(DYNAMIC_OLDER) 'NO_CBLAS='$(NO_CBLAS) 'NO_LAPACK='$(NO_LAPACK) 'NO_LAPACKE='$(NO_LAPACKE) 'NO_AFFINITY='$(NO_AFFINITY) 'USE_OPENMP='$(USE_OPENMP) $(CORE) 'MAX_THREADS='$(NUM_THREADS)>> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/openblas.pc"
-	@echo 'version='$(VERSION) >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/openblas.pc"
-	@echo 'extralib='$(EXTRALIB) >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/openblas.pc"
-	@cat openblas.pc.in >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/openblas.pc"
-
-
 #Generating OpenBLASConfig.cmake
 	@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)
+	@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)
+ifndef NO_SHARED
 #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)"
+ifeq ($(OSNAME), $(filter $(OSNAME),Linux FreeBSD NetBSD))
+	@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)"
+	@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)"
+	@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)"
+	@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.power

@@ -1,38 +1,4 @@
-
-ifdef USE_THREAD
-ifeq ($(USE_THREAD), 0)
-USE_OPENMP = 0
-else
-USE_OPENMP = 1
-endif
-else
-USE_OPENMP = 1
-endif
-
-ifeq ($(CORE), POWER9)
-ifeq ($(USE_OPENMP), 1)
-COMMON_OPT += -Ofast -mcpu=power9 -mtune=power9 -mvsx -malign-power -DUSE_OPENMP -fno-fast-math -fopenmp
-FCOMMON_OPT += -O2 -frecursive -mcpu=power9 -mtune=power9 -malign-power -DUSE_OPENMP -fno-fast-math -fopenmp
-else
-COMMON_OPT += -Ofast -mcpu=power9 -mtune=power9 -mvsx -malign-power -fno-fast-math
-FCOMMON_OPT += -O2 -frecursive -mcpu=power9 -mtune=power9 -malign-power -fno-fast-math
-endif
-endif
-
-ifeq ($(CORE), POWER8)
-ifeq ($(USE_OPENMP), 1)
-COMMON_OPT += -Ofast -mcpu=power8 -mtune=power8 -mvsx -malign-power -DUSE_OPENMP -fno-fast-math -fopenmp
-FCOMMON_OPT += -O2 -frecursive -mcpu=power8 -mtune=power8 -malign-power -DUSE_OPENMP -fno-fast-math -fopenmp
-else
-COMMON_OPT += -Ofast -mcpu=power8 -mtune=power8 -mvsx -malign-power -fno-fast-math
-FCOMMON_OPT += -O2 -frecursive -mcpu=power8 -mtune=power8 -malign-power -fno-fast-math
-endif
-endif
-
-# workaround for C->FORTRAN ABI violation in LAPACKE
-ifeq ($(F_COMPILER), GFORTRAN)
-FCOMMON_OPT += -fno-optimize-sibling-calls
-endif
+# CCOMMON_OPT	+= -DALLOC_SHM
 
 FLAMEPATH	= $(HOME)/flame/lib
 
@@ -50,16 +16,6 @@ else
 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
 
 

Makefile.prebuild

@@ -17,34 +17,14 @@ ifdef CPUIDEMU
 EXFLAGS = -DCPUIDEMU -DVENDOR=99
 endif
 
-ifeq ($(TARGET), 1004K)
-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
-
 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)
+	perl ./c_check $(TARGET_MAKE) $(TARGET_CONF) $(CC)
 ifneq ($(ONLY_CBLAS), 1)
-	perl ./f_check $(TARGET_MAKE) $(TARGET_CONF) $(FC) $(TARGET_FLAGS)
+	perl ./f_check $(TARGET_MAKE) $(TARGET_CONF) $(FC)
 else
 #When we only build CBLAS, we set NOFORTRAN=2
 	echo "NOFORTRAN=2" >> $(TARGET_MAKE)

Makefile.rule

@@ -3,7 +3,7 @@
 #
 
 # This library's version
-VERSION = 0.3.8
+VERSION = 0.2.14
 
 # If you set the suffix, the library name will be libopenblas_$(LIBNAMESUFFIX).a
 # and libopenblas_$(LIBNAMESUFFIX).so. Meanwhile, the soname in shared library
@@ -17,11 +17,6 @@ VERSION = 0.3.8
 # 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
@@ -48,8 +43,6 @@ VERSION = 0.3.8
 # 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
@@ -58,83 +51,40 @@ VERSION = 0.3.8
 # 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.
+# You can define maximum number of threads. Basically it should be
+# less than actual number of cores. If you don't specify one, it's
+# automatically detected by the the script.
 # 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
-
-# If you don't need to install the static library, please comment this in.
+# if you don't need to install the static library, please comment it in.
 # NO_STATIC = 1
 
-# If you don't need to generate the shared library, please comment this in.
+# if you don't need generate the shared library, please comment it in.
 # NO_SHARED = 1
 
-# If you don't need the CBLAS interface, please comment this in.
+# If you don't need CBLAS interface, please comment it in.
 # NO_CBLAS = 1
 
-# If you only want the CBLAS interface without installing a Fortran compiler,
-# please comment this in.
+# If you only want CBLAS interface without installing Fortran compiler,
+# please comment it 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.
+# If you don't need LAPACK, please comment it in.
+# If you set NO_LAPACK=1, the library automatically sets NO_LAPACKE=1.
 # NO_LAPACK = 1
 
-# If you don't need LAPACKE (C Interface to LAPACK), please comment this in.
+# If you don't need LAPACKE (C Interface to LAPACK), please comment it 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.
+# If you want to use 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).
+# compiler supports this. It's safe to keep comment it out if you
+# are not sure(equivalent to "-i8" option).
 # INTERFACE64 = 1
 
 # Unfortunately most of kernel won't give us high quality buffer.
@@ -142,18 +92,10 @@ BUILD_LAPACK_DEPRECATED = 1
 # 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
+# If you want to disable CPU/Memory affinity on Linux.
 NO_AFFINITY = 1
 
-# If you are compiling for Linux and you have more than 16 numa nodes or more than 256 cpus
+# 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
@@ -163,67 +105,55 @@ NO_AFFINITY = 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
 
+# Support for integer matrix and vector (e.g. iaxpy)
+# INTEGER_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
+# system). Also you can control this mumber by THREAD_TIMEOUT
 # CCOMMON_OPT	+= -DTHREAD_TIMEOUT=26
 
-# Using special device driver for mapping physically contiguous memory
+# Using special device driver for mapping physically contigous 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).
+# If any gemm arguement m, n or k is less or equal this threshold, gemm will be execute
+# with single thread. You can use this flag to avoid the overhead of multi-threading
+# in small matrix sizes. The default value is 4.
 # GEMM_MULTITHREAD_THRESHOLD = 4
 
-# If you need sanity check by comparing results to reference BLAS. It'll be very
+# If you need santy check by comparing reference BLAS. It'll be very
 # slow (Not implemented yet).
 # SANITY_CHECK = 1
 
+# Run testcases in utest/ . When you enable UTEST_CHECK, it would enable
+# SANITY_CHECK to compare the result with reference BLAS.
+# UTEST_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
+# gfortran option for LAPACK
+# enable this flag only on 64bit Linux and if you need a thread safe lapack library
 # FCOMMON_OPT = -frecursive
 
 # Profiling flags
@@ -232,38 +162,19 @@ 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
+# Improve GEMV and GER for small matrices by stack allocation.
+# For details, https://github.com/xianyi/OpenBLAS/pull/482
 #
-# MAX_STACK_ALLOC = 0
+ MAX_STACK_ALLOC=2048
 
 # 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
-
 #
 #  End of user configuration
 #

Makefile.system

@@ -9,26 +9,6 @@ ifndef TOPDIR
 TOPDIR = .
 endif
 
-# If ARCH is not set, we use the host system's architecture for getarch compile options.
-ifndef ARCH
-HOSTARCH := $(shell uname -m)
-else
-HOSTARCH = $(ARCH)
-endif
-
-# Catch conflicting usage of ARCH in some BSD environments
-ifeq ($(ARCH), amd64)
-override ARCH=x86_64
-else ifeq ($(ARCH), powerpc64)
-override ARCH=power
-else ifeq ($(ARCH), i386)
-override ARCH=x86
-else ifeq ($(ARCH), aarch64)
-override ARCH=arm64
-else ifeq ($(ARCH), zarch)
-override ARCH=zarch
-endif
-
 NETLIB_LAPACK_DIR = $(TOPDIR)/lapack-netlib
 
 # Default C compiler
@@ -37,24 +17,15 @@ NETLIB_LAPACK_DIR = $(TOPDIR)/lapack-netlib
 #   http://stackoverflow.com/questions/4029274/mingw-and-make-variables
 # - Default value is 'cc' which is not always a valid command (e.g. MinGW).
 ifeq ($(origin CC),default)
-
-# Check if $(CC) refers to a valid command and set the value to gcc if not
-ifneq ($(findstring cmd.exe,$(SHELL)),)
-ifeq ($(shell where $(CC) 2>NUL),)
 CC = gcc
+# Change the default compile to clang on Mac OSX.
+# http://stackoverflow.com/questions/714100/os-detecting-makefile
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Darwin)
+     CC = clang
+#     EXTRALIB += -Wl,-no_compact_unwind
+endif
 endif
-else # POSIX-ish
-ifeq ($(shell command -v $(CC) 2>/dev/null),)
-ifeq ($(shell uname -s),Darwin)
-CC = clang
-# EXTRALIB += -Wl,-no_compact_unwind
-else
-CC = gcc
-endif # Darwin
-endif # CC exists
-endif # Shell is sane
-
-endif # CC is set to default
 
 # Default Fortran compiler (FC) is selected by f_check.
 
@@ -74,7 +45,6 @@ endif
 
 ifdef TARGET
 GETARCH_FLAGS := -DFORCE_$(TARGET)
-GETARCH_FLAGS += -DUSER_TARGET
 endif
 
 # Force fallbacks for 32bit
@@ -83,9 +53,6 @@ ifeq ($(BINARY), 32)
 ifeq ($(TARGET), HASWELL)
 GETARCH_FLAGS := -DFORCE_NEHALEM
 endif
-ifeq ($(TARGET), SKYLAKEX)
-GETARCH_FLAGS := -DFORCE_NEHALEM
-endif
 ifeq ($(TARGET), SANDYBRIDGE)
 GETARCH_FLAGS := -DFORCE_NEHALEM
 endif
@@ -101,12 +68,6 @@ endif
 ifeq ($(TARGET), EXCAVATOR)
 GETARCH_FLAGS := -DFORCE_BARCELONA
 endif
-ifeq ($(TARGET), ZEN)
-GETARCH_FLAGS := -DFORCE_BARCELONA
-endif
-ifeq ($(TARGET), ARMV8)
-GETARCH_FLAGS := -DFORCE_ARMV7
-endif
 endif
 
 
@@ -122,9 +83,6 @@ ifeq ($(BINARY), 32)
 ifeq ($(TARGET_CORE), HASWELL)
 GETARCH_FLAGS := -DFORCE_NEHALEM
 endif
-ifeq ($(TARGET_CORE), SKYLAKEX)
-GETARCH_FLAGS := -DFORCE_NEHALEM
-endif
 ifeq ($(TARGET_CORE), SANDYBRIDGE)
 GETARCH_FLAGS := -DFORCE_NEHALEM
 endif
@@ -140,18 +98,10 @@ endif
 ifeq ($(TARGET_CORE), EXCAVATOR)
 GETARCH_FLAGS := -DFORCE_BARCELONA
 endif
-ifeq ($(TARGET_CORE), ZEN)
-GETARCH_FLAGS := -DFORCE_BARCELONA
-endif
 endif
 
 
-# On x86_64 build getarch with march=native unless the compiler is PGI. This is required to detect AVX512 support in getarch.
-ifeq ($(HOSTARCH), x86_64)
-ifeq ($(findstring pgcc,$(HOSTCC)),)
-GETARCH_FLAGS += -march=native
-endif
-endif
+
 
 ifdef INTERFACE64
 ifneq ($(INTERFACE64), 0)
@@ -169,18 +119,13 @@ GETARCH_FLAGS	+= -DNO_AVX
 endif
 
 ifeq ($(BINARY), 32)
-GETARCH_FLAGS	+= -DNO_AVX -DNO_AVX2 -DNO_AVX512
-NO_AVX512 = 1
+GETARCH_FLAGS	+= -DNO_AVX
 endif
 
 ifeq ($(NO_AVX2), 1)
 GETARCH_FLAGS	+= -DNO_AVX2
 endif
 
-ifeq ($(NO_AVX512), 1)
-GETARCH_FLAGS	+= -DNO_AVX512
-endif
-
 ifeq ($(DEBUG), 1)
 GETARCH_FLAGS	+= -g
 endif
@@ -194,10 +139,6 @@ NO_PARALLEL_MAKE=0
 endif
 GETARCH_FLAGS	+= -DNO_PARALLEL_MAKE=$(NO_PARALLEL_MAKE)
 
-ifdef MAKE_NB_JOBS
-GETARCH_FLAGS += -DMAKE_NB_JOBS=$(MAKE_NB_JOBS)
-endif
-
 ifeq ($(HOSTCC), loongcc)
 GETARCH_FLAGS  += -static
 endif
@@ -214,7 +155,7 @@ ifndef GOTOBLAS_MAKEFILE
 export GOTOBLAS_MAKEFILE = 1
 
 # Generating Makefile.conf and config.h
-DUMMY := $(shell $(MAKE) -C $(TOPDIR) -f Makefile.prebuild CC="$(CC)" FC="$(FC)" HOSTCC="$(HOSTCC)" CFLAGS="$(GETARCH_FLAGS)" BINARY=$(BINARY) USE_OPENMP=$(USE_OPENMP) TARGET_CORE=$(TARGET_CORE) ONLY_CBLAS=$(ONLY_CBLAS) TARGET=$(TARGET) all)
+DUMMY := $(shell $(MAKE) -C $(TOPDIR) -f Makefile.prebuild CC="$(CC)" FC="$(FC)" HOSTCC="$(HOSTCC)" CFLAGS="$(GETARCH_FLAGS)" BINARY=$(BINARY) USE_OPENMP=$(USE_OPENMP) TARGET_CORE=$(TARGET_CORE) ONLY_CBLAS=$(ONLY_CBLAS) all)
 
 ifndef TARGET_CORE
 include $(TOPDIR)/Makefile.conf
@@ -224,17 +165,12 @@ endif
 
 endif
 
-ifndef NUM_PARALLEL
-NUM_PARALLEL = 1
-endif
-
 ifndef NUM_THREADS
 NUM_THREADS = $(NUM_CORES)
 endif
 
 ifeq ($(NUM_THREADS), 1)
 override USE_THREAD = 0
-override USE_OPENMP = 0
 endif
 
 ifdef USE_THREAD
@@ -251,10 +187,6 @@ SMP = 1
 endif
 endif
 
-ifeq ($(SMP), 1)
-USE_LOCKING = 
-endif
-
 ifndef NEED_PIC
 NEED_PIC = 1
 endif
@@ -271,10 +203,9 @@ OBJCOPY = $(CROSS_SUFFIX)objcopy
 OBJCONV = $(CROSS_SUFFIX)objconv
 
 
-# When fortran support was either not detected or actively deselected, only build BLAS.
+# For detect fortran failed, only build BLAS.
 ifeq ($(NOFORTRAN), 1)
 NO_LAPACK = 1
-override FEXTRALIB = 
 endif
 
 #
@@ -282,13 +213,11 @@ endif
 #
 
 ifeq ($(OSNAME), Darwin)
-ifndef MACOSX_DEPLOYMENT_TARGET
-export MACOSX_DEPLOYMENT_TARGET=10.8
-endif
+export MACOSX_DEPLOYMENT_TARGET=10.6
 MD5SUM = md5 -r
 endif
 
-ifneq (,$(findstring $(OSNAME), FreeBSD OpenBSD DragonFly))
+ifeq ($(OSNAME), FreeBSD)
 MD5SUM = md5 -r
 endif
 
@@ -301,10 +230,6 @@ EXTRALIB	+= -lm
 NO_EXPRECISION = 1
 endif
 
-ifeq ($(OSNAME), Android)
-EXTRALIB	+= -lm
-endif
-
 ifeq ($(OSNAME), AIX)
 EXTRALIB	+= -lm
 endif
@@ -324,14 +249,12 @@ CCOMMON_OPT	+= -DMS_ABI
 endif
 
 ifeq ($(C_COMPILER), GCC)
-#Version tests for supporting specific features (MS_ABI, POWER9 intrinsics)
+#Test for supporting MS_ABI
 GCCVERSIONGTEQ4 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 4)
 GCCVERSIONGT4 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \> 4)
-GCCVERSIONGT5 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \> 5)
-GCCVERSIONGTEQ9 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 9)
 GCCMINORVERSIONGTEQ7 := $(shell expr `$(CC) -dumpversion | cut -f2 -d.` \>= 7)
 ifeq ($(GCCVERSIONGT4), 1)
-# GCC Major version > 4
+# GCC Majar version > 4
 # It is compatible with MSVC ABI.
 CCOMMON_OPT	+= -DMS_ABI
 endif
@@ -364,20 +287,17 @@ endif
 ifeq ($(OSNAME), CYGWIN_NT)
 NEED_PIC = 0
 NO_EXPRECISION = 1
-OS_CYGWIN_NT = 1
 endif
 
 ifneq ($(OSNAME), WINNT)
 ifneq ($(OSNAME), CYGWIN_NT)
 ifneq ($(OSNAME), Interix)
-ifneq ($(OSNAME), Android)
 ifdef SMP
 EXTRALIB   += -lpthread
 endif
 endif
 endif
 endif
-endif
 
 # ifeq logical or
 ifeq ($(OSNAME), $(filter $(OSNAME),WINNT CYGWIN_NT Interix))
@@ -389,6 +309,10 @@ CCOMMON_OPT	+= -DQUAD_PRECISION
 NO_EXPRECISION = 1
 endif
 
+ifdef INTEGER_PRECISION
+CCOMMON_OPT	+= -DINTEGER_PRECISION
+endif
+
 ifneq ($(ARCH), x86)
 ifneq ($(ARCH), x86_64)
 NO_EXPRECISION = 1
@@ -404,17 +328,10 @@ ifdef SANITY_CHECK
 CCOMMON_OPT	+= -DSANITY_CHECK -DREFNAME=$(*F)f$(BU)
 endif
 
-MAX_STACK_ALLOC ?= 2048
-ifneq ($(MAX_STACK_ALLOC), 0)
+ifdef MAX_STACK_ALLOC
 CCOMMON_OPT	+= -DMAX_STACK_ALLOC=$(MAX_STACK_ALLOC)
 endif
 
-ifdef USE_LOCKING
-ifneq ($(USE_LOCKING), 0)
-CCOMMON_OPT	+= -DUSE_LOCKING
-endif
-endif
-
 #
 #  Architecture dependent settings
 #
@@ -423,11 +340,6 @@ ifeq ($(ARCH), x86)
 ifndef BINARY
 NO_BINARY_MODE	= 1
 endif
-
-ifeq ($(CORE), generic)
-NO_EXPRECISION = 1
-endif
-
 ifndef NO_EXPRECISION
 ifeq ($(F_COMPILER), GFORTRAN)
 # ifeq logical or. GCC or LSB
@@ -446,11 +358,6 @@ endif
 endif
 
 ifeq ($(ARCH), x86_64)
-
-ifeq ($(CORE), generic)
-NO_EXPRECISION = 1
-endif
-
 ifndef NO_EXPRECISION
 ifeq ($(F_COMPILER), GFORTRAN)
 # ifeq logical or. GCC or LSB
@@ -461,7 +368,7 @@ FCOMMON_OPT	+= -m128bit-long-double
 endif
 ifeq ($(C_COMPILER), CLANG)
 EXPRECISION	= 1
-CCOMMON_OPT	+= -DEXPRECISION
+CCOMMON_OPT	+= -DEXPRECISION 
 FCOMMON_OPT	+= -m128bit-long-double
 endif
 endif
@@ -475,7 +382,7 @@ endif
 
 ifeq ($(USE_OPENMP), 1)
 
-#check
+#check 
 ifeq ($(USE_THREAD), 0)
 $(error OpenBLAS: Cannot set both USE_OPENMP=1 and USE_THREAD=0. The USE_THREAD=0 is only for building single thread version.)
 endif
@@ -486,11 +393,12 @@ CCOMMON_OPT    += -fopenmp
 endif
 
 ifeq ($(C_COMPILER), CLANG)
+$(error OpenBLAS: Clang didn't support OpenMP yet.)
 CCOMMON_OPT    += -fopenmp
 endif
 
 ifeq ($(C_COMPILER), INTEL)
-CCOMMON_OPT    += -fopenmp
+CCOMMON_OPT    += -openmp
 endif
 
 ifeq ($(C_COMPILER), PGI)
@@ -515,74 +423,17 @@ DYNAMIC_CORE = KATMAI COPPERMINE NORTHWOOD PRESCOTT BANIAS \
 endif
 
 ifeq ($(ARCH), x86_64)
-DYNAMIC_CORE = PRESCOTT CORE2 
-ifeq ($(DYNAMIC_OLDER), 1)
-DYNAMIC_CORE += PENRYN DUNNINGTON 
-endif
-DYNAMIC_CORE += NEHALEM 
-ifeq ($(DYNAMIC_OLDER), 1)
-DYNAMIC_CORE += OPTERON OPTERON_SSE3 
-endif
-DYNAMIC_CORE += BARCELONA 
-ifeq ($(DYNAMIC_OLDER), 1)
-DYNAMIC_CORE += BOBCAT ATOM NANO
-endif
+DYNAMIC_CORE = PRESCOTT CORE2 PENRYN DUNNINGTON NEHALEM OPTERON OPTERON_SSE3 BARCELONA BOBCAT ATOM NANO
 ifneq ($(NO_AVX), 1)
 DYNAMIC_CORE += SANDYBRIDGE BULLDOZER PILEDRIVER STEAMROLLER EXCAVATOR
 endif
 ifneq ($(NO_AVX2), 1)
-DYNAMIC_CORE += HASWELL ZEN
-endif
-ifneq ($(NO_AVX512), 1)
-ifneq ($(NO_AVX2), 1)
-DYNAMIC_CORE += SKYLAKEX
-endif
+DYNAMIC_CORE += HASWELL
 endif
 endif
 
-ifdef DYNAMIC_LIST
-override DYNAMIC_CORE = PRESCOTT $(DYNAMIC_LIST)
-XCCOMMON_OPT = -DDYNAMIC_LIST -DDYN_PRESCOTT
-XCCOMMON_OPT += $(foreach dcore,$(DYNAMIC_LIST),-DDYN_$(dcore))
-CCOMMON_OPT += $(XCCOMMON_OPT)
-#CCOMMON_OPT	+= -DDYNAMIC_LIST='$(DYNAMIC_LIST)'
-endif
-
-ifeq ($(ARCH), arm64)
-DYNAMIC_CORE =  ARMV8
-DYNAMIC_CORE += CORTEXA53
-DYNAMIC_CORE += CORTEXA57
-DYNAMIC_CORE += CORTEXA72
-DYNAMIC_CORE += CORTEXA73
-DYNAMIC_CORE += FALKOR
-DYNAMIC_CORE += THUNDERX
-DYNAMIC_CORE += THUNDERX2T99
-DYNAMIC_CORE += TSV110
-endif
-
-ifeq ($(ARCH), zarch)
-DYNAMIC_CORE = Z13
-DYNAMIC_CORE += Z14
-endif
-
-ifeq ($(ARCH), power)
-DYNAMIC_CORE = POWER6
-DYNAMIC_CORE += POWER8
-ifneq ($(C_COMPILER), GCC)
-DYNAMIC_CORE += POWER9
-endif
-ifeq ($(C_COMPILER), GCC)
-ifeq ($(GCCVERSIONGT5), 1)
-DYNAMIC_CORE += POWER9
-else
-$(info, OpenBLAS: Your gcc version is too old to build the POWER9 kernels.)
-endif
-endif
-endif
-
-# If DYNAMIC_CORE is not set, DYNAMIC_ARCH cannot do anything, so force it to empty
 ifndef DYNAMIC_CORE
-override DYNAMIC_ARCH=
+DYNAMIC_ARCH =
 endif
 endif
 
@@ -598,7 +449,7 @@ endif
 endif
 endif
 
-ifeq ($(ARCH), $(filter $(ARCH),mips64 mips))
+ifeq ($(ARCH), mips64)
 NO_BINARY_MODE	= 1
 endif
 
@@ -610,23 +461,6 @@ endif
 ifeq ($(ARCH), arm)
 NO_BINARY_MODE  = 1
 BINARY_DEFINED  = 1
-
-CCOMMON_OPT += -marm
-FCOMMON_OPT += -marm
-
-# If softfp abi is mentioned on the command line, force it.
-ifeq ($(ARM_SOFTFP_ABI), 1)
-CCOMMON_OPT += -mfloat-abi=softfp
-FCOMMON_OPT += -mfloat-abi=softfp
-endif
-
-ifeq ($(OSNAME), Android)
-ifeq ($(ARM_SOFTFP_ABI), 1)
-EXTRALIB	+= -lm
-else
-EXTRALIB	+= -Wl,-lm_hard
-endif
-endif
 endif
 
 ifeq ($(ARCH), arm64)
@@ -655,16 +489,13 @@ endif
 
 ifdef NO_BINARY_MODE
 
-ifeq ($(ARCH), $(filter $(ARCH),mips64))
+ifeq ($(ARCH), mips64)
 ifdef BINARY64
 CCOMMON_OPT += -mabi=64
 else
 CCOMMON_OPT += -mabi=n32
 endif
 BINARY_DEFINED = 1
-else ifeq ($(ARCH), $(filter $(ARCH),mips))
-CCOMMON_OPT += -mabi=32
-BINARY_DEFINED = 1
 endif
 
 ifeq ($(CORE), LOONGSON3A)
@@ -677,31 +508,6 @@ CCOMMON_OPT += -march=mips64
 FCOMMON_OPT += -march=mips64
 endif
 
-ifeq ($(CORE), 1004K)
-CCOMMON_OPT += -mips32r2   $(MSA_FLAGS)
-FCOMMON_OPT += -mips32r2   $(MSA_FLAGS)
-endif
-
-ifeq ($(CORE), P5600)
-CCOMMON_OPT += -mips32r5 -mnan=2008 -mtune=p5600  $(MSA_FLAGS)
-FCOMMON_OPT += -mips32r5 -mnan=2008 -mtune=p5600  $(MSA_FLAGS)
-endif
-
-ifeq ($(CORE), I6400)
-CCOMMON_OPT += -mips64r6 -mnan=2008 -mtune=i6400 $(MSA_FLAGS)
-FCOMMON_OPT += -mips64r6 -mnan=2008 -mtune=i6400 $(MSA_FLAGS)
-endif
-
-ifeq ($(CORE), P6600)
-CCOMMON_OPT += -mips64r6 -mnan=2008 -mtune=p6600 $(MSA_FLAGS)
-FCOMMON_OPT += -mips64r6 -mnan=2008 -mtune=p6600 $(MSA_FLAGS)
-endif
-
-ifeq ($(CORE), I6500)
-CCOMMON_OPT += -mips64r6 -mnan=2008 -mtune=i6400 $(MSA_FLAGS)
-FCOMMON_OPT += -mips64r6 -mnan=2008 -mtune=i6400 $(MSA_FLAGS)
-endif
-
 ifeq ($(OSNAME), AIX)
 BINARY_DEFINED = 1
 endif
@@ -709,20 +515,18 @@ endif
 endif
 
 ifndef BINARY_DEFINED
-ifneq ($(OSNAME), AIX)
 ifdef BINARY64
 CCOMMON_OPT += -m64
 else
 CCOMMON_OPT += -m32
 endif
 endif
-endif
 
 endif
 
 ifeq ($(C_COMPILER), PGI)
 ifdef BINARY64
-CCOMMON_OPT += -tp p7-64 -D__MMX__ -Mnollvm
+CCOMMON_OPT += -tp p7-64
 else
 CCOMMON_OPT += -tp p7
 endif
@@ -740,28 +544,10 @@ endif
 #  Fortran Compiler dependent settings
 #
 
-ifeq ($(F_COMPILER), FLANG)
-CCOMMON_OPT += -DF_INTERFACE_FLANG
-ifdef BINARY64
-ifdef INTERFACE64
-ifneq ($(INTERFACE64), 0)
-FCOMMON_OPT += -i8
-endif
-endif
-FCOMMON_OPT += -Wall
-else
-FCOMMON_OPT += -Wall
-endif
-ifeq ($(USE_OPENMP), 1)
-FCOMMON_OPT += -fopenmp
-endif
-endif
-
 ifeq ($(F_COMPILER), G77)
 CCOMMON_OPT += -DF_INTERFACE_G77
 FCOMMON_OPT += -Wall
 ifndef NO_BINARY_MODE
-ifneq ($(OSNAME), AIX)
 ifdef BINARY64
 FCOMMON_OPT += -m64
 else
@@ -769,12 +555,10 @@ FCOMMON_OPT += -m32
 endif
 endif
 endif
-endif
 
 ifeq ($(F_COMPILER), G95)
 CCOMMON_OPT += -DF_INTERFACE_G95
 FCOMMON_OPT += -Wall
-ifneq ($(OSNAME), AIX)
 ifndef NO_BINARY_MODE
 ifdef BINARY64
 FCOMMON_OPT += -m64
@@ -782,49 +566,35 @@ else
 FCOMMON_OPT += -m32
 endif
 endif
-ifneq ($(NO_LAPACKE), 1)
-FCOMMON_OPT += -fno-second-underscore
-endif
-endif
 endif
 
 ifeq ($(F_COMPILER), GFORTRAN)
 CCOMMON_OPT += -DF_INTERFACE_GFORT
 FCOMMON_OPT += -Wall
-# make single-threaded LAPACK calls thread-safe #1847
-FCOMMON_OPT += -frecursive
-# work around ABI problem with passing single-character arguments
-FCOMMON_OPT += -fno-optimize-sibling-calls
 #Don't include -lgfortran, when NO_LAPACK=1 or lsbcc
 ifneq ($(NO_LAPACK), 1)
 EXTRALIB += -lgfortran
 endif
 ifdef NO_BINARY_MODE
-ifeq ($(ARCH), $(filter $(ARCH),mips64))
+ifeq ($(ARCH), mips64)
 ifdef BINARY64
 FCOMMON_OPT += -mabi=64
 else
 FCOMMON_OPT += -mabi=n32
 endif
-else ifeq ($(ARCH), $(filter $(ARCH),mips))
-FCOMMON_OPT += -mabi=32
 endif
 else
 ifdef BINARY64
-ifneq ($(OSNAME), AIX)
 FCOMMON_OPT += -m64
-endif
 ifdef INTERFACE64
 ifneq ($(INTERFACE64), 0)
 FCOMMON_OPT +=  -fdefault-integer-8
 endif
 endif
 else
-ifneq ($(OSNAME), AIX)
 FCOMMON_OPT += -m32
 endif
 endif
-endif
 ifeq ($(USE_OPENMP), 1)
 FCOMMON_OPT += -fopenmp
 endif
@@ -838,7 +608,7 @@ FCOMMON_OPT += -i8
 endif
 endif
 ifeq ($(USE_OPENMP), 1)
-FCOMMON_OPT += -fopenmp
+FCOMMON_OPT += -openmp
 endif
 endif
 
@@ -894,7 +664,21 @@ FCOMMON_OPT += -i8
 endif
 endif
 endif
- 
+
+ifneq ($(ARCH), mips64)
+ifndef BINARY64
+FCOMMON_OPT += -m32
+else
+FCOMMON_OPT += -m64
+endif
+else
+ifdef BINARY64
+FCOMMON_OPT += -mabi=64
+else
+FCOMMON_OPT += -mabi=n32
+endif
+endif
+
 ifeq ($(USE_OPENMP), 1)
 FCOMMON_OPT += -mp
 endif
@@ -910,7 +694,7 @@ endif
 endif
 endif
 
-ifeq ($(ARCH), $(filter $(ARCH),mips64 mips))
+ifeq ($(ARCH), mips64)
 ifndef BINARY64
 FCOMMON_OPT += -n32
 else
@@ -940,7 +724,7 @@ endif
 
 ifeq ($(C_COMPILER), OPEN64)
 
-ifeq ($(ARCH), $(filter $(ARCH),mips64 mips))
+ifeq ($(ARCH), mips64)
 ifndef BINARY64
 CCOMMON_OPT += -n32
 else
@@ -1018,10 +802,6 @@ ifeq ($(DYNAMIC_ARCH), 1)
 CCOMMON_OPT	+= -DDYNAMIC_ARCH
 endif
 
-ifeq ($(DYNAMIC_OLDER), 1)
-CCOMMON_OPT	+= -DDYNAMIC_OLDER
-endif
-
 ifeq ($(NO_LAPACK), 1)
 CCOMMON_OPT	+= -DNO_LAPACK
 #Disable LAPACK C interface
@@ -1044,10 +824,6 @@ ifeq ($(NO_AVX2), 1)
 CCOMMON_OPT	+= -DNO_AVX2
 endif
 
-ifeq ($(NO_AVX512), 1)
-CCOMMON_OPT	+= -DNO_AVX512
-endif
-
 ifdef SMP
 CCOMMON_OPT	+= -DSMP_SERVER
 
@@ -1094,18 +870,16 @@ endif
 
 CCOMMON_OPT	+= -DMAX_CPU_NUMBER=$(NUM_THREADS)
 
-CCOMMON_OPT	+= -DMAX_PARALLEL_NUMBER=$(NUM_PARALLEL)
-
 ifdef USE_SIMPLE_THREADED_LEVEL3
 CCOMMON_OPT	+= -DUSE_SIMPLE_THREADED_LEVEL3
 endif
 
-ifeq ($(USE_TLS), 1)
-CCOMMON_OPT += -DUSE_TLS
+ifndef LIBNAMESUFFIX
+LIBPREFIX = libopenblas
+else
+LIBPREFIX = libopenblas_$(LIBNAMESUFFIX)
 endif
 
-CCOMMON_OPT += -DVERSION=\"$(VERSION)\"
-
 ifndef SYMBOLPREFIX
 SYMBOLPREFIX =
 endif
@@ -1114,18 +888,6 @@ ifndef SYMBOLSUFFIX
 SYMBOLSUFFIX =
 endif
 
-ifndef LIBNAMESUFFIX
-LIBNAMEBASE = $(SYMBOLPREFIX)openblas$(SYMBOLSUFFIX)
-else
-LIBNAMEBASE = $(SYMBOLPREFIX)openblas$(SYMBOLSUFFIX)_$(LIBNAMESUFFIX)
-endif
-
-ifeq ($(OSNAME), CYGWIN_NT)
-LIBPREFIX = cyg$(LIBNAMEBASE)
-else
-LIBPREFIX = lib$(LIBNAMEBASE)
-endif
-
 KERNELDIR	= $(TOPDIR)/kernel/$(ARCH)
 
 include $(TOPDIR)/Makefile.$(ARCH)
@@ -1153,12 +915,8 @@ endif
 endif
 
 ifdef NO_AFFINITY
-ifeq ($(NO_AFFINITY), 0)
-override undefine NO_AFFINITY
-else
 CCOMMON_OPT	+= -DNO_AFFINITY
 endif
-endif
 
 ifdef FUNCTION_PROFILE
 CCOMMON_OPT	+= -DFUNCTION_PROFILE
@@ -1188,18 +946,17 @@ ifeq ($(OSNAME), SunOS)
 TAR	= gtar
 PATCH	= gpatch
 GREP	= ggrep
-AWK	= nawk
 else
 TAR	= tar
 PATCH	= patch
 GREP	= grep
-AWK	= awk
 endif
 
 ifndef MD5SUM
 MD5SUM	= md5sum
 endif
 
+AWK	= awk
 
 REVISION = -r$(VERSION)
 MAJOR_VERSION = $(word 1,$(subst ., ,$(VERSION)))
@@ -1208,31 +965,18 @@ ifeq ($(DEBUG), 1)
 COMMON_OPT += -g
 endif
 
-ifeq ($(DEBUG), 1)
-FCOMMON_OPT += -g
-endif
-
 ifndef COMMON_OPT
 COMMON_OPT = -O2
 endif
 
-ifndef FCOMMON_OPT
-FCOMMON_OPT = -O2 -frecursive
-endif
 
 override CFLAGS     += $(COMMON_OPT) $(CCOMMON_OPT) -I$(TOPDIR)
 override PFLAGS     += $(COMMON_OPT) $(CCOMMON_OPT) -I$(TOPDIR) -DPROFILE $(COMMON_PROF)
 
 override FFLAGS     += $(COMMON_OPT) $(FCOMMON_OPT)
-override FPFLAGS    += $(FCOMMON_OPT) $(COMMON_PROF)
+override FPFLAGS    += $(COMMON_OPT) $(FCOMMON_OPT) $(COMMON_PROF)
 #MAKEOVERRIDES =
 
-ifdef NEED_PIC
-ifeq (,$(findstring PIC,$(FFLAGS)))
-override FFLAGS += -fPIC
-endif
-endif
-
 #For LAPACK Fortran codes.
 #Disable -fopenmp for LAPACK Fortran codes on Windows.
 ifdef OS_WINDOWS
@@ -1290,12 +1034,7 @@ endif
 
 
 LIBDLLNAME   = $(LIBPREFIX).dll
-IMPLIBNAME   = lib$(LIBNAMEBASE).dll.a
-ifneq ($(OSNAME), AIX)
 LIBSONAME    = $(LIBNAME:.$(LIBSUFFIX)=.so)
-else
-LIBSONAME    = $(LIBNAME:.$(LIBSUFFIX)=.a)
-endif
 LIBDYNNAME   = $(LIBNAME:.$(LIBSUFFIX)=.dylib)
 LIBDEFNAME   = $(LIBNAME:.$(LIBSUFFIX)=.def)
 LIBEXPNAME   = $(LIBNAME:.$(LIBSUFFIX)=.exp)
@@ -1315,9 +1054,6 @@ LIB_COMPONENTS += LAPACK
 ifneq ($(NO_LAPACKE), 1)
 LIB_COMPONENTS += LAPACKE
 endif
-ifeq ($(BUILD_RELAPACK), 1)
-LIB_COMPONENTS += ReLAPACK
-endif
 endif
 
 ifeq ($(ONLY_CBLAS), 1)
@@ -1367,12 +1103,9 @@ export HAVE_VFP
 export HAVE_VFPV3
 export HAVE_VFPV4
 export HAVE_NEON
-export HAVE_MSA
-export MSA_FLAGS
 export KERNELDIR
 export FUNCTION_PROFILE
 export TARGET_CORE
-export NO_AVX512
 
 export SGEMM_UNROLL_M
 export SGEMM_UNROLL_N
@@ -1431,3 +1164,4 @@ SUNPATH		= /opt/sunstudio12.1
 else
 SUNPATH		= /opt/SUNWspro
 endif
+

Makefile.tail

@@ -4,6 +4,7 @@ QBLASOBJS_P = $(QBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 CBLASOBJS_P = $(CBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 ZBLASOBJS_P = $(ZBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 XBLASOBJS_P = $(XBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
+IBLASOBJS_P = $(IBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 
 COMMONOBJS_P = $(COMMONOBJS:.$(SUFFIX)=.$(PSUFFIX))
 
@@ -22,12 +23,18 @@ BLASOBJS   += $(QBLASOBJS)   $(XBLASOBJS)
 BLASOBJS_P += $(QBLASOBJS_P) $(XBLASOBJS_P)
 endif
 
+ifdef INTEGER_PRECISION
+BLASOBJS   += $(IBLASOBJS)
+BLASOBJS_P += $(IBLASOBJS_P)
+endif
+
 $(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
+$(IBLASOBJS) $(IBLASOBJS_P) : override CFLAGS += -DINTEGER -UCOMPLEX
 
 $(SBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
 $(DBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
@@ -35,6 +42,7 @@ $(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)
+$(IBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
 
 libs    :: $(BLASOBJS) $(COMMONOBJS)
 	$(AR) $(ARFLAGS) -ru $(TOPDIR)/$(LIBNAME) $^

Makefile.x86_64

@@ -8,38 +8,6 @@ endif
 endif
 endif
 
-ifeq ($(CORE), SKYLAKEX)
-ifndef DYNAMIC_ARCH
-ifndef NO_AVX512
-CCOMMON_OPT += -march=skylake-avx512
-FCOMMON_OPT += -march=skylake-avx512
-ifeq ($(OSNAME), CYGWIN_NT)
-CCOMMON_OPT += -fno-asynchronous-unwind-tables
-endif
-ifeq ($(OSNAME), WINNT)
-ifeq ($(C_COMPILER), GCC)
-CCOMMON_OPT += -fno-asynchronous-unwind-tables
-endif
-endif
-endif
-endif
-endif
-
-ifeq ($(CORE), HASWELL)
-ifndef DYNAMIC_ARCH
-ifndef NO_AVX2
-ifeq ($(C_COMPILER), GCC)
-CCOMMON_OPT += -mavx2
-endif
-ifeq ($(F_COMPILER), GFORTRAN)
-FCOMMON_OPT += -mavx2
-endif
-endif
-endif
-endif
-
-
-
 ifeq ($(OSNAME), Interix)
 ARFLAGS		= -m x64
 endif

Makefile.zarch

@@ -1,10 +0,0 @@
-
-ifeq ($(CORE), Z13)
-CCOMMON_OPT += -march=z13 -mzvector
-FCOMMON_OPT += -march=z13 -mzvector
-endif
-
-ifeq ($(CORE), Z14)
-CCOMMON_OPT += -march=z14 -mzvector
-FCOMMON_OPT += -march=z14 -mzvector
-endif

README.md

@@ -1,253 +1,138 @@
 # 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)
-
-[![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)
+[![Build Status](https://travis-ci.org/xianyi/OpenBLAS.png?branch=develop)](https://travis-ci.org/xianyi/OpenBLAS)
 
 ## Introduction
-
 OpenBLAS is an optimized BLAS library based on GotoBLAS2 1.13 BSD version.
 
-Please read the documentation on the OpenBLAS wiki pages: <https://github.com/xianyi/OpenBLAS/wiki>.
+Please read the documents on OpenBLAS wiki pages <http://github.com/xianyi/OpenBLAS/wiki>.
 
 ## Binary Packages
-
-We provide official binary packages for the following platform:
+We provide 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. http://xianyi.github.com/OpenBLAS/
 
-Download from project homepage, https://xianyi.github.com/OpenBLAS/, or check out the code
-using Git from https://github.com/xianyi/OpenBLAS.git.
-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)
-
+Or, check out codes from git://github.com/xianyi/OpenBLAS.git
 ### 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`.
+  * type "make" to detect the CPU automatically.
+  or
+  * type "make TARGET=xxx" to set target CPU, e.g. "make TARGET=NEHALEM". The full target list is in file TargetList.txt.
 
 ### 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.
+Please set CC and FC with the cross toolchains. Then, set HOSTCC with your host C compiler. At last, set TARGET explicitly.
 
 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
-  ```
+On X86 box, compile this library for loongson3a CPU.
 
-* 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
-  ```
+    make BINARY=64 CC=mips64el-unknown-linux-gnu-gcc FC=mips64el-unknown-linux-gnu-gfortran HOSTCC=gcc TARGET=LOONGSON3A
+
+On X86 box, compile this library for loongson3a CPU with loongcc (based on Open64) compiler.
+
+    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`.
+    make DEBUG=1
 
-### Compile with MASS support on Power CPU (optional)
+### Install to the directory (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:
+Example:
 
-* 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
-  ```
+    make install PREFIX=your_installation_directory
 
-* 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
-  ```
+The default directory is /opt/OpenBLAS
 
-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`.
+## Support CPU & OS
+Please read GotoBLAS_01Readme.txt
 
-### 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
+### Additional support CPU:
 
+#### 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.
+- **Intel Haswell**: Optimized Level-3 and Level-2 BLAS with AVX2 and FMA  on x86-64.
 - **AMD Bobcat**: Used GotoBLAS2 Barcelona codes.
-- **AMD Bulldozer**: x86-64 ?GEMM FMA4 kernels. (Thanks to Werner Saar)
+- **AMD Bulldozer**: x86-64 ?GEMM FMA4 kernels. (Thank 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.
-
-#### MIPS64
 
+#### MIPS64:
 - **ICT Loongson 3A**: Optimized Level-3 BLAS and the part of Level-1,2.
 - **ICT Loongson 3B**: Experimental
 
-#### ARM
+#### 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 )
 
-- **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
-- **TSV110**: Optimized some Level-3 helper functions
-
-#### 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. 
-
-#### IBM zEnterprise System
-
-- **Z13**: Optimized Level-3 BLAS and Level-1,2
-- **Z14**: Optimized Level-3 BLAS and (single precision) Level-1,2
-
-### 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
+#### ARM64:
+- **ARMV8**: Experimental
 
+### Support 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:
+- **MingWin/Windows**: Please read <https://github.com/xianyi/OpenBLAS/wiki/How-to-use-OpenBLAS-in-Microsoft-Visual-Studio>.
+- **Darwin/Mac OS X**: Experimental. Although GotoBLAS2 supports Darwin, we are the beginner on Mac OS X.
+- **FreeBSD**: Supported by community. We didn't test the library on this OS.
 
-## Usage
+## Usages
+Link with libopenblas.a or -lopenblas for shared library.
 
-Statically link with `libopenblas.a` or dynamically link with `-lopenblas` if OpenBLAS was
-compiled as a shared library.
+### Set the number of threads with environment variables.
 
-### Setting the number of threads using environment variables
+Examples:
 
-Environment variables are used to specify a maximum number of threads.
-For example,
+    export OPENBLAS_NUM_THREADS=4
 
-```sh
-export OPENBLAS_NUM_THREADS=4
-export GOTO_NUM_THREADS=4
-export OMP_NUM_THREADS=4
-```
+ or
 
-The priorities are `OPENBLAS_NUM_THREADS` > `GOTO_NUM_THREADS` > `OMP_NUM_THREADS`.
+    export GOTO_NUM_THREADS=4
 
-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`.
+ or
 
-### Setting the number of threads at runtime
+    export OMP_NUM_THREADS=4
 
-We provide the following functions to control the number of threads at runtime:
+The priorities are OPENBLAS_NUM_THREADS > GOTO_NUM_THREADS > OMP_NUM_THREADS.
 
-```c
-void goto_set_num_threads(int num_threads);
-void openblas_set_num_threads(int num_threads);
-```
+If you compile this lib with USE_OPENMP=1, you should set OMP_NUM_THREADS environment variable. OpenBLAS ignores OPENBLAS_NUM_THREADS and GOTO_NUM_THREADS with USE_OPENMP=1.
 
-If you compile this library with `USE_OPENMP=1`, you should use the above functions too.
+### Set the number of threads on runtime.
 
-## Reporting bugs
+We provided the below functions to control the number of threads on runtime.
 
-Please submit an issue in https://github.com/xianyi/OpenBLAS/issues.
+    void goto_set_num_threads(int num_threads);
+
+    void openblas_set_num_threads(int num_threads);
+
+If you compile this lib with USE_OPENMP=1, you should use the above functions, too.
+
+## Report Bugs
+Please add a 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.
+## ChangeLog
+Please see Changelog.txt to obtain the differences between 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.
+* 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.
 
 ## 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`.
+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.
+1. Fork the [OpenBLAS](https://github.com/xianyi/OpenBLAS) repository to start making your changes.
+1. Write a test which shows that the bug was fixed or that the feature works as expected.
+1. 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

@@ -20,7 +20,6 @@ DUNNINGTON
 NEHALEM
 SANDYBRIDGE
 HASWELL
-SKYLAKEX
 ATOM
 
 b)AMD CPU:
@@ -35,7 +34,6 @@ BULLDOZER
 PILEDRIVER
 STEAMROLLER
 EXCAVATOR
-ZEN
 
 c)VIA CPU:
 SSE_GENERIC
@@ -46,9 +44,6 @@ NANO
 POWER4
 POWER5
 POWER6
-POWER7
-POWER8
-POWER9
 PPCG4
 PPC970
 PPC970MP
@@ -56,44 +51,24 @@ PPC440
 PPC440FP2
 CELL
 
-3.MIPS CPU:
-P5600
-1004K
-
-4.MIPS64 CPU:
+3.MIPS64 CPU:
 SICORTEX
 LOONGSON3A
 LOONGSON3B
-I6400
-P6600
-I6500
 
-5.IA64 CPU:
+4.IA64 CPU:
 ITANIUM2
 
-6.SPARC CPU:
+5.SPARC CPU:
 SPARC
 SPARCV7
 
-7.ARM CPU:
+6.ARM CPU:
 CORTEXA15
 CORTEXA9
 ARMV7
 ARMV6
 ARMV5
 
-8.ARM 64-bit CPU:
+7.ARM 64-bit CPU:
 ARMV8
-CORTEXA53
-CORTEXA57
-CORTEXA72
-CORTEXA73
-FALKOR
-THUNDERX
-THUNDERX2T99
-TSV110
-
-9.System Z:
-ZARCH_GENERIC
-Z13
-Z14

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,82 +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: yes
-    - COMPILER: clang-cl
-      DYNAMIC_ARCH: ON
-      WITH_FORTRAN: no
-    - COMPILER: cl
-    - COMPILER: MinGW64-gcc-7.2.0-mingw
-      DYNAMIC_ARCH: OFF
-      WITH_FORTRAN: ignore
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      COMPILER: MinGW-gcc-6.3.0-32   
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      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
-
-  - if [%WITH_FORTRAN%]==[no] conda install --yes --quiet ninja
-  - if [%WITH_FORTRAN%]==[yes] conda install --yes --quiet -c isuruf kitware-ninja
-  - if [%WITH_FORTRAN%]==[yes] conda install --yes --quiet flang
-
-  - if [%COMPILER%]==[clang-cl] call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat" x64
-  - if [%COMPILER%]==[clang-cl] set "LIB=%CONDA_INSTALL_LOCN%\Library\lib;%LIB%"
-  - if [%COMPILER%]==[clang-cl] set "CPATH=%CONDA_INSTALL_LOCN%\Library\include;%CPATH%"
-
-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%]==[no] cmake -G "Ninja" -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_C_COMPILER=clang-cl -DMSVC_STATIC_CRT=ON ..
-  - if [%WITH_FORTRAN%]==[yes] cmake -G "Ninja" -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_C_COMPILER=clang-cl -DCMAKE_Fortran_COMPILER=flang -DBUILD_WITHOUT_LAPACK=no -DNOFORTRAN=0 ..
-  - if [%DYNAMIC_ARCH%]==[ON] cmake -DDYNAMIC_ARCH=ON -DDYNAMIC_LIST='CORE2;NEHALEM;SANDYBRIDGE;BULLDOZER;HASWELL' ..
-
-build_script:
-  - cmake --build .
-
-test_script:
-  - echo Running Test
-  - cd utest
-  - openblas_utest
-  

azure-pipelines.yml

@@ -1,51 +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'

benchmark/Makefile

@@ -33,22 +33,6 @@ LIBMKL = -L$(MKL) -lmkl_intel_lp64 -lmkl_gnu_thread -lmkl_core -lgomp -lpthread
 # Apple vecLib
 LIBVECLIB = -framework Accelerate
 
-ESSL=/opt/ibm/lib
-#LIBESSL = -lesslsmp $(ESSL)/libxlomp_ser.so.1 $(ESSL)/libxlf90_r.so.1 $(ESSL)/libxlfmath.so.1 $(ESSL)/libxlsmp.so.1 /opt/ibm/xlC/13.1.3/lib/libxl.a
-LIBESSL = -lesslsmp  $(ESSL)/libxlf90_r.so.1 $(ESSL)/libxlfmath.so.1 $(ESSL)/libxlsmp.so.1 /opt/ibm/xlC/13.1.3/lib/libxl.a
-
-ifneq ($(NO_LAPACK), 1)
-GOTO_LAPACK_TARGETS=slinpack.goto dlinpack.goto clinpack.goto zlinpack.goto \
-		    scholesky.goto dcholesky.goto ccholesky.goto zcholesky.goto \
-		    sgesv.goto dgesv.goto cgesv.goto zgesv.goto \
-		    sgeev.goto dgeev.goto cgeev.goto zgeev.goto \
-		    csymv.goto zsymv.goto \
-		    sgetri.goto dgetri.goto cgetri.goto zgetri.goto \
-		    spotrf.goto dpotrf.goto cpotrf.goto zpotrf.goto
-else
-GOTO_LAPACK_TARGETS=
-endif
-
 ifeq ($(OSNAME), WINNT)
 
 goto :: slinpack.goto dlinpack.goto clinpack.goto zlinpack.goto \
@@ -60,7 +44,6 @@ goto :: slinpack.goto dlinpack.goto clinpack.goto zlinpack.goto \
        ssyr2k.goto dsyr2k.goto csyr2k.goto zsyr2k.goto \
        sger.goto dger.goto cger.goto zger.goto \
        sdot.goto ddot.goto \
-       srot.goto drot.goto \
        saxpy.goto daxpy.goto caxpy.goto zaxpy.goto \
        scopy.goto dcopy.goto ccopy.goto zcopy.goto \
        sswap.goto dswap.goto cswap.goto zswap.goto \
@@ -159,29 +142,31 @@ mkl :: slinpack.mkl dlinpack.mkl clinpack.mkl zlinpack.mkl \
 
 else
 
-goto :: sgemm.goto dgemm.goto cgemm.goto zgemm.goto \
+goto :: slinpack.goto dlinpack.goto clinpack.goto zlinpack.goto \
+       scholesky.goto dcholesky.goto ccholesky.goto zcholesky.goto \
+       sgemm.goto dgemm.goto cgemm.goto zgemm.goto \
        strmm.goto dtrmm.goto ctrmm.goto ztrmm.goto \
        strsm.goto dtrsm.goto ctrsm.goto ztrsm.goto \
        ssyrk.goto dsyrk.goto csyrk.goto zsyrk.goto \
        ssyr2k.goto dsyr2k.goto csyr2k.goto zsyr2k.goto \
        sger.goto dger.goto cger.goto zger.goto \
        sdot.goto ddot.goto cdot.goto zdot.goto \
-       srot.goto drot.goto \
        saxpy.goto daxpy.goto caxpy.goto zaxpy.goto \
        scopy.goto dcopy.goto ccopy.goto zcopy.goto \
        sswap.goto dswap.goto cswap.goto zswap.goto \
        sscal.goto dscal.goto cscal.goto zscal.goto \
        sasum.goto dasum.goto casum.goto zasum.goto \
-       ssymv.goto dsymv.goto \
+       ssymv.goto dsymv.goto csymv.goto zsymv.goto \
        chemv.goto zhemv.goto \
        chemm.goto zhemm.goto \
        cherk.goto zherk.goto \
        cher2k.goto zher2k.goto \
        sgemv.goto dgemv.goto cgemv.goto zgemv.goto \
-       ssymm.goto dsymm.goto csymm.goto zsymm.goto \
-       smallscaling \
-       isamax.goto idamax.goto icamax.goto izamax.goto \
-       snrm2.goto dnrm2.goto scnrm2.goto dznrm2.goto $(GOTO_LAPACK_TARGETS)
+       sgesv.goto dgesv.goto cgesv.goto zgesv.goto \
+       sgeev.goto dgeev.goto cgeev.goto zgeev.goto \
+       sgetri.goto dgetri.goto cgetri.goto zgetri.goto \
+       spotrf.goto dpotrf.goto cpotrf.goto zpotrf.goto \
+       ssymm.goto dsymm.goto csymm.goto zsymm.goto
 
 acml :: slinpack.acml dlinpack.acml clinpack.acml zlinpack.acml \
        scholesky.acml dcholesky.acml ccholesky.acml zcholesky.acml \
@@ -234,9 +219,7 @@ atlas :: slinpack.atlas dlinpack.atlas clinpack.atlas zlinpack.atlas \
        sgesv.atlas dgesv.atlas cgesv.atlas zgesv.atlas \
        sgetri.atlas dgetri.atlas cgetri.atlas zgetri.atlas \
        spotrf.atlas dpotrf.atlas cpotrf.atlas zpotrf.atlas \
-       ssymm.atlas dsymm.atlas csymm.atlas zsymm.atlas \
-       isamax.atlas idamax.atlas icamax.atlas izamax.atlas \
-       snrm2.goto dnrm2.goto scnrm2.goto dznrm2.goto
+       ssymm.atlas dsymm.atlas csymm.atlas zsymm.atlas
 
 mkl :: slinpack.mkl dlinpack.mkl clinpack.mkl zlinpack.mkl \
        scholesky.mkl dcholesky.mkl ccholesky.mkl zcholesky.mkl \
@@ -269,11 +252,7 @@ mkl :: slinpack.mkl dlinpack.mkl clinpack.mkl zlinpack.mkl \
 
 endif
 
-essl :: sgemm.essl strmm.essl dgemm.essl dtrmm.essl  \
-	cgemm.essl ctrmm.essl zgemm.essl ztrmm.essl  \
-	slinpack.essl clinpack.essl dlinpack.essl zlinpack.essl \
-	scholesky.essl ccholesky.essl dcholesky.essl zcholesky.essl \
-	strsm.essl dtrsm.essl ctrsm.essl ztrsm.essl
+
 
 veclib :: slinpack.veclib dlinpack.veclib clinpack.veclib zlinpack.veclib \
        scholesky.veclib dcholesky.veclib ccholesky.veclib zcholesky.veclib \
@@ -326,9 +305,6 @@ slinpack.mkl : slinpack.$(SUFFIX)
 slinpack.veclib : slinpack.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-slinpack.essl : slinpack.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Dlinpack ####################################################
 dlinpack.goto : dlinpack.$(SUFFIX) ../$(LIBNAME)
 	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
@@ -345,9 +321,6 @@ dlinpack.mkl : dlinpack.$(SUFFIX)
 dlinpack.veclib : dlinpack.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-dlinpack.essl : dlinpack.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Clinpack ####################################################
 
 clinpack.goto : clinpack.$(SUFFIX) ../$(LIBNAME)
@@ -365,9 +338,6 @@ clinpack.mkl : clinpack.$(SUFFIX)
 clinpack.veclib : clinpack.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-clinpack.essl : clinpack.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Zlinpack ####################################################
 
 zlinpack.goto : zlinpack.$(SUFFIX) ../$(LIBNAME)
@@ -385,9 +355,6 @@ zlinpack.mkl : zlinpack.$(SUFFIX)
 zlinpack.veclib : zlinpack.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-zlinpack.essl : zlinpack.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Scholesky ###################################################
 
 scholesky.goto : scholesky.$(SUFFIX) ../$(LIBNAME)
@@ -405,9 +372,6 @@ scholesky.mkl : scholesky.$(SUFFIX)
 scholesky.veclib : scholesky.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-scholesky.essl : scholesky.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Dcholesky ###################################################
 
 dcholesky.goto : dcholesky.$(SUFFIX) ../$(LIBNAME)
@@ -425,9 +389,6 @@ dcholesky.mkl : dcholesky.$(SUFFIX)
 dcholesky.veclib : dcholesky.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-dcholesky.essl : dcholesky.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Ccholesky ###################################################
 
 ccholesky.goto : ccholesky.$(SUFFIX) ../$(LIBNAME)
@@ -445,9 +406,6 @@ ccholesky.mkl : ccholesky.$(SUFFIX)
 ccholesky.veclib : ccholesky.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-ccholesky.essl : ccholesky.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 
 ##################################### Zcholesky ###################################################
 
@@ -466,9 +424,6 @@ zcholesky.mkl : zcholesky.$(SUFFIX)
 zcholesky.veclib : zcholesky.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-zcholesky.essl : zcholesky.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Sgemm ####################################################
 sgemm.goto : sgemm.$(SUFFIX) ../$(LIBNAME)
 	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
@@ -485,9 +440,6 @@ sgemm.mkl : sgemm.$(SUFFIX)
 sgemm.veclib : sgemm.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-sgemm.essl : sgemm.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Dgemm ####################################################
 dgemm.goto : dgemm.$(SUFFIX) ../$(LIBNAME)
 	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
@@ -504,9 +456,6 @@ dgemm.mkl : dgemm.$(SUFFIX)
 dgemm.veclib : dgemm.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-dgemm.essl : dgemm.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Cgemm ####################################################
 
 cgemm.goto : cgemm.$(SUFFIX) ../$(LIBNAME)
@@ -524,9 +473,6 @@ cgemm.mkl : cgemm.$(SUFFIX)
 cgemm.veclib : cgemm.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-cgemm.essl : cgemm.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Zgemm ####################################################
 
 zgemm.goto : zgemm.$(SUFFIX) ../$(LIBNAME)
@@ -544,9 +490,6 @@ zgemm.mkl : zgemm.$(SUFFIX)
 zgemm.veclib : zgemm.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-zgemm.essl : zgemm.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Ssymm ####################################################
 ssymm.goto : ssymm.$(SUFFIX) ../$(LIBNAME)
 	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
@@ -629,9 +572,6 @@ strmm.mkl : strmm.$(SUFFIX)
 strmm.veclib : strmm.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-strmm.essl : strmm.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Dtrmm ####################################################
 dtrmm.goto : dtrmm.$(SUFFIX) ../$(LIBNAME)
 	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
@@ -648,9 +588,6 @@ dtrmm.mkl : dtrmm.$(SUFFIX)
 dtrmm.veclib : dtrmm.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-dtrmm.essl : dtrmm.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Ctrmm ####################################################
 
 ctrmm.goto : ctrmm.$(SUFFIX) ../$(LIBNAME)
@@ -668,9 +605,6 @@ ctrmm.mkl : ctrmm.$(SUFFIX)
 ctrmm.veclib : ctrmm.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-ctrmm.essl : ctrmm.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Ztrmm ####################################################
 
 ztrmm.goto : ztrmm.$(SUFFIX) ../$(LIBNAME)
@@ -688,9 +622,6 @@ ztrmm.mkl : ztrmm.$(SUFFIX)
 ztrmm.veclib : ztrmm.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-ztrmm.essl : ztrmm.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Strsm ####################################################
 strsm.goto : strsm.$(SUFFIX) ../$(LIBNAME)
 	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
@@ -707,9 +638,6 @@ strsm.mkl : strsm.$(SUFFIX)
 strsm.veclib : strsm.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-strsm.essl : strsm.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Dtrsm ####################################################
 dtrsm.goto : dtrsm.$(SUFFIX) ../$(LIBNAME)
 	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
@@ -726,9 +654,6 @@ dtrsm.mkl : dtrsm.$(SUFFIX)
 dtrsm.veclib : dtrsm.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-dtrsm.essl : dtrsm.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Ctrsm ####################################################
 
 ctrsm.goto : ctrsm.$(SUFFIX) ../$(LIBNAME)
@@ -746,9 +671,6 @@ ctrsm.mkl : ctrsm.$(SUFFIX)
 ctrsm.veclib : ctrsm.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-ctrsm.essl : ctrsm.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Ztrsm ####################################################
 
 ztrsm.goto : ztrsm.$(SUFFIX) ../$(LIBNAME)
@@ -766,9 +688,6 @@ ztrsm.mkl : ztrsm.$(SUFFIX)
 ztrsm.veclib : ztrsm.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-ztrsm.essl : ztrsm.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBESSL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
 ##################################### Ssyrk ####################################################
 ssyrk.goto : ssyrk.$(SUFFIX) ../$(LIBNAME)
 	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
@@ -1493,39 +1412,6 @@ zdot.mkl : zdot-intel.$(SUFFIX)
 zdot.veclib : zdot-intel.$(SUFFIX)
 	$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-##################################### Srot ####################################################
-srot.goto : srot.$(SUFFIX) ../$(LIBNAME)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
-
-srot.acml : srot.$(SUFFIX)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(LIBACML) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-srot.atlas : srot.$(SUFFIX)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(LIBATLAS) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-srot.mkl : srot.$(SUFFIX)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(LIBMKL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-srot.veclib : srot.$(SUFFIX)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-##################################### Drot ####################################################
-drot.goto : drot.$(SUFFIX) ../$(LIBNAME)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
-
-drot.acml : drot.$(SUFFIX)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(LIBACML) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-drot.atlas : drot.$(SUFFIX)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(LIBATLAS) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-drot.mkl : drot.$(SUFFIX)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(LIBMKL) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-drot.veclib : drot.$(SUFFIX)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-
 ##################################### Saxpy ####################################################
 saxpy.goto : saxpy.$(SUFFIX) ../$(LIBNAME)
 	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
@@ -1947,63 +1833,6 @@ zgemm3m.mkl : zgemm3m.$(SUFFIX)
 zgemm3m.veclib : zgemm3m.$(SUFFIX)
 	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBVECLIB) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
 
-############################################## ISAMAX ##############################################
-isamax.goto : isamax.$(SUFFIX) ../$(LIBNAME)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
-
-isamax.atlas : isamax.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBATLAS) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-############################################## IDAMAX ##############################################
-idamax.goto : idamax.$(SUFFIX) ../$(LIBNAME)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
-
-idamax.atlas : idamax.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBATLAS) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-############################################## ICAMAX ##############################################
-icamax.goto : icamax.$(SUFFIX) ../$(LIBNAME)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
-
-icamax.atlas : icamax.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBATLAS) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-############################################## IZAMAX ##############################################
-izamax.goto : izamax.$(SUFFIX) ../$(LIBNAME)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
-
-izamax.atlas : izamax.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBATLAS) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-############################################## SNRM2 ##############################################
-snrm2.goto : snrm2.$(SUFFIX) ../$(LIBNAME)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
-
-snrm2.atlas : snrm2.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBATLAS) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-############################################## DNRM2 ##############################################
-dnrm2.goto : dnrm2.$(SUFFIX) ../$(LIBNAME)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
-
-dnrm2.atlas : dnrm2.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBATLAS) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-############################################## Sscnrm2 ##############################################
-scnrm2.goto : scnrm2.$(SUFFIX) ../$(LIBNAME)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
-
-scnrm2.atlas : scnrm2.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBATLAS) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-############################################## Ddznrm2 ##############################################
-dznrm2.goto : dznrm2.$(SUFFIX) ../$(LIBNAME)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB) -lm
-
-dznrm2.atlas : dznrm2.$(SUFFIX)
-	-$(CC) $(CFLAGS) -o $(@F) $^ $(LIBATLAS) $(CEXTRALIB) $(EXTRALIB) $(FEXTRALIB)
-
-
 ###################################################################################################
 
 slinpack.$(SUFFIX) : linpack.c
@@ -2294,13 +2123,6 @@ cgesv.$(SUFFIX) : gesv.c
 zgesv.$(SUFFIX) : gesv.c
 	$(CC) $(CFLAGS) -c -DCOMPLEX -DDOUBLE -o $(@F) $^
 
-srot.$(SUFFIX) : rot.c
-	$(CC) $(CFLAGS) -c -UCOMPLEX -UDOUBLE -o $(@F) $^
-
-drot.$(SUFFIX) : rot.c
-	$(CC) $(CFLAGS) -c -UCOMPLEX -DDOUBLE -o $(@F) $^
-
-
 
 
 
@@ -2311,37 +2133,8 @@ zgemm3m.$(SUFFIX) : gemm3m.c
 	$(CC) $(CFLAGS) -c -DCOMPLEX -DDOUBLE -o $(@F) $^
 
 
-isamax.$(SUFFIX) : iamax.c
-	$(CC) $(CFLAGS) -c -UCOMPLEX -UDOUBLE -o $(@F) $^
-
-idamax.$(SUFFIX) : iamax.c
-	$(CC) $(CFLAGS) -c -UCOMPLEX -DDOUBLE -o $(@F) $^
-
-icamax.$(SUFFIX) : iamax.c
-	$(CC) $(CFLAGS) -c -DCOMPLEX -UDOUBLE -o $(@F) $^
-
-izamax.$(SUFFIX) : iamax.c
-	$(CC) $(CFLAGS) -c -DCOMPLEX -DDOUBLE -o $(@F) $^
-
-
-snrm2.$(SUFFIX) : nrm2.c
-	$(CC) $(CFLAGS) -c -UCOMPLEX -UDOUBLE -o $(@F) $^
-
-dnrm2.$(SUFFIX) : nrm2.c
-	$(CC) $(CFLAGS) -c -UCOMPLEX -DDOUBLE -o $(@F) $^
-
-scnrm2.$(SUFFIX) : nrm2.c
-	$(CC) $(CFLAGS) -c -DCOMPLEX -UDOUBLE -o $(@F) $^
-
-dznrm2.$(SUFFIX) : nrm2.c
-	$(CC) $(CFLAGS) -c -DCOMPLEX -DDOUBLE -o $(@F) $^
-
-
-smallscaling: smallscaling.c ../$(LIBNAME)
-	$(CC) $(CFLAGS) -o $(@F) $^ $(EXTRALIB) -fopenmp -lm -lpthread
-
 clean ::
-	@rm -f *.goto *.mkl *.acml *.atlas *.veclib *.essl smallscaling
+	@rm -f *.goto *.mkl *.acml *.atlas *.veclib
 
 include $(TOPDIR)/Makefile.tail
 

benchmark/asum.c

@@ -183,9 +183,9 @@ int main(int argc, char *argv[]){
     timeg /= loops;
 
 #ifdef COMPLEX
-    fprintf(stderr, " %10.2f MFlops %10.6f sec\n", 4. * (double)m / timeg * 1.e-6, timeg);
+    fprintf(stderr, " %10.2f MFlops\n", 4. * (double)m / timeg * 1.e-6);
 #else
-    fprintf(stderr, " %10.2f MFlops %10.6f sec\n", 2. * (double)m / timeg * 1.e-6, timeg);
+    fprintf(stderr, " %10.2f MFlops\n", 2. * (double)m / timeg * 1.e-6);
 #endif
 
   }

benchmark/axpy.c

@@ -190,8 +190,8 @@ int main(int argc, char *argv[]){
     timeg /= loops;
 
     fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m / timeg * 1.e-6, timeg);
+	    " %10.2f MFlops\n",
+	    COMPSIZE * COMPSIZE * 2. * (double)m / timeg * 1.e-6);
 
   }
 

benchmark/copy.c

@@ -190,8 +190,8 @@ int main(int argc, char *argv[]){
     timeg /= loops;
 
     fprintf(stderr,
-	    " %10.2f MBytes %10.6f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
+	    " %10.2f MBytes\n",
+	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6);
 
   }
 

benchmark/dot.c

@@ -184,8 +184,8 @@ int main(int argc, char *argv[]){
     timeg /= loops;
 
     fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m / timeg * 1.e-6, timeg);
+	    " %10.2f MFlops\n",
+	    COMPSIZE * COMPSIZE * 2. * (double)m / timeg * 1.e-6);
 
   }
 

benchmark/gemm.c

@@ -121,15 +121,13 @@ static void *huge_malloc(BLASLONG size){
 int main(int argc, char *argv[]){
 
   FLOAT *a, *b, *c;
-  FLOAT alpha[] = {1.0, 0.0};
+  FLOAT alpha[] = {1.0, 1.0};
   FLOAT beta [] = {0.0, 0.0};
-  char transa = 'N';
-  char transb = 'N';
-  blasint m, n, k, i, j, lda, ldb, ldc;
+  char trans='N';
+  blasint m, n, i, j;
   int loops = 1;
-  int has_param_m = 0;
-  int has_param_n = 0;
-  int has_param_k = 0;
+  int has_param_n=0;
+  int l;
   char *p;
 
   int from =   1;
@@ -137,108 +135,86 @@ int main(int argc, char *argv[]){
   int step =   1;
 
   struct timeval start, stop;
-  double time1, timeg;
+  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 (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);
+  if ((p = getenv("OPENBLAS_TRANS")))  trans=*p;
 
-  fprintf(stderr, "From : %3d  To : %3d Step=%d : Transa=%c : Transb=%c\n", from, to, step, transa, transb);
+  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);
-  }
+  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 = (FLOAT *)malloc(sizeof(FLOAT) * m * k * COMPSIZE)) == NULL) {
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-  if (( b = (FLOAT *)malloc(sizeof(FLOAT) * k * n * COMPSIZE)) == NULL) {
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-  if (( c = (FLOAT *)malloc(sizeof(FLOAT) * m * n * COMPSIZE)) == NULL) {
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
+          n = atoi(p);
+	  has_param_n=1;	  
   }
 
 #ifdef linux
   srandom(getpid());
 #endif
+ 
+	for(j = 0; j < m; j++){
+      		for(i = 0; i < to * COMPSIZE; i++){
+			a[i + j * to * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+			b[i + j * to * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+			c[i + j * to * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+      		}
+    	}
 
-  for (i = 0; i < m * k * COMPSIZE; i++) {
-    a[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-  }
-  for (i = 0; i < k * n * COMPSIZE; i++) {
-    b[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-  }
-  for (i = 0; i < m * n * COMPSIZE; i++) {
-    c[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-  }
 
-  fprintf(stderr, "          SIZE                   Flops             Time\n");
 
-  for (i = from; i <= to; i += step) {
-    
+  fprintf(stderr, "   SIZE          Flops          Time\n");
+
+  for(m = from; m <= to; m += step)
+  {
+
     timeg=0;
 
-    if (!has_param_m) { m = i; }
-    if (!has_param_n) { n = i; }
-    if (!has_param_k) { k = i; }
+    if ( has_param_n == 1 && n <= m )
+    	n=n;
+    else
+    	n=m;
 
-    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);
+
+    fprintf(stderr, " %6dx%d : ", (int)m, (int)n);
     gettimeofday( &start, (struct timezone *)0);
 
-    for (j=0; j<loops; j++) {
-      GEMM (&transa, &transb, &m, &n, &k, alpha, a, &lda, b, &ldb, beta, c, &ldc);
-    }
+    for (l=0; l<loops; l++)
+    {
 
-    gettimeofday( &stop, (struct timezone *)0);
-    time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
+    	GEMM (&trans, &trans, &m, &n, &m, alpha, a, &m, b, &m, beta, c, &m );
+
+
+
+    }
+   gettimeofday( &stop, (struct timezone *)0);
+   time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 
     timeg = time1/loops;
     fprintf(stderr,
 	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)k * (double)m * (double)n / timeg * 1.e-6, time1);
-    
+	    COMPSIZE * COMPSIZE * 2. * (double)m * (double)m * (double)n / timeg * 1.e-6, time1);
+
   }
 
   return 0;

benchmark/gemv.c

@@ -122,7 +122,7 @@ int main(int argc, char *argv[]){
 
   FLOAT *a, *x, *y;
   FLOAT alpha[] = {1.0, 1.0};
-  FLOAT beta [] = {1.0, 0.0};
+  FLOAT beta [] = {1.0, 1.0};
   char trans='N';
   blasint m, i, j;
   blasint inc_x=1,inc_y=1;
@@ -197,7 +197,7 @@ int main(int argc, char *argv[]){
    		fprintf(stderr, " %6dx%d : ", (int)m,(int)n);
    		for(j = 0; j < m; j++){
       			for(i = 0; i < n * COMPSIZE; i++){
-				a[j + i * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+				a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       			}
    		}
 
@@ -208,7 +208,7 @@ int main(int argc, char *argv[]){
 				x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    			}
 
-   			for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
+   			for(i = 0; i < n * COMPSIZE * abs(inc_y); i++){
 				y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    			}
     			gettimeofday( &start, (struct timezone *)0);
@@ -221,7 +221,7 @@ int main(int argc, char *argv[]){
 
     		timeg /= loops;
 
-    		fprintf(stderr, " %10.2f MFlops %10.6f sec\n", COMPSIZE * COMPSIZE * 2. * (double)m * (double)n / timeg * 1.e-6, timeg);
+    		fprintf(stderr, " %10.2f MFlops\n", COMPSIZE * COMPSIZE * 2. * (double)m * (double)n / timeg * 1.e-6);
 
   	}
   }
@@ -234,7 +234,7 @@ int main(int argc, char *argv[]){
    		fprintf(stderr, " %6dx%d : ", (int)m,(int)n);
    		for(j = 0; j < m; j++){
       			for(i = 0; i < n * COMPSIZE; i++){
-				a[j + i * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+				a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       			}
    		}
 
@@ -245,7 +245,7 @@ int main(int argc, char *argv[]){
 				x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    			}
 
-   			for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
+   			for(i = 0; i < n * COMPSIZE * abs(inc_y); i++){
 				y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    			}
     			gettimeofday( &start, (struct timezone *)0);
@@ -258,7 +258,7 @@ int main(int argc, char *argv[]){
 
     		timeg /= loops;
 
-    		fprintf(stderr, " %10.2f MFlops %10.6f sec\n", COMPSIZE * COMPSIZE * 2. * (double)m * (double)n / timeg * 1.e-6, timeg);
+    		fprintf(stderr, " %10.2f MFlops\n", COMPSIZE * COMPSIZE * 2. * (double)m * (double)n / timeg * 1.e-6);
 
   	}
   }

benchmark/iamax.c

@@ -1,192 +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 <stdio.h>
-#include <stdlib.h>
-#ifdef __CYGWIN32__
-#include <sys/time.h>
-#endif
-#include "common.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
-
-#if defined(__WIN32__) || defined(__WIN64__)
-
-#ifndef DELTA_EPOCH_IN_MICROSECS
-#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
-#endif
-
-int gettimeofday(struct timeval *tv, void *tz){
-
-  FILETIME ft;
-  unsigned __int64 tmpres = 0;
-  static int tzflag;
-
-  if (NULL != tv)
-    {
-      GetSystemTimeAsFileTime(&ft);
-
-      tmpres |= ft.dwHighDateTime;
-      tmpres <<= 32;
-      tmpres |= ft.dwLowDateTime;
-
-      /*converting file time to unix epoch*/
-      tmpres /= 10;  /*convert into microseconds*/
-      tmpres -= DELTA_EPOCH_IN_MICROSECS;
-      tv->tv_sec = (long)(tmpres / 1000000UL);
-      tv->tv_usec = (long)(tmpres % 1000000UL);
-    }
-
-  return 0;
-}
-
-#endif
-
-#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
-
-static void *huge_malloc(BLASLONG size){
-  int shmid;
-  void *address;
-
-#ifndef SHM_HUGETLB
-#define SHM_HUGETLB 04000
-#endif
-
-  if ((shmid =shmget(IPC_PRIVATE,
-		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
-		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
-    printf( "Memory allocation failed(shmget).\n");
-    exit(1);
-  }
-
-  address = shmat(shmid, NULL, SHM_RND);
-
-  if ((BLASLONG)address == -1){
-    printf( "Memory allocation failed(shmat).\n");
-    exit(1);
-  }
-
-  shmctl(shmid, IPC_RMID, 0);
-
-  return address;
-}
-
-#define malloc huge_malloc
-
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  struct timeval start, stop;
-  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;
-   	}
-
-    	gettimeofday( &start, (struct timezone *)0);
-
-    	IAMAX (&m, x, &inc_x);
-
-    	gettimeofday( &stop, (struct timezone *)0);
-
-    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
-
-	timeg += time1;
-
-    }
-
-    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,193 +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 <stdio.h>
-#include <stdlib.h>
-#ifdef __CYGWIN32__
-#include <sys/time.h>
-#endif
-#include "common.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
-
-#if defined(__WIN32__) || defined(__WIN64__)
-
-#ifndef DELTA_EPOCH_IN_MICROSECS
-#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
-#endif
-
-int gettimeofday(struct timeval *tv, void *tz){
-
-  FILETIME ft;
-  unsigned __int64 tmpres = 0;
-  static int tzflag;
-
-  if (NULL != tv)
-    {
-      GetSystemTimeAsFileTime(&ft);
-
-      tmpres |= ft.dwHighDateTime;
-      tmpres <<= 32;
-      tmpres |= ft.dwLowDateTime;
-
-      /*converting file time to unix epoch*/
-      tmpres /= 10;  /*convert into microseconds*/
-      tmpres -= DELTA_EPOCH_IN_MICROSECS;
-      tv->tv_sec = (long)(tmpres / 1000000UL);
-      tv->tv_usec = (long)(tmpres % 1000000UL);
-    }
-
-  return 0;
-}
-
-#endif
-
-#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
-
-static void *huge_malloc(BLASLONG size){
-  int shmid;
-  void *address;
-
-#ifndef SHM_HUGETLB
-#define SHM_HUGETLB 04000
-#endif
-
-  if ((shmid =shmget(IPC_PRIVATE,
-		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
-		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
-    printf( "Memory allocation failed(shmget).\n");
-    exit(1);
-  }
-
-  address = shmat(shmid, NULL, SHM_RND);
-
-  if ((BLASLONG)address == -1){
-    printf( "Memory allocation failed(shmat).\n");
-    exit(1);
-  }
-
-  shmctl(shmid, IPC_RMID, 0);
-
-  return address;
-}
-
-#define malloc huge_malloc
-
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  struct timeval start, stop;
-  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;
-   	}
-
-    	gettimeofday( &start, (struct timezone *)0);
-
-    	NRM2 (&m, x, &inc_x);
-
-    	gettimeofday( &stop, (struct timezone *)0);
-
-    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
-
-	timeg += time1;
-
-    }
-
-    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/rot.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 <stdio.h>
-#include <stdlib.h>
-#ifdef __CYGWIN32__
-#include <sys/time.h>
-#endif
-#include "common.h"
-
-
-#undef DOT
-
-
-#ifdef DOUBLE
-#define ROT   BLASFUNC(drot)
-#else
-#define ROT   BLASFUNC(srot)
-#endif
-
-
-#if defined(__WIN32__) || defined(__WIN64__)
-
-#ifndef DELTA_EPOCH_IN_MICROSECS
-#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
-#endif
-
-int gettimeofday(struct timeval *tv, void *tz){
-
-  FILETIME ft;
-  unsigned __int64 tmpres = 0;
-  static int tzflag;
-
-  if (NULL != tv)
-    {
-      GetSystemTimeAsFileTime(&ft);
-
-      tmpres |= ft.dwHighDateTime;
-      tmpres <<= 32;
-      tmpres |= ft.dwLowDateTime;
-
-      /*converting file time to unix epoch*/
-      tmpres /= 10;  /*convert into microseconds*/
-      tmpres -= DELTA_EPOCH_IN_MICROSECS;
-      tv->tv_sec = (long)(tmpres / 1000000UL);
-      tv->tv_usec = (long)(tmpres % 1000000UL);
-    }
-
-  return 0;
-}
-
-#endif
-
-#if !defined(__WIN32__) && !defined(__WIN64__) && !defined(__CYGWIN32__) && 0
-
-static void *huge_malloc(BLASLONG size){
-  int shmid;
-  void *address;
-
-#ifndef SHM_HUGETLB
-#define SHM_HUGETLB 04000
-#endif
-
-  if ((shmid =shmget(IPC_PRIVATE,
-		     (size + HUGE_PAGESIZE) & ~(HUGE_PAGESIZE - 1),
-		     SHM_HUGETLB | IPC_CREAT |0600)) < 0) {
-    printf( "Memory allocation failed(shmget).\n");
-    exit(1);
-  }
-
-  address = shmat(shmid, NULL, SHM_RND);
-
-  if ((BLASLONG)address == -1){
-    printf( "Memory allocation failed(shmat).\n");
-    exit(1);
-  }
-
-  shmctl(shmid, IPC_RMID, 0);
-
-  return address;
-}
-
-#define malloc huge_malloc
-
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x, *y;
-  // 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;
-
-  struct timeval start, stop;
-  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;
-   	}
-    	gettimeofday( &start, (struct timezone *)0);
-
-    	ROT (&m, x, &inc_x, y, &inc_y, c, s);
-
-    	gettimeofday( &stop, (struct timezone *)0);
-
-    	time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f 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/scal.c

@@ -189,9 +189,9 @@ int main(int argc, char *argv[]){
     timeg /= loops;
 
 #ifdef COMPLEX
-    fprintf(stderr, " %10.2f MFlops %10.6f sec\n", 6. * (double)m / timeg * 1.e-6, timeg);
+    fprintf(stderr, " %10.2f MFlops\n", 6. * (double)m / timeg * 1.e-6);
 #else
-    fprintf(stderr, " %10.2f MFlops %10.6f sec\n", 1. * (double)m / timeg * 1.e-6, timeg);
+    fprintf(stderr, " %10.2f MFlops\n", 1. * (double)m / timeg * 1.e-6);
 #endif
 
   }

benchmark/scripts/R/deig.R

@@ -2,47 +2,61 @@
 
 argv <- commandArgs(trailingOnly = TRUE)
 
-if (!is.null(options("matprod")[[1]])) options(matprod = "blas")
+nfrom = 128
+nto = 2048
+nstep = 128
+loops = 1
 
-nfrom <- 128
-nto <- 2048
-nstep <- 128
-loops <- 1
+if ( length(argv) > 0 ) {
+
+	for ( z in 1:length(argv) ) {
+
+		if ( z == 1 ) {
+			nfrom <- as.numeric(argv[z])
+		} else if ( z==2 ) {
+			nto <- as.numeric(argv[z])
+		} else if ( z==3 ) {
+			nstep <- as.numeric(argv[z])
+		} else if ( z==4 ) {
+			loops <- as.numeric(argv[z])
+		}
+	}
 
-if (length(argv) > 0) {
-  for (z in 1:length(argv)) {
-    if (z == 1) {
-      nfrom <- as.numeric(argv[z])
-    } else if (z == 2) {
-      nto <- as.numeric(argv[z])
-    } else if (z == 3) {
-      nstep <- as.numeric(argv[z])
-    } else if (z == 4) {
-      loops <- as.numeric(argv[z])
-    }
-  }
 }
 
-p <- Sys.getenv("OPENBLAS_LOOPS")
-if (p != "") {
-  loops <- as.numeric(p)
-}
+p=Sys.getenv("OPENBLAS_LOOPS")
+if ( p != "" ) {
+	loops <- as.numeric(p)
+}	
 
-cat(sprintf("From %.0f To %.0f Step=%.0f Loops=%.0f\n", nfrom, nto, nstep, loops))
+
+cat(sprintf("From %.0f To %.0f Step=%.0f Loops=%.0f\n",nfrom, nto, nstep, loops))
 cat(sprintf("      SIZE             Flops                   Time\n"))
 
-n <- nfrom
-while (n <= nto) {
-  A <- matrix(rnorm(n * n), nrow = n)
-  ev <- 0
-  z <- system.time(for (l in 1:loops) {
-    ev <- eigen(A)
-  })
+n = nfrom
+while ( n <= nto ) {
 
-  mflops <- (26.66 * n * n * n) * loops / (z[3] * 1e+06)
+	A <- matrix(runif(n*n), ncol = n, nrow = n, byrow = TRUE)
+	
+	l = 1
 
-  st <- sprintf("%.0fx%.0f :", n, n)
-  cat(sprintf("%20s %10.2f MFlops %10.6f sec\n", st, mflops, z[3]))
+	start <- proc.time()[3]
+
+	while ( l <= loops ) {
+
+		ev <- eigen(A)
+		l = l + 1
+	}
+
+	end <- proc.time()[3]
+	timeg = end - start
+	mflops = (26.66 *n*n*n ) * loops / ( timeg * 1.0e6 )
+
+	st = sprintf("%.0fx%.0f :",n , n)
+	cat(sprintf("%20s %10.2f MFlops %10.6f sec\n", st, mflops, timeg))
+
+	n = n + nstep
 
-  n <- n + nstep
 }
+
+

benchmark/scripts/R/dgemm.R

@@ -2,50 +2,62 @@
 
 argv <- commandArgs(trailingOnly = TRUE)
 
-if (!is.null(options("matprod")[[1]])) options(matprod = "blas")
+nfrom = 128
+nto = 2048
+nstep = 128
+loops = 1
 
-nfrom <- 128
-nto <- 2048
-nstep <- 128
-loops <- 1
+if ( length(argv) > 0 ) {
+
+	for ( z in 1:length(argv) ) {
+
+		if ( z == 1 ) {
+			nfrom <- as.numeric(argv[z])
+		} else if ( z==2 ) {
+			nto <- as.numeric(argv[z])
+		} else if ( z==3 ) {
+			nstep <- as.numeric(argv[z])
+		} else if ( z==4 ) {
+			loops <- as.numeric(argv[z])
+		}
+	}
 
-if (length(argv) > 0) {
-  for (z in 1:length(argv)) {
-    if (z == 1) {
-      nfrom <- as.numeric(argv[z])
-    } else if (z == 2) {
-      nto <- as.numeric(argv[z])
-    } else if (z == 3) {
-      nstep <- as.numeric(argv[z])
-    } else if (z == 4) {
-      loops <- as.numeric(argv[z])
-    }
-  }
 }
 
-p <- Sys.getenv("OPENBLAS_LOOPS")
-if (p != "") {
-  loops <- as.numeric(p)
-}
+p=Sys.getenv("OPENBLAS_LOOPS")
+if ( p != "" ) {
+	loops <- as.numeric(p)
+}	
 
-cat(sprintf("From %.0f To %.0f Step=%.0f Loops=%.0f\n", nfrom, nto, nstep, loops))
+
+cat(sprintf("From %.0f To %.0f Step=%.0f Loops=%.0f\n",nfrom, nto, nstep, loops))
 cat(sprintf("      SIZE             Flops                   Time\n"))
 
-n <- nfrom
-while (n <= nto) {
-  A <- matrix(runif(n * n), nrow = n)
-  B <- matrix(runif(n * n), nrow = n)
-  C <- 1
+n = nfrom
+while ( n <= nto ) {
 
-  z <- system.time(for (l in 1:loops) {
-    C <- A %*% B
-    l <- l + 1
-  })
+	A <- matrix(runif(n*n), ncol = n, nrow = n, byrow = TRUE)
+	B <- matrix(runif(n*n), ncol = n, nrow = n, byrow = TRUE)
+	
+	l = 1
 
-  mflops <- (2.0 * n * n * n) * loops / (z[3] * 1e+06)
+	start <- proc.time()[3]
 
-  st <- sprintf("%.0fx%.0f :", n, n)
-  cat(sprintf("%20s %10.2f MFlops %10.6f sec\n", st, mflops, z[3]))
+	while ( l <= loops ) {
+
+		C <- A %*% B
+		l = l + 1
+	}
+
+	end <- proc.time()[3]
+	timeg = end - start
+	mflops = ( 2.0 *n*n*n ) * loops / ( timeg * 1.0e6 )
+
+	st = sprintf("%.0fx%.0f :",n , n)
+	cat(sprintf("%20s %10.2f MFlops %10.6f sec\n", st, mflops, timeg))
+
+	n = n + nstep
 
-  n <- n + nstep
 }
+
+

benchmark/scripts/R/dsolve.R

@@ -2,48 +2,62 @@
 
 argv <- commandArgs(trailingOnly = TRUE)
 
-if (!is.null(options("matprod")[[1]])) options(matprod = "blas")
+nfrom = 128
+nto = 2048
+nstep = 128
+loops = 1
 
-nfrom <- 128
-nto <- 2048
-nstep <- 128
-loops <- 1
+if ( length(argv) > 0 ) {
+
+	for ( z in 1:length(argv) ) {
+
+		if ( z == 1 ) {
+			nfrom <- as.numeric(argv[z])
+		} else if ( z==2 ) {
+			nto <- as.numeric(argv[z])
+		} else if ( z==3 ) {
+			nstep <- as.numeric(argv[z])
+		} else if ( z==4 ) {
+			loops <- as.numeric(argv[z])
+		}
+	}
 
-if (length(argv) > 0) {
-  for (z in 1:length(argv)) {
-    if (z == 1) {
-      nfrom <- as.numeric(argv[z])
-    } else if (z == 2) {
-      nto <- as.numeric(argv[z])
-    } else if (z == 3) {
-      nstep <- as.numeric(argv[z])
-    } else if (z == 4) {
-      loops <- as.numeric(argv[z])
-    }
-  }
 }
 
-p <- Sys.getenv("OPENBLAS_LOOPS")
-if (p != "") {
-  loops <- as.numeric(p)
-}
+p=Sys.getenv("OPENBLAS_LOOPS")
+if ( p != "" ) {
+	loops <- as.numeric(p)
+}	
 
-cat(sprintf("From %.0f To %.0f Step=%.0f Loops=%.0f\n", nfrom, nto, nstep, loops))
+
+cat(sprintf("From %.0f To %.0f Step=%.0f Loops=%.0f\n",nfrom, nto, nstep, loops))
 cat(sprintf("      SIZE             Flops                   Time\n"))
 
-n <- nfrom
-while (n <= nto) {
-  A <- matrix(rnorm(n * n), nrow = n)
-  B <- matrix(rnorm(n * n), nrow = n)
+n = nfrom
+while ( n <= nto ) {
 
-  z <- system.time(for (l in 1:loops) {
-    solve(A, B)
-  })
+	A <- matrix(runif(n*n), ncol = n, nrow = n, byrow = TRUE)
+	B <- matrix(runif(n*n), ncol = n, nrow = n, byrow = TRUE)
+	
+	l = 1
 
-  mflops <- (8.0 / 3 * n * n * n) * loops / (z[3] * 1e+06)
+	start <- proc.time()[3]
 
-  st <- sprintf("%.0fx%.0f :", n, n)
-  cat(sprintf("%20s %10.2f MFlops %10.6f sec\n", st, mflops, z[3]))
+	while ( l <= loops ) {
+
+		solve(A,B)
+		l = l + 1
+	}
+
+	end <- proc.time()[3]
+	timeg = end - start
+	mflops = (2.0/3.0 *n*n*n + 2.0 *n*n*n ) * loops / ( timeg * 1.0e6 )
+
+	st = sprintf("%.0fx%.0f :",n , n)
+	cat(sprintf("%20s %10.2f MFlops %10.6f sec\n", st, mflops, timeg))
+
+	n = n + nstep
 
-  n <- n + nstep
 }
+
+

benchmark/scripts/SCIPY/dsyrk.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python
-
-import os
-import sys
-import time
-import numpy
-from numpy import zeros
-from numpy.random import randn
-from scipy.linalg import blas
-
-
-def run_dsyrk(N, l):
-
-    A = randn(N, N).astype('float64', order='F')
-    C = zeros((N, N), dtype='float64', order='F')
-
-    start = time.time()
-    for i in range(0, l):
-        blas.dsyrk(1.0, A, c=C, overwrite_c=True)
-    end = time.time()
-
-    timediff = (end - start)
-    mflops = (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_dsyrk(i, LOOPS)

benchmark/scripts/SCIPY/ssyrk.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python
-
-import os
-import sys
-import time
-import numpy
-from numpy import zeros
-from numpy.random import randn
-from scipy.linalg import blas
-
-
-def run_ssyrk(N, l):
-
-    A = randn(N, N).astype('float32', order='F')
-    C = zeros((N, N), dtype='float32', order='F')
-
-    start = time.time()
-    for i in range(0, l):
-        blas.ssyrk(1.0, A, c=C, overwrite_c=True)
-    end = time.time()
-
-    timediff = (end - start)
-    mflops = (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_ssyrk(i, LOOPS)

benchmark/smallscaling.c

@@ -1,197 +0,0 @@
-// run with OPENBLAS_NUM_THREADS=1 and OMP_NUM_THREADS=n
-#include <math.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <time.h>
-#include <cblas.h>
-#include <omp.h>
-#include <pthread.h>
-#define MIN_SIZE 5
-#define MAX_SIZE 60
-#define NB_SIZE 10
-
-// number of loop for a 1x1 matrix. Lower it if the test is
-// too slow on you computer.
-#define NLOOP 2e7
-
-typedef struct {
-    int matrix_size;
-    int n_loop;
-    void (* bench_func)();
-    void (* blas_func)();
-    void * (* create_matrix)(int size);
-} BenchParam;
-
-void * s_create_matrix(int size) {
-    float * r = malloc(size * sizeof(double));
-    int i;
-    for(i = 0; i < size; i++)
-        r[i] = 1e3 * i / size;
-    return r;
-}
-
-void * c_create_matrix(int size) {
-    float * r = malloc(size * 2 * sizeof(double));
-    int i;
-    for(i = 0; i < 2 * size; i++)
-        r[i] = 1e3 * i / size;
-    return r;
-}
-
-void * z_create_matrix(int size) {
-    double * r = malloc(size * 2 * sizeof(double));
-    int i;
-    for(i = 0; i < 2 * size; i++)
-        r[i] = 1e3 * i / size;
-    return r;
-}
-
-void * d_create_matrix(int size) {
-    double * r = malloc(size * sizeof(double));
-    int i;
-    for(i = 0; i < size; i++)
-        r[i] = 1e3 * i / size;
-    return r;
-}
-
-void trmv_bench(BenchParam * param)
-{
-    int i, n;
-    int size = param->matrix_size;
-    n = param->n_loop / size;
-    int one = 1;
-    void * A = param->create_matrix(size * size);
-    void * y = param->create_matrix(size);
-    for(i = 0; i < n; i++) {
-        param->blas_func("U", "N", "N", &size, A, &size, y, &one);
-    }
-    free(A);
-    free(y);
-}
-
-void gemv_bench(BenchParam * param)
-{
-    int i, n;
-    int size = param->matrix_size;
-    n = param->n_loop / size;
-    double v = 1.01;
-    int one = 1;
-    void * A = param->create_matrix(size * size);
-    void * y = param->create_matrix(size);
-    for(i = 0; i < n; i++) {
-        param->blas_func("N", &size, &size, &v, A, &size, y, &one, &v, y, &one);
-    }
-    free(A);
-    free(y);
-}
-
-void ger_bench(BenchParam * param) {
-    int i, n;
-    int size = param->matrix_size;
-    n = param->n_loop / size;
-    double v = 1.01;
-    int one = 1;
-    void * A = param->create_matrix(size * size);
-    void * y = param->create_matrix(size);
-    for(i = 0; i < n; i++) {
-        param->blas_func(&size, &size, &v, y, &one, y, &one, A, &size);
-    }
-    free(A);
-    free(y);
-}
-
-#ifndef _WIN32
-void * pthread_func_wrapper(void * param) {
-    ((BenchParam *)param)->bench_func(param);
-    pthread_exit(NULL);
-}
-#endif
-
-#define NB_TESTS 5
-void * TESTS[4 * NB_TESTS] = {
-    trmv_bench, ztrmv_, z_create_matrix, "ztrmv",
-    gemv_bench, dgemv_, d_create_matrix, "dgemv",
-    gemv_bench, zgemv_, z_create_matrix, "zgemv",
-    ger_bench, dger_, d_create_matrix, "dger",
-    ger_bench, zgerc_, z_create_matrix, "zgerc",
-};
-
-inline static double delta_time(struct timespec tick) {
-    struct timespec tock;
-	clock_gettime(CLOCK_MONOTONIC, &tock);
-	return (tock.tv_sec - tick.tv_sec) + (tock.tv_nsec - tick.tv_nsec) / 1e9;
-}
-
-double pthread_bench(BenchParam * param, int nb_threads)
-{
-#ifdef _WIN32
-    return 0;
-#else
-    BenchParam threaded_param = *param;
-    pthread_t threads[nb_threads];
-    int t, rc;
-    struct timespec tick;
-    threaded_param.n_loop /= nb_threads;
-    clock_gettime(CLOCK_MONOTONIC, &tick);
-    for(t=0; t<nb_threads; t++){
-        rc = pthread_create(&threads[t], NULL, pthread_func_wrapper, &threaded_param);
-        if (rc){
-            printf("ERROR; return code from pthread_create() is %d\n", rc);
-            exit(-1);
-        }
-    }
-    for(t=0; t<nb_threads; t++){
-        pthread_join(threads[t], NULL);
-    }
-	return delta_time(tick);
-#endif
-}
-
-double seq_bench(BenchParam * param) {
-    struct timespec tick;
-    clock_gettime(CLOCK_MONOTONIC, &tick);
-    param->bench_func(param);
-    return delta_time(tick);
-}
-
-double omp_bench(BenchParam * param) {
-    BenchParam threaded_param = *param;
-    struct timespec tick;
-    int t;
-    int nb_threads = omp_get_max_threads();
-    threaded_param.n_loop /= nb_threads;
-    clock_gettime(CLOCK_MONOTONIC, &tick);
-    #pragma omp parallel for
-    for(t = 0; t < nb_threads; t ++){
-        param->bench_func(&threaded_param);
-    }
-    return delta_time(tick);
-}
-
-int main(int argc, char * argv[]) {
-    double inc_factor = exp(log((double)MAX_SIZE / MIN_SIZE) / NB_SIZE);
-    BenchParam param;
-    int test_id;
-    printf ("Running on %d threads\n", omp_get_max_threads());
-    for(test_id = 0; test_id < NB_TESTS; test_id ++) {
-        double size = MIN_SIZE;
-        param.bench_func = TESTS[test_id * 4];
-        param.blas_func = TESTS[test_id * 4 + 1];
-        param.create_matrix = TESTS[test_id * 4 + 2];
-        printf("\nBenchmark of %s\n", (char*)TESTS[test_id * 4 + 3]);
-        param.n_loop = NLOOP;
-        while(size <= MAX_SIZE) {
-            param.matrix_size = (int)(size + 0.5);
-            double seq_time = seq_bench(&param);
-            double omp_time = omp_bench(&param);
-            double pthread_time = pthread_bench(&param, omp_get_max_threads());
-            printf("matrix size %d, sequential %gs, openmp %gs, speedup %g, "
-                   "pthread %gs, speedup %g\n",
-                   param.matrix_size, seq_time,
-                   omp_time, seq_time / omp_time,
-                   pthread_time, seq_time / pthread_time);
-            size *= inc_factor;
-        }
-    }
-    return(0);
-}

benchmark/swap.c

@@ -190,8 +190,8 @@ int main(int argc, char *argv[]){
     timeg /= loops;
 
     fprintf(stderr,
-	    " %10.2f MBytes %10.6f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
+	    " %10.2f MBytes\n",
+	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6);
 
   }
 

benchmark/trmm.c

@@ -191,8 +191,8 @@ int main(int argc, char *argv[]){
     gettimeofday( &start, (struct timezone *)0);
 
     fprintf(stderr,
-	    " %10.2f MFlops  %10.6f sec\n",
-	    COMPSIZE * COMPSIZE * 1. * (double)m * (double)m * (double)m / time1 * 1.e-6, time1);
+	    " %10.2f MFlops\n",
+	    COMPSIZE * COMPSIZE * 1. * (double)m * (double)m * (double)m / time1 * 1.e-6);
 
   }
 

benchmark/zdot.c

@@ -184,8 +184,8 @@ int main(int argc, char *argv[]){
     timeg /= loops;
 
     fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m / timeg * 1.e-6, timeg);
+	    " %10.2f MFlops\n",
+	    COMPSIZE * COMPSIZE * 2. * (double)m / timeg * 1.e-6);
 
   }
 

c_check

@@ -1,18 +1,12 @@
 #!/usr/bin/perl
 
-#use File::Basename;
-# use File::Temp qw(tempfile);
-
 # Checking cross compile
 $hostos   = `uname -s | sed -e s/\-.*//`;    chop($hostos);
 $hostarch = `uname -m | sed -e s/i.86/x86/`;chop($hostarch);
 $hostarch = "x86_64" if ($hostarch eq "amd64");
 $hostarch = "arm" if ($hostarch =~ /^arm.*/);
 $hostarch = "arm64" if ($hostarch eq "aarch64");
-$hostarch = "power" if ($hostarch =~ /^(powerpc|ppc).*/);
-$hostarch = "zarch" if ($hostarch eq "s390x");
 
-#$tmpf = new File::Temp( UNLINK => 1 );
 $binary = $ENV{"BINARY"};
 
 $makefile = shift(@ARGV);
@@ -31,24 +25,13 @@ if ($?) {
 
 $cross_suffix = "";
 
-eval "use File::Basename";
-if ($@){ 
-    warn "could not load PERL module File::Basename, emulating its functionality";
-    my $dirnam = substr($compiler_name, 0, rindex($compiler_name, "/")-1 );
-    if ($dirnam ne ".") {
-	$cross_suffix .= $dirnam . "/";
-    }
-    my $basnam = substr($compiler_name, rindex($compiler_name,"/")+1, length($compiler_name)-rindex($compiler_name,"/")-1);
-	if ($basnam =~ /([^\s]*-)(.*)/) {
-	$cross_suffix .= $1;
+if ($ARGV[0] =~ /(.*)(-[.\d]+)/) {
+    if ($1 =~ /(.*-)(.*)/) {
+	$cross_suffix = $1;
     }
 } else {
-    if (dirname($compiler_name) ne ".") {
-	$cross_suffix .= dirname($compiler_name) . "/";
-    }
-
-    if (basename($compiler_name) =~ /([^\s]*-)(.*)/) {
-	$cross_suffix .= $1;
+    if ($ARGV[0] =~ /(.*-)(.*)/) {
+	$cross_suffix = $1;
     }
 }
 
@@ -67,8 +50,6 @@ $compiler = GCC       if ($compiler eq "");
 $os = Linux           if ($data =~ /OS_LINUX/);
 $os = FreeBSD         if ($data =~ /OS_FREEBSD/);
 $os = NetBSD          if ($data =~ /OS_NETBSD/);
-$os = OpenBSD         if ($data =~ /OS_OPENBSD/);
-$os = DragonFly       if ($data =~ /OS_DRAGONFLY/);
 $os = Darwin          if ($data =~ /OS_DARWIN/);
 $os = SunOS           if ($data =~ /OS_SUNOS/);
 $os = AIX             if ($data =~ /OS_AIX/);
@@ -77,19 +58,17 @@ $os = WINNT           if ($data =~ /OS_WINNT/);
 $os = CYGWIN_NT       if ($data =~ /OS_CYGWIN_NT/);
 $os = Interix         if ($data =~ /OS_INTERIX/);
 $os = Android         if ($data =~ /OS_ANDROID/);
-$os = Haiku           if ($data =~ /OS_HAIKU/);
 
 $architecture = x86    if ($data =~ /ARCH_X86/);
 $architecture = x86_64 if ($data =~ /ARCH_X86_64/);
 $architecture = power  if ($data =~ /ARCH_POWER/);
-$architecture = mips   if ($data =~ /ARCH_MIPS/);
+$architecture = mips32 if ($data =~ /ARCH_MIPS32/);
 $architecture = mips64 if ($data =~ /ARCH_MIPS64/);
 $architecture = alpha  if ($data =~ /ARCH_ALPHA/);
 $architecture = sparc  if ($data =~ /ARCH_SPARC/);
 $architecture = ia64   if ($data =~ /ARCH_IA64/);
 $architecture = arm    if ($data =~ /ARCH_ARM/);
 $architecture = arm64  if ($data =~ /ARCH_ARM64/);
-$architecture = zarch  if ($data =~ /ARCH_ZARCH/);
 
 $defined = 0;
 
@@ -99,12 +78,7 @@ if ($os eq "AIX") {
     $defined = 1;
 }
 
-if ($architecture eq "mips") {
-    $compiler_name .= " -mabi=32";
-    $defined = 1;
-}
-
-if ($architecture eq "mips64") {
+if (($architecture eq "mips32") || ($architecture eq "mips64")) {
     $compiler_name .= " -mabi=n32" if ($binary eq "32");
     $compiler_name .= " -mabi=64" if ($binary eq "64");
     $defined = 1;
@@ -114,11 +88,6 @@ if (($architecture eq "arm") || ($architecture eq "arm64")) {
     $defined = 1;
 }
 
-if ($architecture eq "zarch") {
-    $defined = 1;
-    $binary = 64;
-}
-
 if ($architecture eq "alpha") {
     $defined = 1;
     $binary = 64;
@@ -182,71 +151,20 @@ if ($?) {
     die 1;
 }
 
-$have_msa = 0;
-if (($architecture eq "mips") || ($architecture eq "mips64")) {
-    eval "use File::Temp qw(tempfile)";
-    if ($@){ 
-	warn "could not load PERL module File::Temp, so could not check MSA capatibility";
-    } else {
-	$tmpf = new File::Temp( SUFFIX => '.c' , UNLINK => 1 );
-	$code = '"addvi.b $w0, $w1, 1"';
-	$msa_flags = "-mmsa -mfp64 -msched-weight -mload-store-pairs";
-	print $tmpf "#include <msa.h>\n\n";
-	print $tmpf "void main(void){ __asm__ volatile($code); }\n";
-
-	$args = "$msa_flags -o $tmpf.o $tmpf";
-	my @cmd = ("$compiler_name $args");
-	system(@cmd) == 0;
-	if ($? != 0) {
-	    $have_msa = 0;
-	} else {
-	    $have_msa = 1;
-	}
-	unlink("$tmpf.o");
-    }
-}
-
 $architecture = x86    if ($data =~ /ARCH_X86/);
 $architecture = x86_64 if ($data =~ /ARCH_X86_64/);
 $architecture = power  if ($data =~ /ARCH_POWER/);
-$architecture = mips   if ($data =~ /ARCH_MIPS/);
+$architecture = mips32 if ($data =~ /ARCH_MIPS32/);
 $architecture = mips64 if ($data =~ /ARCH_MIPS64/);
 $architecture = alpha  if ($data =~ /ARCH_ALPHA/);
 $architecture = sparc  if ($data =~ /ARCH_SPARC/);
 $architecture = ia64   if ($data =~ /ARCH_IA64/);
 $architecture = arm    if ($data =~ /ARCH_ARM/);
 $architecture = arm64  if ($data =~ /ARCH_ARM64/);
-$architecture = zarch  if ($data =~ /ARCH_ZARCH/);
 
 $binformat    = bin32;
 $binformat    = bin64  if ($data =~ /BINARY_64/);
 
-$no_avx512= 0;
-if (($architecture eq "x86") || ($architecture eq "x86_64")) {
-    eval "use File::Temp qw(tempfile)";
-    if ($@){ 
-	warn "could not load PERL module File::Temp, so could not check compiler compatibility with AVX512";
-	$no_avx512 = 0;
-    } else {
-#	$tmpf = new File::Temp( UNLINK => 1 );
-	($fh,$tmpf) = tempfile( SUFFIX => '.c' , UNLINK => 1 );
-	$code = '"vbroadcastss -4 * 4(%rsi), %zmm2"';
-	print $tmpf "#include <immintrin.h>\n\nint main(void){ __asm__ volatile($code); }\n";
-	$args = " -march=skylake-avx512 -c -o $tmpf.o $tmpf";
-	if ($compiler eq "PGI") {
-	    $args = " -tp skylake -c -o $tmpf.o $tmpf";
-	}
-	my @cmd = ("$compiler_name $args >/dev/null 2>/dev/null");
-	system(@cmd) == 0;
-	if ($? != 0) {
-	    $no_avx512 = 1;
-	} else {
-	    $no_avx512 = 0;
-	}
-	unlink("$tmpf.o");
-    }
-}
-
 $data = `$compiler_name -S ctest1.c && grep globl ctest1.s | head -n 1 && rm -f ctest1.s`;
 
 $data =~ /globl\s([_\.]*)(.*)/;
@@ -254,6 +172,7 @@ $data =~ /globl\s([_\.]*)(.*)/;
 $need_fu      = $1;
 
 $cross = 0;
+$cross = 1 if ($os ne $hostos);
 
 if ($architecture ne $hostarch) {
     $cross = 1;
@@ -261,21 +180,6 @@ if ($architecture ne $hostarch) {
     $cross = 0 if (($hostarch eq "mips64") && ($architecture eq "mips"));
 }
 
-$cross = 1 if ($os ne $hostos);
-
-# rework cross suffix and architecture if we are on OSX cross-compiling for ARMV8-based IOS
-# the initial autodetection will have been confused by the command-line arguments to clang
-# and the cross-compiler apparently still claims to build for x86_64 in its CC -E output
-if (($os eq "Darwin") && ($cross_suffix ne "")) {
-  my $tmpnam = `xcrun --sdk iphoneos --find clang`;
-  $cross_suffix = substr($tmpnam, 0, rindex($tmpnam, "/")+1 ); 
-# this should produce something like $cross_suffix="/Applications/Xcode-10.1.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/";
-  $cross =1;
-  $architecture = arm64;
-}
-
-
-
 $openmp = "" if $ENV{USE_OPENMP} != 1;
 
 $linker_L = "";
@@ -304,11 +208,6 @@ $linker_a = "";
 	    $linker_L .= "-Wl,". $flags . " "
 	    }
 
-	if ($flags =~ /^\--exclude-libs/) {
-	    $linker_L .= "-Wl,". $flags . " ";
-	    $flags="";
-	   }
-
 	if (
 	    ($flags =~ /^\-l/)
 	    && ($flags !~ /gfortranbegin/)
@@ -321,7 +220,6 @@ $linker_a = "";
 	    && ($flags !~ /kernel32/)
 	    && ($flags !~ /advapi32/)
 	    && ($flags !~ /shell32/)
-	    && ($flags !~ /omp/)
 	    ) {
 	    $linker_l .= $flags . " "
 	}
@@ -344,12 +242,9 @@ print MAKEFILE "BINARY64=\n" if $binformat ne bin64;
 print MAKEFILE "BINARY32=1\n" if $binformat eq bin32;
 print MAKEFILE "BINARY64=1\n" if $binformat eq bin64;
 print MAKEFILE "FU=$need_fu\n" if $need_fu ne "";
-print MAKEFILE "CROSS_SUFFIX=$cross_suffix\n" if $cross != 0 && $cross_suffix ne "";
+print MAKEFILE "CROSS_SUFFIX=$cross_suffix\n" if $cross_suffix ne "";
 print MAKEFILE "CROSS=1\n" if $cross != 0;
 print MAKEFILE "CEXTRALIB=$linker_L $linker_l $linker_a\n";
-print MAKEFILE "HAVE_MSA=1\n" if $have_msa eq 1;
-print MAKEFILE "MSA_FLAGS=$msa_flags\n" if $have_msa eq 1;
-print MAKEFILE "NO_AVX512=1\n" if $no_avx512 eq 1;
 
 $os           =~ tr/[a-z]/[A-Z]/;
 $architecture =~ tr/[a-z]/[A-Z]/;
@@ -361,7 +256,6 @@ print CONFFILE "#define C_$compiler\t1\n";
 print CONFFILE "#define __32BIT__\t1\n"  if $binformat eq bin32;
 print CONFFILE "#define __64BIT__\t1\n"  if $binformat eq bin64;
 print CONFFILE "#define FUNDERSCORE\t$need_fu\n" if $need_fu ne "";
-print CONFFILE "#define HAVE_MSA\t1\n"  if $have_msa eq 1;
 
 if ($os eq "LINUX") {
 

cblas.h

@@ -51,72 +51,51 @@ typedef enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=1
 typedef enum CBLAS_UPLO      {CblasUpper=121, CblasLower=122} CBLAS_UPLO;
 typedef enum CBLAS_DIAG      {CblasNonUnit=131, CblasUnit=132} CBLAS_DIAG;
 typedef enum CBLAS_SIDE      {CblasLeft=141, CblasRight=142} CBLAS_SIDE;
-typedef CBLAS_ORDER CBLAS_LAYOUT;
-	
+
 float  cblas_sdsdot(OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float *y, OPENBLAS_CONST blasint incy);
 double cblas_dsdot (OPENBLAS_CONST blasint n, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float *y, OPENBLAS_CONST blasint incy);
 float  cblas_sdot(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float  *y, OPENBLAS_CONST blasint incy);
 double cblas_ddot(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST double *y, OPENBLAS_CONST blasint incy);
 
-openblas_complex_float  cblas_cdotu(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void  *y, OPENBLAS_CONST blasint incy);
-openblas_complex_float  cblas_cdotc(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void  *y, OPENBLAS_CONST blasint incy);
-openblas_complex_double cblas_zdotu(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void *y, OPENBLAS_CONST blasint incy);
-openblas_complex_double cblas_zdotc(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void *y, OPENBLAS_CONST blasint incy);
+openblas_complex_float  cblas_cdotu(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float  *y, OPENBLAS_CONST blasint incy);
+openblas_complex_float  cblas_cdotc(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float  *y, OPENBLAS_CONST blasint incy);
+openblas_complex_double cblas_zdotu(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST double *y, OPENBLAS_CONST blasint incy);
+openblas_complex_double cblas_zdotc(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST double *y, OPENBLAS_CONST blasint incy);
 
-void  cblas_cdotu_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void  *y, OPENBLAS_CONST blasint incy, void  *ret);
-void  cblas_cdotc_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void  *y, OPENBLAS_CONST blasint incy, void  *ret);
-void  cblas_zdotu_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void *y, OPENBLAS_CONST blasint incy, void *ret);
-void  cblas_zdotc_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void *y, OPENBLAS_CONST blasint incy, void *ret);
+void  cblas_cdotu_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float  *y, OPENBLAS_CONST blasint incy, openblas_complex_float  *ret);
+void  cblas_cdotc_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float  *y, OPENBLAS_CONST blasint incy, openblas_complex_float  *ret);
+void  cblas_zdotu_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST double *y, OPENBLAS_CONST blasint incy, openblas_complex_double *ret);
+void  cblas_zdotc_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST double *y, OPENBLAS_CONST blasint incy, openblas_complex_double *ret);
 
 float  cblas_sasum (OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
 double cblas_dasum (OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-float  cblas_scasum(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-double cblas_dzasum(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
-
-float  cblas_ssum (OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
-double cblas_dsum (OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-float  cblas_scsum(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-double cblas_dzsum(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
+float  cblas_scasum(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
+double cblas_dzasum(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
 
 float  cblas_snrm2 (OPENBLAS_CONST blasint N, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX);
 double cblas_dnrm2 (OPENBLAS_CONST blasint N, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX);
-float  cblas_scnrm2(OPENBLAS_CONST blasint N, OPENBLAS_CONST void  *X, OPENBLAS_CONST blasint incX);
-double cblas_dznrm2(OPENBLAS_CONST blasint N, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX);
+float  cblas_scnrm2(OPENBLAS_CONST blasint N, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX);
+double cblas_dznrm2(OPENBLAS_CONST blasint N, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX);
 
 CBLAS_INDEX cblas_isamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
 CBLAS_INDEX cblas_idamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-CBLAS_INDEX cblas_icamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-CBLAS_INDEX cblas_izamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
-
-CBLAS_INDEX cblas_isamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
-CBLAS_INDEX cblas_idamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-CBLAS_INDEX cblas_icamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-CBLAS_INDEX cblas_izamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
-
-CBLAS_INDEX cblas_ismax(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
-CBLAS_INDEX cblas_idmax(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-CBLAS_INDEX cblas_icmax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-CBLAS_INDEX cblas_izmax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
-
-CBLAS_INDEX cblas_ismin(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
-CBLAS_INDEX cblas_idmin(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-CBLAS_INDEX cblas_icmin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-CBLAS_INDEX cblas_izmin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_icamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_izamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
 
 void cblas_saxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
 void cblas_daxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
-void cblas_caxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
-void cblas_zaxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
+void cblas_caxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
+void cblas_zaxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
 
 void cblas_scopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
 void cblas_dcopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
-void cblas_ccopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
-void cblas_zcopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
+void cblas_ccopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
+void cblas_zcopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
 
 void cblas_sswap(OPENBLAS_CONST blasint n, float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
 void cblas_dswap(OPENBLAS_CONST blasint n, double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
-void cblas_cswap(OPENBLAS_CONST blasint n, void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
-void cblas_zswap(OPENBLAS_CONST blasint n, void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
+void cblas_cswap(OPENBLAS_CONST blasint n, float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
+void cblas_zswap(OPENBLAS_CONST blasint n, double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
 
 void cblas_srot(OPENBLAS_CONST blasint N, float *X, OPENBLAS_CONST blasint incX, float *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST float c, OPENBLAS_CONST float s);
 void cblas_drot(OPENBLAS_CONST blasint N, double *X, OPENBLAS_CONST blasint incX, double *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST double c, OPENBLAS_CONST double  s);
@@ -132,59 +111,59 @@ void cblas_drotmg(double *d1, double *d2, double *b1, OPENBLAS_CONST double b2,
 
 void cblas_sscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, float *X, OPENBLAS_CONST blasint incX);
 void cblas_dscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, double *X, OPENBLAS_CONST blasint incX);
-void cblas_cscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, void *X, OPENBLAS_CONST blasint incX);
-void cblas_zscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, void *X, OPENBLAS_CONST blasint incX);
-void cblas_csscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, void *X, OPENBLAS_CONST blasint incX);
-void cblas_zdscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, void *X, OPENBLAS_CONST blasint incX);
+void cblas_cscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST float *alpha, float *X, OPENBLAS_CONST blasint incX);
+void cblas_zscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, double *X, OPENBLAS_CONST blasint incX);
+void cblas_csscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, float *X, OPENBLAS_CONST blasint incX);
+void cblas_zdscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, double *X, OPENBLAS_CONST blasint incX);
 
 void cblas_sgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
 		 OPENBLAS_CONST float alpha, OPENBLAS_CONST float  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST float beta,  float  *y, OPENBLAS_CONST blasint incy);
 void cblas_dgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
 		 OPENBLAS_CONST double alpha, OPENBLAS_CONST double  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST double  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST double beta,  double  *y, OPENBLAS_CONST blasint incy);
 void cblas_cgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
-		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST void *beta,  void  *y, OPENBLAS_CONST blasint incy);
+		 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST float *beta,  float  *y, OPENBLAS_CONST blasint incy);
 void cblas_zgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
-		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST void *beta,  void  *y, OPENBLAS_CONST blasint incy);
+		 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST double  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST double *beta,  double  *y, OPENBLAS_CONST blasint incy);
 
 void cblas_sger (OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float   alpha, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float  *Y, OPENBLAS_CONST blasint incY, float  *A, OPENBLAS_CONST blasint lda);
 void cblas_dger (OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double  alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
-void cblas_cgeru(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void  *alpha, OPENBLAS_CONST void  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void  *Y, OPENBLAS_CONST blasint incY, void  *A, OPENBLAS_CONST blasint lda);
-void cblas_cgerc(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void  *alpha, OPENBLAS_CONST void  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void  *Y, OPENBLAS_CONST blasint incY, void  *A, OPENBLAS_CONST blasint lda);
-void cblas_zgeru(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *A, OPENBLAS_CONST blasint lda);
-void cblas_zgerc(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *A, OPENBLAS_CONST blasint lda);
+void cblas_cgeru(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float  *alpha, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float  *Y, OPENBLAS_CONST blasint incY, float  *A, OPENBLAS_CONST blasint lda);
+void cblas_cgerc(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float  *alpha, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float  *Y, OPENBLAS_CONST blasint incY, float  *A, OPENBLAS_CONST blasint lda);
+void cblas_zgeru(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
+void cblas_zgerc(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
 
 void cblas_strsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
 void cblas_dtrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
-void cblas_ctrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
-void cblas_ztrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
+void cblas_ctrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
+void cblas_ztrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
 
 void cblas_strmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
 void cblas_dtrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
-void cblas_ctrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
-void cblas_ztrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
+void cblas_ctrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
+void cblas_ztrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
 
 void cblas_ssyr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, float *A, OPENBLAS_CONST blasint lda);
 void cblas_dsyr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, double *A, OPENBLAS_CONST blasint lda);
-void cblas_cher(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, void *A, OPENBLAS_CONST blasint lda);
-void cblas_zher(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, void *A, OPENBLAS_CONST blasint lda);
+void cblas_cher(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, float *A, OPENBLAS_CONST blasint lda);
+void cblas_zher(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, double *A, OPENBLAS_CONST blasint lda);
 
 void cblas_ssyr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo,OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X,
                 OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *Y, OPENBLAS_CONST blasint incY, float *A, OPENBLAS_CONST blasint lda);
 void cblas_dsyr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X,
                 OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
-void cblas_cher2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX,
-                OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *A, OPENBLAS_CONST blasint lda);
-void cblas_zher2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX,
-                OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *A, OPENBLAS_CONST blasint lda);
+void cblas_cher2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX,
+                OPENBLAS_CONST float *Y, OPENBLAS_CONST blasint incY, float *A, OPENBLAS_CONST blasint lda);
+void cblas_zher2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX,
+                OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
 
 void cblas_sgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float beta, float *Y, OPENBLAS_CONST blasint incY);
 void cblas_dgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double beta, double *Y, OPENBLAS_CONST blasint incY);
 void cblas_cgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
-                 OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
+                 OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *beta, float *Y, OPENBLAS_CONST blasint incY);
 void cblas_zgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
-                 OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
+                 OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *beta, double *Y, OPENBLAS_CONST blasint incY);
 
 void cblas_ssbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A,
                  OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float beta, float *Y, OPENBLAS_CONST blasint incY);
@@ -197,45 +176,45 @@ void cblas_stbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLA
 void cblas_dtbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
 void cblas_ctbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
-                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
 void cblas_ztbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
-                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
 
 void cblas_stbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
 void cblas_dtbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
 void cblas_ctbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
-                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
 void cblas_ztbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
-                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
 
 void cblas_stpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST float *Ap, float *X, OPENBLAS_CONST blasint incX);
 void cblas_dtpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST double *Ap, double *X, OPENBLAS_CONST blasint incX);
 void cblas_ctpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
-                 OPENBLAS_CONST blasint N, OPENBLAS_CONST void *Ap, void *X, OPENBLAS_CONST blasint incX);
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST float *Ap, float *X, OPENBLAS_CONST blasint incX);
 void cblas_ztpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
-                 OPENBLAS_CONST blasint N, OPENBLAS_CONST void *Ap, void *X, OPENBLAS_CONST blasint incX);
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST double *Ap, double *X, OPENBLAS_CONST blasint incX);
 
 void cblas_stpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST float *Ap, float *X, OPENBLAS_CONST blasint incX);
 void cblas_dtpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST double *Ap, double *X, OPENBLAS_CONST blasint incX);
 void cblas_ctpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
-                 OPENBLAS_CONST blasint N, OPENBLAS_CONST void *Ap, void *X, OPENBLAS_CONST blasint incX);
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST float *Ap, float *X, OPENBLAS_CONST blasint incX);
 void cblas_ztpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
-                 OPENBLAS_CONST blasint N, OPENBLAS_CONST void *Ap, void *X, OPENBLAS_CONST blasint incX);
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST double *Ap, double *X, OPENBLAS_CONST blasint incX);
 
 void cblas_ssymv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A,
                  OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float beta, float *Y, OPENBLAS_CONST blasint incY);
 void cblas_dsymv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A,
                  OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double beta, double *Y, OPENBLAS_CONST blasint incY);
-void cblas_chemv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A,
-                 OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
-void cblas_zhemv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A,
-                 OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
+void cblas_chemv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A,
+                 OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *beta, float *Y, OPENBLAS_CONST blasint incY);
+void cblas_zhemv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A,
+                 OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *beta, double *Y, OPENBLAS_CONST blasint incY);
 
 
 void cblas_sspmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *Ap,
@@ -246,36 +225,36 @@ void cblas_dspmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLA
 void cblas_sspr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, float *Ap);
 void cblas_dspr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, double *Ap);
 
-void cblas_chpr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, void *A);
-void cblas_zhpr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST void *X,OPENBLAS_CONST blasint incX, void *A);
+void cblas_chpr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, float *A);
+void cblas_zhpr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X,OPENBLAS_CONST blasint incX, double *A);
 
 void cblas_sspr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *Y, OPENBLAS_CONST blasint incY, float *A);
 void cblas_dspr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A);
-void cblas_chpr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *Ap);
-void cblas_zhpr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *Ap);
+void cblas_chpr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *Y, OPENBLAS_CONST blasint incY, float *Ap);
+void cblas_zhpr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *Ap);
 
 void cblas_chbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
+		 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *beta, float *Y, OPENBLAS_CONST blasint incY);
 void cblas_zhbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
+		 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *beta, double *Y, OPENBLAS_CONST blasint incY);
 
 void cblas_chpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N,
-		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *Ap, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
+		 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *Ap, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *beta, float *Y, OPENBLAS_CONST blasint incY);
 void cblas_zhpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N,
-		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *Ap, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
+		 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *Ap, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *beta, double *Y, OPENBLAS_CONST blasint incY);
 
 void cblas_sgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
 		 OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
 void cblas_dgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
 		 OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
 void cblas_cgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
+		 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float *beta, float *C, OPENBLAS_CONST blasint ldc);
 void cblas_cgemm3m(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
+		 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float *beta, float *C, OPENBLAS_CONST blasint ldc);
 void cblas_zgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
+		 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double *beta, double *C, OPENBLAS_CONST blasint ldc);
 void cblas_zgemm3m(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
+		 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double *beta, double *C, OPENBLAS_CONST blasint ldc);
 
 
 void cblas_ssymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
@@ -283,60 +262,60 @@ void cblas_ssymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLA
 void cblas_dsymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
 void cblas_csymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
-                 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
+                 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float *beta, float *C, OPENBLAS_CONST blasint ldc);
 void cblas_zsymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
-                 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
+                 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double *beta, double *C, OPENBLAS_CONST blasint ldc);
 
 void cblas_ssyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
 		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
 void cblas_dsyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
 		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
 void cblas_csyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
-		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
+		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *beta, float *C, OPENBLAS_CONST blasint ldc);
 void cblas_zsyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
-		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
+		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *beta, double *C, OPENBLAS_CONST blasint ldc);
 
 void cblas_ssyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
 		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
 void cblas_dsyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
 		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
 void cblas_csyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
-		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
+		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float *beta, float *C, OPENBLAS_CONST blasint ldc);
 void cblas_zsyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
-		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
+		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double *beta, double *C, OPENBLAS_CONST blasint ldc);
 
 void cblas_strmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                  OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *B, OPENBLAS_CONST blasint ldb);
 void cblas_dtrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                  OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *B, OPENBLAS_CONST blasint ldb);
 void cblas_ctrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
-                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *B, OPENBLAS_CONST blasint ldb);
+                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *B, OPENBLAS_CONST blasint ldb);
 void cblas_ztrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
-                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *B, OPENBLAS_CONST blasint ldb);
+                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *B, OPENBLAS_CONST blasint ldb);
 
 void cblas_strsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                  OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *B, OPENBLAS_CONST blasint ldb);
 void cblas_dtrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                  OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *B, OPENBLAS_CONST blasint ldb);
 void cblas_ctrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
-                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *B, OPENBLAS_CONST blasint ldb);
+                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *B, OPENBLAS_CONST blasint ldb);
 void cblas_ztrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
-                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *B, OPENBLAS_CONST blasint ldb);
+                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *B, OPENBLAS_CONST blasint ldb);
 
 void cblas_chemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
-                 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
+                 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float *beta, float *C, OPENBLAS_CONST blasint ldc);
 void cblas_zhemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
-                 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
+                 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double *beta, double *C, OPENBLAS_CONST blasint ldc);
 
 void cblas_cherk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-                 OPENBLAS_CONST float alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float beta, void *C, OPENBLAS_CONST blasint ldc);
+                 OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
 void cblas_zherk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-                 OPENBLAS_CONST double alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double beta, void *C, OPENBLAS_CONST blasint ldc);
+                 OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
 
 void cblas_cher2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-                  OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, void *C, OPENBLAS_CONST blasint ldc);
+                  OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
 void cblas_zher2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-                  OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, void *C, OPENBLAS_CONST blasint ldc);
+                  OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
 
 void cblas_xerbla(blasint p, char *rout, char *form, ...);
 
@@ -346,9 +325,9 @@ void cblas_saxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS
 
 void cblas_daxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST double beta, double *y, OPENBLAS_CONST blasint incy);
 
-void cblas_caxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST void *beta, void *y, OPENBLAS_CONST blasint incy);
+void cblas_caxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST float *beta, float *y, OPENBLAS_CONST blasint incy);
 
-void cblas_zaxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST void *beta, void *y, OPENBLAS_CONST blasint incy);
+void cblas_zaxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST double *beta, double *y, OPENBLAS_CONST blasint incy);
 
 void cblas_somatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float calpha, OPENBLAS_CONST float *a, 
 		     OPENBLAS_CONST blasint clda, float *b, OPENBLAS_CONST blasint cldb); 

cblas_noconst.h

@@ -0,0 +1,350 @@
+#ifndef CBLAS_H
+#define CBLAS_H
+
+#include <stddef.h>
+#include "common.h"
+
+#ifdef __cplusplus
+extern "C" {
+	/* Assume C declarations for C++ */
+#endif  /* __cplusplus */
+
+/*Set the number of threads on runtime.*/
+void openblas_set_num_threads(int num_threads);
+void goto_set_num_threads(int num_threads);
+
+/*Get the number of threads on runtime.*/
+int openblas_get_num_threads(void);
+
+/*Get the number of physical processors (cores).*/
+int openblas_get_num_procs(void);
+
+/*Get the build configure on runtime.*/
+char* openblas_get_config(void);
+
+/* Get the parallelization type which is used by OpenBLAS */
+int openblas_get_parallel(void);
+/* OpenBLAS is compiled for sequential use  */
+#define OPENBLAS_SEQUENTIAL  0
+/* OpenBLAS is compiled using normal threading model */
+#define OPENBLAS_THREAD  1
+/* OpenBLAS is compiled using OpenMP threading model */
+#define OPENBLAS_OPENMP 2
+
+
+#define CBLAS_INDEX size_t
+
+typedef enum CBLAS_ORDER     {CblasRowMajor=101, CblasColMajor=102} CBLAS_ORDER;
+typedef enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113, CblasConjNoTrans=114} CBLAS_TRANSPOSE;
+typedef enum CBLAS_UPLO      {CblasUpper=121, CblasLower=122} CBLAS_UPLO;
+typedef enum CBLAS_DIAG      {CblasNonUnit=131, CblasUnit=132} CBLAS_DIAG;
+typedef enum CBLAS_SIDE      {CblasLeft=141, CblasRight=142} CBLAS_SIDE;
+
+float  cblas_sdsdot(blasint n, float alpha, float *x, blasint incx, float *y, blasint incy);
+double cblas_dsdot (blasint n, float *x, blasint incx, float *y, blasint incy);
+float  cblas_sdot(blasint n, float  *x, blasint incx, float  *y, blasint incy);
+double cblas_ddot(blasint n, double *x, blasint incx, double *y, blasint incy);
+
+openblas_complex_float  cblas_cdotu(blasint n, float  *x, blasint incx, float  *y, blasint incy);
+openblas_complex_float  cblas_cdotc(blasint n, float  *x, blasint incx, float  *y, blasint incy);
+openblas_complex_double cblas_zdotu(blasint n, double *x, blasint incx, double *y, blasint incy);
+openblas_complex_double cblas_zdotc(blasint n, double *x, blasint incx, double *y, blasint incy);
+
+void  cblas_cdotu_sub(blasint n, float  *x, blasint incx, float  *y, blasint incy, openblas_complex_float  *ret);
+void  cblas_cdotc_sub(blasint n, float  *x, blasint incx, float  *y, blasint incy, openblas_complex_float  *ret);
+void  cblas_zdotu_sub(blasint n, double *x, blasint incx, double *y, blasint incy, openblas_complex_double *ret);
+void  cblas_zdotc_sub(blasint n, double *x, blasint incx, double *y, blasint incy, openblas_complex_double *ret);
+
+float  cblas_sasum (blasint n, float  *x, blasint incx);
+double cblas_dasum (blasint n, double *x, blasint incx);
+float  cblas_scasum(blasint n, float  *x, blasint incx);
+double cblas_dzasum(blasint n, double *x, blasint incx);
+
+float  cblas_snrm2 (blasint N, float  *X, blasint incX);
+double cblas_dnrm2 (blasint N, double *X, blasint incX);
+float  cblas_scnrm2(blasint N, float  *X, blasint incX);
+double cblas_dznrm2(blasint N, double *X, blasint incX);
+
+CBLAS_INDEX cblas_isamax(blasint n, float  *x, blasint incx);
+CBLAS_INDEX cblas_idamax(blasint n, double *x, blasint incx);
+CBLAS_INDEX cblas_icamax(blasint n, float  *x, blasint incx);
+CBLAS_INDEX cblas_izamax(blasint n, double *x, blasint incx);
+
+void cblas_saxpy(blasint n, float alpha, float *x, blasint incx, float *y, blasint incy);
+void cblas_daxpy(blasint n, double alpha, double *x, blasint incx, double *y, blasint incy);
+void cblas_caxpy(blasint n, float *alpha, float *x, blasint incx, float *y, blasint incy);
+void cblas_zaxpy(blasint n, double *alpha, double *x, blasint incx, double *y, blasint incy);
+
+void cblas_scopy(blasint n, float *x, blasint incx, float *y, blasint incy);
+void cblas_dcopy(blasint n, double *x, blasint incx, double *y, blasint incy);
+void cblas_ccopy(blasint n, float *x, blasint incx, float *y, blasint incy);
+void cblas_zcopy(blasint n, double *x, blasint incx, double *y, blasint incy);
+
+void cblas_sswap(blasint n, float *x, blasint incx, float *y, blasint incy);
+void cblas_dswap(blasint n, double *x, blasint incx, double *y, blasint incy);
+void cblas_cswap(blasint n, float *x, blasint incx, float *y, blasint incy);
+void cblas_zswap(blasint n, double *x, blasint incx, double *y, blasint incy);
+
+void cblas_srot(blasint N, float *X, blasint incX, float *Y, blasint incY, float c, float s);
+void cblas_drot(blasint N, double *X, blasint incX, double *Y, blasint incY, double c, double  s);
+
+void cblas_srotg(float *a, float *b, float *c, float *s);
+void cblas_drotg(double *a, double *b, double *c, double *s);
+
+void cblas_srotm(blasint N, float *X, blasint incX, float *Y, blasint incY, float *P);
+void cblas_drotm(blasint N, double *X, blasint incX, double *Y, blasint incY, double *P);
+
+void cblas_srotmg(float *d1, float *d2, float *b1, float b2, float *P);
+void cblas_drotmg(double *d1, double *d2, double *b1, double b2, double *P);
+
+void cblas_sscal(blasint N, float alpha, float *X, blasint incX);
+void cblas_dscal(blasint N, double alpha, double *X, blasint incX);
+void cblas_cscal(blasint N, float *alpha, float *X, blasint incX);
+void cblas_zscal(blasint N, double *alpha, double *X, blasint incX);
+void cblas_csscal(blasint N, float alpha, float *X, blasint incX);
+void cblas_zdscal(blasint N, double alpha, double *X, blasint incX);
+
+void cblas_sgemv(enum CBLAS_ORDER order,  enum CBLAS_TRANSPOSE trans,  blasint m, blasint n,
+		 float alpha, float  *a, blasint lda,  float  *x, blasint incx,  float beta,  float  *y, blasint incy);
+void cblas_dgemv(enum CBLAS_ORDER order,  enum CBLAS_TRANSPOSE trans,  blasint m, blasint n,
+		 double alpha, double  *a, blasint lda,  double  *x, blasint incx,  double beta,  double  *y, blasint incy);
+void cblas_cgemv(enum CBLAS_ORDER order,  enum CBLAS_TRANSPOSE trans,  blasint m, blasint n,
+		 float *alpha, float  *a, blasint lda,  float  *x, blasint incx,  float *beta,  float  *y, blasint incy);
+void cblas_zgemv(enum CBLAS_ORDER order,  enum CBLAS_TRANSPOSE trans,  blasint m, blasint n,
+		 double *alpha, double  *a, blasint lda,  double  *x, blasint incx,  double *beta,  double  *y, blasint incy);
+
+void cblas_sger (enum CBLAS_ORDER order, blasint M, blasint N, float   alpha, float  *X, blasint incX, float  *Y, blasint incY, float  *A, blasint lda);
+void cblas_dger (enum CBLAS_ORDER order, blasint M, blasint N, double  alpha, double *X, blasint incX, double *Y, blasint incY, double *A, blasint lda);
+void cblas_cgeru(enum CBLAS_ORDER order, blasint M, blasint N, float  *alpha, float  *X, blasint incX, float  *Y, blasint incY, float  *A, blasint lda);
+void cblas_cgerc(enum CBLAS_ORDER order, blasint M, blasint N, float  *alpha, float  *X, blasint incX, float  *Y, blasint incY, float  *A, blasint lda);
+void cblas_zgeru(enum CBLAS_ORDER order, blasint M, blasint N, double *alpha, double *X, blasint incX, double *Y, blasint incY, double *A, blasint lda);
+void cblas_zgerc(enum CBLAS_ORDER order, blasint M, blasint N, double *alpha, double *X, blasint incX, double *Y, blasint incY, double *A, blasint lda);
+
+void cblas_strsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, float *A, blasint lda, float *X, blasint incX);
+void cblas_dtrsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, double *A, blasint lda, double *X, blasint incX);
+void cblas_ctrsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, float *A, blasint lda, float *X, blasint incX);
+void cblas_ztrsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, double *A, blasint lda, double *X, blasint incX);
+
+void cblas_strmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, float *A, blasint lda, float *X, blasint incX);
+void cblas_dtrmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, double *A, blasint lda, double *X, blasint incX);
+void cblas_ctrmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, float *A, blasint lda, float *X, blasint incX);
+void cblas_ztrmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, double *A, blasint lda, double *X, blasint incX);
+
+void cblas_ssyr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *X, blasint incX, float *A, blasint lda);
+void cblas_dsyr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *X, blasint incX, double *A, blasint lda);
+void cblas_cher(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *X, blasint incX, float *A, blasint lda);
+void cblas_zher(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *X, blasint incX, double *A, blasint lda);
+
+void cblas_ssyr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo,blasint N, float alpha, float *X,
+                blasint incX, float *Y, blasint incY, float *A, blasint lda);
+void cblas_dsyr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *X,
+                blasint incX, double *Y, blasint incY, double *A, blasint lda);
+void cblas_cher2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float *alpha, float *X, blasint incX,
+                float *Y, blasint incY, float *A, blasint lda);
+void cblas_zher2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double *alpha, double *X, blasint incX,
+                double *Y, blasint incY, double *A, blasint lda);
+
+void cblas_sgbmv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE TransA, blasint M, blasint N,
+                 blasint KL, blasint KU, float alpha, float *A, blasint lda, float *X, blasint incX, float beta, float *Y, blasint incY);
+void cblas_dgbmv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE TransA, blasint M, blasint N,
+                 blasint KL, blasint KU, double alpha, double *A, blasint lda, double *X, blasint incX, double beta, double *Y, blasint incY);
+void cblas_cgbmv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE TransA, blasint M, blasint N,
+                 blasint KL, blasint KU, float *alpha, float *A, blasint lda, float *X, blasint incX, float *beta, float *Y, blasint incY);
+void cblas_zgbmv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE TransA, blasint M, blasint N,
+                 blasint KL, blasint KU, double *alpha, double *A, blasint lda, double *X, blasint incX, double *beta, double *Y, blasint incY);
+
+void cblas_ssbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, blasint K, float alpha, float *A,
+                 blasint lda, float *X, blasint incX, float beta, float *Y, blasint incY);
+void cblas_dsbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, blasint K, double alpha, double *A,
+                 blasint lda, double *X, blasint incX, double beta, double *Y, blasint incY);
+
+
+void cblas_stbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, blasint K, float *A, blasint lda, float *X, blasint incX);
+void cblas_dtbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, blasint K, double *A, blasint lda, double *X, blasint incX);
+void cblas_ctbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, blasint K, float *A, blasint lda, float *X, blasint incX);
+void cblas_ztbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, blasint K, double *A, blasint lda, double *X, blasint incX);
+
+void cblas_stbsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, blasint K, float *A, blasint lda, float *X, blasint incX);
+void cblas_dtbsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, blasint K, double *A, blasint lda, double *X, blasint incX);
+void cblas_ctbsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, blasint K, float *A, blasint lda, float *X, blasint incX);
+void cblas_ztbsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, blasint K, double *A, blasint lda, double *X, blasint incX);
+
+void cblas_stpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, float *Ap, float *X, blasint incX);
+void cblas_dtpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, double *Ap, double *X, blasint incX);
+void cblas_ctpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, float *Ap, float *X, blasint incX);
+void cblas_ztpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, double *Ap, double *X, blasint incX);
+
+void cblas_stpsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, float *Ap, float *X, blasint incX);
+void cblas_dtpsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, double *Ap, double *X, blasint incX);
+void cblas_ctpsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, float *Ap, float *X, blasint incX);
+void cblas_ztpsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag,
+                 blasint N, double *Ap, double *X, blasint incX);
+
+void cblas_ssymv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *A,
+                 blasint lda, float *X, blasint incX, float beta, float *Y, blasint incY);
+void cblas_dsymv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *A,
+                 blasint lda, double *X, blasint incX, double beta, double *Y, blasint incY);
+void cblas_chemv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float *alpha, float *A,
+                 blasint lda, float *X, blasint incX, float *beta, float *Y, blasint incY);
+void cblas_zhemv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double *alpha, double *A,
+                 blasint lda, double *X, blasint incX, double *beta, double *Y, blasint incY);
+
+
+void cblas_sspmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *Ap,
+                 float *X, blasint incX, float beta, float *Y, blasint incY);
+void cblas_dspmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *Ap,
+                 double *X, blasint incX, double beta, double *Y, blasint incY);
+
+void cblas_sspr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *X, blasint incX, float *Ap);
+void cblas_dspr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *X, blasint incX, double *Ap);
+
+void cblas_chpr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *X, blasint incX, float *A);
+void cblas_zhpr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *X,blasint incX, double *A);
+
+void cblas_sspr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *X, blasint incX, float *Y, blasint incY, float *A);
+void cblas_dspr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *X, blasint incX, double *Y, blasint incY, double *A);
+void cblas_chpr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float *alpha, float *X, blasint incX, float *Y, blasint incY, float *Ap);
+void cblas_zhpr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double *alpha, double *X, blasint incX, double *Y, blasint incY, double *Ap);
+
+void cblas_chbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, blasint K,
+		 float *alpha, float *A, blasint lda, float *X, blasint incX, float *beta, float *Y, blasint incY);
+void cblas_zhbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, blasint K,
+		 double *alpha, double *A, blasint lda, double *X, blasint incX, double *beta, double *Y, blasint incY);
+
+void cblas_chpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N,
+		 float *alpha, float *Ap, float *X, blasint incX, float *beta, float *Y, blasint incY);
+void cblas_zhpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N,
+		 double *alpha, double *Ap, double *X, blasint incX, double *beta, double *Y, blasint incY);
+
+void cblas_sgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, blasint M, blasint N, blasint K,
+		 float alpha, float *A, blasint lda, float *B, blasint ldb, float beta, float *C, blasint ldc);
+void cblas_dgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, blasint M, blasint N, blasint K,
+		 double alpha, double *A, blasint lda, double *B, blasint ldb, double beta, double *C, blasint ldc);
+void cblas_cgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, blasint M, blasint N, blasint K,
+		 float *alpha, float *A, blasint lda, float *B, blasint ldb, float *beta, float *C, blasint ldc);
+void cblas_cgemm3m(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, blasint M, blasint N, blasint K,
+		 float *alpha, float *A, blasint lda, float *B, blasint ldb, float *beta, float *C, blasint ldc);
+void cblas_zgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, blasint M, blasint N, blasint K,
+		 double *alpha, double *A, blasint lda, double *B, blasint ldb, double *beta, double *C, blasint ldc);
+void cblas_zgemm3m(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, blasint M, blasint N, blasint K,
+		 double *alpha, double *A, blasint lda, double *B, blasint ldb, double *beta, double *C, blasint ldc);
+
+void cblas_ssymm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, blasint M, blasint N,
+                 float alpha, float *A, blasint lda, float *B, blasint ldb, float beta, float *C, blasint ldc);
+void cblas_dsymm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, blasint M, blasint N,
+                 double alpha, double *A, blasint lda, double *B, blasint ldb, double beta, double *C, blasint ldc);
+void cblas_csymm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, blasint M, blasint N,
+                 float *alpha, float *A, blasint lda, float *B, blasint ldb, float *beta, float *C, blasint ldc);
+void cblas_zsymm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, blasint M, blasint N,
+                 double *alpha, double *A, blasint lda, double *B, blasint ldb, double *beta, double *C, blasint ldc);
+
+void cblas_ssyrk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans,
+		 blasint N, blasint K, float alpha, float *A, blasint lda, float beta, float *C, blasint ldc);
+void cblas_dsyrk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans,
+		 blasint N, blasint K, double alpha, double *A, blasint lda, double beta, double *C, blasint ldc);
+void cblas_csyrk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans,
+		 blasint N, blasint K, float *alpha, float *A, blasint lda, float *beta, float *C, blasint ldc);
+void cblas_zsyrk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans,
+		 blasint N, blasint K, double *alpha, double *A, blasint lda, double *beta, double *C, blasint ldc);
+
+void cblas_ssyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans,
+		  blasint N, blasint K, float alpha, float *A, blasint lda, float *B, blasint ldb, float beta, float *C, blasint ldc);
+void cblas_dsyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans,
+		  blasint N, blasint K, double alpha, double *A, blasint lda, double *B, blasint ldb, double beta, double *C, blasint ldc);
+void cblas_csyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans,
+		  blasint N, blasint K, float *alpha, float *A, blasint lda, float *B, blasint ldb, float *beta, float *C, blasint ldc);
+void cblas_zsyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans,
+		  blasint N, blasint K, double *alpha, double *A, blasint lda, double *B, blasint ldb, double *beta, double *C, blasint ldc);
+
+void cblas_strmm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,
+                 enum CBLAS_DIAG Diag, blasint M, blasint N, float alpha, float *A, blasint lda, float *B, blasint ldb);
+void cblas_dtrmm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,
+                 enum CBLAS_DIAG Diag, blasint M, blasint N, double alpha, double *A, blasint lda, double *B, blasint ldb);
+void cblas_ctrmm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,
+                 enum CBLAS_DIAG Diag, blasint M, blasint N, float *alpha, float *A, blasint lda, float *B, blasint ldb);
+void cblas_ztrmm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,
+                 enum CBLAS_DIAG Diag, blasint M, blasint N, double *alpha, double *A, blasint lda, double *B, blasint ldb);
+
+void cblas_strsm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,
+                 enum CBLAS_DIAG Diag, blasint M, blasint N, float alpha, float *A, blasint lda, float *B, blasint ldb);
+void cblas_dtrsm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,
+                 enum CBLAS_DIAG Diag, blasint M, blasint N, double alpha, double *A, blasint lda, double *B, blasint ldb);
+void cblas_ctrsm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,
+                 enum CBLAS_DIAG Diag, blasint M, blasint N, float *alpha, float *A, blasint lda, float *B, blasint ldb);
+void cblas_ztrsm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,
+                 enum CBLAS_DIAG Diag, blasint M, blasint N, double *alpha, double *A, blasint lda, double *B, blasint ldb);
+
+void cblas_chemm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, blasint M, blasint N,
+                 float *alpha, float *A, blasint lda, float *B, blasint ldb, float *beta, float *C, blasint ldc);
+void cblas_zhemm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, blasint M, blasint N,
+                 double *alpha, double *A, blasint lda, double *B, blasint ldb, double *beta, double *C, blasint ldc);
+
+void cblas_cherk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, blasint N, blasint K,
+                 float alpha, float *A, blasint lda, float beta, float *C, blasint ldc);
+void cblas_zherk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, blasint N, blasint K,
+                 double alpha, double *A, blasint lda, double beta, double *C, blasint ldc);
+
+void cblas_cher2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, blasint N, blasint K,
+                  float *alpha, float *A, blasint lda, float *B, blasint ldb, float beta, float *C, blasint ldc);
+void cblas_zher2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, blasint N, blasint K,
+                  double *alpha, double *A, blasint lda, double *B, blasint ldb, double beta, double *C, blasint ldc);
+
+void cblas_xerbla(blasint p, char *rout, char *form, ...);
+
+/*** BLAS extensions ***/
+
+void cblas_saxpby(blasint n, float alpha, float *x, blasint incx,float beta, float *y, blasint incy);
+
+void cblas_daxpby(blasint n, double alpha, double *x, blasint incx,double beta, double *y, blasint incy);
+
+void cblas_caxpby(blasint n, float *alpha, float *x, blasint incx,float *beta, float *y, blasint incy);
+
+void cblas_zaxpby(blasint n, double *alpha, double *x, blasint incx,double *beta, double *y, blasint incy);
+
+void cblas_somatcopy( enum CBLAS_ORDER CORDER,  enum CBLAS_TRANSPOSE CTRANS,  blasint crows,  blasint ccols,  float calpha,  float *a, 
+		      blasint clda, float *b,  blasint cldb); 
+void cblas_domatcopy( enum CBLAS_ORDER CORDER,  enum CBLAS_TRANSPOSE CTRANS,  blasint crows,  blasint ccols,  double calpha,  double *a,
+		      blasint clda, double *b,  blasint cldb); 
+void cblas_comatcopy( enum CBLAS_ORDER CORDER,  enum CBLAS_TRANSPOSE CTRANS,  blasint crows,  blasint ccols,  void* calpha,  void* a, 
+		      blasint clda, void *b,  blasint cldb); 
+void cblas_zomatcopy( enum CBLAS_ORDER CORDER,  enum CBLAS_TRANSPOSE CTRANS,  blasint crows,  blasint ccols,  void* calpha,  void* a, 
+		      blasint clda,  void *b,  blasint cldb); 
+
+void cblas_simatcopy( enum CBLAS_ORDER CORDER,  enum CBLAS_TRANSPOSE CTRANS,  blasint crows,  blasint ccols,  float calpha, float *a, 
+		      blasint clda,  blasint cldb); 
+void cblas_dimatcopy( enum CBLAS_ORDER CORDER,  enum CBLAS_TRANSPOSE CTRANS,  blasint crows,  blasint ccols,  double calpha, double *a,
+		      blasint clda,  blasint cldb); 
+void cblas_cimatcopy( enum CBLAS_ORDER CORDER,  enum CBLAS_TRANSPOSE CTRANS,  blasint crows,  blasint ccols,  float* calpha, float* a, 
+		      blasint clda,  blasint cldb); 
+void cblas_zimatcopy( enum CBLAS_ORDER CORDER,  enum CBLAS_TRANSPOSE CTRANS,  blasint crows,  blasint ccols,  double* calpha, double* a, 
+		      blasint clda,  blasint cldb); 
+
+void cblas_sgeadd( enum CBLAS_ORDER CORDER, blasint crows,  blasint ccols,  float calpha, float *a,  blasint clda,  float cbeta, 
+		  float *c,  blasint cldc); 
+void cblas_dgeadd( enum CBLAS_ORDER CORDER, blasint crows,  blasint ccols,  double calpha, double *a,  blasint clda,  double cbeta, 
+		  double *c,  blasint cldc); 
+void cblas_cgeadd( enum CBLAS_ORDER CORDER, blasint crows,  blasint ccols,  float *calpha, float *a,  blasint clda,  float *cbeta, 
+		  float *c,  blasint cldc); 
+void cblas_zgeadd( enum CBLAS_ORDER CORDER, blasint crows,  blasint ccols,  double *calpha, double *a,  blasint clda,  double *cbeta, 
+		  double *c,  blasint cldc); 
+
+#ifdef __cplusplus
+}
+#endif  /* __cplusplus */
+
+#endif

cmake/OpenBLASConfig.cmake.in

@@ -1,79 +0,0 @@
-# OpenBLASConfig.cmake
-# --------------------
-#
-# OpenBLAS cmake module.
-# This module sets the following variables in your project::
-#
-#   OpenBLAS_FOUND - true if OpenBLAS and all required components found on the system
-#   OpenBLAS_VERSION - OpenBLAS version in format Major.Minor.Release
-#   OpenBLAS_INCLUDE_DIRS - Directory where OpenBLAS header is located.
-#   OpenBLAS_INCLUDE_DIR - same as DIRS
-#   OpenBLAS_LIBRARIES - OpenBLAS library to link against.
-#   OpenBLAS_LIBRARY - same as LIBRARIES
-#
-#
-# Available components::
-#
-##   shared - search for only shared library
-##   static - search for only static library
-#   serial - search for unthreaded library
-#   pthread - search for native pthread threaded library
-#   openmp - search for OpenMP threaded library
-#
-#
-# Exported targets::
-#
-# If OpenBLAS is found, this module defines the following :prop_tgt:`IMPORTED`
-## target. Target is shared _or_ static, so, for both, use separate, not
-## overlapping, installations. ::
-#
-#   OpenBLAS::OpenBLAS - the main OpenBLAS library #with header & defs attached.
-#
-#
-# Suggested usage::
-#
-#   find_package(OpenBLAS)
-#   find_package(OpenBLAS 0.2.20 EXACT CONFIG REQUIRED COMPONENTS pthread)
-#
-#
-# The following variables can be set to guide the search for this package::
-#
-#   OpenBLAS_DIR - CMake variable, set to directory containing this Config file
-#   CMAKE_PREFIX_PATH - CMake variable, set to root directory of this package
-#   PATH - environment variable, set to bin directory of this package
-#   CMAKE_DISABLE_FIND_PACKAGE_OpenBLAS - CMake variable, disables
-#     find_package(OpenBLAS) when not REQUIRED, perhaps to force internal build
-
-@PACKAGE_INIT@
-
-set(PN OpenBLAS)
-
-# need to check that the @USE_*@ evaluate to something cmake can perform boolean logic upon
-if(@USE_OPENMP@)
-    set(${PN}_openmp_FOUND 1)
-elseif(@USE_THREAD@)
-    set(${PN}_pthread_FOUND 1)
-else()
-    set(${PN}_serial_FOUND 1)
-endif()
-
-check_required_components(${PN})
-
-#-----------------------------------------------------------------------------
-# Don't include targets if this file is being picked up by another
-# project which has already built this as a subproject
-#-----------------------------------------------------------------------------
-if(NOT TARGET ${PN}::OpenBLAS)
-    include("${CMAKE_CURRENT_LIST_DIR}/${PN}Targets.cmake")
-
-    get_property(_loc TARGET ${PN}::OpenBLAS PROPERTY LOCATION)
-    set(${PN}_LIBRARY ${_loc})
-    get_property(_ill TARGET ${PN}::OpenBLAS PROPERTY INTERFACE_LINK_LIBRARIES)
-    set(${PN}_LIBRARIES ${_ill})
-
-    get_property(_id TARGET ${PN}::OpenBLAS PROPERTY INCLUDE_DIRECTORIES)
-    set(${PN}_INCLUDE_DIR ${_id})
-    get_property(_iid TARGET ${PN}::OpenBLAS PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
-    set(${PN}_INCLUDE_DIRS ${_iid})
-endif()
-

cmake/arch.cmake

@@ -1,123 +0,0 @@
-##
-## Author: Hank Anderson <hank@statease.com>
-## Description: Ported from portion of OpenBLAS/Makefile.system
-##              Sets various variables based on architecture.
-
-if (X86 OR X86_64)
-
-  if (X86)
-    if (NOT BINARY)
-      set(NO_BINARY_MODE 1)
-    endif ()
-  endif ()
-
-  if (NOT NO_EXPRECISION)
-    if (${F_COMPILER} MATCHES "GFORTRAN")
-      # N.B. I'm not sure if CMake differentiates between GCC and LSB -hpa
-      if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU" OR ${CMAKE_C_COMPILER_ID} STREQUAL "LSB")
-        set(EXPRECISION	1)
-        set(CCOMMON_OPT "${CCOMMON_OPT} -DEXPRECISION -m128bit-long-double")
-        set(FCOMMON_OPT	"${FCOMMON_OPT} -m128bit-long-double")
-      endif ()
-      if (${CMAKE_C_COMPILER_ID} STREQUAL "Clang")
-        set(EXPRECISION	1)
-        set(CCOMMON_OPT "${CCOMMON_OPT} -DEXPRECISION")
-        set(FCOMMON_OPT	"${FCOMMON_OPT} -m128bit-long-double")
-      endif ()
-    endif ()
-  endif ()
-endif ()
-
-if (${CMAKE_C_COMPILER_ID} STREQUAL "Intel")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -wd981")
-endif ()
-
-if (USE_OPENMP)
-  # USE_SIMPLE_THREADED_LEVEL3 = 1
-  # NO_AFFINITY = 1
-  find_package(OpenMP REQUIRED)
-  if (OpenMP_FOUND)
-    set(CCOMMON_OPT "${CCOMMON_OPT} ${OpenMP_C_FLAGS} -DUSE_OPENMP")
-    set(FCOMMON_OPT "${FCOMMON_OPT} ${OpenMP_Fortran_FLAGS}")
-  endif()
-endif ()
-
-
-if (DYNAMIC_ARCH)
-  if (ARM64)
-    set(DYNAMIC_CORE ARMV8 CORTEXA53 CORTEXA57 CORTEXA72 CORTEXA73 FALKOR THUNDERX THUNDERX2T99 TSV110)
-  endif ()
-  
-  if (POWER)
-    set(DYNAMIC_CORE POWER6 POWER8 POWER9)
-  endif ()
-  
-  if (X86)
-    set(DYNAMIC_CORE KATMAI COPPERMINE NORTHWOOD PRESCOTT BANIAS CORE2 PENRYN DUNNINGTON NEHALEM ATHLON OPTERON OPTERON_SSE3 BARCELONA BOBCAT ATOM NANO)
-  endif ()
-
-  if (X86_64)
-    set(DYNAMIC_CORE PRESCOTT CORE2)
-    if (DYNAMIC_OLDER)
-	set (DYNAMIC_CORE ${DYNAMIC_CORE} PENRYN DUNNINGTON)
-    endif ()
-    set (DYNAMIC_CORE ${DYNAMIC_CORE} NEHALEM)
-    if (DYNAMIC_OLDER)
-	set (DYNAMIC_CORE ${DYNAMIC_CORE} OPTERON OPTERON_SSE3)
-    endif ()
-    set (DYNAMIC_CORE ${DYNAMIC_CORE} BARCELONA) 
-    if (DYNAMIC_OLDER)
-	set (DYNAMIC_CORE ${DYNAMIC_CORE} BOBCAT ATOM NANO)
-    endif ()
-    if (NOT NO_AVX)
-      set(DYNAMIC_CORE ${DYNAMIC_CORE} SANDYBRIDGE BULLDOZER PILEDRIVER STEAMROLLER EXCAVATOR)
-    endif ()
-    if (NOT NO_AVX2)
-      set(DYNAMIC_CORE ${DYNAMIC_CORE} HASWELL ZEN)
-    endif ()
-    if (NOT NO_AVX512)
-      set(DYNAMIC_CORE ${DYNAMIC_CORE} SKYLAKEX)
-      string(REGEX REPLACE "-march=native" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-   endif ()
-    if (DYNAMIC_LIST)
-	set(DYNAMIC_CORE PRESCOTT ${DYNAMIC_LIST})
-    endif ()
-  endif ()
-
-  if (NOT DYNAMIC_CORE)
-    message (STATUS "DYNAMIC_ARCH is not supported on this architecture, removing from options")
-    unset(DYNAMIC_ARCH CACHE)
-  endif ()
-endif ()
-
-if (${ARCH} STREQUAL "ia64")
-  set(NO_BINARY_MODE 1)
-  set(BINARY_DEFINED 1)
-
-  if (${F_COMPILER} MATCHES "GFORTRAN")
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
-      # EXPRECISION	= 1
-      # CCOMMON_OPT	+= -DEXPRECISION
-    endif ()
-  endif ()
-endif ()
-
-if (MIPS64)
-  set(NO_BINARY_MODE 1)
-endif ()
-
-if (${ARCH} STREQUAL "alpha")
-  set(NO_BINARY_MODE 1)
-  set(BINARY_DEFINED 1)
-endif ()
-
-if (ARM)
-  set(NO_BINARY_MODE 1)
-  set(BINARY_DEFINED 1)
-endif ()
-
-if (ARM64)
-  set(NO_BINARY_MODE 1)
-  set(BINARY_DEFINED 1)
-endif ()
-

cmake/cc.cmake

@@ -1,105 +0,0 @@
-##
-## Author: Hank Anderson <hank@statease.com>
-## Description: Ported from portion of OpenBLAS/Makefile.system
-##              Sets C related variables.
-
-if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU" OR ${CMAKE_C_COMPILER_ID} STREQUAL "LSB" OR ${CMAKE_C_COMPILER_ID} MATCHES "Clang")
-
-  set(CCOMMON_OPT "${CCOMMON_OPT} -Wall")
-  set(COMMON_PROF "${COMMON_PROF} -fno-inline")
-  set(NO_UNINITIALIZED_WARN "-Wno-uninitialized")
-
-  if (QUIET_MAKE)
-    set(CCOMMON_OPT "${CCOMMON_OPT} ${NO_UNINITIALIZED_WARN} -Wno-unused")
-  endif ()
-
-  if (NO_BINARY_MODE)
-
-    if (MIPS64)
-      if (BINARY64)
-        set(CCOMMON_OPT "${CCOMMON_OPT} -mabi=64")
-      else ()
-        set(CCOMMON_OPT "${CCOMMON_OPT} -mabi=n32")
-      endif ()
-      set(BINARY_DEFINED 1)
-    endif ()
-
-    if (${CORE} STREQUAL "LOONGSON3A" OR ${CORE} STREQUAL "LOONGSON3B")
-      set(CCOMMON_OPT "${CCOMMON_OPT} -march=mips64")
-      set(FCOMMON_OPT "${FCOMMON_OPT} -march=mips64")
-    endif ()
-
-    if (CMAKE_SYSTEM_NAME STREQUAL "AIX")
-      set(BINARY_DEFINED 1)
-    endif ()
-  endif ()
-
-  if (NOT BINARY_DEFINED)
-    if (BINARY64)
-      set(CCOMMON_OPT "${CCOMMON_OPT} -m64")
-    else ()
-      set(CCOMMON_OPT "${CCOMMON_OPT} -m32")
-    endif ()
-  endif ()
-endif ()
-
-if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI")
-  if (BINARY64)
-    set(CCOMMON_OPT "${CCOMMON_OPT} -tp p7-64")
-  else ()
-    set(CCOMMON_OPT "${CCOMMON_OPT} -tp p7")
-  endif ()
-endif ()
-
-if (${CMAKE_C_COMPILER_ID} STREQUAL "PATHSCALE")
-  if (BINARY64)
-    set(CCOMMON_OPT "${CCOMMON_OPT} -m64")
-  else ()
-    set(CCOMMON_OPT "${CCOMMON_OPT} -m32")
-  endif ()
-endif ()
-
-if (${CMAKE_C_COMPILER_ID} STREQUAL "OPEN64")
-
-  if (MIPS64)
-
-    if (NOT BINARY64)
-      set(CCOMMON_OPT "${CCOMMON_OPT} -n32")
-    else ()
-      set(CCOMMON_OPT "${CCOMMON_OPT} -n64")
-    endif ()
-
-    if (${CORE} STREQUAL "LOONGSON3A")
-      set(CCOMMON_OPT "${CCOMMON_OPT} -loongson3 -static")
-    endif ()
-
-    if (${CORE} STREQUAL "LOONGSON3B")
-      set(CCOMMON_OPT "${CCOMMON_OPT} -loongson3 -static")
-    endif ()
-
-  else ()
-
-    if (BINARY64)
-      set(CCOMMON_OPT "${CCOMMON_OPT} -m32")
-    else ()
-      set(CCOMMON_OPT "${CCOMMON_OPT} -m64")
-    endif ()
-  endif ()
-endif ()
-
-if (${CMAKE_C_COMPILER_ID} STREQUAL "SUN")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -w")
-  if (X86)
-    set(CCOMMON_OPT "${CCOMMON_OPT} -m32")
-  else ()
-    set(CCOMMON_OPT "${CCOMMON_OPT} -m64")
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL "SKYLAKEX")
-  if (NOT DYNAMIC_ARCH)
-    if (NOT NO_AVX512)
-      set (CCOMMON_OPT = "${CCOMMON_OPT} -march=skylake-avx512")
-    endif ()
-  endif ()
-endif ()

cmake/export.cmake

@@ -1,61 +0,0 @@
-
-#Only generate .def for dll on MSVC
-if(MSVC)
-
-set_source_files_properties(${OpenBLAS_DEF_FILE} PROPERTIES GENERATED 1)
-
-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()
-
-add_custom_command(
-  OUTPUT ${PROJECT_BINARY_DIR}/openblas.def
-  #TARGET ${OpenBLAS_LIBNAME} PRE_LINK
-  COMMAND perl 
-  ARGS "${PROJECT_SOURCE_DIR}/exports/gensymbol" "win2k" "${ARCH_IN}" "dummy" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" "${SYMBOLPREFIX}" "${SYMBOLSUFFIX}" > "${PROJECT_BINARY_DIR}/openblas.def"
-  COMMENT "Create openblas.def file"
-  VERBATIM)
-
-endif()

cmake/f_check.cmake

@@ -1,56 +0,0 @@
-##
-## Author: Hank Anderson <hank@statease.com>
-## Copyright: (c) Stat-Ease, Inc.
-## Created: 12/29/14
-## Last Modified: 12/29/14
-## Description: Ported from the OpenBLAS/f_check perl script.
-##              This is triggered by prebuild.cmake and runs before any of the code is built.
-##              Appends Fortran information to config.h and Makefile.conf.
-
-# CMake vars set by this file:
-# F_COMPILER
-# FC
-# BU
-# NOFORTRAN
-# NEED2UNDERSCORES
-# FEXTRALIB
-
-# Defines set by this file:
-# BUNDERSCORE
-# NEEDBUNDERSCORE
-# NEED2UNDERSCORES
-
-if (NOT NO_LAPACK)
-  enable_language(Fortran)
-else()
-  include(CMakeForceCompiler)
-  CMAKE_FORCE_Fortran_COMPILER(gfortran GNU)
-endif()
-
-if (NOT ONLY_CBLAS)
-  # run f_check (appends to TARGET files)
-
-  # TODO: detect whether underscore needed, set #defines and BU appropriately - use try_compile
-  # TODO: set FEXTRALIB flags a la f_check?
-
-  set(BU "_")
-  file(APPEND ${TARGET_CONF_TEMP}
-    "#define BUNDERSCORE _\n"
-    "#define NEEDBUNDERSCORE 1\n"
-    "#define NEED2UNDERSCORES 0\n")
-
-else ()
-
-  #When we only build CBLAS, we set NOFORTRAN=2
-  set(NOFORTRAN 2)
-  set(NO_FBLAS 1)
-  #set(F_COMPILER GFORTRAN) # CMake handles the fortran compiler
-  set(BU "_")
-  file(APPEND ${TARGET_CONF_TEMP}
-    "#define BUNDERSCORE _\n"
-    "#define NEEDBUNDERSCORE 1\n")
-endif()
-
-get_filename_component(F_COMPILER ${CMAKE_Fortran_COMPILER} NAME_WE)
-string(TOUPPER ${F_COMPILER} F_COMPILER)
-

cmake/fc.cmake

@@ -1,218 +0,0 @@
-##
-## Author: Hank Anderson <hank@statease.com>
-## Description: Ported from portion of OpenBLAS/Makefile.system
-##              Sets Fortran related variables.
-
-if (INTERFACE64)
-  set(SUFFIX64 64)
-  set(SUFFIX64_UNDERSCORE _64)
-endif()
-
-if (${F_COMPILER} STREQUAL "FLANG")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_FLANG")
-  if (BINARY64 AND INTERFACE64)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -i8")
-  endif ()
-  if (USE_OPENMP)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -fopenmp")
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "G77")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_G77")
-  set(FCOMMON_OPT "${FCOMMON_OPT} -Wall")
-  if (NOT NO_BINARY_MODE)
-    if (BINARY64)
-      set(FCOMMON_OPT "${FCOMMON_OPT} -m64")
-    else ()
-      set(FCOMMON_OPT "${FCOMMON_OPT} -m32")
-    endif ()
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "G95")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_G95")
-  set(FCOMMON_OPT "${FCOMMON_OPT} -Wall")
-  if (NOT NO_BINARY_MODE)
-    if (BINARY64)
-      set(FCOMMON_OPT "${FCOMMON_OPT} -m64")
-    else ()
-      set(FCOMMON_OPT "${FCOMMON_OPT} -m32")
-    endif ()
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "GFORTRAN")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_GFORT")
-  # ensure reentrancy of lapack codes
-  set(FCOMMON_OPT "${FCOMMON_OPT} -Wall -frecursive")
-  # work around ABI violation in passing string arguments from C
-  set(FCOMMON_OPT "${FCOMMON_OPT} -fno-optimize-sibling-calls")
-  #Don't include -lgfortran, when NO_LAPACK=1 or lsbcc
-  if (NOT NO_LAPACK)
-    set(EXTRALIB "{EXTRALIB} -lgfortran")
-  endif ()
-  if (NO_BINARY_MODE)
-    if (MIPS64)
-      if (BINARY64)
-        set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=64")
-      else ()
-        set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=n32")
-      endif ()
-    endif ()
-  else ()
-    if (BINARY64)
-      set(FCOMMON_OPT "${FCOMMON_OPT} -m64")
-      if (INTERFACE64)
-        set(FCOMMON_OPT "${FCOMMON_OPT} -fdefault-integer-8")
-      endif ()
-    else ()
-      set(FCOMMON_OPT "${FCOMMON_OPT} -m32")
-    endif ()
-  endif ()
-
-  if (USE_OPENMP)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -fopenmp")
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "INTEL")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_INTEL")
-  if (INTERFACE64)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -i8")
-  endif ()
-  if (USE_OPENMP)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -openmp")
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "FUJITSU")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_FUJITSU")
-  if (USE_OPENMP)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -openmp")
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "IBM")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_IBM")
-  # FCOMMON_OPT	+= -qarch=440
-  if (BINARY64)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -q64")
-    if (INTERFACE64)
-      set(FCOMMON_OPT "${FCOMMON_OPT} -qintsize=8")
-    endif ()
-  else ()
-    set(FCOMMON_OPT "${FCOMMON_OPT} -q32")
-  endif ()
-  if (USE_OPENMP)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -openmp")
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "PGI")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_PGI")
-  set(COMMON_PROF "${COMMON_PROF} -DPGICOMPILER")
-  if (BINARY64)
-    if (INTERFACE64)
-      set(FCOMMON_OPT "${FCOMMON_OPT} -i8")
-    endif ()
-    set(FCOMMON_OPT "${FCOMMON_OPT} -tp p7-64")
-  else ()
-    set(FCOMMON_OPT "${FCOMMON_OPT} -tp p7")
-  endif ()
-  if (USE_OPENMP)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -mp")
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "PATHSCALE")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_PATHSCALE")
-  if (BINARY64)
-    if (INTERFACE64)
-      set(FCOMMON_OPT "${FCOMMON_OPT} -i8")
-    endif ()
-  endif ()
-
-  if (NOT MIPS64)
-    if (NOT BINARY64)
-      set(FCOMMON_OPT "${FCOMMON_OPT} -m32")
-    else ()
-      set(FCOMMON_OPT "${FCOMMON_OPT} -m64")
-    endif ()
-  else ()
-    if (BINARY64)
-      set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=64")
-    else ()
-    set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=n32")
-    endif ()
-  endif ()
-
-  if (USE_OPENMP)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -mp")
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "OPEN64")
-
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_OPEN64")
-  if (BINARY64)
-    if (INTERFACE64)
-      set(FCOMMON_OPT "${FCOMMON_OPT} -i8")
-    endif ()
-  endif ()
-
-  if (MIPS64)
-
-    if (NOT BINARY64)
-      set(FCOMMON_OPT "${FCOMMON_OPT} -n32")
-    else ()
-      set(FCOMMON_OPT "${FCOMMON_OPT} -n64")
-    endif ()
-
-    if (${CORE} STREQUAL "LOONGSON3A")
-      set(FCOMMON_OPT "${FCOMMON_OPT} -loongson3 -static")
-    endif ()
-
-    if (${CORE} STREQUAL "LOONGSON3B")
-    set(FCOMMON_OPT "${FCOMMON_OPT} -loongson3 -static")
-    endif ()
-  else ()
-    if (NOT BINARY64)
-      set(FCOMMON_OPT "${FCOMMON_OPT} -m32")
-    else ()
-      set(FCOMMON_OPT "${FCOMMON_OPT} -m64")
-    endif ()
-  endif ()
-
-  if (USE_OPENMP)
-    set(FEXTRALIB "${FEXTRALIB} -lstdc++")
-    set(FCOMMON_OPT "${FCOMMON_OPT} -mp")
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "SUN")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_SUN")
-  if (X86)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -m32")
-  else ()
-    set(FCOMMON_OPT "${FCOMMON_OPT} -m64")
-  endif ()
-  if (USE_OPENMP)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -xopenmp=parallel")
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "COMPAQ")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_COMPAQ")
-  if (USE_OPENMP)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -openmp")
-  endif ()
-endif ()
-
-# from the root Makefile - this is for lapack-netlib to compile the correct secnd file.
-if (${F_COMPILER} STREQUAL "GFORTRAN")
-  set(TIMER "INT_ETIME")
-else ()
-  set(TIMER "NONE")
-endif ()
-

cmake/kernel.cmake

@@ -1,171 +0,0 @@
-# helper functions for the kernel CMakeLists.txt
-
-
-# Set the default filenames for L1 objects. Most of these will be overridden by the appropriate KERNEL file.
-macro(SetDefaultL1)
-  set(SAMAXKERNEL amax.S)
-  set(DAMAXKERNEL amax.S)
-  set(QAMAXKERNEL amax.S)
-  set(CAMAXKERNEL zamax.S)
-  set(ZAMAXKERNEL zamax.S)
-  set(XAMAXKERNEL zamax.S)
-  set(SAMINKERNEL amin.S)
-  set(DAMINKERNEL amin.S)
-  set(QAMINKERNEL amin.S)
-  set(CAMINKERNEL zamin.S)
-  set(ZAMINKERNEL zamin.S)
-  set(XAMINKERNEL zamin.S)
-  set(SMAXKERNEL max.S)
-  set(DMAXKERNEL max.S)
-  set(QMAXKERNEL max.S)
-  set(SMINKERNEL min.S)
-  set(DMINKERNEL min.S)
-  set(QMINKERNEL min.S)
-  set(ISAMAXKERNEL iamax.S)
-  set(IDAMAXKERNEL iamax.S)
-  set(IQAMAXKERNEL iamax.S)
-  set(ICAMAXKERNEL izamax.S)
-  set(IZAMAXKERNEL izamax.S)
-  set(IXAMAXKERNEL izamax.S)
-  set(ISAMINKERNEL iamin.S)
-  set(IDAMINKERNEL iamin.S)
-  set(IQAMINKERNEL iamin.S)
-  set(ICAMINKERNEL izamin.S)
-  set(IZAMINKERNEL izamin.S)
-  set(IXAMINKERNEL izamin.S)
-  set(ISMAXKERNEL iamax.S)
-  set(IDMAXKERNEL iamax.S)
-  set(IQMAXKERNEL iamax.S)
-  set(ISMINKERNEL iamin.S)
-  set(IDMINKERNEL iamin.S)
-  set(IQMINKERNEL iamin.S)
-  set(SASUMKERNEL asum.S)
-  set(DASUMKERNEL asum.S)
-  set(CASUMKERNEL zasum.S)
-  set(ZASUMKERNEL zasum.S)
-  set(QASUMKERNEL asum.S)
-  set(XASUMKERNEL zasum.S)
-  set(SAXPYKERNEL axpy.S)
-  set(DAXPYKERNEL axpy.S)
-  set(CAXPYKERNEL zaxpy.S)
-  set(ZAXPYKERNEL zaxpy.S)
-  set(QAXPYKERNEL axpy.S)
-  set(XAXPYKERNEL zaxpy.S)
-  set(SCOPYKERNEL copy.S)
-  set(DCOPYKERNEL copy.S)
-  set(CCOPYKERNEL zcopy.S)
-  set(ZCOPYKERNEL zcopy.S)
-  set(QCOPYKERNEL copy.S)
-  set(XCOPYKERNEL zcopy.S)
-  set(SDOTKERNEL dot.S)
-  set(DDOTKERNEL dot.S)
-  set(CDOTKERNEL zdot.S)
-  set(ZDOTKERNEL zdot.S)
-  set(QDOTKERNEL dot.S)
-  set(XDOTKERNEL zdot.S)
-  set(SNRM2KERNEL nrm2.S)
-  set(DNRM2KERNEL nrm2.S)
-  set(QNRM2KERNEL nrm2.S)
-  set(CNRM2KERNEL znrm2.S)
-  set(ZNRM2KERNEL znrm2.S)
-  set(XNRM2KERNEL znrm2.S)
-  set(SROTKERNEL rot.S)
-  set(DROTKERNEL rot.S)
-  set(QROTKERNEL rot.S)
-  set(CROTKERNEL zrot.S)
-  set(ZROTKERNEL zrot.S)
-  set(XROTKERNEL zrot.S)
-  set(SSCALKERNEL scal.S)
-  set(DSCALKERNEL scal.S)
-  set(CSCALKERNEL zscal.S)
-  set(ZSCALKERNEL zscal.S)
-  set(QSCALKERNEL scal.S)
-  set(XSCALKERNEL zscal.S)
-  set(SSWAPKERNEL swap.S)
-  set(DSWAPKERNEL swap.S)
-  set(CSWAPKERNEL zswap.S)
-  set(ZSWAPKERNEL zswap.S)
-  set(QSWAPKERNEL swap.S)
-  set(XSWAPKERNEL zswap.S)
-  set(SGEMVNKERNEL gemv_n.S)
-  set(SGEMVTKERNEL gemv_t.S)
-  set(DGEMVNKERNEL gemv_n.S)
-  set(DGEMVTKERNEL gemv_t.S)
-  set(CGEMVNKERNEL zgemv_n.S)
-  set(CGEMVTKERNEL zgemv_t.S)
-  set(ZGEMVNKERNEL zgemv_n.S)
-  set(ZGEMVTKERNEL zgemv_t.S)
-  set(QGEMVNKERNEL gemv_n.S)
-  set(QGEMVTKERNEL gemv_t.S)
-  set(XGEMVNKERNEL zgemv_n.S)
-  set(XGEMVTKERNEL zgemv_t.S)
-  set(SCABS_KERNEL ../generic/cabs.c)
-  set(DCABS_KERNEL ../generic/cabs.c)
-  set(QCABS_KERNEL ../generic/cabs.c)
-  set(LSAME_KERNEL ../generic/lsame.c)
-  set(SAXPBYKERNEL ../arm/axpby.c)
-  set(DAXPBYKERNEL ../arm/axpby.c)
-  set(CAXPBYKERNEL ../arm/zaxpby.c)
-  set(ZAXPBYKERNEL ../arm/zaxpby.c)
-  set(SSUMKERNEL sum.S)
-  set(DSUMKERNEL sum.S)
-  set(CSUMKERNEL zsum.S)
-  set(ZSUMKERNEL zsum.S)
-  set(QSUMKERNEL sum.S)
-  set(XSUMKERNEL zsum.S)
-endmacro ()
-
-macro(SetDefaultL2)
-  set(SGEMVNKERNEL gemv_n.S)
-  set(SGEMVTKERNEL gemv_t.S)
-  set(DGEMVNKERNEL gemv_n.S)
-  set(DGEMVTKERNEL gemv_t.S)
-  set(CGEMVNKERNEL zgemv_n.S)
-  set(CGEMVTKERNEL zgemv_t.S)
-  set(ZGEMVNKERNEL zgemv_n.S)
-  set(ZGEMVTKERNEL zgemv_t.S)
-  set(QGEMVNKERNEL gemv_n.S)
-  set(QGEMVTKERNEL gemv_t.S)
-  set(XGEMVNKERNEL zgemv_n.S)
-  set(XGEMVTKERNEL zgemv_t.S)
-  set(SGERKERNEL ../generic/ger.c)
-  set(DGERKERNEL ../generic/ger.c)
-  set(QGERKERNEL ../generic/ger.c)
-  set(CGERUKERNEL ../generic/zger.c)
-  set(CGERCKERNEL ../generic/zger.c)
-  set(ZGERUKERNEL ../generic/zger.c)
-  set(ZGERCKERNEL ../generic/zger.c)
-  set(XGERUKERNEL ../generic/zger.c)
-  set(XGERCKERNEL ../generic/zger.c)
-  set(SSYMV_U_KERNEL ../generic/symv_k.c)
-  set(SSYMV_L_KERNEL ../generic/symv_k.c)
-  set(DSYMV_U_KERNEL ../generic/symv_k.c)
-  set(DSYMV_L_KERNEL ../generic/symv_k.c)
-  set(QSYMV_U_KERNEL ../generic/symv_k.c)
-  set(QSYMV_L_KERNEL ../generic/symv_k.c)
-  set(CSYMV_U_KERNEL ../generic/zsymv_k.c)
-  set(CSYMV_L_KERNEL ../generic/zsymv_k.c)
-  set(ZSYMV_U_KERNEL ../generic/zsymv_k.c)
-  set(ZSYMV_L_KERNEL ../generic/zsymv_k.c)
-  set(XSYMV_U_KERNEL ../generic/zsymv_k.c)
-  set(XSYMV_L_KERNEL ../generic/zsymv_k.c)
-  set(CHEMV_U_KERNEL ../generic/zhemv_k.c)
-  set(CHEMV_L_KERNEL ../generic/zhemv_k.c)
-  set(CHEMV_V_KERNEL ../generic/zhemv_k.c)
-  set(CHEMV_M_KERNEL ../generic/zhemv_k.c)
-  set(ZHEMV_U_KERNEL ../generic/zhemv_k.c)
-  set(ZHEMV_L_KERNEL ../generic/zhemv_k.c)
-  set(ZHEMV_V_KERNEL ../generic/zhemv_k.c)
-  set(ZHEMV_M_KERNEL ../generic/zhemv_k.c)
-  set(XHEMV_U_KERNEL ../generic/zhemv_k.c)
-  set(XHEMV_L_KERNEL ../generic/zhemv_k.c)
-  set(XHEMV_V_KERNEL ../generic/zhemv_k.c)
-  set(XHEMV_M_KERNEL ../generic/zhemv_k.c)
-endmacro ()
-
-macro(SetDefaultL3)
-  set(SGEADD_KERNEL ../generic/geadd.c)
-  set(DGEADD_KERNEL ../generic/geadd.c)
-  set(CGEADD_KERNEL ../generic/zgeadd.c)
-  set(ZGEADD_KERNEL ../generic/zgeadd.c)
-endmacro ()

cmake/lapack.cmake

@@ -1,493 +0,0 @@
-# Sources for compiling lapack-netlib. Can't use CMakeLists.txt because lapack-netlib already has its own cmake files.
-
-set(ALLAUX ilaenv.f ilaenv2stage.f ieeeck.f lsamen.f iparmq.f iparam2stage.F
-   ilaprec.f ilatrans.f ilauplo.f iladiag.f chla_transtype.f
-   ../INSTALL/ilaver.f xerbla_array.f
-   ../INSTALL/slamch.f)
-
-set(SCLAUX
-   sbdsdc.f
-   sbdsqr.f sdisna.f slabad.f slacpy.f sladiv.f slae2.f  slaebz.f
-   slaed0.f slaed1.f slaed2.f slaed3.f slaed4.f slaed5.f slaed6.f
-   slaed7.f slaed8.f slaed9.f slaeda.f slaev2.f slagtf.f
-   slagts.f slamrg.f slanst.f
-   slapy2.f slapy3.f slarnv.f
-   slarra.f slarrb.f slarrc.f slarrd.f slarre.f slarrf.f slarrj.f
-   slarrk.f slarrr.f slaneg.f
-   slartg.f slaruv.f slas2.f  slascl.f
-   slasd0.f slasd1.f slasd2.f slasd3.f slasd4.f slasd5.f slasd6.f
-   slasd7.f slasd8.f slasda.f slasdq.f slasdt.f
-   slaset.f slasq1.f slasq2.f slasq3.f slasq4.f slasq5.f slasq6.f
-   slasr.f  slasrt.f slassq.f slasv2.f spttrf.f sstebz.f sstedc.f
-   ssteqr.f ssterf.f slaisnan.f sisnan.f
-   slartgp.f slartgs.f
-   ../INSTALL/second_${TIMER}.f)
-
-set(DZLAUX
-   dbdsdc.f
-   dbdsqr.f ddisna.f dlabad.f dlacpy.f dladiv.f dlae2.f  dlaebz.f
-   dlaed0.f dlaed1.f dlaed2.f dlaed3.f dlaed4.f dlaed5.f dlaed6.f
-   dlaed7.f dlaed8.f dlaed9.f dlaeda.f dlaev2.f dlagtf.f
-   dlagts.f dlamrg.f dlanst.f
-   dlapy2.f dlapy3.f dlarnv.f
-   dlarra.f dlarrb.f dlarrc.f dlarrd.f dlarre.f dlarrf.f dlarrj.f
-   dlarrk.f dlarrr.f dlaneg.f
-   dlartg.f dlaruv.f dlas2.f  dlascl.f
-   dlasd0.f dlasd1.f dlasd2.f dlasd3.f dlasd4.f dlasd5.f dlasd6.f
-   dlasd7.f dlasd8.f dlasda.f dlasdq.f dlasdt.f
-   dlaset.f dlasq1.f dlasq2.f dlasq3.f dlasq4.f dlasq5.f dlasq6.f
-   dlasr.f  dlasrt.f dlassq.f dlasv2.f dpttrf.f dstebz.f dstedc.f
-   dsteqr.f dsterf.f dlaisnan.f disnan.f
-   dlartgp.f dlartgs.f
-   ../INSTALL/dlamch.f ../INSTALL/dsecnd_${TIMER}.f)
-
-set(SLASRC
-   sbdsvdx.f sgbbrd.f sgbcon.f sgbequ.f sgbrfs.f sgbsv.f
-   sgbsvx.f sgbtf2.f sgbtrf.f sgbtrs.f sgebak.f sgebal.f sgebd2.f
-   sgebrd.f sgecon.f sgeequ.f sgees.f  sgeesx.f sgeev.f  sgeevx.f
-   sgehd2.f sgehrd.f sgelq2.f sgelqf.f
-   sgels.f  sgelsd.f sgelss.f sgelsy.f sgeql2.f sgeqlf.f
-   sgeqp3.f sgeqr2.f sgeqr2p.f sgeqrf.f sgeqrfp.f sgerfs.f sgerq2.f sgerqf.f
-   sgesc2.f sgesdd.f sgesvd.f sgesvdx.f sgesvx.f sgetc2.f
-   sgetrf2.f sgetri.f
-   sggbak.f sggbal.f
-   sgges.f  sgges3.f sggesx.f sggev.f  sggev3.f sggevx.f
-   sggglm.f sgghrd.f sgghd3.f sgglse.f sggqrf.f
-   sggrqf.f sggsvd3.f sggsvp3.f sgtcon.f sgtrfs.f sgtsv.f
-   sgtsvx.f sgttrf.f sgttrs.f sgtts2.f shgeqz.f
-   shsein.f shseqr.f slabrd.f slacon.f slacn2.f
-   slaein.f slaexc.f slag2.f  slags2.f slagtm.f slagv2.f slahqr.f
-   slahr2.f slaic1.f slaln2.f slals0.f slalsa.f slalsd.f
-   slangb.f slange.f slangt.f slanhs.f slansb.f slansp.f
-   slansy.f slantb.f slantp.f slantr.f slanv2.f
-   slapll.f slapmt.f
-   slaqgb.f slaqge.f slaqp2.f slaqps.f slaqsb.f slaqsp.f slaqsy.f
-   slaqr0.f slaqr1.f slaqr2.f slaqr3.f slaqr4.f slaqr5.f
-   slaqtr.f slar1v.f slar2v.f ilaslr.f ilaslc.f
-   slarf.f  slarfb.f slarfg.f slarfgp.f slarft.f slarfx.f slarfy.f slargv.f
-   slarrv.f slartv.f
-   slarz.f  slarzb.f slarzt.f slasy2.f
-   slasyf.f slasyf_rook.f slasyf_rk.f slasyf_aa.f
-   slatbs.f slatdf.f slatps.f slatrd.f slatrs.f slatrz.f
-   sopgtr.f sopmtr.f sorg2l.f sorg2r.f
-   sorgbr.f sorghr.f sorgl2.f sorglq.f sorgql.f sorgqr.f sorgr2.f
-   sorgrq.f sorgtr.f sorm2l.f sorm2r.f sorm22.f
-   sormbr.f sormhr.f sorml2.f sormlq.f sormql.f sormqr.f sormr2.f
-   sormr3.f sormrq.f sormrz.f sormtr.f spbcon.f spbequ.f spbrfs.f
-   spbstf.f spbsv.f  spbsvx.f
-   spbtf2.f spbtrf.f spbtrs.f spocon.f spoequ.f sporfs.f sposv.f
-   sposvx.f spotrf2.f spotri.f spstrf.f spstf2.f
-   sppcon.f sppequ.f
-   spprfs.f sppsv.f  sppsvx.f spptrf.f spptri.f spptrs.f sptcon.f
-   spteqr.f sptrfs.f sptsv.f  sptsvx.f spttrs.f sptts2.f srscl.f
-   ssbev.f  ssbevd.f ssbevx.f ssbgst.f ssbgv.f  ssbgvd.f ssbgvx.f
-   ssbtrd.f sspcon.f sspev.f  sspevd.f sspevx.f sspgst.f
-   sspgv.f  sspgvd.f sspgvx.f ssprfs.f sspsv.f  sspsvx.f ssptrd.f
-   ssptrf.f ssptri.f ssptrs.f sstegr.f sstein.f sstev.f  sstevd.f sstevr.f
-   sstevx.f ssycon.f ssyev.f  ssyevd.f ssyevr.f ssyevx.f ssygs2.f
-   ssygst.f ssygv.f  ssygvd.f ssygvx.f ssyrfs.f ssysv.f  ssysvx.f
-   ssytd2.f ssytf2.f ssytrd.f ssytrf.f ssytri.f ssytri2.f ssytri2x.f
-   ssyswapr.f ssytrs.f ssytrs2.f
-   ssyconv.f ssyconvf.f ssyconvf_rook.f
-   ssysv_aa.f ssysv_aa_2stage.f ssytrf_aa.f ssytrf_aa_2stage.f ssytrs_aa.f ssytrs_aa_2stage.f
-   ssytf2_rook.f ssytrf_rook.f ssytrs_rook.f
-   ssytri_rook.f ssycon_rook.f ssysv_rook.f
-   ssytf2_rk.f ssytrf_rk.f ssytrs_3.f
-   ssytri_3.f ssytri_3x.f ssycon_3.f ssysv_rk.f
-   ssysv_aa.f ssytrf_aa.f ssytrs_aa.f
-   stbcon.f
-   stbrfs.f stbtrs.f stgevc.f stgex2.f stgexc.f stgsen.f
-   stgsja.f stgsna.f stgsy2.f stgsyl.f stpcon.f stprfs.f stptri.f
-   stptrs.f
-   strcon.f strevc.f strevc3.f strexc.f strrfs.f strsen.f strsna.f strsyl.f
-   strtrs.f stzrzf.f sstemr.f
-   slansf.f spftrf.f spftri.f spftrs.f ssfrk.f stfsm.f stftri.f stfttp.f
-   stfttr.f stpttf.f stpttr.f strttf.f strttp.f
-   sgejsv.f sgesvj.f sgsvj0.f sgsvj1.f
-   sgeequb.f ssyequb.f spoequb.f sgbequb.f
-   sbbcsd.f slapmr.f sorbdb.f sorbdb1.f sorbdb2.f sorbdb3.f sorbdb4.f
-   sorbdb5.f sorbdb6.f sorcsd.f sorcsd2by1.f
-   sgeqrt.f sgeqrt2.f sgeqrt3.f sgemqrt.f
-   stpqrt.f stpqrt2.f stpmqrt.f stprfb.f
-   sgelqt.f sgelqt3.f sgemlqt.f
-   sgetsls.f sgeqr.f slatsqr.f slamtsqr.f sgemqr.f
-   sgelq.f slaswlq.f slamswlq.f sgemlq.f
-   stplqt.f stplqt2.f stpmlqt.f
-   ssytrd_2stage.f ssytrd_sy2sb.f ssytrd_sb2st.F ssb2st_kernels.f
-   ssyevd_2stage.f ssyev_2stage.f ssyevx_2stage.f ssyevr_2stage.f
-   ssbev_2stage.f ssbevx_2stage.f ssbevd_2stage.f ssygv_2stage.f
-   scombssq.f sgesvdq.f slaorhr_col_getrfnp.f
-   slaorhr_col_getrfnp2.f sorgtsqr.f sorhr_col.f )
-
-set(SXLASRC sgesvxx.f sgerfsx.f sla_gerfsx_extended.f sla_geamv.f
-   sla_gercond.f sla_gerpvgrw.f ssysvxx.f ssyrfsx.f
-   sla_syrfsx_extended.f sla_syamv.f sla_syrcond.f sla_syrpvgrw.f
-   sposvxx.f sporfsx.f sla_porfsx_extended.f sla_porcond.f
-   sla_porpvgrw.f sgbsvxx.f sgbrfsx.f sla_gbrfsx_extended.f
-   sla_gbamv.f sla_gbrcond.f sla_gbrpvgrw.f sla_lin_berr.f slarscl2.f
-   slascl2.f sla_wwaddw.f)
-
-set(CLASRC
-   cbdsqr.f cgbbrd.f cgbcon.f cgbequ.f cgbrfs.f cgbsv.f  cgbsvx.f
-   cgbtf2.f cgbtrf.f cgbtrs.f cgebak.f cgebal.f cgebd2.f cgebrd.f
-   cgecon.f cgeequ.f cgees.f  cgeesx.f cgeev.f  cgeevx.f
-   cgehd2.f cgehrd.f cgelq2.f cgelqf.f
-   cgels.f  cgelsd.f cgelss.f cgelsy.f cgeql2.f cgeqlf.f cgeqp3.f
-   cgeqr2.f cgeqr2p.f cgeqrf.f cgeqrfp.f cgerfs.f cgerq2.f cgerqf.f
-   cgesc2.f cgesdd.f cgesvd.f cgesvdx.f
-   cgesvj.f cgejsv.f cgsvj0.f cgsvj1.f
-   cgesvx.f cgetc2.f cgetrf2.f
-   cgetri.f
-   cggbak.f cggbal.f
-   cgges.f  cgges3.f cggesx.f cggev.f  cggev3.f cggevx.f
-   cggglm.f cgghrd.f cgghd3.f cgglse.f cggqrf.f cggrqf.f
-   cggsvd3.f cggsvp3.f
-   cgtcon.f cgtrfs.f cgtsv.f  cgtsvx.f cgttrf.f cgttrs.f cgtts2.f chbev.f
-   chbevd.f chbevx.f chbgst.f chbgv.f  chbgvd.f chbgvx.f chbtrd.f
-   checon.f cheev.f  cheevd.f cheevr.f cheevx.f chegs2.f chegst.f
-   chegv.f  chegvd.f chegvx.f cherfs.f chesv.f  chesvx.f chetd2.f
-   chetf2.f chetrd.f
-   chetrf.f chetri.f chetri2.f chetri2x.f cheswapr.f
-   chetrs.f chetrs2.f
-   chetf2_rook.f chetrf_rook.f chetri_rook.f
-   chetrs_rook.f checon_rook.f chesv_rook.f
-   chetf2_rk.f chetrf_rk.f chetri_3.f chetri_3x.f
-   chetrs_3.f checon_3.f chesv_rk.f
-   chesv_aa.f chesv_aa_2stage.f chetrf_aa.f chetrf_aa_2stage.f chetrs_aa.f chetrs_aa_2stage.f
-   chgeqz.f chpcon.f chpev.f  chpevd.f
-   chpevx.f chpgst.f chpgv.f  chpgvd.f chpgvx.f chprfs.f chpsv.f
-   chpsvx.f
-   chptrd.f chptrf.f chptri.f chptrs.f chsein.f chseqr.f clabrd.f
-   clacgv.f clacon.f clacn2.f clacp2.f clacpy.f clacrm.f clacrt.f cladiv.f
-   claed0.f claed7.f claed8.f
-   claein.f claesy.f claev2.f clags2.f clagtm.f
-   clahef.f clahef_rook.f clahef_rk.f clahef_aa.f clahqr.f
-   clahr2.f claic1.f clals0.f clalsa.f clalsd.f clangb.f clange.f clangt.f
-   clanhb.f clanhe.f
-   clanhp.f clanhs.f clanht.f clansb.f clansp.f clansy.f clantb.f
-   clantp.f clantr.f clapll.f clapmt.f clarcm.f claqgb.f claqge.f
-   claqhb.f claqhe.f claqhp.f claqp2.f claqps.f claqsb.f
-   claqr0.f claqr1.f claqr2.f claqr3.f claqr4.f claqr5.f
-   claqsp.f claqsy.f clar1v.f clar2v.f ilaclr.f ilaclc.f
-   clarf.f  clarfb.f clarfg.f clarfgp.f clarft.f
-   clarfx.f clarfy.f clargv.f clarnv.f clarrv.f clartg.f clartv.f
-   clarz.f  clarzb.f clarzt.f clascl.f claset.f clasr.f  classq.f
-   clasyf.f clasyf_rook.f clasyf_rk.f clasyf_aa.f
-   clatbs.f clatdf.f clatps.f clatrd.f clatrs.f clatrz.f
-   cpbcon.f cpbequ.f cpbrfs.f cpbstf.f cpbsv.f
-   cpbsvx.f cpbtf2.f cpbtrf.f cpbtrs.f cpocon.f cpoequ.f cporfs.f
-   cposv.f  cposvx.f cpotrf2.f cpotri.f cpstrf.f cpstf2.f
-   cppcon.f cppequ.f cpprfs.f cppsv.f  cppsvx.f cpptrf.f cpptri.f cpptrs.f
-   cptcon.f cpteqr.f cptrfs.f cptsv.f  cptsvx.f cpttrf.f cpttrs.f cptts2.f
-   crot.f   cspcon.f csprfs.f cspsv.f
-   cspsvx.f csptrf.f csptri.f csptrs.f csrscl.f cstedc.f
-   cstegr.f cstein.f csteqr.f csycon.f
-   csyrfs.f csysv.f  csysvx.f csytf2.f csytrf.f csytri.f
-   csytri2.f csytri2x.f csyswapr.f
-   csytrs.f csytrs2.f
-   csyconv.f csyconvf.f csyconvf_rook.f
-   csytf2_rook.f csytrf_rook.f csytrs_rook.f
-   csytri_rook.f csycon_rook.f csysv_rook.f
-   csytf2_rk.f csytrf_rk.f csytrf_aa.f csytrf_aa_2stage.f csytrs_3.f csytrs_aa.f csytrs_aa_2stage.f
-   csytri_3.f csytri_3x.f csycon_3.f csysv_rk.f csysv_aa.f csysv_aa_2stage.f
-   ctbcon.f ctbrfs.f ctbtrs.f ctgevc.f ctgex2.f
-   ctgexc.f ctgsen.f ctgsja.f ctgsna.f ctgsy2.f ctgsyl.f ctpcon.f
-   ctprfs.f ctptri.f
-   ctptrs.f ctrcon.f ctrevc.f ctrevc3.f ctrexc.f ctrrfs.f ctrsen.f ctrsna.f
-   ctrsyl.f ctrtrs.f ctzrzf.f cung2l.f cung2r.f
-   cungbr.f cunghr.f cungl2.f cunglq.f cungql.f cungqr.f cungr2.f
-   cungrq.f cungtr.f cunm2l.f cunm2r.f cunmbr.f cunmhr.f cunml2.f cunm22.f
-   cunmlq.f cunmql.f cunmqr.f cunmr2.f cunmr3.f cunmrq.f cunmrz.f
-   cunmtr.f cupgtr.f cupmtr.f icmax1.f scsum1.f cstemr.f
-   chfrk.f ctfttp.f clanhf.f cpftrf.f cpftri.f cpftrs.f ctfsm.f ctftri.f
-   ctfttr.f ctpttf.f ctpttr.f ctrttf.f ctrttp.f
-   cgeequb.f cgbequb.f csyequb.f cpoequb.f cheequb.f
-   cbbcsd.f clapmr.f cunbdb.f cunbdb1.f cunbdb2.f cunbdb3.f cunbdb4.f
-   cunbdb5.f cunbdb6.f cuncsd.f cuncsd2by1.f
-   cgeqrt.f cgeqrt2.f cgeqrt3.f cgemqrt.f
-   ctpqrt.f ctpqrt2.f ctpmqrt.f ctprfb.f
-   cgelqt.f cgelqt3.f cgemlqt.f
-   cgetsls.f cgeqr.f clatsqr.f clamtsqr.f cgemqr.f
-   cgelq.f claswlq.f clamswlq.f cgemlq.f
-   ctplqt.f ctplqt2.f ctpmlqt.f
-   chetrd_2stage.f chetrd_he2hb.f chetrd_hb2st.F chb2st_kernels.f
-   cheevd_2stage.f cheev_2stage.f cheevx_2stage.f cheevr_2stage.f
-   chbev_2stage.f chbevx_2stage.f chbevd_2stage.f chegv_2stage.f
-   cgesvdq.f claunhr_col_getrfnp.f claunhr_col_getrfnp2.f 
-   cungtsqr.f cunhr_col.f )
-
-set(CXLASRC cgesvxx.f cgerfsx.f cla_gerfsx_extended.f cla_geamv.f
-   cla_gercond_c.f cla_gercond_x.f cla_gerpvgrw.f
-   csysvxx.f csyrfsx.f cla_syrfsx_extended.f cla_syamv.f
-   cla_syrcond_c.f cla_syrcond_x.f cla_syrpvgrw.f
-   cposvxx.f cporfsx.f cla_porfsx_extended.f
-   cla_porcond_c.f cla_porcond_x.f cla_porpvgrw.f
-   cgbsvxx.f cgbrfsx.f cla_gbrfsx_extended.f cla_gbamv.f
-   cla_gbrcond_c.f cla_gbrcond_x.f cla_gbrpvgrw.f
-   chesvxx.f cherfsx.f cla_herfsx_extended.f cla_heamv.f
-   cla_hercond_c.f cla_hercond_x.f cla_herpvgrw.f
-   cla_lin_berr.f clarscl2.f clascl2.f cla_wwaddw.f)
-
-set(DLASRC
-   dbdsvdx.f dgbbrd.f dgbcon.f dgbequ.f dgbrfs.f dgbsv.f
-   dgbsvx.f dgbtf2.f dgbtrf.f dgbtrs.f dgebak.f dgebal.f dgebd2.f
-   dgebrd.f dgecon.f dgeequ.f dgees.f  dgeesx.f dgeev.f  dgeevx.f
-   dgehd2.f dgehrd.f dgelq2.f dgelqf.f
-   dgels.f  dgelsd.f dgelss.f dgelsy.f dgeql2.f dgeqlf.f
-   dgeqp3.f dgeqr2.f dgeqr2p.f dgeqrf.f dgeqrfp.f dgerfs.f dgerq2.f dgerqf.f
-   dgesc2.f dgesdd.f dgesvd.f dgesvdx.f dgesvx.f dgetc2.f
-   dgetrf2.f dgetri.f
-   dggbak.f dggbal.f
-   dgges.f  dgges3.f dggesx.f dggev.f  dggev3.f dggevx.f
-   dggglm.f dgghrd.f dgghd3.f dgglse.f dggqrf.f
-   dggrqf.f dggsvd3.f dggsvp3.f dgtcon.f dgtrfs.f dgtsv.f
-   dgtsvx.f dgttrf.f dgttrs.f dgtts2.f dhgeqz.f
-   dhsein.f dhseqr.f dlabrd.f dlacon.f dlacn2.f
-   dlaein.f dlaexc.f dlag2.f  dlags2.f dlagtm.f dlagv2.f dlahqr.f
-   dlahr2.f dlaic1.f dlaln2.f dlals0.f dlalsa.f dlalsd.f
-   dlangb.f dlange.f dlangt.f dlanhs.f dlansb.f dlansp.f
-   dlansy.f dlantb.f dlantp.f dlantr.f dlanv2.f
-   dlapll.f dlapmt.f
-   dlaqgb.f dlaqge.f dlaqp2.f dlaqps.f dlaqsb.f dlaqsp.f dlaqsy.f
-   dlaqr0.f dlaqr1.f dlaqr2.f dlaqr3.f dlaqr4.f dlaqr5.f
-   dlaqtr.f dlar1v.f dlar2v.f iladlr.f iladlc.f
-   dlarf.f  dlarfb.f dlarfg.f dlarfgp.f dlarft.f dlarfx.f dlarfy.f
-   dlargv.f dlarrv.f dlartv.f
-   dlarz.f  dlarzb.f dlarzt.f dlasy2.f
-   dlasyf.f dlasyf_rook.f dlasyf_rk.f dlasyf_aa.f
-   dlatbs.f dlatdf.f dlatps.f dlatrd.f dlatrs.f dlatrz.f
-   dopgtr.f dopmtr.f dorg2l.f dorg2r.f
-   dorgbr.f dorghr.f dorgl2.f dorglq.f dorgql.f dorgqr.f dorgr2.f
-   dorgrq.f dorgtr.f dorm2l.f dorm2r.f dorm22.f
-   dormbr.f dormhr.f dorml2.f dormlq.f dormql.f dormqr.f dormr2.f
-   dormr3.f dormrq.f dormrz.f dormtr.f dpbcon.f dpbequ.f dpbrfs.f
-   dpbstf.f dpbsv.f  dpbsvx.f
-   dpbtf2.f dpbtrf.f dpbtrs.f dpocon.f dpoequ.f dporfs.f dposv.f
-   dposvx.f dpotrf2.f dpotri.f dpotrs.f dpstrf.f dpstf2.f
-   dppcon.f dppequ.f
-   dpprfs.f dppsv.f  dppsvx.f dpptrf.f dpptri.f dpptrs.f dptcon.f
-   dpteqr.f dptrfs.f dptsv.f  dptsvx.f dpttrs.f dptts2.f drscl.f
-   dsbev.f  dsbevd.f dsbevx.f dsbgst.f dsbgv.f  dsbgvd.f dsbgvx.f
-   dsbtrd.f dspcon.f dspev.f  dspevd.f dspevx.f dspgst.f
-   dspgv.f  dspgvd.f dspgvx.f dsprfs.f dspsv.f  dspsvx.f dsptrd.f
-   dsptrf.f dsptri.f dsptrs.f dstegr.f dstein.f dstev.f  dstevd.f dstevr.f
-   dstevx.f dsycon.f dsyev.f  dsyevd.f dsyevr.f
-   dsyevx.f dsygs2.f dsygst.f dsygv.f  dsygvd.f dsygvx.f dsyrfs.f
-   dsysv.f  dsysvx.f
-   dsytd2.f dsytf2.f dsytrd.f dsytrf.f dsytri.f dsytrs.f dsytrs2.f
-   dsytri2.f dsytri2x.f dsyswapr.f
-   dsyconv.f dsyconvf.f dsyconvf_rook.f
-   dsytf2_rook.f dsytrf_rook.f dsytrs_rook.f
-   dsytri_rook.f dsycon_rook.f dsysv_rook.f
-   dsytf2_rk.f dsytrf_rk.f dsytrs_3.f
-   dsytri_3.f dsytri_3x.f dsycon_3.f dsysv_rk.f
-   dsysv_aa.f dsysv_aa_2stage.f dsytrf_aa.f dsytrf_aa_2stage.f dsytrs_aa.f dsytrs_aa_2stage.f
-   dtbcon.f
-   dtbrfs.f dtbtrs.f dtgevc.f dtgex2.f dtgexc.f dtgsen.f
-   dtgsja.f dtgsna.f dtgsy2.f dtgsyl.f dtpcon.f dtprfs.f dtptri.f
-   dtptrs.f
-   dtrcon.f dtrevc.f dtrevc3.f dtrexc.f dtrrfs.f dtrsen.f dtrsna.f dtrsyl.f
-   dtrtrs.f dtzrzf.f dstemr.f
-   dsgesv.f dsposv.f dlag2s.f slag2d.f dlat2s.f
-   dlansf.f dpftrf.f dpftri.f dpftrs.f dsfrk.f dtfsm.f dtftri.f dtfttp.f
-   dtfttr.f dtpttf.f dtpttr.f dtrttf.f dtrttp.f
-   dgejsv.f dgesvj.f dgsvj0.f dgsvj1.f
-   dgeequb.f dsyequb.f dpoequb.f dgbequb.f
-   dbbcsd.f dlapmr.f dorbdb.f dorbdb1.f dorbdb2.f dorbdb3.f dorbdb4.f
-   dorbdb5.f dorbdb6.f dorcsd.f dorcsd2by1.f
-   dgeqrt.f dgeqrt2.f dgeqrt3.f dgemqrt.f
-   dtpqrt.f dtpqrt2.f dtpmqrt.f dtprfb.f
-   dgelqt.f dgelqt3.f dgemlqt.f
-   dgetsls.f dgeqr.f dlatsqr.f dlamtsqr.f dgemqr.f
-   dgelq.f dlaswlq.f dlamswlq.f dgemlq.f
-   dtplqt.f dtplqt2.f dtpmlqt.f
-   dsytrd_2stage.f dsytrd_sy2sb.f dsytrd_sb2st.F dsb2st_kernels.f
-   dsyevd_2stage.f dsyev_2stage.f dsyevx_2stage.f dsyevr_2stage.f
-   dsbev_2stage.f dsbevx_2stage.f dsbevd_2stage.f dsygv_2stage.f
-   dcombssq.f dgesvdq.f dlaorhr_col_getrfnp.f
-   dlaorhr_col_getrfnp2.f dorgtsqr.f dorhr_col.f )
-
-set(DXLASRC dgesvxx.f dgerfsx.f dla_gerfsx_extended.f dla_geamv.f
-   dla_gercond.f dla_gerpvgrw.f dsysvxx.f dsyrfsx.f
-   dla_syrfsx_extended.f dla_syamv.f dla_syrcond.f dla_syrpvgrw.f
-   dposvxx.f dporfsx.f dla_porfsx_extended.f dla_porcond.f
-   dla_porpvgrw.f dgbsvxx.f dgbrfsx.f dla_gbrfsx_extended.f
-   dla_gbamv.f dla_gbrcond.f dla_gbrpvgrw.f dla_lin_berr.f dlarscl2.f
-   dlascl2.f dla_wwaddw.f)
-
-set(ZLASRC
-   zbdsqr.f zgbbrd.f zgbcon.f zgbequ.f zgbrfs.f zgbsv.f  zgbsvx.f
-   zgbtf2.f zgbtrf.f zgbtrs.f zgebak.f zgebal.f zgebd2.f zgebrd.f
-   zgecon.f zgeequ.f zgees.f  zgeesx.f zgeev.f  zgeevx.f
-   zgehd2.f zgehrd.f zgelq2.f zgelqf.f
-   zgels.f  zgelsd.f zgelss.f zgelsy.f zgeql2.f zgeqlf.f zgeqp3.f
-   zgeqr2.f zgeqr2p.f zgeqrf.f zgeqrfp.f zgerfs.f zgerq2.f zgerqf.f
-   zgesc2.f zgesdd.f zgesvd.f zgesvdx.f zgesvx.f
-   zgesvj.f zgejsv.f zgsvj0.f zgsvj1.f
-   zgetc2.f zgetrf2.f
-   zgetri.f
-   zggbak.f zggbal.f
-   zgges.f  zgges3.f zggesx.f zggev.f  zggev3.f zggevx.f
-   zggglm.f zgghrd.f zgghd3.f zgglse.f zggqrf.f zggrqf.f
-   zggsvd3.f zggsvp3.f
-   zgtcon.f zgtrfs.f zgtsv.f  zgtsvx.f zgttrf.f zgttrs.f zgtts2.f zhbev.f
-   zhbevd.f zhbevx.f zhbgst.f zhbgv.f  zhbgvd.f zhbgvx.f zhbtrd.f
-   zhecon.f zheev.f  zheevd.f zheevr.f zheevx.f zhegs2.f zhegst.f
-   zhegv.f  zhegvd.f zhegvx.f zherfs.f zhesv.f  zhesvx.f zhetd2.f
-   zhetf2.f zhetrd.f
-   zhetrf.f zhetri.f zhetri2.f zhetri2x.f zheswapr.f
-   zhetrs.f zhetrs2.f
-   zhetf2_rook.f zhetrf_rook.f zhetri_rook.f
-   zhetrs_rook.f zhecon_rook.f zhesv_rook.f
-   zhetf2_rk.f zhetrf_rk.f zhetri_3.f zhetri_3x.f
-   zhetrs_3.f zhecon_3.f zhesv_rk.f
-   zhesv_aa.f zhesv_aa_2stage.f zhetrf_aa.f zhetrf_aa_2stage.f zhetrs_aa.f zhetrs_aa_2stage.f
-   zhgeqz.f zhpcon.f zhpev.f  zhpevd.f
-   zhpevx.f zhpgst.f zhpgv.f  zhpgvd.f zhpgvx.f zhprfs.f zhpsv.f
-   zhpsvx.f
-   zhptrd.f zhptrf.f zhptri.f zhptrs.f zhsein.f zhseqr.f zlabrd.f
-   zlacgv.f zlacon.f zlacn2.f zlacp2.f zlacpy.f zlacrm.f zlacrt.f zladiv.f
-   zlaed0.f zlaed7.f zlaed8.f
-   zlaein.f zlaesy.f zlaev2.f zlags2.f zlagtm.f
-   zlahef.f zlahef_rook.f zlahef_rk.f zlahef_aa.f zlahqr.f
-   zlahr2.f zlaic1.f zlals0.f zlalsa.f zlalsd.f zlangb.f zlange.f
-   zlangt.f zlanhb.f
-   zlanhe.f
-   zlanhp.f zlanhs.f zlanht.f zlansb.f zlansp.f zlansy.f zlantb.f
-   zlantp.f zlantr.f zlapll.f zlapmt.f zlaqgb.f zlaqge.f
-   zlaqhb.f zlaqhe.f zlaqhp.f zlaqp2.f zlaqps.f zlaqsb.f
-   zlaqr0.f zlaqr1.f zlaqr2.f zlaqr3.f zlaqr4.f zlaqr5.f
-   zlaqsp.f zlaqsy.f zlar1v.f zlar2v.f ilazlr.f ilazlc.f
-   zlarcm.f zlarf.f  zlarfb.f
-   zlarfg.f zlarfgp.f zlarft.f
-   zlarfx.f zlarfy.f zlargv.f zlarnv.f zlarrv.f zlartg.f zlartv.f
-   zlarz.f  zlarzb.f zlarzt.f zlascl.f zlaset.f zlasr.f
-   zlassq.f zlasyf.f zlasyf_rook.f zlasyf_rk.f zlasyf_aa.f
-   zlatbs.f zlatdf.f zlatps.f zlatrd.f zlatrs.f zlatrz.f
-   zpbcon.f zpbequ.f zpbrfs.f zpbstf.f zpbsv.f
-   zpbsvx.f zpbtf2.f zpbtrf.f zpbtrs.f zpocon.f zpoequ.f zporfs.f
-   zposv.f  zposvx.f zpotrf2.f zpotri.f zpotrs.f zpstrf.f zpstf2.f
-   zppcon.f zppequ.f zpprfs.f zppsv.f  zppsvx.f zpptrf.f zpptri.f zpptrs.f
-   zptcon.f zpteqr.f zptrfs.f zptsv.f  zptsvx.f zpttrf.f zpttrs.f zptts2.f
-   zrot.f   zspcon.f zsprfs.f zspsv.f
-   zspsvx.f zsptrf.f zsptri.f zsptrs.f zdrscl.f zstedc.f
-   zstegr.f zstein.f zsteqr.f zsycon.f
-   zsyrfs.f zsysv.f  zsysvx.f zsytf2.f zsytrf.f zsytri.f
-   zsytri2.f zsytri2x.f zsyswapr.f
-   zsytrs.f zsytrs2.f
-   zsyconv.f zsyconvf.f zsyconvf_rook.f
-   zsytf2_rook.f zsytrf_rook.f zsytrs_rook.f zsytrs_aa.f zsytrs_aa_2stage.f
-   zsytri_rook.f zsycon_rook.f zsysv_rook.f
-   zsytf2_rk.f zsytrf_rk.f zsytrf_aa.f zsytrf_aa_2stage.f zsytrs_3.f
-   zsytri_3.f zsytri_3x.f zsycon_3.f zsysv_rk.f zsysv_aa.f zsysv_aa_2stage.f
-   ztbcon.f ztbrfs.f ztbtrs.f ztgevc.f ztgex2.f
-   ztgexc.f ztgsen.f ztgsja.f ztgsna.f ztgsy2.f ztgsyl.f ztpcon.f
-   ztprfs.f ztptri.f
-   ztptrs.f ztrcon.f ztrevc.f ztrevc3.f ztrexc.f ztrrfs.f ztrsen.f ztrsna.f
-   ztrsyl.f ztrtrs.f ztzrzf.f zung2l.f
-   zung2r.f zungbr.f zunghr.f zungl2.f zunglq.f zungql.f zungqr.f zungr2.f
-   zungrq.f zungtr.f zunm2l.f zunm2r.f zunmbr.f zunmhr.f zunml2.f zunm22.f
-   zunmlq.f zunmql.f zunmqr.f zunmr2.f zunmr3.f zunmrq.f zunmrz.f
-   zunmtr.f zupgtr.f
-   zupmtr.f izmax1.f dzsum1.f zstemr.f
-   zcgesv.f zcposv.f zlag2c.f clag2z.f zlat2c.f
-   zhfrk.f ztfttp.f zlanhf.f zpftrf.f zpftri.f zpftrs.f ztfsm.f ztftri.f
-   ztfttr.f ztpttf.f ztpttr.f ztrttf.f ztrttp.f
-   zgeequb.f zgbequb.f zsyequb.f zpoequb.f zheequb.f
-   zbbcsd.f zlapmr.f zunbdb.f zunbdb1.f zunbdb2.f zunbdb3.f zunbdb4.f
-   zunbdb5.f zunbdb6.f zuncsd.f zuncsd2by1.f
-   zgeqrt.f zgeqrt2.f zgeqrt3.f zgemqrt.f
-   ztpqrt.f ztpqrt2.f ztpmqrt.f ztprfb.f
-   ztplqt.f ztplqt2.f ztpmlqt.f
-   zgelqt.f zgelqt3.f zgemlqt.f
-   zgetsls.f zgeqr.f zlatsqr.f zlamtsqr.f zgemqr.f
-   zgelq.f zlaswlq.f zlamswlq.f zgemlq.f
-   zhetrd_2stage.f zhetrd_he2hb.f zhetrd_hb2st.F zhb2st_kernels.f
-   zheevd_2stage.f zheev_2stage.f zheevx_2stage.f zheevr_2stage.f
-   zhbev_2stage.f zhbevx_2stage.f zhbevd_2stage.f zhegv_2stage.f
-   zgesvdq.f zlaunhr_col_getrfnp.f zlaunhr_col_getrfnp2.f
-   zungtsqr.f zunhr_col.f)
-
-set(ZXLASRC zgesvxx.f zgerfsx.f zla_gerfsx_extended.f zla_geamv.f
-   zla_gercond_c.f zla_gercond_x.f zla_gerpvgrw.f zsysvxx.f zsyrfsx.f
-   zla_syrfsx_extended.f zla_syamv.f zla_syrcond_c.f zla_syrcond_x.f
-   zla_syrpvgrw.f zposvxx.f zporfsx.f zla_porfsx_extended.f
-   zla_porcond_c.f zla_porcond_x.f zla_porpvgrw.f zgbsvxx.f zgbrfsx.f
-   zla_gbrfsx_extended.f zla_gbamv.f zla_gbrcond_c.f zla_gbrcond_x.f
-   zla_gbrpvgrw.f zhesvxx.f zherfsx.f zla_herfsx_extended.f
-   zla_heamv.f zla_hercond_c.f zla_hercond_x.f zla_herpvgrw.f
-   zla_lin_berr.f zlarscl2.f zlascl2.f zla_wwaddw.f)
-
-
-if(USE_XBLAS)
-  set(ALLXOBJ ${SXLASRC} ${DXLASRC} ${CXLASRC} ${ZXLASRC})
-endif()
-
-list(APPEND SLASRC DEPRECATED/sgegs.f DEPRECATED/sgegv.f
-  DEPRECATED/sgeqpf.f DEPRECATED/sgelsx.f DEPRECATED/sggsvd.f
-  DEPRECATED/sggsvp.f DEPRECATED/slahrd.f DEPRECATED/slatzm.f DEPRECATED/stzrqf.f)
-list(APPEND DLASRC DEPRECATED/dgegs.f DEPRECATED/dgegv.f
-  DEPRECATED/dgeqpf.f DEPRECATED/dgelsx.f DEPRECATED/dggsvd.f
-  DEPRECATED/dggsvp.f DEPRECATED/dlahrd.f DEPRECATED/dlatzm.f DEPRECATED/dtzrqf.f)
-list(APPEND CLASRC DEPRECATED/cgegs.f DEPRECATED/cgegv.f
-  DEPRECATED/cgeqpf.f DEPRECATED/cgelsx.f DEPRECATED/cggsvd.f
-  DEPRECATED/cggsvp.f DEPRECATED/clahrd.f DEPRECATED/clatzm.f DEPRECATED/ctzrqf.f)
-list(APPEND ZLASRC DEPRECATED/zgegs.f DEPRECATED/zgegv.f
-  DEPRECATED/zgeqpf.f DEPRECATED/zgelsx.f DEPRECATED/zggsvd.f
-  DEPRECATED/zggsvp.f DEPRECATED/zlahrd.f DEPRECATED/zlatzm.f DEPRECATED/ztzrqf.f)
-message(STATUS "Building deprecated routines")
-
-set(DSLASRC spotrs.f)
-
-set(ZCLASRC cpotrs.f)
-
-set(SCATGEN slatm1.f slaran.f slarnd.f)
-
-set(SMATGEN slatms.f slatme.f slatmr.f slatmt.f
-   slagge.f slagsy.f slakf2.f slarge.f slaror.f slarot.f slatm2.f
-   slatm3.f slatm5.f slatm6.f slatm7.f slahilb.f)
-
-set(CMATGEN clatms.f clatme.f clatmr.f clatmt.f
-   clagge.f claghe.f clagsy.f clakf2.f clarge.f claror.f clarot.f
-   clatm1.f clarnd.f clatm2.f clatm3.f clatm5.f clatm6.f clahilb.f slatm7.f)
-
-set(DZATGEN dlatm1.f dlaran.f dlarnd.f)
-
-set(DMATGEN dlatms.f dlatme.f dlatmr.f dlatmt.f
-   dlagge.f dlagsy.f dlakf2.f dlarge.f dlaror.f dlarot.f dlatm2.f
-   dlatm3.f dlatm5.f dlatm6.f dlatm7.f dlahilb.f)
-
-set(ZMATGEN zlatms.f zlatme.f zlatmr.f zlatmt.f
-  zlagge.f zlaghe.f zlagsy.f zlakf2.f zlarge.f zlaror.f zlarot.f
-  zlatm1.f zlarnd.f zlatm2.f zlatm3.f zlatm5.f zlatm6.f zlahilb.f dlatm7.f)
-
-if(BUILD_SINGLE)
-  set(LA_REL_SRC ${SLASRC} ${DSLASRC} ${ALLAUX} ${SCLAUX})
-  set(LA_GEN_SRC ${SMATGEN} ${SCATGEN})
-  message(STATUS "Building Single Precision")
-endif()
-if(BUILD_DOUBLE)
-  set(LA_REL_SRC ${LA_REL_SRC} ${DLASRC} ${DSLASRC} ${ALLAUX} ${DZLAUX})
-  set(LA_GEN_SRC ${LA_GEN_SRC} ${DMATGEN} ${DZATGEN})
-  message(STATUS "Building Double Precision")
-endif()
-if(BUILD_COMPLEX)
-  set(LA_REL_SRC ${LA_REL_SRC} ${CLASRC} ${ZCLASRC} ${ALLAUX} ${SCLAUX})
-  SET(LA_GEN_SRC ${LA_GEN_SRC} ${CMATGEN} ${SCATGEN})
-  message(STATUS "Building Complex Precision")
-endif()
-if(BUILD_COMPLEX16)
-  set(LA_REL_SRC ${LA_REL_SRC} ${ZLASRC} ${ZCLASRC} ${ALLAUX} ${DZLAUX})
-  SET(LA_GEN_SRC ${LA_GEN_SRC} ${ZMATGEN} ${DZATGEN})
-  message(STATUS "Building Double Complex Precision")
-endif()
-
-# add lapack-netlib folder to the sources
-set(LA_SOURCES "")
-foreach (LA_FILE ${LA_REL_SRC})
-  list(APPEND LA_SOURCES "${NETLIB_LAPACK_DIR}/SRC/${LA_FILE}")
-endforeach ()
-foreach (LA_FILE ${LA_GEN_SRC})
-  list(APPEND LA_SOURCES "${NETLIB_LAPACK_DIR}/TESTING/MATGEN/${LA_FILE}")
-endforeach ()
-set_source_files_properties(${LA_SOURCES} PROPERTIES COMPILE_FLAGS "${LAPACK_FFLAGS}")

cmake/openblas.pc.in

@@ -1,11 +0,0 @@
-libdir=@CMAKE_INSTALL_FULL_LIBDIR@
-libsuffix=@SUFFIX64_UNDERSCORE@
-includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
-
-openblas_config=USE_64BITINT=@USE_64BITINT@ NO_CBLAS=@NO_CBLAS@ NO_LAPACK=@NO_LAPACK@ NO_LAPACKE=@NO_LAPACKE@ DYNAMIC_ARCH=@DYNAMIC_ARCH@ DYNAMIC_OLDER=@DYNAMIC_OLDER@ NO_AFFINITY=@NO_AFFINITY@ USE_OPENMP=@USE_OPENMP@ @CORE@ MAX_THREADS=@NUM_THREADS@ 
-Name: OpenBLAS
-Description: OpenBLAS is an optimized BLAS library based on GotoBLAS2 1.13 BSD version
-Version: @OPENBLAS_VERSION@
-URL: https://github.com/xianyi/OpenBLAS
-Libs: -L${libdir} -lopenblas${libsuffix}
-Cflags: -I${includedir}

cmake/os.cmake

@@ -1,96 +0,0 @@
-##
-## Author: Hank Anderson <hank@statease.com>
-## Description: Ported from portion of OpenBLAS/Makefile.system
-##              Detects the OS and sets appropriate variables.
-
-if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-  set(EXTRALIB "${EXTRALIB} -lm")
-  set(NO_EXPRECISION 1)
-endif ()
-
-if (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD|OpenBSD|NetBSD|DragonFly")
-  set(EXTRALIB "${EXTRALIB} -lm")
-  set(NO_EXPRECISION 1)
-endif ()
-
-if (${CMAKE_SYSTEM_NAME} STREQUAL "AIX")
-  set(EXTRALIB "${EXTRALIB} -lm")
-endif ()
-
-# TODO: this is probably meant for mingw, not other windows compilers
-if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-
-  set(NEED_PIC 0)
-  set(NO_EXPRECISION 1)
-
-  set(EXTRALIB "${EXTRALIB} -defaultlib:advapi32")
-
-  # probably not going to use these
-  set(SUFFIX "obj")
-  set(PSUFFIX "pobj")
-  set(LIBSUFFIX "a")
-
-  if (${CMAKE_C_COMPILER_ID} STREQUAL "Clang")
-    set(CCOMMON_OPT	"${CCOMMON_OPT} -DMS_ABI")
-  endif ()
-
-  if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
-
-    # Test for supporting MS_ABI
-    # removed string parsing in favor of CMake's version comparison -hpa
-    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-    if (${GCC_VERSION} VERSION_GREATER 4.7 OR ${GCC_VERSION} VERSION_EQUAL 4.7)
-      # GCC Version >=4.7
-      # It is compatible with MSVC ABI.
-      set(CCOMMON_OPT "${CCOMMON_OPT} -DMS_ABI")
-    endif ()
-  endif ()
-
-  # Ensure the correct stack alignment on Win32
-  # http://permalink.gmane.org/gmane.comp.lib.openblas.general/97
-  if (X86)
-    if (NOT MSVC AND NOT ${CMAKE_C_COMPILER_ID} STREQUAL "Clang")
-      set(CCOMMON_OPT "${CCOMMON_OPT} -mincoming-stack-boundary=2")
-    endif ()
-    set(FCOMMON_OPT "${FCOMMON_OPT} -mincoming-stack-boundary=2")
-  endif ()
-  
-endif ()
-
-if (${CMAKE_SYSTEM_NAME} STREQUAL "Interix")
-  set(NEED_PIC 0)
-  set(NO_EXPRECISION 1)
-  
-  set(INTERIX_TOOL_DIR STREQUAL "/opt/gcc.3.3/i586-pc-interix3/bin")
-endif ()
-
-if (CYGWIN)
-  set(NEED_PIC 0)
-  set(NO_EXPRECISION 1)
-endif ()
-
-if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Windows" AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Interix" AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Android")
-  if (USE_THREAD)
-    set(EXTRALIB "${EXTRALIB} -lpthread")
-  endif ()
-endif ()
-
-if (QUAD_PRECISION)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DQUAD_PRECISION")
-  set(NO_EXPRECISION 1)
-endif ()
-
-if (X86)
-  set(NO_EXPRECISION 1)
-endif ()
-
-if (UTEST_CHECK)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DUTEST_CHECK")
-  set(SANITY_CHECK 1)
-endif ()
-
-if (SANITY_CHECK)
-  # TODO: need some way to get $(*F) (target filename)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DSANITY_CHECK -DREFNAME=$(*F)f${BU}")
-endif ()
-

cmake/prebuild.cmake

@@ -1,490 +0,0 @@
-##
-## Author: Hank Anderson <hank@statease.com>
-## Description: Ported from OpenBLAS/Makefile.prebuild
-##              This is triggered by system.cmake and runs before any of the code is built.
-##              Creates config.h and Makefile.conf by first running the c_check perl script (which creates those files).
-##              Next it runs f_check and appends some fortran information to the files.
-##              Then it runs getarch and getarch_2nd for even more environment information.
-##              Finally it builds gen_config_h for use at build time to generate config.h.
-
-# CMake vars set by this file:
-# CORE
-# LIBCORE
-# NUM_CORES
-# HAVE_MMX
-# HAVE_SSE
-# HAVE_SSE2
-# HAVE_SSE3
-# MAKE
-# SGEMM_UNROLL_M
-# SGEMM_UNROLL_N
-# DGEMM_UNROLL_M
-# DGEMM_UNROLL_M
-# QGEMM_UNROLL_N
-# QGEMM_UNROLL_N
-# CGEMM_UNROLL_M
-# CGEMM_UNROLL_M
-# ZGEMM_UNROLL_N
-# ZGEMM_UNROLL_N
-# XGEMM_UNROLL_M
-# XGEMM_UNROLL_N
-# CGEMM3M_UNROLL_M
-# CGEMM3M_UNROLL_N
-# ZGEMM3M_UNROLL_M
-# ZGEMM3M_UNROLL_M
-# XGEMM3M_UNROLL_N
-# XGEMM3M_UNROLL_N
-
-# CPUIDEMU = ../../cpuid/table.o
-
-
-if (DEFINED CPUIDEMU)
-  set(EXFLAGS "-DCPUIDEMU -DVENDOR=99")
-endif ()
-
-if (BUILD_KERNEL)
-  # set the C flags for just this file
-  set(GETARCH2_FLAGS "-DBUILD_KERNEL")
-  set(TARGET_CONF "config_kernel.h")
-  set(TARGET_CONF_DIR ${PROJECT_BINARY_DIR}/kernel_config/${TARGET_CORE})
-else()
-  set(TARGET_CONF "config.h")
-  set(TARGET_CONF_DIR ${PROJECT_BINARY_DIR})
-endif ()
-
-set(TARGET_CONF_TEMP "${PROJECT_BINARY_DIR}/${TARGET_CONF}.tmp")
-
-# c_check
-set(FU "")
-if (APPLE OR (MSVC AND NOT ${CMAKE_C_COMPILER_ID} MATCHES "Clang"))
-  set(FU "_")
-endif()
-if(MINGW AND NOT MINGW64)
-  set(FU "_")
-endif()
-
-set(COMPILER_ID ${CMAKE_C_COMPILER_ID})
-if (${COMPILER_ID} STREQUAL "GNU")
-  set(COMPILER_ID "GCC")
-endif ()
-
-string(TOUPPER ${ARCH} UC_ARCH)
-
-file(WRITE ${TARGET_CONF_TEMP}
-  "#define OS_${HOST_OS}\t1\n"
-  "#define ARCH_${UC_ARCH}\t1\n"
-  "#define C_${COMPILER_ID}\t1\n"
-  "#define __${BINARY}BIT__\t1\n"
-  "#define FUNDERSCORE\t${FU}\n")
-
-if (${HOST_OS} STREQUAL "WINDOWSSTORE")
-  file(APPEND ${TARGET_CONF_TEMP}
-    "#define OS_WINNT\t1\n")
-endif ()
-
-# f_check
-if (NOT NOFORTRAN)
-  include("${PROJECT_SOURCE_DIR}/cmake/f_check.cmake")
-else ()
- file(APPEND ${TARGET_CONF_TEMP}
-   "#define BUNDERSCORE _\n"
-   "#define NEEDBUNDERSCORE 1\n")
- set(BU "_")
-endif ()
-
-# Cannot run getarch on target if we are cross-compiling
-if (DEFINED CORE AND CMAKE_CROSSCOMPILING AND NOT (${HOST_OS} STREQUAL "WINDOWSSTORE"))
-  # Write to config as getarch would
-  if (DEFINED TARGET_CORE)
-  set(TCORE ${TARGET_CORE})
-  else()
-  set(TCORE ${CORE})
-  endif()
-
-  # TODO: Set up defines that getarch sets up based on every other target
-  # Perhaps this should be inside a different file as it grows larger
-  file(APPEND ${TARGET_CONF_TEMP}
-    "#define ${TCORE}\n"
-    "#define CORE_${TCORE}\n"
-    "#define CHAR_CORENAME \"${TCORE}\"\n")
-  if ("${TCORE}" STREQUAL "CORE2")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_DATA_SIZE\t32768\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L2_SIZE\t1048576\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define DTB_DEFAULT_ENTRIES\t256\n"
-      "#define DTB_SIZE\t4096\n"
-      "#define HAVE_CMOV\n"
-      "#define HAVE_MMX\n"
-      "#define HAVE_SSE\n"
-      "#define HAVE_SSE2\n"
-      "#define HAVE_SSE3\n"
-      "#define HAVE_SSSE3\n"
-      "#define SLOCAL_BUFFER_SIZE\t16384\n"
-      "#define DLOCAL_BUFFER_SIZE\t16384\n"
-      "#define CLOCAL_BUFFER_SIZE\t16384\n"
-      "#define ZLOCAL_BUFFER_SIZE\t16384\n")
-      set(SGEMM_UNROLL_M 8)
-      set(SGEMM_UNROLL_N 4)
-      set(DGEMM_UNROLL_M 4)
-      set(DGEMM_UNROLL_N 4)
-      set(CGEMM_UNROLL_M 4)
-      set(CGEMM_UNROLL_N 2)
-      set(ZGEMM_UNROLL_M 2)
-      set(ZGEMM_UNROLL_N 2)
-      set(CGEMM3M_UNROLL_M 8)
-      set(CGEMM3M_UNROLL_N 4)
-      set(ZGEMM3M_UNROLL_M 4)
-      set(ZGEMM3M_UNROLL_N 4)
-  elseif ("${TCORE}" STREQUAL "ARMV7")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_DATA_SIZE\t65536\n"
-      "#define L1_DATA_LINESIZE\t32\n"
-      "#define L2_SIZE\t512488\n"
-      "#define L2_LINESIZE\t32\n"
-      "#define DTB_DEFAULT_ENTRIES\t64\n"
-      "#define DTB_SIZE\t4096\n"
-      "#define L2_ASSOCIATIVE\t4\n"
-      "#define HAVE_VFPV3\n"
-      "#define HAVE_VFP\n")
-    set(SGEMM_UNROLL_M 4)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 4)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 2)
-    set(CGEMM_UNROLL_N 2)
-    set(ZGEMM_UNROLL_M 2)
-    set(ZGEMM_UNROLL_N 2)
-  elseif ("${TCORE}" STREQUAL "ARMV8")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_DATA_SIZE\t32768\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L2_SIZE\t262144\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define DTB_DEFAULT_ENTRIES\t64\n"
-      "#define DTB_SIZE\t4096\n"
-      "#define L2_ASSOCIATIVE\t32\n"
-      "#define ARMV8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "CORTEXA57" OR "${TCORE}" STREQUAL "CORTEXA53")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_CODE_SIZE\t32768\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t3\n"
-      "#define L1_DATA_SIZE\t32768\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L1_DATA_ASSOCIATIVE\t2\n"
-      "#define L2_SIZE\t262144\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define L2_ASSOCIATIVE\t16\n"
-      "#define DTB_DEFAULT_ENTRIES\t64\n"
-      "#define DTB_SIZE\t4096\n"
-      "#define HAVE_VFPV4\n"
-      "#define HAVE_VFPV3\n"
-      "#define HAVE_VFP\n"
-      "#define HAVE_NEON\n"
-      "#define ARMV8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "CORTEXA72" OR "${TCORE}" STREQUAL "CORTEXA73")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_CODE_SIZE\t49152\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t3\n"
-      "#define L1_DATA_SIZE\t32768\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L1_DATA_ASSOCIATIVE\t2\n"
-      "#define L2_SIZE\t524288\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define L2_ASSOCIATIVE\t16\n"
-      "#define DTB_DEFAULT_ENTRIES\t64\n"
-      "#define DTB_SIZE\t4096\n"
-      "#define HAVE_VFPV4\n"
-      "#define HAVE_VFPV3\n"
-      "#define HAVE_VFP\n"
-      "#define HAVE_NEON\n"
-      "#define ARMV8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "FALKOR")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_CODE_SIZE\t65536\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t3\n"
-      "#define L1_DATA_SIZE\t32768\n"
-      "#define L1_DATA_LINESIZE\t128\n"
-      "#define L1_DATA_ASSOCIATIVE\t2\n"
-      "#define L2_SIZE\t524288\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define L2_ASSOCIATIVE\t16\n"
-      "#define DTB_DEFAULT_ENTRIES\t64\n"
-      "#define DTB_SIZE\t4096\n"
-      "#define HAVE_VFPV4\n"
-      "#define HAVE_VFPV3\n"
-      "#define HAVE_VFP\n"
-      "#define HAVE_NEON\n"
-      "#define ARMV8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "THUNDERX")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_CODE_SIZE\t32768\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t3\n"
-      "#define L1_DATA_SIZE\t32768\n"
-      "#define L1_DATA_LINESIZE\t128\n"
-      "#define L1_DATA_ASSOCIATIVE\t2\n"
-      "#define L2_SIZE\t167772164\n"
-      "#define L2_LINESIZE\t128\n"
-      "#define L2_ASSOCIATIVE\t16\n"
-      "#define DTB_DEFAULT_ENTRIES\t64\n"
-      "#define DTB_SIZE\t4096\n"
-      "#define HAVE_VFPV4\n"
-      "#define HAVE_VFPV3\n"
-      "#define HAVE_VFP\n"
-      "#define HAVE_NEON\n"
-      "#define ARMV8\n")
-    set(SGEMM_UNROLL_M 4)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 2)
-    set(DGEMM_UNROLL_N 2)
-    set(CGEMM_UNROLL_M 2)
-    set(CGEMM_UNROLL_N 2)
-    set(ZGEMM_UNROLL_M 2)
-    set(ZGEMM_UNROLL_N 2)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "THUNDERX2T99")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_CODE_SIZE\t32768\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t8\n"
-      "#define L1_DATA_SIZE\t32768\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L1_DATA_ASSOCIATIVE\t8\n"
-      "#define L2_SIZE\t262144\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define L2_ASSOCIATIVE\t8\n"
-      "#define L3_SIZE\t33554432\n"
-      "#define L3_LINESIZE\t64\n"
-      "#define L3_ASSOCIATIVE\t32\n"
-      "#define DTB_DEFAULT_ENTRIES\t64\n"
-      "#define DTB_SIZE\t4096\n"
-      "#define ARMV8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "TSV110")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define ARMV8\n"
-      "#define L1_CODE_SIZE\t65536\n"
-      "#define L1_CODE_LINESIZE\t64\n"
-      "#define L1_CODE_ASSOCIATIVE\t4\n"
-      "#define L1_DATA_SIZE\t65536\n"
-      "#define L1_DATA_LINESIZE\t64\n"
-      "#define L1_DATA_ASSOCIATIVE\t4\n"
-      "#define L2_SIZE\t524288\n"
-      "#define L2_LINESIZE\t64\n"
-      "#define L2_ASSOCIATIVE\t8\n"
-      "#define DTB_DEFAULT_ENTRIES\t64\n"
-      "#define DTB_SIZE\t4096\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 8)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 4)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "POWER6")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_DATA_SIZE 32768\n"
-      "#define L1_DATA_LINESIZE 128\n"
-      "#define L2_SIZE 524288\n"
-      "#define L2_LINESIZE 128 \n"
-      "#define DTB_DEFAULT_ENTRIES 128\n"
-      "#define DTB_SIZE 4096\n"
-      "#define L2_ASSOCIATIVE 8\n")
-    set(SGEMM_UNROLL_M 4)
-    set(SGEMM_UNROLL_N 4)
-    set(DGEMM_UNROLL_M 4)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 2)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 2)
-    set(ZGEMM_UNROLL_N 4)
-    set(SYMV_P 8)
-  elseif ("${TCORE}" STREQUAL "POWER8")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_DATA_SIZE 32768\n"
-      "#define L1_DATA_LINESIZE 128\n"
-      "#define L2_SIZE 524288\n"
-      "#define L2_LINESIZE 128 \n"
-      "#define DTB_DEFAULT_ENTRIES 128\n"
-      "#define DTB_SIZE 4096\n"
-      "#define L2_ASSOCIATIVE 8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 8)
-    set(DGEMM_UNROLL_M 16)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 8)
-    set(ZGEMM_UNROLL_N 2)
-    set(SYMV_P 8)
-  elseif ("${TCORE}" STREQUAL "POWER9")
-    file(APPEND ${TARGET_CONF_TEMP}
-      "#define L1_DATA_SIZE 32768\n"
-      "#define L1_DATA_LINESIZE 128\n"
-      "#define L2_SIZE 524288\n"
-      "#define L2_LINESIZE 128 \n"
-      "#define DTB_DEFAULT_ENTRIES 128\n"
-      "#define DTB_SIZE 4096\n"
-      "#define L2_ASSOCIATIVE 8\n")
-    set(SGEMM_UNROLL_M 16)
-    set(SGEMM_UNROLL_N 8)
-    set(DGEMM_UNROLL_M 16)
-    set(DGEMM_UNROLL_N 4)
-    set(CGEMM_UNROLL_M 8)
-    set(CGEMM_UNROLL_N 4)
-    set(ZGEMM_UNROLL_M 8)
-    set(ZGEMM_UNROLL_N 2)
-    set(SYMV_P 8)
-  endif()
-
-  # Or should this actually be NUM_CORES?
-  if (${NUM_THREADS} GREATER 0)
-    file(APPEND ${TARGET_CONF_TEMP} "#define NUM_CORES\t${NUM_THREADS}\n")
-  endif()
-
-  # GetArch_2nd
-  foreach(float_char S;D;Q;C;Z;X)
-    if (NOT DEFINED ${float_char}GEMM_UNROLL_M)
-      set(${float_char}GEMM_UNROLL_M 2)
-    endif()
-    if (NOT DEFINED ${float_char}GEMM_UNROLL_N)
-      set(${float_char}GEMM_UNROLL_N 2)
-    endif()
-  endforeach()
-  file(APPEND ${TARGET_CONF_TEMP}
-    "#define GEMM_MULTITHREAD_THRESHOLD\t${GEMM_MULTITHREAD_THRESHOLD}\n")
-  # Move to where gen_config_h would place it
-  file(MAKE_DIRECTORY ${TARGET_CONF_DIR})
-  file(RENAME ${TARGET_CONF_TEMP} "${TARGET_CONF_DIR}/${TARGET_CONF}")  
-
-else(NOT CMAKE_CROSSCOMPILING)
-  # compile getarch
-  set(GETARCH_SRC
-    ${PROJECT_SOURCE_DIR}/getarch.c
-    ${CPUIDEMU}
-  )
-
-  if ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
-    #Use generic for MSVC now
-    message("MSVC")
-    set(GETARCH_FLAGS ${GETARCH_FLAGS} -DFORCE_GENERIC)
-  else()
-    list(APPEND GETARCH_SRC ${PROJECT_SOURCE_DIR}/cpuid.S)
-    if (DEFINED TARGET_CORE)
-    set(GETARCH_FLAGS ${GETARCH_FLAGS} -DFORCE_${TARGET_CORE})
-  endif ()
-  endif ()
-
-  if ("${CMAKE_SYSTEM_NAME}" STREQUAL "WindowsStore")
-    # disable WindowsStore strict CRT checks
-    set(GETARCH_FLAGS ${GETARCH_FLAGS} -D_CRT_SECURE_NO_WARNINGS)
-  endif ()
-
-  set(GETARCH_DIR "${PROJECT_BINARY_DIR}/getarch_build")
-  set(GETARCH_BIN "getarch${CMAKE_EXECUTABLE_SUFFIX}")
-  file(MAKE_DIRECTORY ${GETARCH_DIR})
-  configure_file(${TARGET_CONF_TEMP} ${GETARCH_DIR}/${TARGET_CONF} COPYONLY)
-  if (NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "WindowsStore")
-    try_compile(GETARCH_RESULT ${GETARCH_DIR}
-      SOURCES ${GETARCH_SRC}
-    COMPILE_DEFINITIONS ${EXFLAGS} ${GETARCH_FLAGS} -I${GETARCH_DIR} -I"${PROJECT_SOURCE_DIR}" -I"${PROJECT_BINARY_DIR}"
-      OUTPUT_VARIABLE GETARCH_LOG
-      COPY_FILE ${PROJECT_BINARY_DIR}/${GETARCH_BIN}
-    )
-  
-    if (NOT ${GETARCH_RESULT})
-      MESSAGE(FATAL_ERROR "Compiling getarch failed ${GETARCH_LOG}")
-    endif ()
-  endif ()
-  message(STATUS "Running getarch")
-
-  # use the cmake binary w/ the -E param to run a shell command in a cross-platform way
-execute_process(COMMAND "${PROJECT_BINARY_DIR}/${GETARCH_BIN}" 0 OUTPUT_VARIABLE GETARCH_MAKE_OUT)
-execute_process(COMMAND "${PROJECT_BINARY_DIR}/${GETARCH_BIN}" 1 OUTPUT_VARIABLE GETARCH_CONF_OUT)
-
-  message(STATUS "GETARCH results:\n${GETARCH_MAKE_OUT}")
-
-  # append config data from getarch to the TARGET file and read in CMake vars
-  file(APPEND ${TARGET_CONF_TEMP} ${GETARCH_CONF_OUT})
-  ParseGetArchVars(${GETARCH_MAKE_OUT})
-
-  set(GETARCH2_DIR "${PROJECT_BINARY_DIR}/getarch2_build")
-  set(GETARCH2_BIN "getarch_2nd${CMAKE_EXECUTABLE_SUFFIX}")
-  file(MAKE_DIRECTORY ${GETARCH2_DIR})
-  configure_file(${TARGET_CONF_TEMP} ${GETARCH2_DIR}/${TARGET_CONF} COPYONLY)
-  if (NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "WindowsStore")
-    try_compile(GETARCH2_RESULT ${GETARCH2_DIR}
-      SOURCES ${PROJECT_SOURCE_DIR}/getarch_2nd.c
-    COMPILE_DEFINITIONS ${EXFLAGS} ${GETARCH_FLAGS} ${GETARCH2_FLAGS} -I${GETARCH2_DIR} -I"${PROJECT_SOURCE_DIR}" -I"${PROJECT_BINARY_DIR}"
-      OUTPUT_VARIABLE GETARCH2_LOG
-      COPY_FILE ${PROJECT_BINARY_DIR}/${GETARCH2_BIN}
-    )
-
-    if (NOT ${GETARCH2_RESULT})
-      MESSAGE(FATAL_ERROR "Compiling getarch_2nd failed ${GETARCH2_LOG}")
-    endif ()
-  endif ()
-
-  # use the cmake binary w/ the -E param to run a shell command in a cross-platform way
-execute_process(COMMAND "${PROJECT_BINARY_DIR}/${GETARCH2_BIN}" 0 OUTPUT_VARIABLE GETARCH2_MAKE_OUT)
-execute_process(COMMAND "${PROJECT_BINARY_DIR}/${GETARCH2_BIN}" 1 OUTPUT_VARIABLE GETARCH2_CONF_OUT)
-
-  # append config data from getarch_2nd to the TARGET file and read in CMake vars
-  file(APPEND ${TARGET_CONF_TEMP} ${GETARCH2_CONF_OUT})
-
-  configure_file(${TARGET_CONF_TEMP} ${TARGET_CONF_DIR}/${TARGET_CONF} COPYONLY)
-
-  ParseGetArchVars(${GETARCH2_MAKE_OUT})
-
-endif()

cmake/system.cmake

@@ -1,554 +0,0 @@
-##
-## Author: Hank Anderson <hank@statease.com>
-## Description: Ported from OpenBLAS/Makefile.system
-##
-set(NETLIB_LAPACK_DIR "${PROJECT_SOURCE_DIR}/lapack-netlib")
-
-# System detection, via CMake.
-include("${PROJECT_SOURCE_DIR}/cmake/system_check.cmake")
-
-if(CMAKE_CROSSCOMPILING AND NOT DEFINED TARGET)
-  # Detect target without running getarch
-  if (ARM64)
-    set(TARGET "ARMV8")
-  elseif(ARM)
-    set(TARGET "ARMV7") # TODO: Ask compiler which arch this is
-  else()
-    message(FATAL_ERROR "When cross compiling, a TARGET is required.")
-  endif()
-endif()
-
-# Other files expect CORE, which is actually TARGET and will become TARGET_CORE for kernel build. Confused yet?
-# It seems we are meant to use TARGET as input and CORE internally as kernel.
-if(NOT DEFINED CORE AND DEFINED TARGET)
-  set(CORE ${TARGET})
-endif()
-
-# TARGET_CORE will override TARGET which is used in DYNAMIC_ARCH=1.
-if (DEFINED TARGET_CORE)
-  set(TARGET ${TARGET_CORE})
-endif ()
-
-# Force fallbacks for 32bit
-if (DEFINED BINARY AND DEFINED TARGET AND BINARY EQUAL 32)
-  message(STATUS "Compiling a ${BINARY}-bit binary.")
-  set(NO_AVX 1)
-  if (${TARGET} STREQUAL "HASWELL" OR ${TARGET} STREQUAL "SANDYBRIDGE" OR ${TARGET} STREQUAL "SKYLAKEX")
-    set(TARGET "NEHALEM")
-  endif ()
-  if (${TARGET} STREQUAL "BULLDOZER" OR ${TARGET} STREQUAL "PILEDRIVER" OR ${TARGET} STREQUAL "ZEN")
-    set(TARGET "BARCELONA")
-  endif ()
-  if (${TARGET} STREQUAL "ARMV8" OR ${TARGET} STREQUAL "CORTEXA57" OR ${TARGET} STREQUAL "CORTEXA53")
-    set(TARGET "ARMV7")
-  endif ()
-endif ()
-
-if (DEFINED TARGET)
-  if (${TARGET} STREQUAL "SKYLAKEX" AND NOT NO_AVX512)
-    set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
-  endif()
-  if (${TARGET} STREQUAL "HASWELL" AND NOT NO_AVX2)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
-      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-      if (${GCC_VERSION} VERSION_GREATER 4.7 OR ${GCC_VERSION} VERSION_EQUAL 4.7)
-        set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mavx2")
-      endif()
-    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "CLANG")
-      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mavx2")
-    endif()
-  endif()
-endif()
-
-if (DEFINED TARGET)
-  message(STATUS "Targeting the ${TARGET} architecture.")
-  set(GETARCH_FLAGS "-DFORCE_${TARGET}")
-endif ()
-
-# On x86_64 build getarch with march=native. This is required to detect AVX512 support in getarch.
-if (X86_64 AND NOT ${CMAKE_C_COMPILER_ID} STREQUAL "PGI")
-  set(GETARCH_FLAGS "${GETARCH_FLAGS} -march=native")
-endif ()
-
-# On x86 no AVX support is available
-if (X86 OR X86_64)
-if ((DEFINED BINARY AND BINARY EQUAL 32) OR ("$CMAKE_SIZEOF_VOID_P}" EQUAL "4"))
-  set(GETARCH_FLAGS "${GETARCH_FLAGS} -DNO_AVX -DNO_AVX2 -DNO_AVX512")
-endif ()
-endif ()
-
-if (INTERFACE64)
-  message(STATUS "Using 64-bit integers.")
-  set(GETARCH_FLAGS	"${GETARCH_FLAGS} -DUSE64BITINT")
-endif ()
-
-if (NOT DEFINED GEMM_MULTITHREAD_THRESHOLD)
-  set(GEMM_MULTITHREAD_THRESHOLD 4)
-endif ()
-message(STATUS "GEMM multithread threshold set to ${GEMM_MULTITHREAD_THRESHOLD}.")
-set(GETARCH_FLAGS	"${GETARCH_FLAGS} -DGEMM_MULTITHREAD_THRESHOLD=${GEMM_MULTITHREAD_THRESHOLD}")
-
-if (NO_AVX)
-  message(STATUS "Disabling Advanced Vector Extensions (AVX).")
-  set(GETARCH_FLAGS "${GETARCH_FLAGS} -DNO_AVX")
-endif ()
-
-if (NO_AVX2)
-  message(STATUS "Disabling Advanced Vector Extensions 2 (AVX2).")
-  set(GETARCH_FLAGS "${GETARCH_FLAGS} -DNO_AVX2")
-endif ()
-
-if (CMAKE_BUILD_TYPE STREQUAL "Debug")
-  set(GETARCH_FLAGS "${GETARCH_FLAGS} ${CMAKE_C_FLAGS_DEBUG}")
-endif ()
-
-if (NOT DEFINED NO_PARALLEL_MAKE)
-  set(NO_PARALLEL_MAKE 0)
-endif ()
-set(GETARCH_FLAGS	"${GETARCH_FLAGS} -DNO_PARALLEL_MAKE=${NO_PARALLEL_MAKE}")
-
-if (CMAKE_C_COMPILER STREQUAL loongcc)
-  set(GETARCH_FLAGS	"${GETARCH_FLAGS} -static")
-endif ()
-
-#if don't use Fortran, it will only compile CBLAS.
-if (ONLY_CBLAS)
-  set(NO_LAPACK 1)
-else ()
-  set(ONLY_CBLAS 0)
-endif ()
-
-# N.B. this is NUM_THREAD in Makefile.system which is probably a bug -hpa
-if (NOT CMAKE_CROSSCOMPILING)
-  if (NOT DEFINED NUM_CORES)
-    include(ProcessorCount)
-    ProcessorCount(NUM_CORES)
-  endif()
-
-endif()
-
-if (NOT DEFINED NUM_PARALLEL)
-  set(NUM_PARALLEL 1)
-endif()
-
-if (NOT DEFINED NUM_THREADS)
-  if (DEFINED NUM_CORES AND NOT NUM_CORES EQUAL 0)
-    # HT?
-    set(NUM_THREADS ${NUM_CORES})
-  else ()
-    set(NUM_THREADS 0)
-  endif ()
-endif()
-
-if (${NUM_THREADS} LESS 2)
-  set(USE_THREAD 0)
-elseif(NOT DEFINED USE_THREAD)
-  set(USE_THREAD 1)
-endif ()
-
-if (USE_THREAD)
-  message(STATUS "Multi-threading enabled with ${NUM_THREADS} threads.")
-else()
-  if (${USE_LOCKING})
-    set(CCOMMON_OPT "${CCOMMON_OPT} -DUSE_LOCKING")
-  endif ()
-endif ()
-
-include("${PROJECT_SOURCE_DIR}/cmake/prebuild.cmake")
-if (DEFINED BINARY)
-  message(STATUS "Compiling a ${BINARY}-bit binary.")
-endif ()
-if (NOT DEFINED NEED_PIC)
-  set(NEED_PIC 1)
-endif ()
-
-# OS dependent settings
-include("${PROJECT_SOURCE_DIR}/cmake/os.cmake")
-
-# Architecture dependent settings
-include("${PROJECT_SOURCE_DIR}/cmake/arch.cmake")
-
-# C Compiler dependent settings
-include("${PROJECT_SOURCE_DIR}/cmake/cc.cmake")
-
-if (NOT NOFORTRAN)
-  # Fortran Compiler dependent settings
-  include("${PROJECT_SOURCE_DIR}/cmake/fc.cmake")
-else ()
-set(NO_LAPACK 1)
-set(NO_LAPACKE 1)
-endif ()
-
-if (BINARY64)
-  if (INTERFACE64)
-    # CCOMMON_OPT += -DUSE64BITINT
-  endif ()
-endif ()
-
-if (NEED_PIC)
-  if (${CMAKE_C_COMPILER} STREQUAL "IBM")
-    set(CCOMMON_OPT "${CCOMMON_OPT} -qpic=large")
-  else ()
-    set(CCOMMON_OPT "${CCOMMON_OPT} -fPIC")
-  endif ()
-
-  if (NOT NOFORTRAN)
-    if (${F_COMPILER} STREQUAL "SUN")
-      set(FCOMMON_OPT "${FCOMMON_OPT} -pic")
-    else ()
-      set(FCOMMON_OPT "${FCOMMON_OPT} -fPIC")
-    endif ()
-  endif()
-endif ()
-
-if (DYNAMIC_ARCH)
-  if (X86 OR X86_64 OR ARM64 OR PPC)
-    set(CCOMMON_OPT "${CCOMMON_OPT} -DDYNAMIC_ARCH")
-    if (DYNAMIC_OLDER)
-      set(CCOMMON_OPT "${CCOMMON_OPT} -DDYNAMIC_OLDER")
-    endif ()
-  else ()
-    unset (DYNAMIC_ARCH)
-    message (STATUS "DYNAMIC_ARCH is not supported on the target architecture, removing")
-  endif ()
-endif ()
-
-if (DYNAMIC_LIST)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DDYNAMIC_LIST")
-  foreach(DCORE ${DYNAMIC_LIST})
-    set(CCOMMON_OPT "${CCOMMON_OPT} -DDYN_${DCORE}")
-  endforeach ()
-endif ()
-
-if (NO_LAPACK)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DNO_LAPACK")
-  #Disable LAPACK C interface
-  set(NO_LAPACKE 1)
-endif ()
-
-if (NO_LAPACKE)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DNO_LAPACKE")
-endif ()
-
-if (NO_AVX)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DNO_AVX")
-endif ()
-
-if (X86)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DNO_AVX")
-endif ()
-
-if (NO_AVX2)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DNO_AVX2")
-endif ()
-
-if (USE_THREAD)
-  # USE_SIMPLE_THREADED_LEVEL3 = 1
-  # NO_AFFINITY = 1
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DSMP_SERVER")
-
-  if (MIPS64)
-    if (NOT ${CORE} STREQUAL "LOONGSON3B")
-      set(USE_SIMPLE_THREADED_LEVEL3 1)
-    endif ()
-  endif ()
-
-  if (BIGNUMA)
-    set(CCOMMON_OPT "${CCOMMON_OPT} -DBIGNUMA")
-  endif ()
-endif ()
-
-if (NO_WARMUP)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DNO_WARMUP")
-endif ()
-
-if (CONSISTENT_FPCSR)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DCONSISTENT_FPCSR")
-endif ()
-
-if (USE_TLS)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DUSE_TLS")
-endif ()
-
-# Only for development
-# set(CCOMMON_OPT "${CCOMMON_OPT} -DPARAMTEST")
-# set(CCOMMON_OPT "${CCOMMON_OPT} -DPREFETCHTEST")
-# set(CCOMMON_OPT "${CCOMMON_OPT} -DNO_SWITCHING")
-# set(USE_PAPI 1)
-
-if (USE_PAPI)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DUSE_PAPI")
-  set(EXTRALIB "${EXTRALIB} -lpapi -lperfctr")
-endif ()
-
-if (DYNAMIC_THREADS)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DDYNAMIC_THREADS")
-endif ()
-
-set(CCOMMON_OPT "${CCOMMON_OPT} -DMAX_CPU_NUMBER=${NUM_THREADS}")
-
-set(CCOMMON_OPT "${CCOMMON_OPT} -DMAX_PARALLEL_NUMBER=${NUM_PARALLEL}")
-
-if (USE_SIMPLE_THREADED_LEVEL3)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DUSE_SIMPLE_THREADED_LEVEL3")
-endif ()
-
-if (DEFINED LIBNAMESUFFIX)
-  set(LIBPREFIX "libopenblas_${LIBNAMESUFFIX}")
-else ()
-  set(LIBPREFIX "libopenblas")
-endif ()
-
-if (NOT DEFINED SYMBOLPREFIX)
-  set(SYMBOLPREFIX "")
-endif ()
-
-if (NOT DEFINED SYMBOLSUFFIX)
-  set(SYMBOLSUFFIX "")
-endif ()
-
-set(KERNELDIR	"${PROJECT_SOURCE_DIR}/kernel/${ARCH}")
-
-# TODO: need to convert these Makefiles
-# include ${PROJECT_SOURCE_DIR}/cmake/${ARCH}.cmake
-
-if (${CORE} STREQUAL "PPC440")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DALLOC_QALLOC")
-endif ()
-
-if (${CORE} STREQUAL "PPC440FP2")
-  set(STATIC_ALLOCATION 1)
-endif ()
-
-if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-  set(NO_AFFINITY 1)
-endif ()
-
-if (NOT X86_64 AND NOT X86 AND NOT ${CORE} STREQUAL "LOONGSON3B")
-  set(NO_AFFINITY 1)
-endif ()
-
-if (NO_AFFINITY)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DNO_AFFINITY")
-endif ()
-
-if (FUNCTION_PROFILE)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DFUNCTION_PROFILE")
-endif ()
-
-if (HUGETLB_ALLOCATION)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DALLOC_HUGETLB")
-endif ()
-
-if (DEFINED HUGETLBFILE_ALLOCATION)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DALLOC_HUGETLBFILE -DHUGETLB_FILE_NAME=${HUGETLBFILE_ALLOCATION})")
-endif ()
-
-if (STATIC_ALLOCATION)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DALLOC_STATIC")
-endif ()
-
-if (DEVICEDRIVER_ALLOCATION)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DALLOC_DEVICEDRIVER -DDEVICEDRIVER_NAME=\"/dev/mapper\"")
-endif ()
-
-if (MIXED_MEMORY_ALLOCATION)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DMIXED_MEMORY_ALLOCATION")
-endif ()
-
-set(CCOMMON_OPT "${CCOMMON_OPT} -DVERSION=\"\\\"${OpenBLAS_VERSION}\\\"\"")
-
-set(REVISION "-r${OpenBLAS_VERSION}")
-set(MAJOR_VERSION ${OpenBLAS_MAJOR_VERSION})
-
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CCOMMON_OPT}")
-if(NOT MSVC)
-set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${CCOMMON_OPT}")
-endif()
-# TODO: not sure what PFLAGS is -hpa
-set(PFLAGS "${PFLAGS} ${CCOMMON_OPT} -I${TOPDIR} -DPROFILE ${COMMON_PROF}")
-
-set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${FCOMMON_OPT}")
-# TODO: not sure what FPFLAGS is -hpa
-set(FPFLAGS "${FPFLAGS} ${FCOMMON_OPT} ${COMMON_PROF}")
-
-#For LAPACK Fortran codes.
-set(LAPACK_FFLAGS "${LAPACK_FFLAGS} ${CMAKE_Fortran_FLAGS}")
-set(LAPACK_FPFLAGS "${LAPACK_FPFLAGS} ${FPFLAGS}")
-
-#Disable -fopenmp for LAPACK Fortran codes on Windows.
-if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-  set(FILTER_FLAGS "-fopenmp;-mp;-openmp;-xopenmp=parallel")
-  foreach (FILTER_FLAG ${FILTER_FLAGS})
-    string(REPLACE ${FILTER_FLAG} "" LAPACK_FFLAGS ${LAPACK_FFLAGS})
-    string(REPLACE ${FILTER_FLAG} "" LAPACK_FPFLAGS ${LAPACK_FPFLAGS})
-  endforeach ()
-endif ()
-
-if ("${F_COMPILER}" STREQUAL "GFORTRAN")
-  # lapack-netlib is rife with uninitialized warnings -hpa
-  set(LAPACK_FFLAGS "${LAPACK_FFLAGS} -Wno-maybe-uninitialized")
-endif ()
-
-set(LAPACK_CFLAGS "${CMAKE_C_CFLAGS} -DHAVE_LAPACK_CONFIG_H")
-if (INTERFACE64)
-  set(LAPACK_CFLAGS "${LAPACK_CFLAGS} -DLAPACK_ILP64")
-endif ()
-
-if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-  set(LAPACK_CFLAGS "${LAPACK_CFLAGS} -DOPENBLAS_OS_WINDOWS")
-endif ()
-
-if (${CMAKE_C_COMPILER} STREQUAL "LSB" OR ${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-  set(LAPACK_CFLAGS "${LAPACK_CFLAGS} -DLAPACK_COMPLEX_STRUCTURE")
-endif ()
-
-if (NOT DEFINED SUFFIX)
-  set(SUFFIX o)
-endif ()
-
-if (NOT DEFINED PSUFFIX)
-  set(PSUFFIX po)
-endif ()
-
-if (NOT DEFINED LIBSUFFIX)
-  set(LIBSUFFIX a)
-endif ()
-
-if (DYNAMIC_ARCH)
-  if (USE_THREAD)
-    set(LIBNAME "${LIBPREFIX}p${REVISION}.${LIBSUFFIX}")
-    set(LIBNAME_P	"${LIBPREFIX}p${REVISION}_p.${LIBSUFFIX}")
-  else ()
-    set(LIBNAME "${LIBPREFIX}${REVISION}.${LIBSUFFIX}")
-    set(LIBNAME_P	"${LIBPREFIX}${REVISION}_p.${LIBSUFFIX}")
-  endif ()
-else ()
-  if (USE_THREAD)
-    set(LIBNAME "${LIBPREFIX}_${LIBCORE}p${REVISION}.${LIBSUFFIX}")
-    set(LIBNAME_P	"${LIBPREFIX}_${LIBCORE}p${REVISION}_p.${LIBSUFFIX}")
-  else ()
-    set(LIBNAME	"${LIBPREFIX}_${LIBCORE}${REVISION}.${LIBSUFFIX}")
-    set(LIBNAME_P	"${LIBPREFIX}_${LIBCORE}${REVISION}_p.${LIBSUFFIX}")
-  endif ()
-endif ()
-
-
-set(LIBDLLNAME "${LIBPREFIX}.dll")
-set(LIBSONAME "${LIBNAME}.${LIBSUFFIX}.so")
-set(LIBDYNNAME "${LIBNAME}.${LIBSUFFIX}.dylib")
-set(LIBDEFNAME "${LIBNAME}.${LIBSUFFIX}.def")
-set(LIBEXPNAME "${LIBNAME}.${LIBSUFFIX}.exp")
-set(LIBZIPNAME "${LIBNAME}.${LIBSUFFIX}.zip")
-
-set(LIBS "${PROJECT_SOURCE_DIR}/${LIBNAME}")
-set(LIBS_P "${PROJECT_SOURCE_DIR}/${LIBNAME_P}")
-
-
-set(LIB_COMPONENTS BLAS)
-if (NOT NO_CBLAS)
-  set(LIB_COMPONENTS "${LIB_COMPONENTS} CBLAS")
-endif ()
-
-if (NOT NO_LAPACK)
-  set(LIB_COMPONENTS "${LIB_COMPONENTS} LAPACK")
-  if (NOT NO_LAPACKE)
-    set(LIB_COMPONENTS "${LIB_COMPONENTS} LAPACKE")
-  endif ()
-  if (BUILD_RELAPACK)
-    set(LIB_COMPONENTS "${LIB_COMPONENTS} ReLAPACK")
-  endif ()
-endif ()
-
-if (ONLY_CBLAS)
-  set(LIB_COMPONENTS CBLAS)
-endif ()
-
-
-# For GEMM3M
-set(USE_GEMM3M 0)
-
-if (DEFINED ARCH)
-  if (X86 OR X86_64 OR ${ARCH} STREQUAL "ia64" OR MIPS64)
-    set(USE_GEMM3M 1)
-  endif ()
-
-  if (${CORE} STREQUAL "generic")
-    set(USE_GEMM3M 0)
-  endif ()
-endif ()
-
-
-#export OSNAME
-#export ARCH
-#export CORE
-#export LIBCORE
-#export PGCPATH
-#export CONFIG
-#export CC
-#export FC
-#export BU
-#export FU
-#export NEED2UNDERSCORES
-#export USE_THREAD
-#export NUM_THREADS
-#export NUM_CORES
-#export SMP
-#export MAKEFILE_RULE
-#export NEED_PIC
-#export BINARY
-#export BINARY32
-#export BINARY64
-#export F_COMPILER
-#export C_COMPILER
-#export USE_OPENMP
-#export CROSS
-#export CROSS_SUFFIX
-#export NOFORTRAN
-#export NO_FBLAS
-#export EXTRALIB
-#export CEXTRALIB
-#export FEXTRALIB
-#export HAVE_SSE
-#export HAVE_SSE2
-#export HAVE_SSE3
-#export HAVE_SSSE3
-#export HAVE_SSE4_1
-#export HAVE_SSE4_2
-#export HAVE_SSE4A
-#export HAVE_SSE5
-#export HAVE_AVX
-#export HAVE_VFP
-#export HAVE_VFPV3
-#export HAVE_VFPV4
-#export HAVE_NEON
-#export KERNELDIR
-#export FUNCTION_PROFILE
-#export TARGET_CORE
-#
-#export SGEMM_UNROLL_M
-#export SGEMM_UNROLL_N
-#export DGEMM_UNROLL_M
-#export DGEMM_UNROLL_N
-#export QGEMM_UNROLL_M
-#export QGEMM_UNROLL_N
-#export CGEMM_UNROLL_M
-#export CGEMM_UNROLL_N
-#export ZGEMM_UNROLL_M
-#export ZGEMM_UNROLL_N
-#export XGEMM_UNROLL_M
-#export XGEMM_UNROLL_N
-#export CGEMM3M_UNROLL_M
-#export CGEMM3M_UNROLL_N
-#export ZGEMM3M_UNROLL_M
-#export ZGEMM3M_UNROLL_N
-#export XGEMM3M_UNROLL_M
-#export XGEMM3M_UNROLL_N
-
-
-#if (USE_CUDA)
-#  export CUDADIR
-#  export CUCC
-#  export CUFLAGS
-#  export CULIB
-#endif

cmake/system_check.cmake

@@ -1,118 +0,0 @@
-##
-## Author: Hank Anderson <hank@statease.com>
-## Description: Ported from the OpenBLAS/c_check perl script.
-##              This is triggered by prebuild.cmake and runs before any of the code is built.
-##              Creates config.h and Makefile.conf.
-
-# Convert CMake vars into the format that OpenBLAS expects
-string(TOUPPER ${CMAKE_SYSTEM_NAME} HOST_OS)
-if (${HOST_OS} STREQUAL "WINDOWS")
-  set(HOST_OS WINNT)
-endif ()
-
-if (${HOST_OS} STREQUAL "LINUX")
-# check if we're building natively on Android (TERMUX)
-    EXECUTE_PROCESS( COMMAND uname -o COMMAND tr -d '\n' OUTPUT_VARIABLE OPERATING_SYSTEM)
-      if(${OPERATING_SYSTEM} MATCHES "Android")
-        set(HOST_OS ANDROID)
-      endif()
-endif()
-
-
-
-if(CMAKE_COMPILER_IS_GNUCC AND WIN32)
-    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpmachine
-              OUTPUT_VARIABLE OPENBLAS_GCC_TARGET_MACHINE
-              OUTPUT_STRIP_TRAILING_WHITESPACE)
-    if(OPENBLAS_GCC_TARGET_MACHINE MATCHES "amd64|x86_64|AMD64")
-      set(MINGW64 1)
-    endif()
-endif()
-
-# Pretty thorough determination of arch. Add more if needed
-if(CMAKE_CL_64 OR MINGW64)
-  set(X86_64 1)
-elseif(MINGW OR (MSVC AND NOT CMAKE_CROSSCOMPILING))
-  set(X86 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc.*|power.*|Power.*")
-  set(PPC 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "mips64.*")
-  set(MIPS64 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*")
-  if (NOT BINARY)
-    if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
-      set(X86_64 1)
-    else()
-      set(X86 1)
-    endif()
-  else()
-    if (${BINARY} EQUAL "64")
-       set(X86_64 1)
-    else ()
-       set(X86 1)
-    endif()
-  endif()
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "i686.*|i386.*|x86.*|amd64.*|AMD64.*")
-  set(X86 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(arm.*|ARM.*)")
-  set(ARM 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*)")
-  if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
-    set(ARM64 1)
-  else()
-    set(ARM 1)
-  endif()
-elseif (${CMAKE_CROSSCOMPILING})
-   if (${TARGET} STREQUAL "CORE2")
-    if (NOT BINARY)
-       set(X86 1)
-    elseif (${BINARY} EQUAL "64")
-       set(X86_64 1)
-    else ()
-       set(X86 1)
-    endif()
-   elseif (${TARGET} STREQUAL "ARMV7")
-       set(ARM 1)
-   else()
-       set(ARM64 1)
-   endif ()
-else ()
-   message(WARNING "Target ARCH could not be determined, got \"${CMAKE_SYSTEM_PROCESSOR}\"")
-endif()
-
-if (X86_64)
-  set(ARCH "x86_64")
-elseif(X86)
-  set(ARCH "x86")
-elseif(PPC)
-  set(ARCH "power")
-elseif(ARM)
-  set(ARCH "arm")
-elseif(ARM64)
-  set(ARCH "arm64")
-else()
-  set(ARCH ${CMAKE_SYSTEM_PROCESSOR} CACHE STRING "Target Architecture")
-endif ()
-
-if (NOT BINARY)
-  if (X86_64 OR ARM64 OR PPC OR MIPS64)
-    set(BINARY 64)
-  else ()
-    set(BINARY 32)
-  endif ()
-endif()
-
-if(BINARY EQUAL 64)
-  set(BINARY64 1)
-else()
-  set(BINARY32 1)
-endif()
-
-if (X86_64 OR X86)
-  file(WRITE ${PROJECT_BINARY_DIR}/avx512.tmp "#include <immintrin.h>\n\nint main(void){ __asm__ volatile(\"vbroadcastss -4 * 4(%rsi), %zmm2\"); }")
-execute_process(COMMAND ${CMAKE_C_COMPILER} -march=skylake-avx512 -c -v -o ${PROJECT_BINARY_DIR}/avx512.o -x c ${PROJECT_BINARY_DIR}/avx512.tmp OUTPUT_QUIET ERROR_QUIET RESULT_VARIABLE NO_AVX512)
-if (NO_AVX512 EQUAL 1)
-set (CCOMMON_OPT "${CCOMMON_OPT} -DNO_AVX512")
-endif()
-  file(REMOVE "avx512.tmp" "avx512.o")
-endif()

cmake/utils.cmake

@@ -1,350 +0,0 @@
-# Functions to help with the OpenBLAS build
-
-# Reads string from getarch into CMake vars. Format of getarch vars is VARNAME=VALUE
-function(ParseGetArchVars GETARCH_IN)
-  string(REGEX MATCHALL "[0-9_a-zA-Z]+=[0-9_a-zA-Z]+" GETARCH_RESULT_LIST "${GETARCH_IN}")
-  foreach (GETARCH_LINE ${GETARCH_RESULT_LIST})
-    # split the line into var and value, then assign the value to a CMake var
-    string(REGEX MATCHALL "[0-9_a-zA-Z]+" SPLIT_VAR "${GETARCH_LINE}")
-    list(GET SPLIT_VAR 0 VAR_NAME)
-    list(GET SPLIT_VAR 1 VAR_VALUE)
-    set(${VAR_NAME} ${VAR_VALUE} PARENT_SCOPE)
-  endforeach ()
-endfunction ()
-
-# Reads a Makefile into CMake vars.
-macro(ParseMakefileVars MAKEFILE_IN)
-  message(STATUS "Reading vars from ${MAKEFILE_IN}...")
-  file(STRINGS ${MAKEFILE_IN} makefile_contents)
-  foreach (makefile_line ${makefile_contents})
-    string(REGEX MATCH "([0-9_a-zA-Z]+)[ \t]*=[ \t]*(.+)$" line_match "${makefile_line}")
-    if (NOT "${line_match}" STREQUAL "")
-      set(var_name ${CMAKE_MATCH_1})
-      set(var_value ${CMAKE_MATCH_2})
-      # check for Makefile variables in the string, e.g. $(TSUFFIX)
-      string(REGEX MATCHALL "\\$\\(([0-9_a-zA-Z]+)\\)" make_var_matches ${var_value})
-      foreach (make_var ${make_var_matches})
-        # strip out Makefile $() markup
-        string(REGEX REPLACE "\\$\\(([0-9_a-zA-Z]+)\\)" "\\1" make_var ${make_var})
-        # now replace the instance of the Makefile variable with the value of the CMake variable (note the double quote)
-        string(REPLACE "$(${make_var})" "${${make_var}}" var_value ${var_value})
-      endforeach ()
-      set(${var_name} ${var_value})
-    else ()
-      string(REGEX MATCH "include \\$\\(KERNELDIR\\)/(.+)$" line_match "${makefile_line}")
-      if (NOT "${line_match}" STREQUAL "")
-        ParseMakefileVars(${KERNELDIR}/${CMAKE_MATCH_1})
-      endif ()
-    endif ()
-  endforeach ()
-endmacro ()
-
-# Returns all combinations of the input list, as a list with colon-separated combinations
-# E.g. input of A B C returns A B C A:B A:C B:C
-# N.B. The input is meant to be a list, and to past a list to a function in CMake you must quote it (e.g. AllCombinations("${LIST_VAR}")).
-# #param absent_codes codes to use when an element is absent from a combination. For example, if you have TRANS;UNIT;UPPER you may want the code to be NNL when nothing is present.
-# @returns LIST_OUT a list of combinations
-#          CODES_OUT a list of codes corresponding to each combination, with N meaning the item is not present, and the first letter of the list item meaning it is presen
-function(AllCombinations list_in absent_codes_in)
-  list(LENGTH list_in list_count)
-  set(num_combos 1)
-  # subtract 1 since we will iterate from 0 to num_combos
-  math(EXPR num_combos "(${num_combos} << ${list_count}) - 1")
-  set(LIST_OUT "")
-  set(CODES_OUT "")
-  foreach (c RANGE 0 ${num_combos})
-
-    set(current_combo "")
-    set(current_code "")
-
-    # this is a little ridiculous just to iterate through a list w/ indices
-    math(EXPR last_list_index "${list_count} - 1")
-    foreach (list_index RANGE 0 ${last_list_index})
-      math(EXPR bit "1 << ${list_index}")
-      math(EXPR combo_has_bit "${c} & ${bit}")
-      list(GET list_in ${list_index} list_elem)
-      if (combo_has_bit)
-        if (current_combo)
-          set(current_combo "${current_combo}:${list_elem}")
-        else ()
-          set(current_combo ${list_elem})
-        endif ()
-        string(SUBSTRING ${list_elem} 0 1 code_char)
-      else ()
-        list(GET absent_codes_in ${list_index} code_char)
-      endif ()
-      set(current_code "${current_code}${code_char}")
-    endforeach ()
-
-    if (current_combo STREQUAL "")
-      list(APPEND LIST_OUT " ") # Empty set is a valid combination, but CMake isn't appending the empty string for some reason, use a space
-    else ()
-      list(APPEND LIST_OUT ${current_combo})
-    endif ()
-    list(APPEND CODES_OUT ${current_code})
-
-  endforeach ()
-
-  set(LIST_OUT ${LIST_OUT} PARENT_SCOPE)
-  set(CODES_OUT ${CODES_OUT} PARENT_SCOPE)
-endfunction ()
-
-# generates object files for each of the sources, using the BLAS naming scheme to pass the function name as a preprocessor definition
-# @param sources_in the source files to build from
-# @param defines_in (optional) preprocessor definitions that will be applied to all objects
-# @param name_in (optional) if this is set this name will be used instead of the filename. Use a * to indicate where the float character should go, if no star the character will be prepended.
-#                           e.g. with DOUBLE set, "i*max" will generate the name "idmax", and "max" will be "dmax"
-# @param replace_last_with replaces the last character in the filename with this string (e.g. symm_k should be symm_TU)
-# @param append_with appends the filename with this string (e.g. trmm_R should be trmm_RTUU or some other combination of characters)
-# @param no_float_type turns off the float type define for this build (e.g. SINGLE/DOUBLE/etc)
-# @param complex_filename_scheme some routines have separate source files for complex and non-complex float types.
-#                               0 - compiles for all types
-#                               1 - compiles the sources for non-complex types only (SINGLE/DOUBLE)
-#                               2 - compiles for complex types only (COMPLEX/DOUBLE COMPLEX)
-#                               3 - compiles for all types, but changes source names for complex by prepending z (e.g. axpy.c becomes zaxpy.c)
-#                               4 - compiles for complex types only, but changes source names for complex by prepending z (e.g. hemv.c becomes zhemv.c)
-#                               STRING - compiles only the given type (e.g. DOUBLE)
-function(GenerateNamedObjects sources_in)
-
-  if (DEFINED ARGV1)
-    set(defines_in ${ARGV1})
-  endif ()
-
-  if (DEFINED ARGV2 AND NOT "${ARGV2}" STREQUAL "")
-    set(name_in ${ARGV2})
-    # strip off extension for kernel files that pass in the object name.
-    get_filename_component(name_in ${name_in} NAME_WE)
-  endif ()
-
-  if (DEFINED ARGV3)
-    set(use_cblas ${ARGV3})
-  else ()
-    set(use_cblas false)
-  endif ()
-
-  if (DEFINED ARGV4)
-    set(replace_last_with ${ARGV4})
-  endif ()
-
-  if (DEFINED ARGV5)
-    set(append_with ${ARGV5})
-  endif ()
-
-  if (DEFINED ARGV6)
-    set(no_float_type ${ARGV6})
-  else ()
-    set(no_float_type false)
-  endif ()
-
-  if (no_float_type)
-    set(float_list "DUMMY") # still need to loop once
-  else ()
-    set(float_list "${FLOAT_TYPES}")
-  endif ()
-
-  set(real_only false)
-  set(complex_only false)
-  set(mangle_complex_sources false)
-  if (DEFINED ARGV7 AND NOT "${ARGV7}" STREQUAL "")
-    if (${ARGV7} EQUAL 1)
-      set(real_only true)
-    elseif (${ARGV7} EQUAL 2)
-      set(complex_only true)
-    elseif (${ARGV7} EQUAL 3)
-      set(mangle_complex_sources true)
-    elseif (${ARGV7} EQUAL 4)
-      set(mangle_complex_sources true)
-      set(complex_only true)
-    elseif (NOT ${ARGV7} EQUAL 0)
-      set(float_list ${ARGV7})
-    endif ()
-  endif ()
-
-  if (complex_only)
-    list(REMOVE_ITEM float_list "SINGLE")
-    list(REMOVE_ITEM float_list "DOUBLE")
-  elseif (real_only)
-    list(REMOVE_ITEM float_list "COMPLEX")
-    list(REMOVE_ITEM float_list "ZCOMPLEX")
-  endif ()
-
-  set(float_char "")
-  set(OBJ_LIST_OUT "")
-  foreach (float_type ${float_list})
-    foreach (source_file ${sources_in})
-
-      if (NOT no_float_type)
-        string(SUBSTRING ${float_type} 0 1 float_char)
-        string(TOLOWER ${float_char} float_char)
-      endif ()
-
-      if (NOT name_in)
-        get_filename_component(source_name ${source_file} NAME_WE)
-        set(obj_name "${float_char}${source_name}")
-      else ()
-        # replace * with float_char
-        if (${name_in} MATCHES "\\*")
-          string(REPLACE "*" ${float_char} obj_name ${name_in})
-        else ()
-          set(obj_name "${float_char}${name_in}")
-        endif ()
-      endif ()
-
-      if (replace_last_with)
-        string(REGEX REPLACE ".$" ${replace_last_with} obj_name ${obj_name})
-      else ()
-        set(obj_name "${obj_name}${append_with}")
-      endif ()
-
-      # now add the object and set the defines
-      set(obj_defines ${defines_in})
-
-      if (use_cblas)
-        set(obj_name "cblas_${obj_name}")
-        list(APPEND obj_defines "CBLAS")
-      elseif (NOT "${obj_name}" MATCHES "${ARCH_SUFFIX}")
-        set(obj_name "${obj_name}${ARCH_SUFFIX}")
-      endif ()
-
-      list(APPEND obj_defines "ASMNAME=${FU}${obj_name};ASMFNAME=${FU}${obj_name}${BU};NAME=${obj_name}${BU};CNAME=${obj_name};CHAR_NAME=\"${obj_name}${BU}\";CHAR_CNAME=\"${obj_name}\"")
-      if (${float_type} STREQUAL "DOUBLE" OR ${float_type} STREQUAL "ZCOMPLEX")
-        list(APPEND obj_defines "DOUBLE")
-      endif ()
-      if (${float_type} STREQUAL "COMPLEX" OR ${float_type} STREQUAL "ZCOMPLEX")
-        list(APPEND obj_defines "COMPLEX")
-        if (mangle_complex_sources)
-          # add a z to the filename
-          get_filename_component(source_name ${source_file} NAME)
-          get_filename_component(source_dir ${source_file} DIRECTORY)
-          string(REPLACE ${source_name} "z${source_name}" source_file ${source_file})
-        endif ()
-      endif ()
-
-      if (VERBOSE_GEN)
-        message(STATUS "${obj_name}:${source_file}")
-        message(STATUS "${obj_defines}")
-      endif ()
-
-      # create a copy of the source to avoid duplicate obj filename problem with ar.exe
-      get_filename_component(source_extension ${source_file} EXT)
-      set(new_source_file "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${obj_name}${source_extension}")
-      if (IS_ABSOLUTE ${source_file})
-        set(old_source_file ${source_file})
-      else ()
-        set(old_source_file "${CMAKE_CURRENT_LIST_DIR}/${source_file}")
-      endif ()
-
-      string(REPLACE ";" "\n#define " define_source "${obj_defines}")
-      string(REPLACE "=" " " define_source "${define_source}")
-      file(WRITE ${new_source_file}.tmp "#define ${define_source}\n#include \"${old_source_file}\"")
-      configure_file(${new_source_file}.tmp ${new_source_file} COPYONLY)
-      file(REMOVE ${new_source_file}.tmp)
-      list(APPEND SRC_LIST_OUT ${new_source_file})
-
-    endforeach ()
-  endforeach ()
-
-  list(APPEND OPENBLAS_SRC ${SRC_LIST_OUT})
-  set(OPENBLAS_SRC ${OPENBLAS_SRC} PARENT_SCOPE)
-endfunction ()
-
-# generates object files for each of the sources for each of the combinations of the preprocessor definitions passed in
-# @param sources_in the source files to build from
-# @param defines_in the preprocessor definitions that will be combined to create the object files
-# @param all_defines_in (optional) preprocessor definitions that will be applied to all objects
-# @param replace_scheme If 1, replace the "k" in the filename with the define combo letters. E.g. symm_k.c with TRANS and UNIT defined will be symm_TU.
-#                  If 0, it will simply append the code, e.g. symm_L.c with TRANS and UNIT will be symm_LTU.
-#                  If 2, it will append the code with an underscore, e.g. symm.c with TRANS and UNIT will be symm_TU.
-#                  If 3, it will insert the code *around* the last character with an underscore, e.g. symm_L.c with TRANS and UNIT will be symm_TLU (required by BLAS level2 objects).
-#                  If 4, it will insert the code before the last underscore. E.g. trtri_U_parallel with TRANS will be trtri_UT_parallel
-# @param alternate_name replaces the source name as the object name (define codes are still appended)
-# @param no_float_type turns off the float type define for this build (e.g. SINGLE/DOUBLE/etc)
-# @param complex_filename_scheme see GenerateNamedObjects
-function(GenerateCombinationObjects sources_in defines_in absent_codes_in all_defines_in replace_scheme)
-
-  set(alternate_name_in "")
-  if (DEFINED ARGV5)
-    set(alternate_name_in ${ARGV5})
-  endif ()
-
-  set(no_float_type false)
-  if (DEFINED ARGV6)
-    set(no_float_type ${ARGV6})
-  endif ()
-
-  set(complex_filename_scheme "")
-  if (DEFINED ARGV7)
-    set(complex_filename_scheme ${ARGV7})
-  endif ()
-
-  AllCombinations("${defines_in}" "${absent_codes_in}")
-  set(define_combos ${LIST_OUT})
-  set(define_codes ${CODES_OUT})
-
-  list(LENGTH define_combos num_combos)
-  math(EXPR num_combos "${num_combos} - 1")
-
-  foreach (c RANGE 0 ${num_combos})
-
-    list(GET define_combos ${c} define_combo)
-    list(GET define_codes ${c} define_code)
-
-    foreach (source_file ${sources_in})
-
-      set(alternate_name ${alternate_name_in})
-
-      # replace colon separated list with semicolons, this turns it into a CMake list that we can use foreach with
-      string(REPLACE ":" ";" define_combo ${define_combo})
-
-      # now add the object and set the defines
-      set(cur_defines ${define_combo})
-      if ("${cur_defines}" STREQUAL " ")
-        set(cur_defines ${all_defines_in})
-      else ()
-        list(APPEND cur_defines ${all_defines_in})
-      endif ()
-
-      set(replace_code "")
-      set(append_code "")
-      if (replace_scheme EQUAL 1)
-        set(replace_code ${define_code})
-      else ()
-        if (replace_scheme EQUAL 2)
-          set(append_code "_${define_code}")
-        elseif (replace_scheme EQUAL 3)
-          if ("${alternate_name}" STREQUAL "")
-            string(REGEX MATCH "[a-zA-Z]\\." last_letter ${source_file})
-          else ()
-            string(REGEX MATCH "[a-zA-Z]$" last_letter ${alternate_name})
-          endif ()
-          # first extract the last letter
-          string(SUBSTRING ${last_letter} 0 1 last_letter) # remove period from match
-          # break the code up into the first letter and the remaining (should only be 2 anyway)
-          string(SUBSTRING ${define_code} 0 1 define_code_first)
-          string(SUBSTRING ${define_code} 1 -1 define_code_second)
-          set(replace_code "${define_code_first}${last_letter}${define_code_second}")
-        elseif (replace_scheme EQUAL 4)
-          # insert code before the last underscore and pass that in as the alternate_name
-          if ("${alternate_name}" STREQUAL "")
-            get_filename_component(alternate_name ${source_file} NAME_WE)
-          endif ()
-          set(extra_underscore "")
-          # check if filename has two underscores, insert another if not (e.g. getrs_parallel needs to become getrs_U_parallel not getrsU_parallel)
-          string(REGEX MATCH "_[a-zA-Z]+_" underscores ${alternate_name})
-          string(LENGTH "${underscores}" underscores)
-          if (underscores EQUAL 0)
-            set(extra_underscore "_")
-          endif ()
-          string(REGEX REPLACE "(.+)(_[^_]+)$" "\\1${extra_underscore}${define_code}\\2" alternate_name ${alternate_name})
-        else()
-          set(append_code ${define_code}) # replace_scheme should be 0
-        endif ()
-      endif ()
-
-      GenerateNamedObjects("${source_file}" "${cur_defines}" "${alternate_name}" false "${replace_code}" "${append_code}" "${no_float_type}" "${complex_filename_scheme}")
-    endforeach ()
-  endforeach ()
-
-  set(OPENBLAS_SRC ${OPENBLAS_SRC} PARENT_SCOPE)
-endfunction ()
-

common.h

@@ -82,33 +82,19 @@ extern "C" {
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-
-#if !defined(_MSC_VER)
 #include <unistd.h>
-#elif _MSC_VER < 1900
-#define snprintf _snprintf
-#endif
-#include <time.h>
 
 #ifdef OS_LINUX
 #include <malloc.h>
 #include <sched.h>
 #endif
 
-#if defined(OS_DARWIN) || defined(OS_FREEBSD) || defined(OS_NETBSD) || defined(OS_OPENBSD) || defined(OS_DRAGONFLY) || defined(OS_ANDROID)
+#if defined(OS_DARWIN) || defined(OS_FREEBSD) || defined(OS_NETBSD)
 #include <sched.h>
 #endif
 
 #ifdef OS_ANDROID
 #define NO_SYSV_IPC
-//Android NDK only supports complex.h since Android 5.0
-#if __ANDROID_API__ < 21
-#define FORCE_OPENBLAS_COMPLEX_STRUCT
-#endif
-#endif
-
-#ifdef OS_HAIKU
-#define NO_SYSV_IPC
 #endif
 
 #ifdef OS_WINDOWS
@@ -128,10 +114,9 @@ extern "C" {
 #include <sys/shm.h>
 #endif
 #include <sys/time.h>
-#include <time.h>
 #include <unistd.h>
 #include <math.h>
-#if defined(SMP) || defined(USE_LOCKING)
+#ifdef SMP
 #include <pthread.h>
 #endif
 #endif
@@ -185,7 +170,7 @@ extern "C" {
 
 #define ALLOCA_ALIGN 63UL
 
-#define NUM_BUFFERS MAX(50,(MAX_CPU_NUMBER * 2 * MAX_PARALLEL_NUMBER))
+#define NUM_BUFFERS (MAX_CPU_NUMBER * 2)
 
 #ifdef NEEDBUNDERSCORE
 #define BLASFUNC(FUNC) FUNC##_
@@ -200,7 +185,7 @@ extern "C" {
 #error "You can't specify both LOCK operation!"
 #endif
 
-#if defined(SMP) || defined(USE_LOCKING)
+#ifdef SMP
 #define USE_PTHREAD_LOCK
 #undef	USE_PTHREAD_SPINLOCK
 #endif
@@ -259,14 +244,8 @@ typedef unsigned long BLASULONG;
 
 #ifdef USE64BITINT
 typedef BLASLONG blasint;
-#if defined(OS_WINDOWS) && defined(__64BIT__)
-#define blasabs(x) llabs(x)
-#else
-#define blasabs(x) labs(x)
-#endif
 #else
 typedef int blasint;
-#define blasabs(x) abs(x)
 #endif
 #else
 #ifdef USE64BITINT
@@ -297,6 +276,11 @@ typedef int blasint;
 #define SIZE	8
 #define  BASE_SHIFT 3
 #define ZBASE_SHIFT 4
+#elif defined(INTEGER) //extend for integer matrix
+#define FLOAT	int
+#define SIZE    4
+#define  BASE_SHIFT 2
+#define ZBASE_SHIFT 3
 #else
 #define FLOAT	float
 #define SIZE    4
@@ -314,6 +298,13 @@ typedef int blasint;
 #define COMPSIZE  2
 #endif
 
+#if defined(C_PGI) || defined(C_SUN)
+#define CREAL(X)	(*((FLOAT *)&X + 0))
+#define CIMAG(X)	(*((FLOAT *)&X + 1))
+#else
+#define CREAL	__real__
+#define CIMAG	__imag__
+#endif
 
 #define Address_H(x) (((x)+(1<<15))>>16)
 #define Address_L(x) ((x)-((Address_H(x))<<16))
@@ -327,12 +318,8 @@ typedef int blasint;
 #endif
 
 #if defined(OS_WINDOWS)
-#if defined(_MSC_VER) && !defined(__clang__)
-#define YIELDING    YieldProcessor()
-#else
 #define YIELDING	SwitchToThread()
 #endif
-#endif
 
 #if defined(ARMV7) || defined(ARMV6) || defined(ARMV8) || defined(ARMV5)
 #define YIELDING        asm volatile ("nop;nop;nop;nop;nop;nop;nop;nop; \n");
@@ -344,25 +331,12 @@ typedef int blasint;
 #endif
 #endif
 
-#ifdef POWER8
-#ifndef YIELDING
-#define YIELDING        __asm__ __volatile__ ("nop;nop;nop;nop;nop;nop;nop;nop;\n");
-#endif
-#endif
 
-#ifdef POWER9
-#ifndef YIELDING
-#define YIELDING        __asm__ __volatile__ ("nop;nop;nop;nop;nop;nop;nop;nop;\n");
-#endif
-#endif
-
-/*
 #ifdef PILEDRIVER
 #ifndef YIELDING
 #define YIELDING        __asm__ __volatile__ ("nop;nop;nop;nop;nop;nop;nop;nop;\n");
 #endif
 #endif
-*/
 
 /*
 #ifdef STEAMROLLER
@@ -421,10 +395,6 @@ please https://github.com/xianyi/OpenBLAS/issues/246
 #include "common_sparc.h"
 #endif
 
-#ifdef ARCH_MIPS
-#include "common_mips.h"
-#endif
-
 #ifdef ARCH_MIPS64
 #include "common_mips64.h"
 #endif
@@ -437,69 +407,16 @@ please https://github.com/xianyi/OpenBLAS/issues/246
 #include "common_arm64.h"
 #endif
 
-#ifdef ARCH_ZARCH
-#include "common_zarch.h"
-#endif
-
 #ifndef ASSEMBLER
-#ifdef OS_WINDOWSSTORE
+#ifdef OS_WINDOWS
 typedef char env_var_t[MAX_PATH];
-#define readenv(p, n) 0
-#else
-#if defined(OS_WINDOWS) && !defined(OS_CYGWIN_NT)
-typedef char env_var_t[MAX_PATH];
-#define readenv(p, n) GetEnvironmentVariable((LPCTSTR)(n), (LPTSTR)(p), sizeof(p))
+#define readenv(p, n) GetEnvironmentVariable((n), (p), sizeof(p))
 #else
 typedef char* env_var_t;
 #define readenv(p, n) ((p)=getenv(n))
 #endif
 #endif
 
-#if !defined(RPCC_DEFINED) && !defined(OS_WINDOWS)
-#ifdef _POSIX_MONOTONIC_CLOCK
-#if defined(__GLIBC_PREREQ) // cut the if condition if two lines, otherwise will fail at __GLIBC_PREREQ(2, 17)
-#if __GLIBC_PREREQ(2, 17) // don't require -lrt
-#define USE_MONOTONIC
-#endif
-#elif defined(OS_ANDROID)
-#define USE_MONOTONIC
-#endif
-#endif
-/* use similar scale as x86 rdtsc for timeouts to work correctly */
-static inline unsigned long long rpcc(void){
-#ifdef USE_MONOTONIC
-  struct timespec ts;
-  clock_gettime(CLOCK_MONOTONIC, &ts);
-  return (unsigned long long)ts.tv_sec * 1000000000ull + ts.tv_nsec;
-#else
-  struct timeval tv;
-  gettimeofday(&tv,NULL);
-  return (unsigned long long)tv.tv_sec * 1000000000ull + tv.tv_usec * 1000;
-#endif
-}
-#define RPCC_DEFINED
-#define RPCC64BIT
-#endif // !RPCC_DEFINED
-
-#if !defined(BLAS_LOCK_DEFINED) && defined(__GNUC__)
-static void __inline blas_lock(volatile BLASULONG *address){
-
-  do {
-    while (*address) {YIELDING;};
-
-  } while (!__sync_bool_compare_and_swap(address, 0, 1));
-}
-#define BLAS_LOCK_DEFINED
-#endif
-
-#ifndef RPCC_DEFINED
-#error "rpcc() implementation is missing for your platform"
-#endif
-#ifndef BLAS_LOCK_DEFINED
-#error "blas_lock() implementation is missing for your platform"
-#endif
-#endif // !ASSEMBLER
-
 #ifdef OS_LINUX
 #include "common_linux.h"
 #endif
@@ -512,33 +429,6 @@ static void __inline blas_lock(volatile BLASULONG *address){
 #define MMAP_POLICY (MAP_PRIVATE | MAP_ANONYMOUS)
 #endif
 
-#ifndef ASSEMBLER
-/* C99 supports complex floating numbers natively, which GCC also offers as an
-   extension since version 3.0.  If neither are available, use a compatible
-   structure as fallback (see Clause 6.2.5.13 of the C99 standard). */
-#if ((defined(__STDC_IEC_559_COMPLEX__) || __STDC_VERSION__ >= 199901L || \
-      (__GNUC__ >= 3 && !defined(__cplusplus))) && !(defined(FORCE_OPENBLAS_COMPLEX_STRUCT))) && !defined(_MSC_VER)
-  #define OPENBLAS_COMPLEX_C99
-  #ifndef __cplusplus
-    #include <complex.h>
-  #endif
-  typedef float _Complex openblas_complex_float;
-  typedef double _Complex openblas_complex_double;
-  typedef xdouble _Complex openblas_complex_xdouble;
-  #define openblas_make_complex_float(real, imag)    ((real) + ((imag) * _Complex_I))
-  #define openblas_make_complex_double(real, imag)   ((real) + ((imag) * _Complex_I))
-  #define openblas_make_complex_xdouble(real, imag)  ((real) + ((imag) * _Complex_I))
-#else
-  #define OPENBLAS_COMPLEX_STRUCT
-  typedef struct { float real, imag; } openblas_complex_float;
-  typedef struct { double real, imag; } openblas_complex_double;
-  typedef struct { xdouble real, imag; } openblas_complex_xdouble;
-  #define openblas_make_complex_float(real, imag)    {(real), (imag)}
-  #define openblas_make_complex_double(real, imag)   {(real), (imag)}
-  #define openblas_make_complex_xdouble(real, imag)  {(real), (imag)}
-#endif
-#endif
-
 #include "param.h"
 #include "common_param.h"
 
@@ -568,35 +458,21 @@ static void __inline blas_lock(volatile BLASULONG *address){
 #include <stdio.h>
 #endif  // NOINCLUDE
 
-#ifdef XDOUBLE
-#define OPENBLAS_COMPLEX_FLOAT openblas_complex_xdouble
-#define OPENBLAS_MAKE_COMPLEX_FLOAT(r,i) openblas_make_complex_xdouble(r,i)
-#elif defined(DOUBLE)
-#define OPENBLAS_COMPLEX_FLOAT openblas_complex_double
-#define OPENBLAS_MAKE_COMPLEX_FLOAT(r,i) openblas_make_complex_double(r,i)
+/* C99 supports complex floating numbers natively, which GCC also offers as an
+   extension since version 3.0.  If neither are available, use a compatible
+   structure as fallback (see Clause 6.2.5.13 of the C99 standard). */
+#if (defined(__STDC_IEC_559_COMPLEX__) || __STDC_VERSION__ >= 199901L || \
+     (__GNUC__ >= 3 && !defined(__cplusplus)))
+  #define OPENBLAS_COMPLEX_C99
+  typedef float _Complex openblas_complex_float;
+  typedef double _Complex openblas_complex_double;
+  typedef xdouble _Complex openblas_complex_xdouble;
 #else
-#define OPENBLAS_COMPLEX_FLOAT openblas_complex_float
-#define OPENBLAS_MAKE_COMPLEX_FLOAT(r,i) openblas_make_complex_float(r,i)
+  #define OPENBLAS_COMPLEX_STRUCT
+  typedef struct { float real, imag; } openblas_complex_float;
+  typedef struct { double real, imag; } openblas_complex_double;
+  typedef struct { xdouble real, imag; } openblas_complex_xdouble;
 #endif
-
-#if defined(C_PGI) || defined(C_SUN)
-  #if defined(__STDC_IEC_559_COMPLEX__)
-     #define CREAL(X)   creal(X)
-     #define CIMAG(X)   cimag(X)
-  #else
-     #define CREAL(X)	(*((FLOAT *)&X + 0))
-     #define CIMAG(X)	(*((FLOAT *)&X + 1))
-  #endif
-#else
-#ifdef OPENBLAS_COMPLEX_STRUCT
-#define CREAL(Z)	((Z).real)
-#define CIMAG(Z)	((Z).imag)
-#else
-#define CREAL	__real__
-#define CIMAG	__imag__
-#endif
-#endif
-
 #endif  // ASSEMBLER
 
 #ifndef IFLUSH
@@ -613,10 +489,6 @@ static void __inline blas_lock(volatile BLASULONG *address){
 #endif
 #endif
 
-#if defined(C_MSVC)
-#define inline __inline
-#endif
-
 #ifndef ASSEMBLER
 
 #ifndef MIN
@@ -659,29 +531,8 @@ void gotoblas_profile_init(void);
 void gotoblas_profile_quit(void);
 
 #ifdef USE_OPENMP
-
-#ifndef C_MSVC
 int omp_in_parallel(void);
 int omp_get_num_procs(void);
-#else
-__declspec(dllimport) int __cdecl omp_in_parallel(void);
-__declspec(dllimport) int __cdecl omp_get_num_procs(void);
-#endif
-
-#if (__STDC_VERSION__ >= 201112L)
-#if defined(C_GCC) && ( __GNUC__ < 7) 
-// workaround for GCC bug 65467
-#ifndef _Atomic
-#define _Atomic volatile
-#endif
-#endif
-#include <stdatomic.h>
-#else
-#ifndef _Atomic
-#define _Atomic volatile
-#endif
-#endif
-
 #else
 #ifdef __ELF__
 int omp_in_parallel  (void) __attribute__ ((weak));
@@ -694,11 +545,7 @@ static __inline void blas_unlock(volatile BLASULONG *address){
   *address = 0;
 }
 
-#ifdef OS_WINDOWSSTORE
-static __inline int readenv_atoi(char *env) {
-	return 0;
-}
-#else
+
 #ifdef OS_WINDOWS
 static __inline int readenv_atoi(char *env) {
   env_var_t p;
@@ -713,7 +560,7 @@ static __inline int readenv_atoi(char *env) {
 	return(0);
 }
 #endif
-#endif
+
 
 #if !defined(XDOUBLE) || !defined(QUAD_PRECISION)
 
@@ -797,7 +644,6 @@ typedef struct {
 #endif
 
 #ifndef ASSEMBLER
-#include "common_stackalloc.h"
 #if 0
 #include "symcopy.h"
 #endif

common_alpha.h

@@ -76,7 +76,6 @@ static void __inline blas_lock(unsigned long *address){
     "30:", address);
 #endif
 }
-#define BLAS_LOCK_DEFINED
 
 static __inline unsigned int rpcc(void){
 
@@ -90,7 +89,6 @@ static __inline unsigned int rpcc(void){
 
   return r0;
 }
-#define RPCC_DEFINED
 
 
 #define HALT 	ldq	$0, 0($0)

common_arm.h

@@ -51,8 +51,6 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSEMBLER
 
-#if defined(ARMV6) || defined(ARMV7) || defined(ARMV8)
-
 static void __inline blas_lock(volatile BLASULONG *address){
 
   int register ret;
@@ -61,29 +59,40 @@ static void __inline blas_lock(volatile BLASULONG *address){
     while (*address) {YIELDING;};
 
     __asm__ __volatile__(
-                         "ldrex r2, [%1]      \n\t"
-                         "strex %0, %2, [%1]  \n\t"
-                         "orr   %0, r2        \n\t"
-                         : "=&r"(ret)
-                         : "r"(address), "r"(1)
-                         : "memory", "r2"
+			 "1:								\n\t"
+                         "ldrex r2, [%1]                                                \n\t"
+                         "mov   r2, #0                                                  \n\t"
+                         "strex r3, r2, [%1]                                            \n\t"
+			 "cmp	r3, #0							\n\t"
+			 "bne	1b							\n\t"
+			 "mov	%0 , r3							\n\t"
+                         : "=r"(ret), "=r"(address)
+                         : "1"(address)
+                         : "memory", "r2" , "r3"
+
+
     );
 
   } while (ret);
-  MB;
+
 }
 
-#define BLAS_LOCK_DEFINED
-#endif
+
+static inline unsigned long long rpcc(void){
+  unsigned long long ret=0;
+  double v;
+  struct timeval tv;
+  gettimeofday(&tv,NULL);
+  v=(double) tv.tv_sec + (double) tv.tv_usec * 1e-6;
+  ret = (unsigned long long) ( v * 1000.0d );
+  return ret;
+}
 
 static inline int blas_quickdivide(blasint x, blasint y){
   return x / y;
 }
 
-#if !defined(HAVE_VFP)
-/* no FPU, soft float */
-#define GET_IMAGE(res)
-#elif defined(DOUBLE)
+#if defined(DOUBLE)
 #define GET_IMAGE(res)  __asm__ __volatile__("vstr.f64 d1, %0" : "=m"(res) : : "memory")
 #else
 #define GET_IMAGE(res)  __asm__ __volatile__("vstr.f32 s1, %0" : "=m"(res) : : "memory")
@@ -105,6 +114,7 @@ static inline int blas_quickdivide(blasint x, blasint y){
 #define PROLOGUE \
 	.arm		 ;\
 	.global	REALNAME ;\
+	.func	REALNAME  ;\
 REALNAME:
 
 #define EPILOGUE
@@ -130,8 +140,4 @@ REALNAME:
 #define MAP_ANONYMOUS MAP_ANON
 #endif
 
-#if !defined(ARMV5) && !defined(ARMV6) && !defined(ARMV7) && !defined(ARMV8)
-#error "you must define ARMV5, ARMV6, ARMV7 or ARMV8"
-#endif
-
 #endif

common_arm64.h

@@ -39,58 +39,48 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #define INLINE inline
 
-#ifdef F_INTERFACE_FLANG
-#define RETURN_BY_STACK
-#else
 #define RETURN_BY_COMPLEX
-#endif
 
 #ifndef ASSEMBLER
 
-
 static void __inline blas_lock(volatile BLASULONG *address){
 
-  BLASULONG ret;
+  int register ret;
+  int register tmp;
 
   do {
     while (*address) {YIELDING;};
 
     __asm__ __volatile__(
-			 "mov	x4, #1							\n\t"
                          "1:                                                            \n\t"
-                         "ldaxr x2, [%1]                                                \n\t"
-                         "cbnz  x2, 1b                                                  \n\t"
-			 "2:								\n\t"
-                         "stxr  w3, x4, [%1]                                            \n\t"
-                         "cbnz  w3, 1b                                                  \n\t"
-                         "mov   %0, #0                                                  \n\t"
-                         : "=r"(ret), "=r"(address)
+                         "ldaxr %2, [%1]                                                \n\t"
+                         "mov   %2, #0                                                  \n\t"
+                         "stlxr %w0, %2, [%1]                                            \n\t"
+                         "cbnz  %w0, 1b                                                  \n\t"
+			 "mov   %0 , #0                                                  \n\t"
+                         : "=r"(ret), "=r"(address), "=r"(tmp)
                          : "1"(address)
-                         : "memory", "x2" , "x3", "x4"
+                         : "memory", "%w0"
+			   //, "%r2" , "%r3"
 
 
     );
 
-
   } while (ret);
 
 }
 
-#define BLAS_LOCK_DEFINED
-
-#if !defined(OS_DARWIN) && !defined (OS_ANDROID)
-static __inline BLASULONG rpcc(void){
-  BLASULONG ret = 0;
- 
-  __asm__ __volatile__ ("isb; mrs %0,cntvct_el0":"=r"(ret));
 
+static inline unsigned long long rpcc(void){
+  unsigned long long ret=0;
+  double v;
+  struct timeval tv;
+  gettimeofday(&tv,NULL);
+  v=(double) tv.tv_sec + (double) tv.tv_usec * 1e-6;
+  ret = (unsigned long long) ( v * 1000.0d );
   return ret;
 }
 
-#define RPCC_DEFINED
-#define RPCC64BIT
-#endif 
-
 static inline int blas_quickdivide(blasint x, blasint y){
   return x / y;
 }
@@ -114,16 +104,10 @@ static inline int blas_quickdivide(blasint x, blasint y){
 
 #if defined(ASSEMBLER) && !defined(NEEDPARAM)
 
-.macro PROLOGUE 
-	.text ;
-	.p2align 2 ;
-	.global	REALNAME ;
-#ifndef __APPLE__
-	.type	REALNAME, %function ;
-#endif
+#define PROLOGUE \
+	.global	REALNAME ;\
+	.func	REALNAME  ;\
 REALNAME:
-.endm
-
 
 #define EPILOGUE
 
@@ -139,11 +123,7 @@ REALNAME:
 #endif
 #define HUGE_PAGESIZE   ( 4 << 20)
 
-#if defined(CORTEXA57)
-#define BUFFER_SIZE     (20 << 20)
-#else
 #define BUFFER_SIZE     (16 << 20)
-#endif
 
 
 #define BASE_ADDRESS (START_ADDRESS - BUFFER_SIZE * MAX_CPU_NUMBER)

common_c.h

@@ -19,7 +19,6 @@
 #define	CDOTC_K			cdotc_k
 #define	CNRM2_K			cnrm2_k
 #define	CSCAL_K			cscal_k
-#define	CSUM_K			csum_k
 #define	CSWAP_K			cswap_k
 #define	CROT_K			csrot_k
 
@@ -221,15 +220,6 @@
 #define COMATCOPY_K_CTC         comatcopy_k_ctc
 #define COMATCOPY_K_RTC         comatcopy_k_rtc
 
-#define CIMATCOPY_K_CN          cimatcopy_k_cn
-#define CIMATCOPY_K_RN          cimatcopy_k_rn
-#define CIMATCOPY_K_CT          cimatcopy_k_ct
-#define CIMATCOPY_K_RT          cimatcopy_k_rt
-#define CIMATCOPY_K_CNC         cimatcopy_k_cnc
-#define CIMATCOPY_K_RNC         cimatcopy_k_rnc
-#define CIMATCOPY_K_CTC         cimatcopy_k_ctc
-#define CIMATCOPY_K_RTC         cimatcopy_k_rtc
-
 #define CGEADD_K                cgeadd_k 
 
 #else
@@ -250,7 +240,6 @@
 #define	CDOTC_K			gotoblas -> cdotc_k
 #define	CNRM2_K			gotoblas -> cnrm2_k
 #define	CSCAL_K			gotoblas -> cscal_k
-#define	CSUM_K			gotoblas -> csum_k
 #define	CSWAP_K			gotoblas -> cswap_k
 #define	CROT_K			gotoblas -> csrot_k
 
@@ -414,16 +403,6 @@
 #define COMATCOPY_K_RNC         gotoblas -> comatcopy_k_rnc
 #define COMATCOPY_K_CTC         gotoblas -> comatcopy_k_ctc
 #define COMATCOPY_K_RTC         gotoblas -> comatcopy_k_rtc
-
-#define CIMATCOPY_K_CN          gotoblas -> cimatcopy_k_cn
-#define CIMATCOPY_K_RN          gotoblas -> cimatcopy_k_rn
-#define CIMATCOPY_K_CT          gotoblas -> cimatcopy_k_ct
-#define CIMATCOPY_K_RT          gotoblas -> cimatcopy_k_rt
-#define CIMATCOPY_K_CNC         gotoblas -> cimatcopy_k_cnc
-#define CIMATCOPY_K_RNC         gotoblas -> cimatcopy_k_rnc
-#define CIMATCOPY_K_CTC         gotoblas -> cimatcopy_k_ctc
-#define CIMATCOPY_K_RTC         gotoblas -> cimatcopy_k_rtc
-
 #define CGEADD_K                gotoblas -> cgeadd_k 
 
 #endif

common_d.h

@@ -19,7 +19,6 @@
 #define	DDOTC_K			ddot_k
 #define	DNRM2_K			dnrm2_k
 #define	DSCAL_K			dscal_k
-#define	DSUM_K			dsum_k
 #define	DSWAP_K			dswap_k
 #define	DROT_K			drot_k
 
@@ -150,11 +149,6 @@
 #define DOMATCOPY_K_RN		domatcopy_k_rn
 #define DOMATCOPY_K_CT		domatcopy_k_ct
 #define DOMATCOPY_K_RT		domatcopy_k_rt
-
-#define DIMATCOPY_K_CN		dimatcopy_k_cn
-#define DIMATCOPY_K_RN		dimatcopy_k_rn
-#define DIMATCOPY_K_CT      dimatcopy_k_ct
-#define DIMATCOPY_K_RT      dimatcopy_k_rt
 #define DGEADD_K                dgeadd_k 
 
 #else
@@ -175,7 +169,6 @@
 #define	DDOTC_K			gotoblas -> ddot_k
 #define	DNRM2_K			gotoblas -> dnrm2_k
 #define	DSCAL_K			gotoblas -> dscal_k
-#define	DSUM_K			gotoblas -> dsum_k
 #define	DSWAP_K			gotoblas -> dswap_k
 #define	DROT_K			gotoblas -> drot_k
 
@@ -274,10 +267,6 @@
 #define DOMATCOPY_K_RN		gotoblas -> domatcopy_k_rn
 #define DOMATCOPY_K_CT		gotoblas -> domatcopy_k_ct
 #define DOMATCOPY_K_RT		gotoblas -> domatcopy_k_rt
-#define DIMATCOPY_K_CN		gotoblas -> dimatcopy_k_cn
-#define DIMATCOPY_K_RN		gotoblas -> dimatcopy_k_rn
-#define DIMATCOPY_K_CT		gotoblas -> dimatcopy_k_ct
-#define DIMATCOPY_K_RT		gotoblas -> dimatcopy_k_rt
 
 #define DGEADD_K                gotoblas -> dgeadd_k 
 

common_i.h

@@ -0,0 +1,9 @@
+#ifndef COMMON_I_H
+#define COMMON_I_H
+
+#ifndef DYNAMIC_ARCH
+#define	IAXPYU_K		iaxpy_k
+#else
+#error
+#endif
+#endif

common_ia64.h

@@ -68,7 +68,6 @@ static __inline void blas_lock(volatile unsigned long *address){
 			  : "ar.ccv", "memory");
   } while (ret);
 }
-#define BLAS_LOCK_DEFINED
 
 static __inline unsigned long rpcc(void) {
   unsigned long clocks;
@@ -76,7 +75,6 @@ static __inline unsigned long rpcc(void) {
   __asm__ __volatile__ ("mov %0=ar.itc" : "=r"(clocks));
   return clocks;
 }
-#define RPCC_DEFINED
 
 
 static __inline unsigned long stmxcsr(void){
@@ -101,12 +99,10 @@ static __inline void blas_lock(volatile unsigned long *address){
   while (*address || _InterlockedCompareExchange((volatile int *) address,1,0))
     ;
 }
-#define BLAS_LOCK_DEFINED
 
 static __inline unsigned int rpcc(void) {
   return __getReg(_IA64_REG_AR_ITC);
 }
-#define RPCC_DEFINED
 
 static __inline unsigned int stmxcsr(void) {
   return __getReg(_IA64_REG_AR_FPSR);

common_interface.h

@@ -93,6 +93,7 @@ openblas_complex_xdouble BLASFUNC(xdotc)  (blasint *, xdouble  *, blasint *, xdo
 
 void    BLASFUNC(saxpy) (blasint *, float  *, float  *, blasint *, float  *, blasint *);
 void    BLASFUNC(daxpy) (blasint *, double *, double *, blasint *, double *, blasint *);
+void    BLASFUNC(iaxpy) (blasint *, int  *, int  *, blasint *, int  *, blasint *);
 void    BLASFUNC(qaxpy) (blasint *, xdouble *, xdouble *, blasint *, xdouble *, blasint *);
 void    BLASFUNC(caxpy) (blasint *, float  *, float  *, blasint *, float  *, blasint *);
 void    BLASFUNC(zaxpy) (blasint *, double *, double *, blasint *, double *, blasint *);
@@ -122,13 +123,6 @@ xdouble BLASFUNC(qasum) (blasint *, xdouble *, blasint *);
 double BLASFUNC(dzasum)(blasint *, double *, blasint *);
 xdouble BLASFUNC(qxasum)(blasint *, xdouble *, blasint *);
 
-FLOATRET  BLASFUNC(ssum) (blasint *, float  *, blasint *);
-FLOATRET  BLASFUNC(scsum)(blasint *, float  *, blasint *);
-double BLASFUNC(dsum) (blasint *, double *, blasint *);
-xdouble BLASFUNC(qsum) (blasint *, xdouble *, blasint *);
-double BLASFUNC(dzsum)(blasint *, double *, blasint *);
-xdouble BLASFUNC(qxsum)(blasint *, xdouble *, blasint *);
-
 blasint    BLASFUNC(isamax)(blasint *, float  *, blasint *);
 blasint    BLASFUNC(idamax)(blasint *, double *, blasint *);
 blasint    BLASFUNC(iqamax)(blasint *, xdouble *, blasint *);

common_lapack.h

@@ -293,150 +293,4 @@ blasint zlarf_R(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLO
 blasint xlarf_L(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
 blasint xlarf_R(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
 
-blasint strtrs_UNU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_UNN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_UTU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_UTN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_LNU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_LNN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_LTU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_LTN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint dtrtrs_UNU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_UNN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_UTU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_UTN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_LNU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_LNN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_LTU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_LTN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint qtrtrs_UNU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_UNN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_UTU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_UTN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_LNU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_LNN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_LTU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_LTN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint ctrtrs_UNU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_UNN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_UTU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_UTN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_URU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_URN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_UCU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_UCN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LNU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LNN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LTU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LTN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LRU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LRN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LCU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LCN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ztrtrs_UNU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_UNN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_UTU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_UTN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_URU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_URN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_UCU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_UCN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LNU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LNN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LTU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LTN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LRU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LRN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LCU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LCN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint xtrtrs_UNU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_UNN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_UTU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_UTN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_URU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_URN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_UCU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_UCN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LNU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LNN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LTU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LTN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LRU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LRN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LCU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LCN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-
-blasint strtrs_UNU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_UNN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_UTU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_UTN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_LNU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_LNN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_LTU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint strtrs_LTN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint dtrtrs_UNU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_UNN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_UTU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_UTN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_LNU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_LNN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_LTU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint dtrtrs_LTN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint qtrtrs_UNU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_UNN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_UTU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_UTN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_LNU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_LNN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_LTU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint qtrtrs_LTN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint ctrtrs_UNU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_UNN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_UTU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_UTN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_URU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_URN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_UCU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_UCN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LNU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LNN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LTU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LTN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LRU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LRN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LCU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ctrtrs_LCN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG);
-blasint ztrtrs_UNU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_UNN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_UTU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_UTN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_URU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_URN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_UCU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_UCN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LNU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LNN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LTU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LTN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LRU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LRN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LCU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint ztrtrs_LCN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG);
-blasint xtrtrs_UNU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_UNN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_UTU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_UTN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_URU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_URN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_UCU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_UCN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LNU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LNN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LTU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LTN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LRU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LRN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LCU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-blasint xtrtrs_LCN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG);
-
 #endif

common_level1.h

@@ -47,12 +47,12 @@ double dsdot_k(BLASLONG, float   *, BLASLONG, float *, BLASLONG);
 double  ddot_k(BLASLONG, double  *, BLASLONG, double  *, BLASLONG);
 xdouble qdot_k(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
 
-openblas_complex_float cdotc_k (BLASLONG, float  *, BLASLONG, float  *, BLASLONG);
-openblas_complex_float cdotu_k (BLASLONG, float  *, BLASLONG, float  *, BLASLONG);
-openblas_complex_double zdotc_k (BLASLONG, double *, BLASLONG, double *, BLASLONG);
-openblas_complex_double zdotu_k (BLASLONG, double *, BLASLONG, double *, BLASLONG);
-openblas_complex_xdouble xdotc_k (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
-openblas_complex_xdouble xdotu_k (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
+float   _Complex cdotc_k (BLASLONG, float  *, BLASLONG, float  *, BLASLONG);
+float   _Complex cdotu_k (BLASLONG, float  *, BLASLONG, float  *, BLASLONG);
+double  _Complex zdotc_k (BLASLONG, double *, BLASLONG, double *, BLASLONG);
+double  _Complex zdotu_k (BLASLONG, double *, BLASLONG, double *, BLASLONG);
+xdouble _Complex xdotc_k (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
+xdouble _Complex xdotu_k (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
 
 int    saxpy_k (BLASLONG, BLASLONG, BLASLONG, float,
 	       float  *, BLASLONG, float  *, BLASLONG, float  *, BLASLONG);
@@ -60,6 +60,8 @@ int    daxpy_k (BLASLONG, BLASLONG, BLASLONG, double,
 	       double *, BLASLONG, double *, BLASLONG, double *, BLASLONG);
 int    qaxpy_k (BLASLONG, BLASLONG, BLASLONG, xdouble,
 	       xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
+int    iaxpy_k (BLASLONG, BLASLONG, BLASLONG, int,
+	       int  *, BLASLONG, int  *, BLASLONG, int  *, BLASLONG);
 int    caxpy_k (BLASLONG, BLASLONG, BLASLONG, float,  float,
 	       float  *, BLASLONG, float  *, BLASLONG, float  *, BLASLONG);
 int    zaxpy_k (BLASLONG, BLASLONG, BLASLONG, double, double,
@@ -100,13 +102,6 @@ float   casum_k (BLASLONG, float  *, BLASLONG);
 double  zasum_k (BLASLONG, double *, BLASLONG);
 xdouble xasum_k (BLASLONG, xdouble *, BLASLONG);
 
-float   ssum_k (BLASLONG, float  *, BLASLONG);
-double  dsum_k (BLASLONG, double *, BLASLONG);
-xdouble qsum_k (BLASLONG, xdouble *, BLASLONG);
-float   csum_k (BLASLONG, float  *, BLASLONG);
-double  zsum_k (BLASLONG, double *, BLASLONG);
-xdouble xsum_k (BLASLONG, xdouble *, BLASLONG);
-
 float   samax_k (BLASLONG, float  *, BLASLONG);
 double  damax_k (BLASLONG, double *, BLASLONG);
 xdouble qamax_k (BLASLONG, xdouble *, BLASLONG);

common_level3.h

@@ -47,14 +47,6 @@ __global__ void cuda_dgemm_kernel(int, int, int, double *, double *, double *);
 extern "C" {
 #endif
 
-extern void sgemm_kernel_direct(BLASLONG M, BLASLONG N, BLASLONG K,
-	float * A, BLASLONG strideA,
-	float * B, BLASLONG strideB,
-	float * R, BLASLONG strideR);
-
-extern int sgemm_kernel_direct_performant(BLASLONG M, BLASLONG N, BLASLONG K);
-
-
 int sgemm_beta(BLASLONG, BLASLONG, BLASLONG, float,
 	       float  *, BLASLONG, float   *, BLASLONG, float  *, BLASLONG);
 int dgemm_beta(BLASLONG, BLASLONG, BLASLONG, double,
@@ -1744,55 +1736,31 @@ int somatcopy_k_cn(BLASLONG, BLASLONG,  float, float *, BLASLONG, float  *, BLAS
 int somatcopy_k_rn(BLASLONG, BLASLONG,  float, float *, BLASLONG, float  *, BLASLONG);
 int somatcopy_k_ct(BLASLONG, BLASLONG,  float, float *, BLASLONG, float  *, BLASLONG);
 int somatcopy_k_rt(BLASLONG, BLASLONG,  float, float *, BLASLONG, float  *, BLASLONG);
-int simatcopy_k_cn(BLASLONG, BLASLONG,  float, float *, BLASLONG);
-int simatcopy_k_rn(BLASLONG, BLASLONG,  float, float *, BLASLONG);
-int simatcopy_k_ct(BLASLONG, BLASLONG,  float, float *, BLASLONG);
-int simatcopy_k_rt(BLASLONG, BLASLONG,  float, float *, BLASLONG);
 
 int domatcopy_k_cn(BLASLONG, BLASLONG,  double, double *, BLASLONG, double  *, BLASLONG);
 int domatcopy_k_rn(BLASLONG, BLASLONG,  double, double *, BLASLONG, double  *, BLASLONG);
 int domatcopy_k_ct(BLASLONG, BLASLONG,  double, double *, BLASLONG, double  *, BLASLONG);
 int domatcopy_k_rt(BLASLONG, BLASLONG,  double, double *, BLASLONG, double  *, BLASLONG);
-int dimatcopy_k_cn(BLASLONG, BLASLONG,  double, double *, BLASLONG);
-int dimatcopy_k_rn(BLASLONG, BLASLONG,  double, double *, BLASLONG);
-int dimatcopy_k_ct(BLASLONG, BLASLONG,  double, double *, BLASLONG);
-int dimatcopy_k_rt(BLASLONG, BLASLONG,  double, double *, BLASLONG);
 
 int comatcopy_k_cn(BLASLONG, BLASLONG,  float, float, float *, BLASLONG, float  *, BLASLONG);
 int comatcopy_k_rn(BLASLONG, BLASLONG,  float, float, float *, BLASLONG, float  *, BLASLONG);
 int comatcopy_k_ct(BLASLONG, BLASLONG,  float, float, float *, BLASLONG, float  *, BLASLONG);
 int comatcopy_k_rt(BLASLONG, BLASLONG,  float, float, float *, BLASLONG, float  *, BLASLONG);
-int cimatcopy_k_cn(BLASLONG, BLASLONG,  float, float, float *, BLASLONG);
-int cimatcopy_k_rn(BLASLONG, BLASLONG,  float, float, float *, BLASLONG);
-int cimatcopy_k_ct(BLASLONG, BLASLONG,  float, float, float *, BLASLONG);
-int cimatcopy_k_rt(BLASLONG, BLASLONG,  float, float, float *, BLASLONG);
 
 int comatcopy_k_cnc(BLASLONG, BLASLONG,  float, float, float *, BLASLONG, float  *, BLASLONG);
 int comatcopy_k_rnc(BLASLONG, BLASLONG,  float, float, float *, BLASLONG, float  *, BLASLONG);
 int comatcopy_k_ctc(BLASLONG, BLASLONG,  float, float, float *, BLASLONG, float  *, BLASLONG);
 int comatcopy_k_rtc(BLASLONG, BLASLONG,  float, float, float *, BLASLONG, float  *, BLASLONG);
-int cimatcopy_k_cnc(BLASLONG, BLASLONG,  float, float, float *, BLASLONG);
-int cimatcopy_k_rnc(BLASLONG, BLASLONG,  float, float, float *, BLASLONG);
-int cimatcopy_k_ctc(BLASLONG, BLASLONG,  float, float, float *, BLASLONG);
-int cimatcopy_k_rtc(BLASLONG, BLASLONG,  float, float, float *, BLASLONG);
 
 int zomatcopy_k_cn(BLASLONG, BLASLONG,  double, double, double *, BLASLONG, double  *, BLASLONG);
 int zomatcopy_k_rn(BLASLONG, BLASLONG,  double, double, double *, BLASLONG, double  *, BLASLONG);
 int zomatcopy_k_ct(BLASLONG, BLASLONG,  double, double, double *, BLASLONG, double  *, BLASLONG);
 int zomatcopy_k_rt(BLASLONG, BLASLONG,  double, double, double *, BLASLONG, double  *, BLASLONG);
-int zimatcopy_k_cn(BLASLONG, BLASLONG,  double, double, double *, BLASLONG);
-int zimatcopy_k_rn(BLASLONG, BLASLONG,  double, double, double *, BLASLONG);
-int zimatcopy_k_ct(BLASLONG, BLASLONG,  double, double, double *, BLASLONG);
-int zimatcopy_k_rt(BLASLONG, BLASLONG,  double, double, double *, BLASLONG);
 
 int zomatcopy_k_cnc(BLASLONG, BLASLONG,  double, double, double *, BLASLONG, double  *, BLASLONG);
 int zomatcopy_k_rnc(BLASLONG, BLASLONG,  double, double, double *, BLASLONG, double  *, BLASLONG);
 int zomatcopy_k_ctc(BLASLONG, BLASLONG,  double, double, double *, BLASLONG, double  *, BLASLONG);
 int zomatcopy_k_rtc(BLASLONG, BLASLONG,  double, double, double *, BLASLONG, double  *, BLASLONG);
-int zimatcopy_k_cnc(BLASLONG, BLASLONG,  double, double, double *, BLASLONG);
-int zimatcopy_k_rnc(BLASLONG, BLASLONG,  double, double, double *, BLASLONG);
-int zimatcopy_k_ctc(BLASLONG, BLASLONG,  double, double, double *, BLASLONG);
-int zimatcopy_k_rtc(BLASLONG, BLASLONG,  double, double, double *, BLASLONG);
 
 int sgeadd_k(BLASLONG, BLASLONG, float, float*, BLASLONG, float, float *, BLASLONG); 
 int dgeadd_k(BLASLONG, BLASLONG, double, double*, BLASLONG, double, double *, BLASLONG); 

common_linux.h

@@ -70,7 +70,7 @@ extern long int syscall (long int __sysno, ...);
 static inline int my_mbind(void *addr, unsigned long len, int mode,
 			   unsigned long *nodemask, unsigned long maxnode,
 			   unsigned flags) {
-#if defined (__LSB_VERSION__) || defined(ARCH_ZARCH)
+#if defined (__LSB_VERSION__)
 // So far,  LSB (Linux Standard Base) don't support syscall().
 // https://lsbbugs.linuxfoundation.org/show_bug.cgi?id=3482
         return 0;
@@ -90,7 +90,7 @@ static inline int my_mbind(void *addr, unsigned long len, int mode,
 }
 
 static inline int my_set_mempolicy(int mode, const unsigned long *addr, unsigned long flag) {
-#if defined (__LSB_VERSION__) || defined(ARCH_ZARCH)
+#if defined (__LSB_VERSION__)
 // So far,  LSB (Linux Standard Base) don't support syscall().
 // https://lsbbugs.linuxfoundation.org/show_bug.cgi?id=3482
   return 0;

common_macro.h

@@ -47,6 +47,10 @@
 #include "common_z.h"
 #include "common_x.h"
 
+#ifdef INTEGER_PRECISION
+#include "common_i.h"
+#endif
+
 #ifndef COMPLEX
 #ifdef XDOUBLE
 
@@ -66,7 +70,6 @@
 #define	DOTC_K			QDOTC_K
 #define	NRM2_K			QNRM2_K
 #define	SCAL_K			QSCAL_K
-#define	SUM_K			QSUM_K
 #define	SWAP_K			QSWAP_K
 #define	ROT_K			QROT_K
 
@@ -357,7 +360,6 @@
 #define	DOTC_K			DDOTC_K
 #define	NRM2_K			DNRM2_K
 #define	SCAL_K			DSCAL_K
-#define	SUM_K			DSUM_K
 #define	SWAP_K			DSWAP_K
 #define	ROT_K			DROT_K
 
@@ -636,12 +638,10 @@
 #define OMATCOPY_K_RN		DOMATCOPY_K_RN
 #define OMATCOPY_K_CT		DOMATCOPY_K_CT
 #define OMATCOPY_K_RT		DOMATCOPY_K_RT
-#define IMATCOPY_K_CN		DIMATCOPY_K_CN
-#define IMATCOPY_K_RN		DIMATCOPY_K_RN
-#define IMATCOPY_K_CT		DIMATCOPY_K_CT
-#define IMATCOPY_K_RT		DIMATCOPY_K_RT
+#define GEADD_K                 DGEADD_K 
 
-#define GEADD_K                 DGEADD_K
+#elif defined(INTEGER)
+#define AXPYU_K                 IAXPYU_K
 #else
 
 #define	AMAX_K			SAMAX_K
@@ -660,7 +660,6 @@
 #define	DOTC_K			SDOTC_K
 #define	NRM2_K			SNRM2_K
 #define	SCAL_K			SSCAL_K
-#define	SUM_K			SSUM_K
 #define	SWAP_K			SSWAP_K
 #define	ROT_K			SROT_K
 
@@ -939,12 +938,8 @@
 #define OMATCOPY_K_RN		SOMATCOPY_K_RN
 #define OMATCOPY_K_CT		SOMATCOPY_K_CT
 #define OMATCOPY_K_RT		SOMATCOPY_K_RT
-#define IMATCOPY_K_CN		SIMATCOPY_K_CN
-#define IMATCOPY_K_RN		SIMATCOPY_K_RN
-#define IMATCOPY_K_CT		SIMATCOPY_K_CT
-#define IMATCOPY_K_RT		SIMATCOPY_K_RT
 
-#define GEADD_K 		SGEADD_K
+#define GEADD_K 		SGEADD_K 
 #endif
 #else
 #ifdef XDOUBLE
@@ -965,7 +960,6 @@
 #define	DOTC_K			XDOTC_K
 #define	NRM2_K			XNRM2_K
 #define	SCAL_K			XSCAL_K
-#define	SUM_K			XSUM_K
 #define	SWAP_K			XSWAP_K
 #define	ROT_K			XROT_K
 
@@ -1367,7 +1361,6 @@
 #define	DOTC_K			ZDOTC_K
 #define	NRM2_K			ZNRM2_K
 #define	SCAL_K			ZSCAL_K
-#define	SUM_K			ZSUM_K
 #define	SWAP_K			ZSWAP_K
 #define	ROT_K			ZROT_K
 
@@ -1761,16 +1754,7 @@
 #define OMATCOPY_K_RNC		ZOMATCOPY_K_RNC
 #define OMATCOPY_K_CTC		ZOMATCOPY_K_CTC
 #define OMATCOPY_K_RTC		ZOMATCOPY_K_RTC
-#define IMATCOPY_K_CN		ZIMATCOPY_K_CN
-#define IMATCOPY_K_RN		ZIMATCOPY_K_RN
-#define IMATCOPY_K_CT		ZIMATCOPY_K_CT
-#define IMATCOPY_K_RT		ZIMATCOPY_K_RT
-#define IMATCOPY_K_CNC		ZIMATCOPY_K_CNC
-#define IMATCOPY_K_RNC		ZIMATCOPY_K_RNC
-#define IMATCOPY_K_CTC		ZIMATCOPY_K_CTC
-#define IMATCOPY_K_RTC		ZIMATCOPY_K_RTC
-
-#define GEADD_K                 ZGEADD_K
+#define GEADD_K                 ZGEADD_K 
 
 #else
 
@@ -1790,7 +1774,6 @@
 #define	DOTC_K			CDOTC_K
 #define	NRM2_K			CNRM2_K
 #define	SCAL_K			CSCAL_K
-#define	SUM_K			CSUM_K
 #define	SWAP_K			CSWAP_K
 #define	ROT_K			CROT_K
 
@@ -2184,22 +2167,14 @@
 #define OMATCOPY_K_RNC		COMATCOPY_K_RNC
 #define OMATCOPY_K_CTC		COMATCOPY_K_CTC
 #define OMATCOPY_K_RTC		COMATCOPY_K_RTC
-#define IMATCOPY_K_CN		CIMATCOPY_K_CN
-#define IMATCOPY_K_RN		CIMATCOPY_K_RN
-#define IMATCOPY_K_CT		CIMATCOPY_K_CT
-#define IMATCOPY_K_RT		CIMATCOPY_K_RT
-#define IMATCOPY_K_CNC		CIMATCOPY_K_CNC
-#define IMATCOPY_K_RNC		CIMATCOPY_K_RNC
-#define IMATCOPY_K_CTC		CIMATCOPY_K_CTC
-#define IMATCOPY_K_RTC		CIMATCOPY_K_RTC
 
-#define GEADD_K                 CGEADD_K
+#define GEADD_K                 CGEADD_K 
 
 #endif
 #endif
 
 #ifndef ASSEMBLER
-#if defined(ARCH_X86) || defined(ARCH_X86_64) || defined(ARCH_IA64) || defined(ARCH_MIPS64) || defined(ARCH_ARM64)
+#if defined(ARCH_X86) || defined(ARCH_X86_64) || defined(ARCH_IA64) || defined(ARCH_MIPS64)
 extern BLASLONG gemm_offset_a;
 extern BLASLONG gemm_offset_b;
 extern BLASLONG sgemm_p;
@@ -2806,160 +2781,3 @@ typedef struct {
 #endif
 
 #endif
-
-#ifndef COMPLEX
-#ifdef XDOUBLE
-#define  TRTRS_UNU_SINGLE  qtrtrs_UNU_single
-#define  TRTRS_UNN_SINGLE  qtrtrs_UNN_single
-#define  TRTRS_UTU_SINGLE  qtrtrs_UTU_single
-#define  TRTRS_UTN_SINGLE  qtrtrs_UTN_single
-#define  TRTRS_LNU_SINGLE  qtrtrs_LNU_single
-#define  TRTRS_LNN_SINGLE  qtrtrs_LNN_single
-#define  TRTRS_LTU_SINGLE  qtrtrs_LTU_single
-#define  TRTRS_LTN_SINGLE  qtrtrs_LTN_single
-#define  TRTRS_UNU_PARALLEL  qtrtrs_UNU_parallel
-#define  TRTRS_UNN_PARALLEL  qtrtrs_UNN_parallel
-#define  TRTRS_UTU_PARALLEL  qtrtrs_UTU_parallel
-#define  TRTRS_UTN_PARALLEL  qtrtrs_UTN_parallel
-#define  TRTRS_LNU_PARALLEL  qtrtrs_LNU_parallel
-#define  TRTRS_LNN_PARALLEL  qtrtrs_LNN_parallel
-#define  TRTRS_LTU_PARALLEL  qtrtrs_LTU_parallel
-#define  TRTRS_LTN_PARALLEL  qtrtrs_LTN_parallel
-
-#elif defined(DOUBLE)
-#define  TRTRS_UNU_SINGLE  dtrtrs_UNU_single
-#define  TRTRS_UNN_SINGLE  dtrtrs_UNN_single
-#define  TRTRS_UTU_SINGLE  dtrtrs_UTU_single
-#define  TRTRS_UTN_SINGLE  dtrtrs_UTN_single
-#define  TRTRS_LNU_SINGLE  dtrtrs_LNU_single
-#define  TRTRS_LNN_SINGLE  dtrtrs_LNN_single
-#define  TRTRS_LTU_SINGLE  dtrtrs_LTU_single
-#define  TRTRS_LTN_SINGLE  dtrtrs_LTN_single
-#define  TRTRS_UNU_PARALLEL  dtrtrs_UNU_parallel
-#define  TRTRS_UNN_PARALLEL  dtrtrs_UNN_parallel
-#define  TRTRS_UTU_PARALLEL  dtrtrs_UTU_parallel
-#define  TRTRS_UTN_PARALLEL  dtrtrs_UTN_parallel
-#define  TRTRS_LNU_PARALLEL  dtrtrs_LNU_parallel
-#define  TRTRS_LNN_PARALLEL  dtrtrs_LNN_parallel
-#define  TRTRS_LTU_PARALLEL  dtrtrs_LTU_parallel
-#define  TRTRS_LTN_PARALLEL  dtrtrs_LTN_parallel
-#else
-#define  TRTRS_UNU_SINGLE  strtrs_UNU_single
-#define  TRTRS_UNN_SINGLE  strtrs_UNN_single
-#define  TRTRS_UTU_SINGLE  strtrs_UTU_single
-#define  TRTRS_UTN_SINGLE  strtrs_UTN_single
-#define  TRTRS_LNU_SINGLE  strtrs_LNU_single
-#define  TRTRS_LNN_SINGLE  strtrs_LNN_single
-#define  TRTRS_LTU_SINGLE  strtrs_LTU_single
-#define  TRTRS_LTN_SINGLE  strtrs_LTN_single
-#define  TRTRS_UNU_PARALLEL  strtrs_UNU_parallel
-#define  TRTRS_UNN_PARALLEL  strtrs_UNN_parallel
-#define  TRTRS_UTU_PARALLEL  strtrs_UTU_parallel
-#define  TRTRS_UTN_PARALLEL  strtrs_UTN_parallel
-#define  TRTRS_LNU_PARALLEL  strtrs_LNU_parallel
-#define  TRTRS_LNN_PARALLEL  strtrs_LNN_parallel
-#define  TRTRS_LTU_PARALLEL  strtrs_LTU_parallel
-#define  TRTRS_LTN_PARALLEL  strtrs_LTN_parallel
-#endif
-#else
-#ifdef XDOUBLE
-#define  TRTRS_UNU_SINGLE  xtrtrs_UNU_single
-#define  TRTRS_UNN_SINGLE  xtrtrs_UNN_single
-#define  TRTRS_UTU_SINGLE  xtrtrs_UTU_single
-#define  TRTRS_UTN_SINGLE  xtrtrs_UTN_single
-#define  TRTRS_URU_SINGLE  xtrtrs_URU_single
-#define  TRTRS_URN_SINGLE  xtrtrs_URN_single
-#define  TRTRS_UCU_SINGLE  xtrtrs_UCU_single
-#define  TRTRS_UCN_SINGLE  xtrtrs_UCN_single
-#define  TRTRS_LNU_SINGLE  xtrtrs_LNU_single
-#define  TRTRS_LNN_SINGLE  xtrtrs_LNN_single
-#define  TRTRS_LTU_SINGLE  xtrtrs_LTU_single
-#define  TRTRS_LTN_SINGLE  xtrtrs_LTN_single
-#define  TRTRS_LRU_SINGLE  xtrtrs_LRU_single
-#define  TRTRS_LRN_SINGLE  xtrtrs_LRN_single
-#define  TRTRS_LCU_SINGLE  xtrtrs_LCU_single
-#define  TRTRS_LCN_SINGLE  xtrtrs_LCN_single
-#define  TRTRS_UNU_PARALLEL  xtrtrs_UNU_parallel
-#define  TRTRS_UNN_PARALLEL  xtrtrs_UNN_parallel
-#define  TRTRS_UTU_PARALLEL  xtrtrs_UTU_parallel
-#define  TRTRS_UTN_PARALLEL  xtrtrs_UTN_parallel
-#define  TRTRS_URU_PARALLEL  xtrtrs_URU_parallel
-#define  TRTRS_URN_PARALLEL  xtrtrs_URN_parallel
-#define  TRTRS_UCU_PARALLEL  xtrtrs_UCU_parallel
-#define  TRTRS_UCN_PARALLEL  xtrtrs_UCN_parallel
-#define  TRTRS_LNU_PARALLEL  xtrtrs_LNU_parallel
-#define  TRTRS_LNN_PARALLEL  xtrtrs_LNN_parallel
-#define  TRTRS_LTU_PARALLEL  xtrtrs_LTU_parallel
-#define  TRTRS_LTN_PARALLEL  xtrtrs_LTN_parallel
-#define  TRTRS_LRU_PARALLEL  xtrtrs_LRU_parallel
-#define  TRTRS_LRN_PARALLEL  xtrtrs_LRN_parallel
-#define  TRTRS_LCU_PARALLEL  xtrtrs_LCU_parallel
-#define  TRTRS_LCN_PARALLEL  xtrtrs_LCN_parallel
-#elif defined(DOUBLE)
-#define  TRTRS_UNU_SINGLE  ztrtrs_UNU_single
-#define  TRTRS_UNN_SINGLE  ztrtrs_UNN_single
-#define  TRTRS_UTU_SINGLE  ztrtrs_UTU_single
-#define  TRTRS_UTN_SINGLE  ztrtrs_UTN_single
-#define  TRTRS_URU_SINGLE  ztrtrs_URU_single
-#define  TRTRS_URN_SINGLE  ztrtrs_URN_single
-#define  TRTRS_UCU_SINGLE  ztrtrs_UCU_single
-#define  TRTRS_UCN_SINGLE  ztrtrs_UCN_single
-#define  TRTRS_LNU_SINGLE  ztrtrs_LNU_single
-#define  TRTRS_LNN_SINGLE  ztrtrs_LNN_single
-#define  TRTRS_LTU_SINGLE  ztrtrs_LTU_single
-#define  TRTRS_LTN_SINGLE  ztrtrs_LTN_single
-#define  TRTRS_LRU_SINGLE  ztrtrs_LRU_single
-#define  TRTRS_LRN_SINGLE  ztrtrs_LRN_single
-#define  TRTRS_LCU_SINGLE  ztrtrs_LCU_single
-#define  TRTRS_LCN_SINGLE  ztrtrs_LCN_single
-#define  TRTRS_UNU_PARALLEL  ztrtrs_UNU_parallel
-#define  TRTRS_UNN_PARALLEL  ztrtrs_UNN_parallel
-#define  TRTRS_UTU_PARALLEL  ztrtrs_UTU_parallel
-#define  TRTRS_UTN_PARALLEL  ztrtrs_UTN_parallel
-#define  TRTRS_URU_PARALLEL  ztrtrs_URU_parallel
-#define  TRTRS_URN_PARALLEL  ztrtrs_URN_parallel
-#define  TRTRS_UCU_PARALLEL  ztrtrs_UCU_parallel
-#define  TRTRS_UCN_PARALLEL  ztrtrs_UCN_parallel
-#define  TRTRS_LNU_PARALLEL  ztrtrs_LNU_parallel
-#define  TRTRS_LNN_PARALLEL  ztrtrs_LNN_parallel
-#define  TRTRS_LTU_PARALLEL  ztrtrs_LTU_parallel
-#define  TRTRS_LTN_PARALLEL  ztrtrs_LTN_parallel
-#define  TRTRS_LRU_PARALLEL  ztrtrs_LRU_parallel
-#define  TRTRS_LRN_PARALLEL  ztrtrs_LRN_parallel
-#define  TRTRS_LCU_PARALLEL  ztrtrs_LCU_parallel
-#define  TRTRS_LCN_PARALLEL  ztrtrs_LCN_parallel
-#else
-#define  TRTRS_UNU_SINGLE  ctrtrs_UNU_single
-#define  TRTRS_UNN_SINGLE  ctrtrs_UNN_single
-#define  TRTRS_UTU_SINGLE  ctrtrs_UTU_single
-#define  TRTRS_UTN_SINGLE  ctrtrs_UTN_single
-#define  TRTRS_URU_SINGLE  ctrtrs_URU_single
-#define  TRTRS_URN_SINGLE  ctrtrs_URN_single
-#define  TRTRS_UCU_SINGLE  ctrtrs_UCU_single
-#define  TRTRS_UCN_SINGLE  ctrtrs_UCN_single
-#define  TRTRS_LNU_SINGLE  ctrtrs_LNU_single
-#define  TRTRS_LNN_SINGLE  ctrtrs_LNN_single
-#define  TRTRS_LTU_SINGLE  ctrtrs_LTU_single
-#define  TRTRS_LTN_SINGLE  ctrtrs_LTN_single
-#define  TRTRS_LRU_SINGLE  ctrtrs_LRU_single
-#define  TRTRS_LRN_SINGLE  ctrtrs_LRN_single
-#define  TRTRS_LCU_SINGLE  ctrtrs_LCU_single
-#define  TRTRS_LCN_SINGLE  ctrtrs_LCN_single
-#define  TRTRS_UNU_PARALLEL  ctrtrs_UNU_parallel
-#define  TRTRS_UNN_PARALLEL  ctrtrs_UNN_parallel
-#define  TRTRS_UTU_PARALLEL  ctrtrs_UTU_parallel
-#define  TRTRS_UTN_PARALLEL  ctrtrs_UTN_parallel
-#define  TRTRS_URU_PARALLEL  ctrtrs_URU_parallel
-#define  TRTRS_URN_PARALLEL  ctrtrs_URN_parallel
-#define  TRTRS_UCU_PARALLEL  ctrtrs_UCU_parallel
-#define  TRTRS_UCN_PARALLEL  ctrtrs_UCN_parallel
-#define  TRTRS_LNU_PARALLEL  ctrtrs_LNU_parallel
-#define  TRTRS_LNN_PARALLEL  ctrtrs_LNN_parallel
-#define  TRTRS_LTU_PARALLEL  ctrtrs_LTU_parallel
-#define  TRTRS_LTN_PARALLEL  ctrtrs_LTN_parallel
-#define  TRTRS_LRU_PARALLEL  ctrtrs_LRU_parallel
-#define  TRTRS_LRN_PARALLEL  ctrtrs_LRN_parallel
-#define  TRTRS_LCU_PARALLEL  ctrtrs_LCU_parallel
-#define  TRTRS_LCN_PARALLEL  ctrtrs_LCN_parallel
-#endif
-#endif

common_mips.h

@@ -1,103 +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 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.
-**********************************************************************************/
-
-#ifndef COMMON_MIPS
-#define COMMON_MIPS
-
-#define MB  __sync_synchronize()
-#define WMB __sync_synchronize()
-
-#define INLINE inline
-
-#define RETURN_BY_COMPLEX
-
-#ifndef ASSEMBLER
-
-static inline unsigned int rpcc(void){
-  unsigned long ret;
-
-  __asm__ __volatile__(".set   push    \n"
-          "rdhwr %0, $30  \n"
-          ".set pop" : "=r"(ret) : : "memory");
-
-  return ret;
-}
-#define RPCC_DEFINED
-
-static inline int blas_quickdivide(blasint x, blasint y){
-  return x / y;
-}
-
-#define GET_IMAGE(res)
-
-#define GET_IMAGE_CANCEL
-
-#endif
-
-
-#ifndef F_INTERFACE
-#define REALNAME ASMNAME
-#else
-#define REALNAME ASMFNAME
-#endif
-
-#if defined(ASSEMBLER) && !defined(NEEDPARAM)
-
-#define PROLOGUE \
-	.arm		 ;\
-	.global	REALNAME ;\
-REALNAME:
-
-#define EPILOGUE
-
-#define PROFCODE
-
-#endif
-
-
-#define SEEK_ADDRESS
-
-#ifndef PAGESIZE
-#define PAGESIZE        ( 4 << 10)
-#endif
-#define HUGE_PAGESIZE   ( 4 << 20)
-
-#define BUFFER_SIZE     (16 << 20)
-
-
-#define BASE_ADDRESS (START_ADDRESS - BUFFER_SIZE * MAX_CPU_NUMBER)
-
-#ifndef MAP_ANONYMOUS
-#define MAP_ANONYMOUS MAP_ANON
-#endif
-
-#endif

common_mips64.h

@@ -71,16 +71,37 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef COMMON_MIPS64
 #define COMMON_MIPS64
 
-#define MB  __sync_synchronize()
-#define WMB __sync_synchronize()
+#define MB
+#define WMB
 
 #define INLINE inline
 
 #ifndef ASSEMBLER
 
+static void INLINE blas_lock(volatile unsigned long *address){
+
+  long int ret, val = 1;
+
+  do {
+    while (*address) {YIELDING;};
+
+    __asm__ __volatile__(
+			 "1:	ll	%0, %3\n"
+			 "	ori	%2, %0, 1\n"
+			 "	sc	%2, %1\n"
+			 "	beqz	%2, 1b\n"
+			 "	 andi	%2, %0, 1\n"
+			 "	sync\n"
+			 : "=&r" (val), "=m" (address), "=&r" (ret)
+			 : "m" (address)
+			 : "memory");
+
+  } while (ret);
+}
+
 static inline unsigned int rpcc(void){
   unsigned long ret;
-
+#if defined(LOONGSON3A) || defined(LOONGSON3B)
   //  unsigned long long tmp;
   //__asm__ __volatile__("dmfc0 %0, $25, 1": "=r"(tmp):: "memory");
   //ret=tmp;
@@ -89,12 +110,18 @@ static inline unsigned int rpcc(void){
                        "rdhwr %0, $2\n"
                        ".set pop": "=r"(ret):: "memory");
 
+#else
+  __asm__ __volatile__(".set   push    \n"
+          ".set   mips32r2\n"
+          "rdhwr %0, $30  \n"
+          ".set pop" : "=r"(ret) : : "memory");
+#endif
   return ret;
 }
-#define RPCC_DEFINED
 
+#if defined(LOONGSON3A) || defined(LOONGSON3B)
 #ifndef NO_AFFINITY
-//#define WHEREAMI
+#define WHEREAMI
 static inline int WhereAmI(void){
   int ret=0;
   __asm__ __volatile__(".set push \n"
@@ -105,6 +132,7 @@ static inline int WhereAmI(void){
 
 }
 #endif
+#endif
 
 static inline int blas_quickdivide(blasint x, blasint y){
   return x / y;

common_param.h

@@ -63,7 +63,6 @@ BLASLONG (*ismin_k) (BLASLONG, float *, BLASLONG);
 
   float  (*snrm2_k) (BLASLONG, float *, BLASLONG);
   float  (*sasum_k) (BLASLONG, float *, BLASLONG);
-  float  (*ssum_k)  (BLASLONG, float *, BLASLONG);
   int    (*scopy_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG);
   float  (*sdot_k)  (BLASLONG, float *, BLASLONG, float *, BLASLONG);
   double (*dsdot_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG);
@@ -155,7 +154,6 @@ BLASLONG (*idmin_k) (BLASLONG, double *, BLASLONG);
 
   double (*dnrm2_k) (BLASLONG, double *, BLASLONG);
   double (*dasum_k) (BLASLONG, double *, BLASLONG);
-  double (*dsum_k)  (BLASLONG, double *, BLASLONG);
   int    (*dcopy_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG);
   double (*ddot_k)  (BLASLONG, double *, BLASLONG, double *, BLASLONG);
   int    (*drot_k)  (BLASLONG, double *, BLASLONG, double *, BLASLONG, double, double);
@@ -247,7 +245,6 @@ BLASLONG (*iqmin_k) (BLASLONG, xdouble *, BLASLONG);
 
  xdouble (*qnrm2_k) (BLASLONG, xdouble *, BLASLONG);
  xdouble (*qasum_k) (BLASLONG, xdouble *, BLASLONG);
- xdouble (*qsum_k)  (BLASLONG, xdouble *, BLASLONG);
   int    (*qcopy_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
  xdouble (*qdot_k)  (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
   int    (*qrot_k)  (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble, xdouble);
@@ -335,10 +332,9 @@ BLASLONG (*icamin_k)(BLASLONG, float *, BLASLONG);
 
   float (*cnrm2_k) (BLASLONG, float *, BLASLONG);
   float (*casum_k) (BLASLONG, float *, BLASLONG);
-  float (*csum_k)  (BLASLONG, float *, BLASLONG);
   int    (*ccopy_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG);
-  openblas_complex_float (*cdotu_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG);
-  openblas_complex_float (*cdotc_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG);
+  float _Complex (*cdotu_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG);
+  float _Complex (*cdotc_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG);
   int    (*csrot_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG, float, float);
 
   int    (*caxpy_k) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG);
@@ -499,10 +495,9 @@ BLASLONG (*izamin_k)(BLASLONG, double *, BLASLONG);
 
   double (*znrm2_k) (BLASLONG, double *, BLASLONG);
   double (*zasum_k) (BLASLONG, double *, BLASLONG);
-  double (*zsum_k)  (BLASLONG, double *, BLASLONG);
   int    (*zcopy_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG);
-  openblas_complex_double (*zdotu_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG);
-  openblas_complex_double (*zdotc_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG);
+  double _Complex (*zdotu_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG);
+  double _Complex (*zdotc_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG);
   int    (*zdrot_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG, double, double);
 
   int    (*zaxpy_k) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG);
@@ -665,10 +660,9 @@ BLASLONG (*ixamin_k)(BLASLONG, xdouble *, BLASLONG);
 
   xdouble (*xnrm2_k) (BLASLONG, xdouble *, BLASLONG);
   xdouble (*xasum_k) (BLASLONG, xdouble *, BLASLONG);
-  xdouble (*xsum_k) (BLASLONG, xdouble *, BLASLONG);
   int    (*xcopy_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
-  openblas_complex_xdouble (*xdotu_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
-  openblas_complex_xdouble (*xdotc_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
+  xdouble _Complex (*xdotu_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
+  xdouble _Complex (*xdotc_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
   int    (*xqrot_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble, xdouble);
 
   int    (*xaxpy_k) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG);
@@ -861,40 +855,10 @@ BLASLONG (*ixamin_k)(BLASLONG, xdouble *, BLASLONG);
   int    (*zomatcopy_k_rnc)	(BLASLONG, BLASLONG, double, double, double*, BLASLONG, double*, BLASLONG);
   int    (*zomatcopy_k_rtc)	(BLASLONG, BLASLONG, double, double, double*, BLASLONG, double*, BLASLONG);
 
-  int    (*simatcopy_k_cn)	(BLASLONG, BLASLONG, float, float*, BLASLONG);
-  int    (*simatcopy_k_ct)	(BLASLONG, BLASLONG, float, float*, BLASLONG);
-  int    (*simatcopy_k_rn)	(BLASLONG, BLASLONG, float, float*, BLASLONG);
-  int    (*simatcopy_k_rt)	(BLASLONG, BLASLONG, float, float*, BLASLONG);
-
-  int    (*dimatcopy_k_cn)	(BLASLONG, BLASLONG, double, double*, BLASLONG);
-  int    (*dimatcopy_k_ct)	(BLASLONG, BLASLONG, double, double*, BLASLONG);
-  int    (*dimatcopy_k_rn)	(BLASLONG, BLASLONG, double, double*, BLASLONG);
-  int    (*dimatcopy_k_rt)	(BLASLONG, BLASLONG, double, double*, BLASLONG);
-
-  int    (*cimatcopy_k_cn)	(BLASLONG, BLASLONG, float, float, float*, BLASLONG);
-  int    (*cimatcopy_k_ct)	(BLASLONG, BLASLONG, float, float, float*, BLASLONG);
-  int    (*cimatcopy_k_rn)	(BLASLONG, BLASLONG, float, float, float*, BLASLONG);
-  int    (*cimatcopy_k_rt)	(BLASLONG, BLASLONG, float, float, float*, BLASLONG);
-
-  int    (*cimatcopy_k_cnc)	(BLASLONG, BLASLONG, float, float, float*, BLASLONG);
-  int    (*cimatcopy_k_ctc)	(BLASLONG, BLASLONG, float, float, float*, BLASLONG);
-  int    (*cimatcopy_k_rnc)	(BLASLONG, BLASLONG, float, float, float*, BLASLONG);
-  int    (*cimatcopy_k_rtc)	(BLASLONG, BLASLONG, float, float, float*, BLASLONG);
-
-  int    (*zimatcopy_k_cn)	(BLASLONG, BLASLONG, double, double, double*, BLASLONG);
-  int    (*zimatcopy_k_ct)	(BLASLONG, BLASLONG, double, double, double*, BLASLONG);
-  int    (*zimatcopy_k_rn)	(BLASLONG, BLASLONG, double, double, double*, BLASLONG);
-  int    (*zimatcopy_k_rt)	(BLASLONG, BLASLONG, double, double, double*, BLASLONG);
-
-  int    (*zimatcopy_k_cnc)	(BLASLONG, BLASLONG, double, double, double*, BLASLONG);
-  int    (*zimatcopy_k_ctc)	(BLASLONG, BLASLONG, double, double, double*, BLASLONG);
-  int    (*zimatcopy_k_rnc)	(BLASLONG, BLASLONG, double, double, double*, BLASLONG);
-  int    (*zimatcopy_k_rtc)	(BLASLONG, BLASLONG, double, double, double*, BLASLONG);
-
   int    (*sgeadd_k) (BLASLONG, BLASLONG, float, float *, BLASLONG, float, float *, BLASLONG); 
   int    (*dgeadd_k) (BLASLONG, BLASLONG, double, double *, BLASLONG, double, double *, BLASLONG); 
   int    (*cgeadd_k) (BLASLONG, BLASLONG, float, float,  float *,  BLASLONG, float, float, float *, BLASLONG); 
-  int    (*zgeadd_k) (BLASLONG, BLASLONG, double, double, double *, BLASLONG, double, double, double *, BLASLONG); 
+  int    (*zgeadd_k) (BLASLONG, BLASLONG, float, double, double *, BLASLONG, double, double, double *, BLASLONG); 
 
 } gotoblas_t;
 

common_power.h

@@ -39,42 +39,8 @@
 #ifndef COMMON_POWER
 #define COMMON_POWER
 
-#define str(x)	#x
-
-#ifdef OS_AIX
-#define XXSPLTD(T,A,z)	xxpermdi	T, A, A, 0b##z##z
-#define XXMRGHD(T,A,B)	xxpermdi	T, A, B, 0b00
-#define XXMRGLD(T,A,B)	xxpermdi	T, A, B, 0b11
-#define XXSWAPD(T,A)	xxpermdi	T, A, A, 0b10
-#define XVMOVDP(T,A)	xvcpsgndp	T, A, A
-
-#define XXSPLTD_S(T,A,z)	"xxpermdi	" str(T) ", " str(A) ", " str(A) ", 0b" str(z ## z) "	\n\t"
-#define XXMRGHD_S(T,A,B)	"xxpermdi	" str(T) ", " str(A) ", " str(B) ", 0b00	\n\t"
-#define XXMRGLD_S(T,A,B)	"xxpermdi	" str(T) ", " str(A) ", " str(B) ", 0b11	\n\t"
-#define XXSWAPD_S(T,A)	"xxpermdi	" str(T) ", " str(A) ", " str(A) ", 0b10	\n\t"
-
-#else
-#define XXSPLTD(T,A,z)	xxspltd	T, A, z
-#define XXMRGHD(T,A,B)	xxmrghd	T, A, B
-#define XXMRGLD(T,A,B)	xxmrgld	T, A, B
-#define XXSWAPD(T,A)	xxswapd	T, A
-#define XVMOVDP(T,A)	xvmovdp	T, A
-
-#define XXSPLTD_S(T,A,z)	"xxspltd	" str(T) ", " str(A) ", " str(z)"	\n\t"
-#define XXMRGHD_S(T,A,B)	"xxmrghd	" str(T) ", " str(A) ", " str(B)"	\n\t"
-#define XXMRGLD_S(T,A,B)	"xxmrgld	" str(T) ", " str(A) ", " str(B)"	\n\t"
-#define XXSWAPD_S(T,A)	"xxswapd	" str(T) ", " str(A) "	\n\t"
-
-#endif
-
-
-#if defined(POWER8) || defined(POWER9)
-#define MB		__asm__ __volatile__ ("eieio":::"memory")
-#define WMB		__asm__ __volatile__ ("eieio":::"memory")
-#else
 #define MB		__asm__ __volatile__ ("sync")
 #define WMB		__asm__ __volatile__ ("sync")
-#endif
 
 #define INLINE inline
 
@@ -121,7 +87,6 @@ static void INLINE blas_lock(volatile unsigned long *address){
 #endif
   } while (ret);
 }
-#define BLAS_LOCK_DEFINED
 
 static inline unsigned long rpcc(void){
   unsigned long ret;
@@ -138,7 +103,6 @@ static inline unsigned long rpcc(void){
 #endif
 
 }
-#define RPCC_DEFINED
 
 #ifdef __64BIT__
 #define RPCC64BIT
@@ -270,7 +234,7 @@ static inline int blas_quickdivide(blasint x, blasint y){
 #define HAVE_PREFETCH
 #endif
 
-#if defined(POWER3) || defined(POWER6) || defined(PPCG4) || defined(CELL) || defined(POWER8) || defined(POWER9) || defined(PPC970)
+#if defined(POWER3) || defined(POWER6) || defined(PPCG4) || defined(CELL)
 #define DCBT_ARG	0
 #else
 #define DCBT_ARG	8
@@ -292,13 +256,6 @@ static inline int blas_quickdivide(blasint x, blasint y){
 #define L1_PREFETCH	dcbtst
 #endif
 
-#if defined(POWER8) || defined(POWER9)
-#define L1_DUALFETCH
-#define L1_PREFETCHSIZE (16 + 128 * 100)
-#define L1_PREFETCH	dcbtst
-#endif
-
-#
 #ifndef L1_PREFETCH
 #define L1_PREFETCH	dcbt
 #endif
@@ -528,7 +485,7 @@ static inline int blas_quickdivide(blasint x, blasint y){
 
 #if defined(ASSEMBLER) && !defined(NEEDPARAM)
 
-#if defined(OS_LINUX) || defined(OS_FREEBSD)
+#ifdef OS_LINUX
 #ifndef __64BIT__
 #define PROLOGUE \
 	.section .text;\
@@ -538,15 +495,6 @@ static inline int blas_quickdivide(blasint x, blasint y){
 REALNAME:
 #define EPILOGUE	.size	REALNAME, .-REALNAME
 #else
-#if _CALL_ELF == 2
-#define PROLOGUE \
-	.section .text;\
-	.align 6;\
-	.globl	REALNAME;\
-	.type	REALNAME, @function;\
-REALNAME:
-#define EPILOGUE	.size	REALNAME, .-REALNAME
-#else
 #define PROLOGUE \
 	.section .text;\
 	.align 5;\
@@ -566,7 +514,6 @@ REALNAME:;\
 	.size	.REALNAME, .-.REALNAME; \
 	.section	.note.GNU-stack,"",@progbits
 #endif
-#endif
 
 #ifdef PROFILE
 #ifndef __64BIT__
@@ -627,14 +574,9 @@ REALNAME:;\
 #ifndef __64BIT__
 #define PROLOGUE \
 	.machine "any";\
-	.toc;\
 	.globl .REALNAME;\
-	.globl REALNAME;\
-	.csect REALNAME[DS],3;\
-REALNAME:;\
-	.long .REALNAME, TOC[tc0], 0;\
 	.csect .text[PR],5;\
-.REALNAME:
+.REALNAME:;
 
 #define EPILOGUE \
 _section_.text:;\
@@ -645,14 +587,9 @@ _section_.text:;\
 
 #define PROLOGUE \
 	.machine "any";\
-	.toc;\
 	.globl .REALNAME;\
-	.globl REALNAME;\
-	.csect REALNAME[DS],3;\
-REALNAME:;\
-	.llong .REALNAME, TOC[tc0], 0;\
 	.csect .text[PR], 5;\
-.REALNAME:
+.REALNAME:;
 
 #define EPILOGUE \
 _section_.text:;\
@@ -813,7 +750,7 @@ Lmcount$lazy_ptr:
 
 #define HALT		mfspr	r0, 1023
 
-#if defined(OS_LINUX) || defined(OS_FREEBSD)
+#ifdef OS_LINUX
 #if defined(PPC440) || defined(PPC440FP2)
 #undef  MAX_CPU_NUMBER
 #define MAX_CPU_NUMBER 1
@@ -841,8 +778,6 @@ Lmcount$lazy_ptr:
 #define BUFFER_SIZE     (  2 << 20)
 #elif defined(PPC440FP2)
 #define BUFFER_SIZE     ( 16 << 20)
-#elif defined(POWER8) || defined(POWER9)
-#define BUFFER_SIZE     ( 64 << 20)
 #else
 #define BUFFER_SIZE     ( 16 << 20)
 #endif
@@ -857,25 +792,4 @@ Lmcount$lazy_ptr:
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
 #endif
-
-#if defined(OS_LINUX) || defined(OS_FREEBSD)
-#ifndef __64BIT__
-#define FRAMESLOT(X) (((X) * 4) + 8)
-#else
-#if _CALL_ELF == 2
-#define FRAMESLOT(X) (((X) * 8) + 96)
-#else
-#define FRAMESLOT(X) (((X) * 8) + 112)
-#endif
-#endif
-#endif
-
-#if defined(OS_AIX) || defined(OS_DARWIN)
-#ifndef __64BIT__
-#define FRAMESLOT(X) (((X) * 4) + 56)
-#else
-#define FRAMESLOT(X) (((X) * 8) + 112)
-#endif
-#endif
-
 #endif

common_q.h

@@ -19,7 +19,6 @@
 #define	QDOTC_K			qdot_k
 #define	QNRM2_K			qnrm2_k
 #define	QSCAL_K			qscal_k
-#define	QSUM_K			qsum_k
 #define	QSWAP_K			qswap_k
 #define	QROT_K			qrot_k
 
@@ -162,7 +161,6 @@
 #define	QDOTC_K			gotoblas -> qdot_k
 #define	QNRM2_K			gotoblas -> qnrm2_k
 #define	QSCAL_K			gotoblas -> qscal_k
-#define	QSUM_K			gotoblas -> qsum_k
 #define	QSWAP_K			gotoblas -> qswap_k
 #define	QROT_K			gotoblas -> qrot_k
 

common_s.h

@@ -12,7 +12,6 @@
 #define	ISMAX_K			ismax_k
 #define	ISMIN_K			ismin_k
 #define	SASUM_K			sasum_k
-#define	SSUM_K			ssum_k
 #define	SAXPYU_K		saxpy_k
 #define	SAXPYC_K		saxpy_k
 #define	SCOPY_K			scopy_k
@@ -153,10 +152,6 @@
 #define SOMATCOPY_K_RN          somatcopy_k_rn
 #define SOMATCOPY_K_CT          somatcopy_k_ct
 #define SOMATCOPY_K_RT          somatcopy_k_rt
-#define SIMATCOPY_K_CN          simatcopy_k_cn
-#define SIMATCOPY_K_RN          simatcopy_k_rn
-#define SIMATCOPY_K_CT          simatcopy_k_ct
-#define SIMATCOPY_K_RT          simatcopy_k_rt
 
 #define SGEADD_K                sgeadd_k 
 
@@ -171,7 +166,6 @@
 #define	ISMAX_K			gotoblas -> ismax_k
 #define	ISMIN_K			gotoblas -> ismin_k
 #define	SASUM_K			gotoblas -> sasum_k
-#define	SSUM_K			gotoblas -> ssum_k
 #define	SAXPYU_K		gotoblas -> saxpy_k
 #define	SAXPYC_K		gotoblas -> saxpy_k
 #define	SCOPY_K			gotoblas -> scopy_k
@@ -280,10 +274,6 @@
 #define SOMATCOPY_K_RN          gotoblas -> somatcopy_k_rn
 #define SOMATCOPY_K_CT          gotoblas -> somatcopy_k_ct
 #define SOMATCOPY_K_RT          gotoblas -> somatcopy_k_rt
-#define SIMATCOPY_K_CN          gotoblas -> simatcopy_k_cn
-#define SIMATCOPY_K_RN          gotoblas -> simatcopy_k_rn
-#define SIMATCOPY_K_CT          gotoblas -> simatcopy_k_ct
-#define SIMATCOPY_K_RT          gotoblas -> simatcopy_k_rt
 
 #define SGEADD_K                gotoblas -> sgeadd_k 
 

common_sparc.h

@@ -58,7 +58,6 @@ static void __inline blas_lock(volatile unsigned long *address){
 			 : "memory");
   } while (ret);
 }
-#define BLAS_LOCK_DEFINED
 
 static __inline unsigned long rpcc(void){
   unsigned long clocks;
@@ -67,7 +66,6 @@ static __inline unsigned long rpcc(void){
 
   return clocks;
 };
-#define RPCC_DEFINED
 
 #ifdef __64BIT__
 #define RPCC64BIT

common_stackalloc.h

@@ -1,74 +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.
-*******************************************************************************/
-
-#define STACK_ALLOC_PROTECT
-#ifdef STACK_ALLOC_PROTECT
-// Try to detect stack smashing
-#include <assert.h>
-#define STACK_ALLOC_PROTECT_SET volatile int stack_check = 0x7fc01234;
-#define STACK_ALLOC_PROTECT_CHECK assert(stack_check == 0x7fc01234);
-#else
-#define STACK_ALLOC_PROTECT_SET
-#define STACK_ALLOC_PROTECT_CHECK
-#endif
-
-#if defined(MAX_STACK_ALLOC) && MAX_STACK_ALLOC > 0
-
-/*
- * Allocate a buffer on the stack if the size is smaller than MAX_STACK_ALLOC.
- * Stack allocation is much faster than blas_memory_alloc or malloc, particularly
- * when OpenBLAS is used from a multi-threaded application.
- * SIZE must be carefully chosen to be:
- * - as small as possible to maximize the number of stack allocation
- * - large enough to support all architectures and kernel
- * Choosing a SIZE too small will lead to a stack smashing.
- */
-#define STACK_ALLOC(SIZE, TYPE, BUFFER)                                        \
-  /* make it volatile because some function (ex: dgemv_n.S) */                 \
-  /* do not restore all register */                                            \
-  volatile int stack_alloc_size = SIZE;                                        \
-  if (stack_alloc_size > MAX_STACK_ALLOC / sizeof(TYPE)) stack_alloc_size = 0; \
-  STACK_ALLOC_PROTECT_SET                                                      \
-  /* Avoid declaring an array of length 0 */                                   \
-  TYPE stack_buffer[stack_alloc_size ? stack_alloc_size : 1]                   \
-      __attribute__((aligned(0x20)));                                          \
-  BUFFER = stack_alloc_size ? stack_buffer : (TYPE *)blas_memory_alloc(1);
-#else
-  //Original OpenBLAS/GotoBLAS codes.
-  #define STACK_ALLOC(SIZE, TYPE, BUFFER) BUFFER = (TYPE *)blas_memory_alloc(1)
-#endif
-
-
-#if defined(MAX_STACK_ALLOC) && MAX_STACK_ALLOC > 0
-#define STACK_FREE(BUFFER)    \
-  STACK_ALLOC_PROTECT_CHECK   \
-  if(!stack_alloc_size)       \
-    blas_memory_free(BUFFER);
-#else
-#define STACK_FREE(BUFFER) blas_memory_free(BUFFER)
-#endif
-

common_thread.h

@@ -65,6 +65,7 @@ extern int blas_omp_linked;
 #define BLAS_XDOUBLE	0x0002U
 #define BLAS_REAL	0x0000U
 #define BLAS_COMPLEX	0x0004U
+#define BLAS_INTEGER    0x0008U
 
 #define BLAS_TRANSA	0x0030U	/* 2bit */
 #define BLAS_TRANSA_N	0x0000U
@@ -194,6 +195,10 @@ int trsm_thread(int mode, BLASLONG m, BLASLONG n,
 
 int syrk_thread(int mode, blas_arg_t *, BLASLONG *, BLASLONG *, int (*function)(), void *, void *, BLASLONG);
 
+int beta_thread(int mode, BLASLONG m, BLASLONG n,
+		double alpha_r, double alpha_i,
+		void *c, BLASLONG ldc, int (*fuction)());
+
 int getrf_thread(int mode, BLASLONG m, BLASLONG n, BLASLONG k,
 		 void *offsetA, BLASLONG lda,
 		 void *offsetB, BLASLONG jb,

common_x.h

@@ -19,7 +19,6 @@
 #define	XDOTC_K			xdotc_k
 #define	XNRM2_K			xnrm2_k
 #define	XSCAL_K			xscal_k
-#define	XSUM_K			xsum_k
 #define	XSWAP_K			xswap_k
 #define	XROT_K			xqrot_k
 
@@ -228,7 +227,6 @@
 #define	XDOTC_K			gotoblas -> xdotc_k
 #define	XNRM2_K			gotoblas -> xnrm2_k
 #define	XSCAL_K			gotoblas -> xscal_k
-#define	XSUM_K			gotoblas -> xsum_k
 #define	XSWAP_K			gotoblas -> xswap_k
 #define	XROT_K			gotoblas -> xqrot_k
 

common_x86.h

@@ -41,10 +41,6 @@
 
 #ifndef ASSEMBLER
 
-#ifdef C_MSVC
-#include <intrin.h>
-#endif
-
 #define MB
 #define WMB
 
@@ -60,67 +56,41 @@ static void __inline blas_lock(volatile BLASULONG *address){
   do {
     while (*address) {YIELDING;};
 
-#if defined(_MSC_VER) && !defined(__clang__)
-	// use intrinsic instead of inline assembly
-	ret = _InterlockedExchange((volatile LONG *)address, 1);
-	// inline assembly
-	/*__asm {
-		mov eax, address
-		mov ebx, 1
-		xchg [eax], ebx
-		mov ret, ebx
-	}*/
-#else
     __asm__ __volatile__(
 			 "xchgl %0, %1\n"
 			 : "=r"(ret), "=m"(*address)
 			 : "0"(1), "m"(*address)
 			 : "memory");
-#endif
 
   } while (ret);
 
 }
-#define BLAS_LOCK_DEFINED
 
 static __inline unsigned long long rpcc(void){
-#if defined(_MSC_VER) && !defined(__clang__)
-  return __rdtsc(); // use MSVC intrinsic
-#else
   unsigned int a, d;
 
   __asm__ __volatile__ ("rdtsc" : "=a" (a), "=d" (d));
 
   return ((unsigned long long)a + ((unsigned long long)d << 32));
-#endif
 };
-#define RPCC_DEFINED
 
 static __inline unsigned long getstackaddr(void){
-#if defined(_MSC_VER) && !defined(__clang__)
-  return (unsigned long)_ReturnAddress(); // use MSVC intrinsic
-#else
   unsigned long addr;
 
   __asm__ __volatile__ ("mov %%esp, %0"
 			 : "=r"(addr) : : "memory");
 
   return addr;
-#endif
 };
 
 
 static __inline long double sqrt_long(long double val) {
-#if defined(_MSC_VER) && !defined(__clang__)
-  return sqrt(val); // not sure if this will use fsqrt
-#else
   long double result;
 
   __asm__ __volatile__ ("fldt %1\n"
 		    "fsqrt\n"
 		    "fstpt %0\n" : "=m" (result) : "m"(val));
   return result;
-#endif
 }
 
 #define SQRT(a)  sqrt_long(a)
@@ -130,7 +100,7 @@ void cpuid(int op, int *eax, int *ebx, int *ecx, int *edx);
 
 #define WHEREAMI
 
-static __inline int WhereAmI(void){
+static inline int WhereAmI(void){
   int eax, ebx, ecx, edx;
   int apicid;
 
@@ -174,23 +144,11 @@ static __inline int blas_quickdivide(unsigned int x, unsigned int y){
 
   if (y <= 1) return x;
 
-#if defined(_MSC_VER) && !defined(__clang__)
-  result = x/y;
-  return result;
-#else
-#if (MAX_CPU_NUMBER > 64)
-  if ( y > 64) {
-	  result = x/y;
-	  return result;
-  }
-#endif
-	
   y = blas_quick_divide_table[y];
 
-  __asm__ __volatile__  ("mull %0" :"=d" (result), "+a"(x): "0" (y));
+  __asm__ __volatile__  ("mull %0" :"=d" (result) :"a"(x), "0" (y));
 
   return result;
-#endif
 }
 #endif
 
@@ -214,7 +172,7 @@ static __inline int blas_quickdivide(unsigned int x, unsigned int y){
 #endif
 
 #if defined(PILEDRIVER) || defined(BULLDOZER) || defined(STEAMROLLER) || defined(EXCAVATOR)
-//Enable some optimization for barcelona.
+//Enable some optimazation for barcelona.
 #define BARCELONA_OPTIMIZATION
 #endif
 
@@ -326,14 +284,10 @@ REALNAME:
 
 #define PROFCODE
 
-#ifdef __clang__
-#define EPILOGUE .end
-#else
 #define EPILOGUE .end	 REALNAME
 #endif
-#endif
 
-#if defined(OS_LINUX) || defined(OS_FREEBSD) || defined(OS_NETBSD) || defined(OS_OPENBSD) || defined(__ELF__)
+#if defined(OS_LINUX) || defined(OS_FREEBSD) || defined(OS_NETBSD) || defined(__ELF__)
 #define PROLOGUE \
 	.text; \
 	.align 16; \

common_x86_64.h

@@ -41,10 +41,6 @@
 
 #ifndef ASSEMBLER
 
-#ifdef C_MSVC
-#include <intrin.h>
-#endif
-
 #ifdef C_SUN
 #define	__asm__ __asm
 #define	__volatile__
@@ -60,55 +56,35 @@
 #endif
 */
 
-#ifdef __GNUC__
-#define MB do { __asm__ __volatile__("": : :"memory"); } while (0)
-#define WMB do { __asm__ __volatile__("": : :"memory"); } while (0)
-#else
-#define MB do {} while (0)
-#define WMB do {} while (0)
-#endif
+#define MB
+#define WMB
 
 static void __inline blas_lock(volatile BLASULONG *address){
 
-#ifndef C_MSVC
   int ret;
-#else
-  BLASULONG ret;
-#endif
 
   do {
     while (*address) {YIELDING;};
 
-#ifndef C_MSVC
     __asm__ __volatile__(
 			 "xchgl %0, %1\n"
 			 : "=r"(ret), "=m"(*address)
 			 : "0"(1), "m"(*address)
 			 : "memory");
-#else
-    ret=InterlockedExchange64((volatile LONG64 *)(address), 1);
-#endif
-  } while (ret);
 
+  } while (ret);
 }
-#define BLAS_LOCK_DEFINED
 
 static __inline BLASULONG rpcc(void){
-#ifdef C_MSVC
-  return __rdtsc();
-#else
   BLASULONG a, d;
 
   __asm__ __volatile__ ("rdtsc" : "=a" (a), "=d" (d));
 
   return ((BLASULONG)a + ((BLASULONG)d << 32));
-#endif
 }
-#define RPCC_DEFINED
 
 #define RPCC64BIT
 
-#ifndef C_MSVC
 static __inline BLASULONG getstackaddr(void){
   BLASULONG addr;
 
@@ -117,33 +93,22 @@ static __inline BLASULONG getstackaddr(void){
 
   return addr;
 }
-#endif
 
 static __inline void cpuid(int op, int *eax, int *ebx, int *ecx, int *edx){
 
-#ifdef C_MSVC
-  int cpuinfo[4];
-  __cpuid(cpuinfo, op);
-  *eax=cpuinfo[0];
-  *ebx=cpuinfo[1];
-  *ecx=cpuinfo[2];
-  *edx=cpuinfo[3];
-#else
-        __asm__ __volatile__("mov $0, %%ecx;"
-			     "cpuid"
+        __asm__ __volatile__("cpuid"
 			     : "=a" (*eax),
 			     "=b" (*ebx),
 			     "=c" (*ecx),
 			     "=d" (*edx)
 			     : "0" (op));
-#endif
 }
 
 /*
 #define WHEREAMI
 */
 
-static __inline int WhereAmI(void){
+static inline int WhereAmI(void){
   int eax, ebx, ecx, edx;
   int apicid;
 
@@ -185,14 +150,10 @@ static __inline int WhereAmI(void){
 #define GET_IMAGE_CANCEL
 
 #ifdef SMP
-#if defined(USE64BITINT)
+#ifdef USE64BITINT
 static __inline blasint blas_quickdivide(blasint x, blasint y){
   return x / y;
 }
-#elif defined (C_MSVC)
-static __inline BLASLONG blas_quickdivide(BLASLONG x, BLASLONG y){
-  return x / y;
-}
 #else
 extern unsigned int blas_quick_divide_table[];
 
@@ -202,16 +163,9 @@ static __inline int blas_quickdivide(unsigned int x, unsigned int y){
 
   if (y <= 1) return x;
 
-#if (MAX_CPU_NUMBER > 64)  
-  if (y > 64) { 
-	  result = x / y;
-	  return result;
-  }
-#endif
-	
   y = blas_quick_divide_table[y];
 
-  __asm__ __volatile__  ("mull %0" :"=d" (result), "+a"(x) : "0" (y));
+  __asm__ __volatile__  ("mull %0" :"=d" (result) :"a"(x), "0" (y));
 
   return result;
 }
@@ -258,10 +212,6 @@ static __inline int blas_quickdivide(unsigned int x, unsigned int y){
 #define RETURN_BY_STACK
 #endif
 
-#ifdef F_INTERFACE_FLANG
-#define RETURN_BY_STACK
-#endif
-
 #ifdef F_INTERFACE_PGI
 #define RETURN_BY_STACK
 #endif
@@ -277,7 +227,7 @@ static __inline int blas_quickdivide(unsigned int x, unsigned int y){
 #ifdef ASSEMBLER
 
 #if defined(PILEDRIVER) || defined(BULLDOZER) || defined(STEAMROLLER) || defined(EXCAVATOR)
-//Enable some optimization for barcelona.
+//Enable some optimazation for barcelona.
 #define BARCELONA_OPTIMIZATION
 #endif
 
@@ -413,10 +363,10 @@ REALNAME:
 
 #define PROFCODE
 
-#define EPILOGUE .end
+#define EPILOGUE .end	 REALNAME
 #endif
 
-#if defined(OS_LINUX) || defined(OS_FREEBSD) || defined(OS_NETBSD) || defined(OS_OPENBSD) || defined(OS_DRAGONFLY) || defined(__ELF__) || defined(C_PGI)
+#if defined(OS_LINUX) || defined(OS_FREEBSD) || defined(OS_NETBSD) || defined(__ELF__) || defined(C_PGI)
 #define PROLOGUE \
 	.text; \
 	.align 512; \

common_z.h

@@ -19,7 +19,6 @@
 #define	ZDOTC_K			zdotc_k
 #define	ZNRM2_K			znrm2_k
 #define	ZSCAL_K			zscal_k
-#define	ZSUM_K			zsum_k
 #define	ZSWAP_K			zswap_k
 #define	ZROT_K			zdrot_k
 
@@ -221,15 +220,6 @@
 #define ZOMATCOPY_K_CTC         zomatcopy_k_ctc
 #define ZOMATCOPY_K_RTC         zomatcopy_k_rtc
 
-#define ZIMATCOPY_K_CN          zimatcopy_k_cn
-#define ZIMATCOPY_K_RN          zimatcopy_k_rn
-#define ZIMATCOPY_K_CT          zimatcopy_k_ct
-#define ZIMATCOPY_K_RT          zimatcopy_k_rt
-#define ZIMATCOPY_K_CNC         zimatcopy_k_cnc
-#define ZIMATCOPY_K_RNC         zimatcopy_k_rnc
-#define ZIMATCOPY_K_CTC         zimatcopy_k_ctc
-#define ZIMATCOPY_K_RTC         zimatcopy_k_rtc
-
 #define ZGEADD_K                zgeadd_k 
 
 #else
@@ -250,7 +240,6 @@
 #define	ZDOTC_K			gotoblas -> zdotc_k
 #define	ZNRM2_K			gotoblas -> znrm2_k
 #define	ZSCAL_K			gotoblas -> zscal_k
-#define	ZSUM_K			gotoblas -> zsum_k
 #define	ZSWAP_K			gotoblas -> zswap_k
 #define	ZROT_K			gotoblas -> zdrot_k
 
@@ -415,15 +404,6 @@
 #define ZOMATCOPY_K_CTC         gotoblas -> zomatcopy_k_ctc
 #define ZOMATCOPY_K_RTC         gotoblas -> zomatcopy_k_rtc
 
-#define ZIMATCOPY_K_CN          gotoblas -> zimatcopy_k_cn
-#define ZIMATCOPY_K_RN          gotoblas -> zimatcopy_k_rn
-#define ZIMATCOPY_K_CT          gotoblas -> zimatcopy_k_ct
-#define ZIMATCOPY_K_RT          gotoblas -> zimatcopy_k_rt
-#define ZIMATCOPY_K_CNC         gotoblas -> zimatcopy_k_cnc
-#define ZIMATCOPY_K_RNC         gotoblas -> zimatcopy_k_rnc
-#define ZIMATCOPY_K_CTC         gotoblas -> zimatcopy_k_ctc
-#define ZIMATCOPY_K_RTC         gotoblas -> zimatcopy_k_rtc
-
 #define ZGEADD_K                gotoblas -> zgeadd_k
 
 #endif

common_zarch.h

@@ -1,140 +0,0 @@
-/*****************************************************************************
-Copyright (c) 2011-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 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.
-**********************************************************************************/
-
-#ifndef COMMON_ZARCH
-#define COMMON_ZARCH
-
-#define MB   
-//__asm__ __volatile__ ("dmb  ish" : : : "memory")
-#define WMB  
-//__asm__ __volatile__ ("dmb  ishst" : : : "memory")
-
-
-#define INLINE inline
-
-#define RETURN_BY_COMPLEX
-
-#ifndef ASSEMBLER
-
-  /*
-static void __inline blas_lock(volatile BLASULONG *address){
-
-  BLASULONG ret;
-
-  do {
-    while (*address) {YIELDING;};
-
-    __asm__ __volatile__(
-			 "mov	x4, #1							\n\t"
-                         "1:                                                            \n\t"
-                         "ldaxr x2, [%1]                                                \n\t"
-                         "cbnz  x2, 1b                                                  \n\t"
-			 "2:								\n\t"
-                         "stxr  w3, x4, [%1]                                            \n\t"
-                         "cbnz  w3, 1b                                                  \n\t"
-                         "mov   %0, #0                                                  \n\t"
-                         : "=r"(ret), "=r"(address)
-                         : "1"(address)
-                         : "memory", "x2" , "x3", "x4"
-
-
-    );
-
-
-  } while (ret);
-
-}
-  */
-//#define BLAS_LOCK_DEFINED
-
-
-
-static inline int blas_quickdivide(blasint x, blasint y){
-  return x / y;
-}
-
-#if defined(DOUBLE)
-#define GET_IMAGE(res)  __asm__ __volatile__("str d1, %0" : "=m"(res) : : "memory")
-#else
-#define GET_IMAGE(res)  __asm__ __volatile__("str s1, %0" : "=m"(res) : : "memory")
-#endif
-
-#define GET_IMAGE_CANCEL
-
-#endif
-
-
-#ifndef F_INTERFACE
-#define REALNAME ASMNAME
-#else
-#define REALNAME ASMFNAME
-#endif
-
-#if defined(ASSEMBLER) && !defined(NEEDPARAM)
-
-#define PROLOGUE \
-	.text ;\
-	.align	256 ;\
-	.global	REALNAME ;\
-	.type	REALNAME, %function ;\
-REALNAME:
- 
-
-#define EPILOGUE
-
-#define PROFCODE
-
-#endif
-
-
-#define SEEK_ADDRESS
-
-#ifndef PAGESIZE
-#define PAGESIZE        ( 4 << 10)
-#endif
-#define HUGE_PAGESIZE   ( 4 << 20)
-
-#if defined(CORTEXA57)
-#define BUFFER_SIZE     (20 << 20)
-#else
-#define BUFFER_SIZE     (16 << 20)
-#endif
-
-
-#define BASE_ADDRESS (START_ADDRESS - BUFFER_SIZE * MAX_CPU_NUMBER)
-
-#ifndef MAP_ANONYMOUS
-#define MAP_ANONYMOUS MAP_ANON
-#endif
-
-#endif
-

cpp_thread_test/Makefile

@@ -1,14 +0,0 @@
-include ../Makefile.rule
-
-all :: dgemv_tester dgemm_tester
-
-dgemv_tester :
-	$(CXX) $(COMMON_OPT) -Wall -Wextra -Wshadow -fopenmp -std=c++11 dgemv_thread_safety.cpp ../libopenblas.a -lpthread -o dgemv_tester
-	./dgemv_tester
-
-dgemm_tester : dgemv_tester
-	$(CXX) $(COMMON_OPT) -Wall -Wextra -Wshadow -fopenmp -std=c++11 dgemm_thread_safety.cpp ../libopenblas.a -lpthread -o dgemm_tester
-	./dgemm_tester
-
-clean ::
-	rm -f dgemv_tester dgemm_tester

cpp_thread_test/cpp_thread_safety_common.h

@@ -1,55 +0,0 @@
-inline void pauser(){
-    /// a portable way to pause a program
-    std::string dummy;
-    std::cout << "Press enter to continue...";
-    std::getline(std::cin, dummy);
-}
-
-void FillMatrices(std::vector<std::vector<double>>& matBlock, std::mt19937_64& PRNG, std::uniform_real_distribution<double>& rngdist, const blasint randomMatSize, const uint32_t numConcurrentThreads, const uint32_t numMat){
-	for(uint32_t i=0; i<numMat; i++){
-		for(uint32_t j = 0; j < static_cast<uint32_t>(randomMatSize*randomMatSize); j++){
-			matBlock[i][j] = rngdist(PRNG);
-		}
-	}
-	for(uint32_t i=numMat; i<(numConcurrentThreads*numMat); i+=numMat){
-		for(uint32_t j=0; j<numMat; j++){
-			matBlock[i+j] = matBlock[j];
-		}
-	}
-}
-
-void FillVectors(std::vector<std::vector<double>>& vecBlock, std::mt19937_64& PRNG, std::uniform_real_distribution<double>& rngdist, const blasint randomMatSize, const uint32_t numConcurrentThreads, const uint32_t numVec){
-	for(uint32_t i=0; i<numVec; i++){
-		for(uint32_t j = 0; j < static_cast<uint32_t>(randomMatSize); j++){
-			vecBlock[i][j] = rngdist(PRNG);
-		}
-	}
-	for(uint32_t i=numVec; i<(numConcurrentThreads*numVec); i+=numVec){
-		for(uint32_t j=0; j<numVec; j++){
-			vecBlock[i+j] = vecBlock[j];
-		}
-	}
-}
-
-std::mt19937_64 InitPRNG(){
-	std::random_device rd;
-	std::mt19937_64 PRNG(rd()); //seed PRNG using /dev/urandom or similar OS provided RNG
-	std::uniform_real_distribution<double> rngdist{-1.0, 1.0};
-	//make sure the internal state of the PRNG is properly mixed by generating 10M random numbers
-	//PRNGs often have unreliable distribution uniformity and other statistical properties before their internal state is sufficiently mixed
-	for (uint32_t i=0;i<10000000;i++) rngdist(PRNG);
-	return PRNG;
-}
-
-void PrintMatrices(const std::vector<std::vector<double>>& matBlock, const blasint randomMatSize, const uint32_t numConcurrentThreads, const uint32_t numMat){
-	for (uint32_t i=0;i<numConcurrentThreads*numMat;i++){
-		std::cout<<i<<std::endl;
-		for (uint32_t j = 0; j < static_cast<uint32_t>(randomMatSize); j++){
-			for (uint32_t k = 0; k < static_cast<uint32_t>(randomMatSize); k++){
-				std::cout<<matBlock[i][j*randomMatSize + k]<<"  ";
-			}
-			std::cout<<std::endl;
-		}
-		std::cout<<std::endl;
-	}
-}

cpp_thread_test/dgemm_thread_safety.cpp

@@ -1,92 +0,0 @@
-#include <iostream>
-#include <vector>
-#include <random>
-#include <future>
-#include <omp.h>
-#include "../cblas.h"
-#include "cpp_thread_safety_common.h"
-
-void launch_cblas_dgemm(double* A, double* B, double* C, const blasint randomMatSize){
-	cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, randomMatSize, randomMatSize, randomMatSize, 1.0, A, randomMatSize, B, randomMatSize, 0.1, C, randomMatSize);
-}
-
-int main(int argc, char* argv[]){
-	blasint randomMatSize = 1024; //dimension of the random square matrices used
-	uint32_t numConcurrentThreads = 52; //number of concurrent calls of the functions being tested
-	uint32_t numTestRounds = 16; //number of testing rounds before success exit
-	
-	if (argc > 4){
-		std::cout<<"ERROR: too many arguments for thread safety tester"<<std::endl;
-		abort();
-	}
-	
-	if(argc == 4){
-		std::vector<std::string> cliArgs;
-		for (int i = 1; i < argc; i++){
-			cliArgs.push_back(argv[i]);
-			std::cout<<argv[i]<<std::endl;
-		}
-		randomMatSize = std::stoul(cliArgs[0]);
-		numConcurrentThreads = std::stoul(cliArgs[1]);
-		numTestRounds = std::stoul(cliArgs[2]);
-	}
-	
-	std::uniform_real_distribution<double> rngdist{-1.0, 1.0};
-	std::vector<std::vector<double>> matBlock(numConcurrentThreads*3);
-	std::vector<std::future<void>> futureBlock(numConcurrentThreads);
-	
-	std::cout<<"*----------------------------*\n";
-	std::cout<<"| DGEMM thread safety tester |\n";
-	std::cout<<"*----------------------------*\n";
-	std::cout<<"Size of random matrices(N=M=K): "<<randomMatSize<<'\n';
-	std::cout<<"Number of concurrent calls into OpenBLAS : "<<numConcurrentThreads<<'\n';
-	std::cout<<"Number of testing rounds : "<<numTestRounds<<'\n';
-	std::cout<<"This test will need "<<(static_cast<uint64_t>(randomMatSize*randomMatSize)*numConcurrentThreads*3*8)/static_cast<double>(1024*1024)<<" MiB of RAM\n"<<std::endl;
-	
-	std::cout<<"Initializing random number generator..."<<std::flush;
-	std::mt19937_64 PRNG = InitPRNG();
-	std::cout<<"done\n";
-	
-	std::cout<<"Preparing to test CBLAS DGEMM thread safety\n";
-	std::cout<<"Allocating matrices..."<<std::flush;
-	for(uint32_t i=0; i<(numConcurrentThreads*3); i++){
-		matBlock[i].resize(randomMatSize*randomMatSize);
-	}
-	std::cout<<"done\n";
-	//pauser();
-	std::cout<<"Filling matrices with random numbers..."<<std::flush;
-	FillMatrices(matBlock, PRNG, rngdist, randomMatSize, numConcurrentThreads, 3);
-	//PrintMatrices(matBlock, randomMatSize, numConcurrentThreads, 3);
-	std::cout<<"done\n";
-	std::cout<<"Testing CBLAS DGEMM thread safety\n";
-	omp_set_num_threads(numConcurrentThreads);
-	for(uint32_t R=0; R<numTestRounds; R++){
-		std::cout<<"DGEMM round #"<<R<<std::endl;
-		std::cout<<"Launching "<<numConcurrentThreads<<" threads simultaneously using OpenMP..."<<std::flush;
-		#pragma omp parallel for default(none) shared(futureBlock, matBlock, randomMatSize, numConcurrentThreads)
-		for(uint32_t i=0; i<numConcurrentThreads; i++){
-			futureBlock[i] = std::async(std::launch::async, launch_cblas_dgemm, &matBlock[i*3][0], &matBlock[i*3+1][0], &matBlock[i*3+2][0], randomMatSize);
-			//launch_cblas_dgemm( &matBlock[i][0], &matBlock[i+1][0], &matBlock[i+2][0]);
-		}
-		std::cout<<"done\n";
-		std::cout<<"Waiting for threads to finish..."<<std::flush;
-		for(uint32_t i=0; i<numConcurrentThreads; i++){
-			futureBlock[i].get();
-		}
-		std::cout<<"done\n";
-		//PrintMatrices(matBlock, randomMatSize, numConcurrentThreads, 3);
-		std::cout<<"Comparing results from different threads..."<<std::flush;
-		for(uint32_t i=3; i<(numConcurrentThreads*3); i+=3){ //i is the index of matrix A, for a given thread
-			for(uint32_t j = 0; j < static_cast<uint32_t>(randomMatSize*randomMatSize); j++){
-				if (std::abs(matBlock[i+2][j] - matBlock[2][j]) > 1.0E-13){ //i+2 is the index of matrix C, for a given thread
-					std::cout<<"ERROR: one of the threads returned a different result! Index : "<<i+2<<std::endl;
-					std::cout<<"CBLAS DGEMM thread safety test FAILED!"<<std::endl;
-					return -1;
-				}
-			}
-		}
-		std::cout<<"OK!\n"<<std::endl;
-	}
-	std::cout<<"CBLAS DGEMM thread safety test PASSED!\n"<<std::endl;
-	return 0;
-}

cpp_thread_test/dgemv_thread_safety.cpp

@@ -1,101 +0,0 @@
-#include <iostream>
-#include <vector>
-#include <random>
-#include <future>
-#include <omp.h>
-#include "../cblas.h"
-#include "cpp_thread_safety_common.h"
-
-void launch_cblas_dgemv(double* A, double* x, double* y, const blasint randomMatSize){
-	const blasint inc = 1;
-	cblas_dgemv(CblasColMajor, CblasNoTrans, randomMatSize, randomMatSize, 1.0, A, randomMatSize, x, inc, 0.1, y, inc);
-}
-
-int main(int argc, char* argv[]){
-	blasint randomMatSize = 1024; //dimension of the random square matrices and vectors being used
-	uint32_t numConcurrentThreads = 52; //number of concurrent calls of the functions being tested
-	uint32_t numTestRounds = 16; //number of testing rounds before success exit
-	
-	if (argc > 4){
-		std::cout<<"ERROR: too many arguments for thread safety tester"<<std::endl;
-		abort();
-	}
-	if(argc == 4){
-		std::vector<std::string> cliArgs;
-		for (int i = 1; i < argc; i++){
-			cliArgs.push_back(argv[i]);
-			std::cout<<argv[i]<<std::endl;
-		}
-		randomMatSize = std::stoul(cliArgs.at(0));
-		numConcurrentThreads = std::stoul(cliArgs.at(1));
-		numTestRounds = std::stoul(cliArgs.at(2));
-	}
-	
-	std::uniform_real_distribution<double> rngdist{-1.0, 1.0};
-	std::vector<std::vector<double>> matBlock(numConcurrentThreads);
-	std::vector<std::vector<double>> vecBlock(numConcurrentThreads*2);
-	std::vector<std::future<void>> futureBlock(numConcurrentThreads);
-	
-	std::cout<<"*----------------------------*\n";
-	std::cout<<"| DGEMV thread safety tester |\n";
-	std::cout<<"*----------------------------*\n";
-	std::cout<<"Size of random matrices and vectors(N=M): "<<randomMatSize<<'\n';
-	std::cout<<"Number of concurrent calls into OpenBLAS : "<<numConcurrentThreads<<'\n';
-	std::cout<<"Number of testing rounds : "<<numTestRounds<<'\n';
-	std::cout<<"This test will need "<<((static_cast<uint64_t>(randomMatSize*randomMatSize)*numConcurrentThreads*8)+(static_cast<uint64_t>(randomMatSize)*numConcurrentThreads*8*2))/static_cast<double>(1024*1024)<<" MiB of RAM\n"<<std::endl;
-	
-	std::cout<<"Initializing random number generator..."<<std::flush;
-	std::mt19937_64 PRNG = InitPRNG();
-	std::cout<<"done\n";
-	
-	std::cout<<"Preparing to test CBLAS DGEMV thread safety\n";
-	std::cout<<"Allocating matrices..."<<std::flush;
-	for(uint32_t i=0; i<numConcurrentThreads; i++){
-		matBlock.at(i).resize(randomMatSize*randomMatSize);
-	}
-	std::cout<<"done\n";
-	std::cout<<"Allocating vectors..."<<std::flush;
-	for(uint32_t i=0; i<(numConcurrentThreads*2); i++){
-		vecBlock.at(i).resize(randomMatSize);
-	}
-	std::cout<<"done\n";
-	//pauser();
-	
-	std::cout<<"Filling matrices with random numbers..."<<std::flush;
-	FillMatrices(matBlock, PRNG, rngdist, randomMatSize, numConcurrentThreads, 1);
-	//PrintMatrices(matBlock, randomMatSize, numConcurrentThreads);
-	std::cout<<"done\n";
-	std::cout<<"Filling vectors with random numbers..."<<std::flush;
-	FillVectors(vecBlock, PRNG, rngdist, randomMatSize, numConcurrentThreads, 2);
-	std::cout<<"done\n";
-	
-	std::cout<<"Testing CBLAS DGEMV thread safety"<<std::endl;
-	omp_set_num_threads(numConcurrentThreads);
-	for(uint32_t R=0; R<numTestRounds; R++){
-		std::cout<<"DGEMV round #"<<R<<std::endl;
-		std::cout<<"Launching "<<numConcurrentThreads<<" threads simultaneously using OpenMP..."<<std::flush;
-		#pragma omp parallel for default(none) shared(futureBlock, matBlock, vecBlock, randomMatSize, numConcurrentThreads)
-		for(uint32_t i=0; i<numConcurrentThreads; i++){
-			futureBlock[i] = std::async(std::launch::async, launch_cblas_dgemv, &matBlock[i][0], &vecBlock[i*2][0], &vecBlock[i*2+1][0], randomMatSize);
-		}
-		std::cout<<"done\n";
-		std::cout<<"Waiting for threads to finish..."<<std::flush;
-		for(uint32_t i=0; i<numConcurrentThreads; i++){
-			futureBlock[i].get();
-		}
-		std::cout<<"done\n";
-		std::cout<<"Comparing results from different threads..."<<std::flush;
-		for(uint32_t i=2; i<(numConcurrentThreads*2); i+=2){ //i is the index of vector x, for a given thread
-			for(uint32_t j = 0; j < static_cast<uint32_t>(randomMatSize); j++){
-				if (std::abs(vecBlock[i+1][j] - vecBlock[1][j]) > 1.0E-13){ //i+1 is the index of vector y, for a given thread
-					std::cout<<"ERROR: one of the threads returned a different result! Index : "<<i+1<<std::endl;
-					std::cout<<"CBLAS DGEMV thread safety test FAILED!"<<std::endl;
-					return -1;
-				}
-			}
-		}
-		std::cout<<"OK!\n"<<std::endl;
-	}
-	std::cout<<"CBLAS DGEMV thread safety test PASSED!\n"<<std::endl;
-	return 0;
-}

cpuid.h

@@ -39,10 +39,6 @@
 #ifndef CPUID_H
 #define CPUID_H
 
-#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)
-#define INTEL_AMD
-#endif
-
 #define VENDOR_INTEL      1
 #define VENDOR_UMC        2
 #define VENDOR_AMD        3
@@ -53,7 +49,6 @@
 #define VENDOR_SIS	  8
 #define VENDOR_TRANSMETA  9
 #define VENDOR_NSC	 10
-#define VENDOR_HYGON	 11
 #define VENDOR_UNKNOWN   99
 
 #define BITMASK(a, b, c) ((((a) >> (b)) & (c)))
@@ -64,7 +59,7 @@
 #define FAMILY_PM     7
 #define FAMILY_IA64   8
 
-#ifdef INTEL_AMD
+#if defined(__i386__) || defined(__x86_64__)
 #define GET_EXFAMILY  1
 #define GET_EXMODEL   2
 #define GET_TYPE      3
@@ -115,9 +110,6 @@
 #define CORE_HASWELL     24
 #define CORE_STEAMROLLER 25
 #define CORE_EXCAVATOR   26
-#define CORE_ZEN         27
-#define CORE_SKYLAKEX    28
-#define CORE_DHYANA	 29
 
 #define HAVE_SSE      (1 <<  0)
 #define HAVE_SSE2     (1 <<  1)
@@ -140,8 +132,6 @@
 #define HAVE_AVX      (1 <<  18)
 #define HAVE_FMA4     (1 <<  19)
 #define HAVE_FMA3     (1 <<  20)
-#define HAVE_AVX512VL (1 <<  21)
-#define HAVE_AVX2     (1 <<  22)
 
 #define CACHE_INFO_L1_I     1
 #define CACHE_INFO_L1_D     2
@@ -215,10 +205,5 @@ typedef struct {
 #define CPUTYPE_HASWELL 		48
 #define CPUTYPE_STEAMROLLER 		49
 #define CPUTYPE_EXCAVATOR 		50
-#define CPUTYPE_ZEN 			51
-#define CPUTYPE_SKYLAKEX		52
-#define CPUTYPE_DHYANA			53
-
-#define CPUTYPE_HYGON_UNKNOWN		54
 
 #endif

cpuid_arm.c

@@ -34,7 +34,7 @@
 #define CPU_CORTEXA15       	4
 
 static char *cpuname[] = {
-  "UNKNOWN",
+  "UNKOWN",
   "ARMV6",
   "ARMV7",
   "CORTEXA9",
@@ -74,7 +74,7 @@ int get_feature(char *search)
   	fclose(infile);
 
 
-	if( p == NULL ) return 0;
+	if( p == NULL ) return;
 
 	t = strtok(p," ");
 	while( t = strtok(NULL," "))
@@ -115,9 +115,6 @@ int detect(void)
 	  if (strstr(p, "0xc0f")) {
 	    return CPU_CORTEXA15;
 	  }
-	  if (strstr(p, "0xd07")) {
-	    return CPU_ARMV7;  //ARMV8 on 32-bit
-	  }
 
 	}
 
@@ -161,27 +158,6 @@ int detect(void)
 
 
 	}
-
-  	p = (char *) NULL ;
-  	infile = fopen("/proc/cpuinfo", "r");
-
-	while (fgets(buffer, sizeof(buffer), infile))
-	{
-
-		if ((!strncmp("CPU architecture", buffer, 16)))
-		{
-			p = strchr(buffer, ':') + 2;
-			break;
-      		}
-  	}
-  	fclose(infile);
-  	if(p != NULL) {
-	  if (strstr(p, "8")) {
-	    return CPU_ARMV7;  //ARMV8 on 32-bit
-	  }
-
-	}
-
 #endif
 
 	return CPU_UNKNOWN;
@@ -216,7 +192,6 @@ void get_cpuconfig(void)
 	{
 	       case CPU_CORTEXA9:
     			printf("#define CORTEXA9\n");
-    			printf("#define ARMV7\n");
     			printf("#define HAVE_VFP\n");
     			printf("#define HAVE_VFPV3\n");
 			if ( get_feature("neon"))	printf("#define HAVE_NEON\n");
@@ -232,7 +207,6 @@ void get_cpuconfig(void)
 
 	       case CPU_CORTEXA15:
     			printf("#define CORTEXA15\n");
-    			printf("#define ARMV7\n");
     			printf("#define HAVE_VFP\n");
     			printf("#define HAVE_VFPV3\n");
 			if ( get_feature("neon"))	printf("#define HAVE_NEON\n");

cpuid_arm64.c

@@ -29,44 +29,12 @@
 
 #define CPU_UNKNOWN     	0
 #define CPU_ARMV8       	1
-// Arm
-#define CPU_CORTEXA53     2
-#define CPU_CORTEXA57     3
-#define CPU_CORTEXA72     4
-#define CPU_CORTEXA73     5
-// Qualcomm
-#define CPU_FALKOR        6
-// Cavium
-#define CPU_THUNDERX      7
-#define CPU_THUNDERX2T99  8
-//Hisilicon
-#define CPU_TSV110        9
 
 static char *cpuname[] = {
-  "UNKNOWN",
-  "ARMV8" ,
-  "CORTEXA53",
-  "CORTEXA57",
-  "CORTEXA72",
-  "CORTEXA73",
-  "FALKOR",
-  "THUNDERX",
-  "THUNDERX2T99",
-  "TSV110"
+  "UNKOWN",
+  "ARMV8"
 };
 
-static char *cpuname_lower[] = {
-  "unknown",
-  "armv8",
-  "cortexa53",
-  "cortexa57",
-  "cortexa72",
-  "cortexa73",
-  "falkor",
-  "thunderx",
-  "thunderx2t99",
-  "tsv110"
-};
 
 int get_feature(char *search)
 {
@@ -85,16 +53,16 @@ int get_feature(char *search)
 		{
 			p = strchr(buffer, ':') + 2;
 			break;
-		}
-	}
+      		}
+  	}
 
-	fclose(infile);
+  	fclose(infile);
 
 
-	if( p == NULL ) return 0;
+	if( p == NULL ) return;
 
 	t = strtok(p," ");
-	while( (t = strtok(NULL," ")))
+	while( t = strtok(NULL," "))
 	{
 		if (!strcmp(t, search))   { return(1); }
 	}
@@ -110,57 +78,15 @@ int detect(void)
 #ifdef linux
 
 	FILE *infile;
-	char buffer[512], *p, *cpu_part = NULL, *cpu_implementer = NULL;
-	p = (char *) NULL ;
+  	char buffer[512], *p;
+  	p = (char *) NULL ;
 
-	infile = fopen("/proc/cpuinfo", "r");
-	while (fgets(buffer, sizeof(buffer), infile)) {
-		if ((cpu_part != NULL) && (cpu_implementer != NULL)) {
-			break;
-		}
+  	infile = fopen("/proc/cpuinfo", "r");
 
-		if ((cpu_part == NULL) && !strncmp("CPU part", buffer, 8)) {
-			cpu_part = strchr(buffer, ':') + 2;
-			cpu_part = strdup(cpu_part);
-		} else if ((cpu_implementer == NULL) && !strncmp("CPU implementer", buffer, 15)) {
-			cpu_implementer = strchr(buffer, ':') + 2;
-			cpu_implementer = strdup(cpu_implementer);
-		}
-	}
-
-	fclose(infile);
-	if(cpu_part != NULL && cpu_implementer != NULL) {
-    // Arm
-    if (strstr(cpu_implementer, "0x41")) {
-      if (strstr(cpu_part, "0xd03"))
-        return CPU_CORTEXA53;
-      else if (strstr(cpu_part, "0xd07"))
-        return CPU_CORTEXA57;
-      else if (strstr(cpu_part, "0xd08"))
-        return CPU_CORTEXA72;
-      else if (strstr(cpu_part, "0xd09"))
-        return CPU_CORTEXA73;
-    }
-    // Qualcomm
-    else if (strstr(cpu_implementer, "0x51") && strstr(cpu_part, "0xc00"))
-      return CPU_FALKOR;
-    // Cavium
-    else if (strstr(cpu_implementer, "0x43") && strstr(cpu_part, "0x0a1"))
-			return CPU_THUNDERX;
-    else if (strstr(cpu_implementer, "0x43") && strstr(cpu_part, "0x0af"))
-			return CPU_THUNDERX2T99;
-    // HiSilicon
-    else if (strstr(cpu_implementer, "0x48") && strstr(cpu_part, "0xd01"))
-                        return CPU_TSV110;
-	}
-
-	p = (char *) NULL ;
-	infile = fopen("/proc/cpuinfo", "r");
 	while (fgets(buffer, sizeof(buffer), infile))
 	{
 
-		if ((!strncmp("model name", buffer, 10)) || (!strncmp("Processor", buffer, 9)) ||
-		    (!strncmp("CPU architecture", buffer, 16)))
+		if ((!strncmp("model name", buffer, 10)) || (!strncmp("Processor", buffer, 9)))
 		{
 			p = strchr(buffer, ':') + 2;
 			break;
@@ -172,9 +98,9 @@ int detect(void)
   	if(p != NULL)
 	{
 
-		if ((strstr(p, "AArch64")) || (strstr(p, "8")))
+		if (strstr(p, "AArch64"))
 		{
-			return CPU_ARMV8;
+			 	return CPU_ARMV8;
 
 		}
 
@@ -192,13 +118,23 @@ char *get_corename(void)
 
 void get_architecture(void)
 {
-	printf("ARM64");
+	printf("ARM");
 }
 
 void get_subarchitecture(void)
 {
 	int d = detect();
-	printf("%s", cpuname[d]);
+	switch (d)
+	{
+
+		case CPU_ARMV8:
+			printf("ARMV8");
+			break;
+
+		default:
+			printf("UNKNOWN");
+			break;
+	}
 }
 
 void get_subdirname(void)
@@ -206,146 +142,44 @@ void get_subdirname(void)
 	printf("arm64");
 }
 
-void get_cpucount(void)
-{
-int n=0;
-
-#ifdef linux
-	FILE *infile;
-  	char buffer[2048], *p,*t;
-  	p = (char *) NULL ;
-
-  	infile = fopen("/proc/cpuinfo", "r");
-
-	while (fgets(buffer, sizeof(buffer), infile))
-	{
-
-		if (!strncmp("processor", buffer, 9))
-		n++;
-  	}
-
-  	fclose(infile);
-
-	printf("#define NUM_CORES %d\n",n);
-#endif
-
-}
-
-
-
 void get_cpuconfig(void)
 {
 
-  // All arches should define ARMv8
-  printf("#define ARMV8\n");
-  printf("#define HAVE_NEON\n"); // This shouldn't be necessary
-  printf("#define HAVE_VFPV4\n"); // This shouldn't be necessary
-
 	int d = detect();
 	switch (d)
 	{
 
-    case CPU_CORTEXA53:
-      printf("#define %s\n", cpuname[d]);
-      // Fall-through
 		case CPU_ARMV8:
-      // Minimum parameters for ARMv8 (based on A53)
-    	printf("#define L1_DATA_SIZE 32768\n");
-    	printf("#define L1_DATA_LINESIZE 64\n");
-    	printf("#define L2_SIZE 262144\n");
-    	printf("#define L2_LINESIZE 64\n");
-    	printf("#define DTB_DEFAULT_ENTRIES 64\n");
-    	printf("#define DTB_SIZE 4096\n");
-    	printf("#define L2_ASSOCIATIVE 4\n");
+    			printf("#define ARMV8\n");
+    			printf("#define L1_DATA_SIZE 32768\n");
+    			printf("#define L1_DATA_LINESIZE 64\n");
+    			printf("#define L2_SIZE 262144\n");
+    			printf("#define L2_LINESIZE 64\n");
+    			printf("#define DTB_DEFAULT_ENTRIES 64\n");
+    			printf("#define DTB_SIZE 4096\n");
+    			printf("#define L2_ASSOCIATIVE 4\n");
 			break;
 
-		case CPU_CORTEXA57:
-		case CPU_CORTEXA72:
-		case CPU_CORTEXA73:
-      // Common minimum settings for these Arm cores
-      // Can change a lot, but we need to be conservative
-      // TODO: detect info from /sys if possible
-      printf("#define %s\n", cpuname[d]);
-			printf("#define L1_CODE_SIZE 49152\n");
-			printf("#define L1_CODE_LINESIZE 64\n");
-			printf("#define L1_CODE_ASSOCIATIVE 3\n");
-			printf("#define L1_DATA_SIZE 32768\n");
-			printf("#define L1_DATA_LINESIZE 64\n");
-			printf("#define L1_DATA_ASSOCIATIVE 2\n");
-      printf("#define L2_SIZE 524288\n");
-			printf("#define L2_LINESIZE 64\n");
-			printf("#define L2_ASSOCIATIVE 16\n");
-			printf("#define DTB_DEFAULT_ENTRIES 64\n");
-			printf("#define DTB_SIZE 4096\n");
-			break;
 
-    case CPU_FALKOR:
-      printf("#define FALKOR\n");
-      printf("#define L1_CODE_SIZE 65536\n");
-      printf("#define L1_CODE_LINESIZE 64\n");
-      printf("#define L1_DATA_SIZE 32768\n");
-      printf("#define L1_DATA_LINESIZE 128\n");
-      printf("#define L2_SIZE 524288\n");
-      printf("#define L2_LINESIZE 64\n");
-      printf("#define DTB_DEFAULT_ENTRIES 64\n");
-      printf("#define DTB_SIZE 4096\n");
-      printf("#define L2_ASSOCIATIVE 16\n");
-      break;
-
-		case CPU_THUNDERX:
-			printf("#define THUNDERX\n");
-			printf("#define L1_DATA_SIZE 32768\n");
-			printf("#define L1_DATA_LINESIZE 128\n");
-			printf("#define L2_SIZE 16777216\n");
-			printf("#define L2_LINESIZE 128\n");
-			printf("#define DTB_DEFAULT_ENTRIES 64\n");
-			printf("#define DTB_SIZE 4096\n");
-			printf("#define L2_ASSOCIATIVE 16\n");
-			break;
-
-		case CPU_THUNDERX2T99:
-			printf("#define THUNDERX2T99                  \n");
-			printf("#define L1_CODE_SIZE         32768    \n");
-			printf("#define L1_CODE_LINESIZE     64       \n");
-			printf("#define L1_CODE_ASSOCIATIVE  8        \n");
-			printf("#define L1_DATA_SIZE         32768    \n");
-			printf("#define L1_DATA_LINESIZE     64       \n");
-			printf("#define L1_DATA_ASSOCIATIVE  8        \n");
-			printf("#define L2_SIZE              262144   \n");
-			printf("#define L2_LINESIZE          64       \n");
-			printf("#define L2_ASSOCIATIVE       8        \n");
-			printf("#define L3_SIZE              33554432 \n");
-			printf("#define L3_LINESIZE          64       \n");
-			printf("#define L3_ASSOCIATIVE       32       \n");
-			printf("#define DTB_DEFAULT_ENTRIES  64       \n");
-			printf("#define DTB_SIZE             4096     \n");
-			break;
-			
-		case CPU_TSV110:
-			printf("#define TSV110                        \n");
-			printf("#define L1_CODE_SIZE         65536    \n");
-			printf("#define L1_CODE_LINESIZE     64       \n");
-			printf("#define L1_CODE_ASSOCIATIVE  4        \n");
-			printf("#define L1_DATA_SIZE         65536    \n");
-			printf("#define L1_DATA_LINESIZE     64       \n");
-			printf("#define L1_DATA_ASSOCIATIVE  4        \n");
-			printf("#define L2_SIZE              524228   \n");
-			printf("#define L2_LINESIZE          64       \n");
-			printf("#define L2_ASSOCIATIVE       8        \n");
-			printf("#define DTB_DEFAULT_ENTRIES  64       \n");
-			printf("#define DTB_SIZE             4096     \n");
-			break;	
 	}
-	get_cpucount();
 }
 
 
 void get_libname(void)
 {
+
 	int d = detect();
-	printf("%s", cpuname_lower[d]);
+	switch (d)
+	{
+
+		case CPU_ARMV8:
+    			printf("armv8\n");
+			break;
+
+	}
 }
 
+
 void get_features(void)
 {
 
@@ -372,10 +206,12 @@ void get_features(void)
 	if( p == NULL ) return;
 
 	t = strtok(p," ");
-	while( (t = strtok(NULL," ")))
+	while( t = strtok(NULL," "))
 	{
 	}
 
 #endif
 	return;
 }
+
+

cpuid_mips.c

@@ -71,13 +71,15 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /*********************************************************************/
 
 #define CPU_UNKNOWN     0
-#define CPU_P5600       1
-#define CPU_1004K	2
+#define CPU_SICORTEX    1
+#define CPU_LOONGSON3A  2
+#define CPU_LOONGSON3B  3
 
 static char *cpuname[] = {
-  "UNKNOWN",
-  "P5600",
-  "1004K"
+  "UNKOWN",
+  "SICORTEX",
+  "LOONGSON3A",
+  "LOONGSON3B"
 };
 
 int detect(void){
@@ -92,7 +94,7 @@ int detect(void){
     if (!strncmp("cpu", buffer, 3)){
 	p = strchr(buffer, ':') + 2;
 #if 0
-	fprintf(stderr, "%s \n", p);
+	fprintf(stderr, "%s\n", p);
 #endif
 	break;
       }
@@ -101,12 +103,42 @@ int detect(void){
   fclose(infile);
 
   if(p != NULL){
-  if (strstr(p, "5600")) {
-    return CPU_P5600;
-  } else if (strstr(p, "1004K")) {
-    return CPU_1004K;
-  } else  
-    return CPU_UNKNOWN;
+  if (strstr(p, "Loongson-3A")){
+    return CPU_LOONGSON3A;
+  }else if(strstr(p, "Loongson-3B")){
+    return CPU_LOONGSON3B;
+  }else if (strstr(p, "Loongson-3")){
+    infile = fopen("/proc/cpuinfo", "r");
+    p = (char *)NULL;
+    while (fgets(buffer, sizeof(buffer), infile)){
+      if (!strncmp("system type", buffer, 11)){
+	p = strchr(buffer, ':') + 2;
+	break;
+      }
+    }
+    fclose(infile);
+    if (strstr(p, "loongson3a"))
+      return CPU_LOONGSON3A;
+  }else{
+    return CPU_SICORTEX;
+  }
+  }
+  //Check model name for Loongson3
+  infile = fopen("/proc/cpuinfo", "r");
+  p = (char *)NULL;
+  while (fgets(buffer, sizeof(buffer), infile)){
+    if (!strncmp("model name", buffer, 10)){
+      p = strchr(buffer, ':') + 2;
+      break;
+    }
+  }
+  fclose(infile);
+  if(p != NULL){
+  if (strstr(p, "Loongson-3A")){
+    return CPU_LOONGSON3A;
+  }else if(strstr(p, "Loongson-3B")){
+    return CPU_LOONGSON3B;
+  }
   }
 #endif
     return CPU_UNKNOWN;
@@ -117,50 +149,64 @@ char *get_corename(void){
 }
 
 void get_architecture(void){
-  printf("MIPS");
+  printf("MIPS64");
 }
 
 void get_subarchitecture(void){
-  if(detect()==CPU_P5600|| detect()==CPU_1004K){
-    printf("P5600");
+  if(detect()==CPU_LOONGSON3A) {
+    printf("LOONGSON3A");
+  }else if(detect()==CPU_LOONGSON3B){
+    printf("LOONGSON3B");
   }else{
-    printf("UNKNOWN");
+    printf("SICORTEX");
   }
 }
 
 void get_subdirname(void){
-  printf("mips");
+  printf("mips64");
 }
 
 void get_cpuconfig(void){
-  if(detect()==CPU_P5600){
-    printf("#define P5600\n");
+  if(detect()==CPU_LOONGSON3A) {
+    printf("#define LOONGSON3A\n");
     printf("#define L1_DATA_SIZE 65536\n");
     printf("#define L1_DATA_LINESIZE 32\n");
-    printf("#define L2_SIZE 1048576\n");
+    printf("#define L2_SIZE 512488\n");
     printf("#define L2_LINESIZE 32\n");
     printf("#define DTB_DEFAULT_ENTRIES 64\n");
     printf("#define DTB_SIZE 4096\n");
-    printf("#define L2_ASSOCIATIVE 8\n");
-  } else if (detect()==CPU_1004K) {
-    printf("#define MIPS1004K\n");
-    printf("#define L1_DATA_SIZE 32768\n");
+    printf("#define L2_ASSOCIATIVE 4\n");
+  }else if(detect()==CPU_LOONGSON3B){
+    printf("#define LOONGSON3B\n");
+    printf("#define L1_DATA_SIZE 65536\n");
     printf("#define L1_DATA_LINESIZE 32\n");
-    printf("#define L2_SIZE 26144\n");
-    printf("#define DTB_DEFAULT_ENTRIES 8\n");
+    printf("#define L2_SIZE 512488\n");
+    printf("#define L2_LINESIZE 32\n");
+    printf("#define DTB_DEFAULT_ENTRIES 64\n");
     printf("#define DTB_SIZE 4096\n");
     printf("#define L2_ASSOCIATIVE 4\n");
   }else{
-    printf("#define UNKNOWN\n");
+    printf("#define SICORTEX\n");
+    printf("#define L1_DATA_SIZE 32768\n");
+    printf("#define L1_DATA_LINESIZE 32\n");
+    printf("#define L2_SIZE 512488\n");
+    printf("#define L2_LINESIZE 32\n");
+    printf("#define DTB_DEFAULT_ENTRIES 32\n");
+    printf("#define DTB_SIZE 4096\n");
+    printf("#define L2_ASSOCIATIVE 8\n");
   }
 }
 
 void get_libname(void){
-  if(detect()==CPU_P5600) {
-    printf("p5600\n");
-  } else if (detect()==CPU_1004K) {
-    printf("1004K\n");
+  if(detect()==CPU_LOONGSON3A) {
+    printf("loongson3a\n");
+  }else if(detect()==CPU_LOONGSON3B) {
+    printf("loongson3b\n");
   }else{
-    printf("mips\n");
+#ifdef __mips64
+  printf("mips64\n");
+#else
+  printf("mips32\n");
+#endif
   }
 }

cpuid_mips64.c

@@ -1,253 +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.
-
-**********************************************************************************/
-
-
-/*********************************************************************/
-/* 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.                 */
-/*********************************************************************/
-
-#define CPU_UNKNOWN     0
-#define CPU_SICORTEX    1
-#define CPU_LOONGSON3A  2
-#define CPU_LOONGSON3B  3
-#define CPU_I6400       4
-#define CPU_P6600       5
-#define CPU_I6500       6
-
-static char *cpuname[] = {
-  "UNKNOWN",
-  "SICORTEX",
-  "LOONGSON3A",
-  "LOONGSON3B",
-  "I6400",
-  "P6600",
-  "I6500"
-};
-
-int detect(void){
-
-#ifdef linux
-  FILE *infile;
-  char buffer[512], *p;
-
-  p = (char *)NULL;
-  infile = fopen("/proc/cpuinfo", "r");
-  while (fgets(buffer, sizeof(buffer), infile)){
-    if (!strncmp("cpu", buffer, 3)){
-	p = strchr(buffer, ':') + 2;
-#if 0
-	fprintf(stderr, "%s\n", p);
-#endif
-	break;
-      }
-  }
-
-  fclose(infile);
-
-  if(p != NULL){
-  if (strstr(p, "Loongson-3A")){
-    return CPU_LOONGSON3A;
-  }else if(strstr(p, "Loongson-3B")){
-    return CPU_LOONGSON3B;
-  }else if (strstr(p, "Loongson-3")){
-    infile = fopen("/proc/cpuinfo", "r");
-    p = (char *)NULL;
-    while (fgets(buffer, sizeof(buffer), infile)){
-      if (!strncmp("system type", buffer, 11)){
-	p = strchr(buffer, ':') + 2;
-	break;
-      }
-    }
-    fclose(infile);
-    if (strstr(p, "loongson3a"))
-      return CPU_LOONGSON3A;
-  }else{
-    return CPU_SICORTEX;
-  }
-  }
-  //Check model name for Loongson3
-  infile = fopen("/proc/cpuinfo", "r");
-  p = (char *)NULL;
-  while (fgets(buffer, sizeof(buffer), infile)){
-    if (!strncmp("model name", buffer, 10)){
-      p = strchr(buffer, ':') + 2;
-      break;
-    }
-  }
-  fclose(infile);
-  if(p != NULL){
-  if (strstr(p, "Loongson-3A")){
-    return CPU_LOONGSON3A;
-  }else if(strstr(p, "Loongson-3B")){
-    return CPU_LOONGSON3B;
-  }
-  }
-#endif
-    return CPU_UNKNOWN;
-}
-
-char *get_corename(void){
-  return cpuname[detect()];
-}
-
-void get_architecture(void){
-  printf("MIPS64");
-}
-
-void get_subarchitecture(void){
-  if(detect()==CPU_LOONGSON3A) {
-    printf("LOONGSON3A");
-  }else if(detect()==CPU_LOONGSON3B){
-    printf("LOONGSON3B");
-  }else if(detect()==CPU_I6400){
-    printf("I6400");
-  }else if(detect()==CPU_P6600){
-    printf("P6600");
-  }else if(detect()==CPU_I6500){
-    printf("I6500");
-  }else{
-    printf("SICORTEX");
-  }
-}
-
-void get_subdirname(void){
-  printf("mips64");
-}
-
-void get_cpuconfig(void){
-  if(detect()==CPU_LOONGSON3A) {
-    printf("#define LOONGSON3A\n");
-    printf("#define L1_DATA_SIZE 65536\n");
-    printf("#define L1_DATA_LINESIZE 32\n");
-    printf("#define L2_SIZE 512488\n");
-    printf("#define L2_LINESIZE 32\n");
-    printf("#define DTB_DEFAULT_ENTRIES 64\n");
-    printf("#define DTB_SIZE 4096\n");
-    printf("#define L2_ASSOCIATIVE 4\n");
-  }else if(detect()==CPU_LOONGSON3B){
-    printf("#define LOONGSON3B\n");
-    printf("#define L1_DATA_SIZE 65536\n");
-    printf("#define L1_DATA_LINESIZE 32\n");
-    printf("#define L2_SIZE 512488\n");
-    printf("#define L2_LINESIZE 32\n");
-    printf("#define DTB_DEFAULT_ENTRIES 64\n");
-    printf("#define DTB_SIZE 4096\n");
-    printf("#define L2_ASSOCIATIVE 4\n");
-  }else if(detect()==CPU_I6400){
-    printf("#define I6400\n");
-    printf("#define L1_DATA_SIZE 65536\n");
-    printf("#define L1_DATA_LINESIZE 32\n");
-    printf("#define L2_SIZE 1048576\n");
-    printf("#define L2_LINESIZE 32\n");
-    printf("#define DTB_DEFAULT_ENTRIES 64\n");
-    printf("#define DTB_SIZE 4096\n");
-    printf("#define L2_ASSOCIATIVE 8\n");
-  }else if(detect()==CPU_P6600){
-    printf("#define P6600\n");
-    printf("#define L1_DATA_SIZE 65536\n");
-    printf("#define L1_DATA_LINESIZE 32\n");
-    printf("#define L2_SIZE 1048576\n");
-    printf("#define L2_LINESIZE 32\n");
-    printf("#define DTB_DEFAULT_ENTRIES 64\n");
-    printf("#define DTB_SIZE 4096\n");
-    printf("#define L2_ASSOCIATIVE 8\n");
-  }else if(detect()==CPU_I6500){
-    printf("#define I6500\n");
-    printf("#define L1_DATA_SIZE 65536\n");
-    printf("#define L1_DATA_LINESIZE 32\n");
-    printf("#define L2_SIZE 1048576\n");
-    printf("#define L2_LINESIZE 32\n");
-    printf("#define DTB_DEFAULT_ENTRIES 64\n");
-    printf("#define DTB_SIZE 4096\n");
-    printf("#define L2_ASSOCIATIVE 8\n");
-  }else{
-    printf("#define SICORTEX\n");
-    printf("#define L1_DATA_SIZE 32768\n");
-    printf("#define L1_DATA_LINESIZE 32\n");
-    printf("#define L2_SIZE 512488\n");
-    printf("#define L2_LINESIZE 32\n");
-    printf("#define DTB_DEFAULT_ENTRIES 32\n");
-    printf("#define DTB_SIZE 4096\n");
-    printf("#define L2_ASSOCIATIVE 8\n");
-  }
-}
-
-void get_libname(void){
-  if(detect()==CPU_LOONGSON3A) {
-    printf("loongson3a\n");
-  }else if(detect()==CPU_LOONGSON3B) {
-    printf("loongson3b\n");
-  }else if(detect()==CPU_I6400) {
-    printf("i6400\n");
-  }else if(detect()==CPU_P6600) {
-    printf("p6600\n");
-  }else if(detect()==CPU_I6500) {
-    printf("i6500\n");
-  }else{
-    printf("mips64\n");
-  }
-}

cpuid_power.c

@@ -55,8 +55,6 @@
 #define CPUTYPE_POWER6     5
 #define CPUTYPE_CELL       6
 #define CPUTYPE_PPCG4	   7
-#define CPUTYPE_POWER8     8
-#define CPUTYPE_POWER9     9
 
 char *cpuname[] = {
   "UNKNOWN",
@@ -67,8 +65,6 @@ char *cpuname[] = {
   "POWER6",
   "CELL",
   "PPCG4",
-  "POWER8",
-  "POWER9"
 };
 
 char *lowercpuname[] = {
@@ -80,8 +76,6 @@ char *lowercpuname[] = {
   "power6",
   "cell",
   "ppcg4",
-  "power8",
-  "power9"	
 };
 
 char *corename[] = {
@@ -93,8 +87,6 @@ char *corename[] = {
   "POWER6",
   "CELL",
   "PPCG4",
-  "POWER8",
-  "POWER9"   	
 };
 
 int detect(void){
@@ -123,8 +115,6 @@ int detect(void){
   if (!strncasecmp(p, "POWER5", 6)) return CPUTYPE_POWER5;
   if (!strncasecmp(p, "POWER6", 6)) return CPUTYPE_POWER6;
   if (!strncasecmp(p, "POWER7", 6)) return CPUTYPE_POWER6;
-  if (!strncasecmp(p, "POWER8", 6)) return CPUTYPE_POWER8;
-  if (!strncasecmp(p, "POWER9", 6)) return CPUTYPE_POWER9;
   if (!strncasecmp(p, "Cell",   4)) return CPUTYPE_CELL;
   if (!strncasecmp(p, "7447",   4)) return CPUTYPE_PPCG4;
 
@@ -132,33 +122,6 @@ int detect(void){
 #endif
 
 #ifdef _AIX
-  FILE *infile;
-  char buffer[512], *p;
-
-  p = (char *)NULL;
-  infile = popen("prtconf|grep 'Processor Type'", "r");
-  while (fgets(buffer, sizeof(buffer), infile)){
-    if (!strncmp("Pro", buffer, 3)){
-	p = strchr(buffer, ':') + 2;
-#if 0
-	fprintf(stderr, "%s\n", p);
-#endif
-	break;
-      }
-  }
-
-  pclose(infile);
-
-  if (!strncasecmp(p, "POWER3", 6)) return CPUTYPE_POWER3;
-  if (!strncasecmp(p, "POWER4", 6)) return CPUTYPE_POWER4;
-  if (!strncasecmp(p, "PPC970", 6)) return CPUTYPE_PPC970;
-  if (!strncasecmp(p, "POWER5", 6)) return CPUTYPE_POWER5;
-  if (!strncasecmp(p, "POWER6", 6)) return CPUTYPE_POWER6;
-  if (!strncasecmp(p, "POWER7", 6)) return CPUTYPE_POWER6;
-  if (!strncasecmp(p, "POWER8", 6)) return CPUTYPE_POWER8;
-  if (!strncasecmp(p, "POWER9", 6)) return CPUTYPE_POWER9;
-  if (!strncasecmp(p, "Cell",   4)) return CPUTYPE_CELL;
-  if (!strncasecmp(p, "7447",   4)) return CPUTYPE_PPCG4;
   return CPUTYPE_POWER5;
 #endif
 
@@ -174,52 +137,6 @@ int detect(void){
 
   return  CPUTYPE_PPC970;
 #endif
-
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
-int id;
-__asm __volatile("mfpvr %0" : "=r"(id));
-switch ( id >> 16 ) {
-  case 0x4e: // POWER9
-    return CPUTYPE_POWER9;
-    break;
-  case 0x4d:
-  case 0x4b: // POWER8/8E 
-    return CPUTYPE_POWER8;
-    break;
-  case 0x4a:
-  case 0x3f:  // POWER7/7E
-    return CPUTYPE_POWER6; 
-    break;
-  case 0x3e:
-    return CPUTYPE_POWER6;
-    break;
-  case 0x3a:
-    return CPUTYPE_POWER5;
-    break;
-  case 0x35:
-  case 0x38: // POWER4 /4+ 
-    return CPUTYPE_POWER4;
-    break;
-  case 0x40:
-  case 0x41: // POWER3 /3+ 
-    return CPUTYPE_POWER3;
-    break;
-  case 0x39:
-  case 0x3c:
-  case 0x44:
-  case 0x45:
-    return CPUTYPE_PPC970;
-    break;
-  case 0x70: 
-    return CPUTYPE_CELL;
-    break;
-  case 0x8003: 
-    return CPUTYPE_PPCG4;
-    break;
-  default:  
-    return  CPUTYPE_UNKNOWN;
-  }
-#endif
 }
 
 void get_architecture(void){

cpuid_sparc.c

@@ -49,7 +49,6 @@ void get_subdirname(void){
 }
 
 void get_cpuconfig(void){
-  printf("#define SPARC\n");
   printf("#define V9\n");
   printf("#define DTB_DEFAULT_ENTRIES 32\n");
 }
@@ -57,8 +56,3 @@ void get_cpuconfig(void){
 void get_libname(void){
   printf("v9\n");
 }
-
-char *get_corename(void){
-  return "sparc";
-}
-