mirror of
https://github.com/amd/blis.git
synced 2026-05-11 17:50:00 +00:00
b9c9f03502
Details:
- Implemented a new sub-framework within BLIS to support the management
of code and kernels that specifically target matrix problems for which
at least one dimension is deemed to be small, which can result in long
and skinny matrix operands that are ill-suited for the conventional
level-3 implementations in BLIS. The new framework tackles the problem
in two ways. First the stripped-down algorithmic loops forgo the
packing that is famously performed in the classic code path. That is,
the computation is performed by a new family of kernels tailored
specifically for operating on the source matrices as-is (unpacked).
Second, these new kernels will typically (and in the case of haswell
and zen, do in fact) include separate assembly sub-kernels for
handling of edge cases, which helps smooth performance when performing
problems whose m and n dimension are not naturally multiples of the
register blocksizes. In a reference to the sub-framework's purpose of
supporting skinny/unpacked level-3 operations, the "sup" operation
suffix (e.g. gemmsup) is typically used to denote a separate namespace
for related code and kernels. NOTE: Since the sup framework does not
perform any packing, it targets row- and column-stored matrices A, B,
and C. For now, if any matrix has non-unit strides in both dimensions,
the problem is computed by the conventional implementation.
- Implemented the default sup handler as a front-end to two variants.
bli_gemmsup_ref_var2() provides a block-panel variant (in which the
2nd loop around the microkernel iterates over n and the 1st loop
iterates over m), while bli_gemmsup_ref_var1() provides a panel-block
variant (2nd loop over m and 1st loop over n). However, these variants
are not used by default and provided for reference only. Instead, the
default sup handler calls _var2m() and _var1n(), which are similar
to _var2() and _var1(), respectively, except that they defer to the
sup kernel itself to iterate over the m and n dimension, respectively.
In other words, these variants rely not on microkernels, but on
so-called "millikernels" that iterate along m and k, or n and k.
The benefit of using millikernels is a reduction of function call
and related (local integer typecast) overhead as well as the ability
for the kernel to know which micropanel (A or B) will change during
the next iteration of the 1st loop, which allows it to focus its
prefetching on that micropanel. (In _var2m()'s millikernel, the upanel
of A changes while the same upanel of B is reused. In _var1n()'s, the
upanel of B changes while the upanel of A is reused.)
- Added a new configure option, --[en|dis]able-sup-handling, which is
enabled by default. However, the default thresholds at which the
default sup handler is activated are set to zero for each of the m, n,
and k dimensions, which effectively disables the implementation. (The
default sup handler only accepts the problem if at least one dimension
is smaller than or equal to its corresponding threshold. If all
dimensions are larger than their thresholds, the problem is rejected
by the sup front-end and control is passed back to the conventional
implementation, which proceeds normally.)
- Added support to the cntx_t structure to track new fields related to
the sup framework, most notably:
- sup thresholds: the thresholds at which the sup handler is called.
- sup handlers: the address of the function to call to implement
the level-3 skinny/unpacked matrix implementation.
- sup blocksizes: the register and cache blocksizes used by the sup
implementation (which may be the same or different from those used
by the conventional packm-based approach).
- sup kernels: the kernels that the handler will use in implementing
the sup functionality.
- sup kernel prefs: the IO preference of the sup kernels, which may
differ from the preferences of the conventional gemm microkernels'
IO preferences.
- Added a bool_t to the rntm_t structure that indicates whether sup
handling should be enabled/disabled. This allows per-call control
of whether the sup implementation is used, which is useful for test
drivers that wish to switch between the conventional and sup codes
without having to link to different copies of BLIS. The corresponding
accessor functions for this new bool_t are defined in bli_rntm.h.
- Implemented several row-preferential gemmsup kernels in a new
directory, kernels/haswell/3/sup. These kernels include two general
implementation types--'rd' and 'rv'--for the 6x8 base shape, with
two specialized millikernels that embed the 1st loop within the kernel
itself.
- Added ref_kernels/3/bli_gemmsup_ref.c, which provides reference
gemmsup microkernels. NOTE: These microkernels, unlike the current
crop of conventional (pack-based) microkernels, do not use constant
loop bounds. Additionally, their inner loop iterates over the k
dimension.
- Defined new typedef enums:
- stor3_t: captures the effective storage combination of the level-3
problem. Valid values are BLIS_RRR, BLIS_RRC, BLIS_RCR, etc. A
special value of BLIS_XXX is used to denote an arbitrary combination
which, in practice, means that at least one of the operands is
stored according to general stride.
- threshid_t: captures each of the three dimension thresholds.
- Changed bli_adjust_strides() in bli_obj.c so that bli_obj_create()
can be passed "-1, -1" as a lazy request for row storage. (Note that
"0, 0" is still accepted as a lazy request for column storage.)
- Added support for various instructions to bli_x86_asm_macros.h,
including imul, vhaddps/pd, and other instructions related to integer
vectors.
- Disabled the older small matrix handling code inserted by AMD in
bli_gemm_front.c, since the sup framework introduced in this commit
is intended to provide a more generalized solution.
- Added test/sup directory, which contains standalone performance test
drivers, a Makefile, a runme.sh script, and an 'octave' directory
containing scripts compatible with GNU Octave. (They also may work
with matlab, but if not, they are probably close to working.)
- Reinterpret the storage combination string (sc_str) in the various
level-3 testsuite modules (e.g. src/test_gemm.c) so that the order
of each matrix storage char is "cab" rather than "abc".
- Comment updates in level-3 BLAS API wrappers in frame/compat.
447 lines
15 KiB
Makefile
447 lines
15 KiB
Makefile
#!/bin/bash
|
|
#
|
|
# BLIS
|
|
# An object-based framework for developing high-performance BLAS-like
|
|
# libraries.
|
|
#
|
|
# Copyright (C) 2014, The University of Texas at Austin
|
|
# Copyright (C) 2019, Advanced Micro Devices, Inc.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are
|
|
# met:
|
|
# - Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# - 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.
|
|
# - Neither the name(s) of the copyright holder(s) 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
|
|
# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
#
|
|
#
|
|
|
|
#
|
|
# Makefile
|
|
#
|
|
# Field G. Van Zee
|
|
#
|
|
# Makefile for standalone BLIS test drivers.
|
|
#
|
|
|
|
#
|
|
# --- Makefile PHONY target definitions ----------------------------------------
|
|
#
|
|
|
|
.PHONY: all all-st all-mt \
|
|
blis blis-st blis-mt \
|
|
clean cleanx
|
|
|
|
|
|
|
|
#
|
|
# --- Determine makefile fragment location -------------------------------------
|
|
#
|
|
|
|
# Comments:
|
|
# - DIST_PATH is assumed to not exist if BLIS_INSTALL_PATH is given.
|
|
# - We must use recursively expanded assignment for LIB_PATH and INC_PATH in
|
|
# the second case because CONFIG_NAME is not yet set.
|
|
ifneq ($(strip $(BLIS_INSTALL_PATH)),)
|
|
LIB_PATH := $(BLIS_INSTALL_PATH)/lib
|
|
INC_PATH := $(BLIS_INSTALL_PATH)/include/blis
|
|
SHARE_PATH := $(BLIS_INSTALL_PATH)/share/blis
|
|
else
|
|
DIST_PATH := ../..
|
|
LIB_PATH = ../../lib/$(CONFIG_NAME)
|
|
INC_PATH = ../../include/$(CONFIG_NAME)
|
|
SHARE_PATH := ../..
|
|
endif
|
|
|
|
|
|
|
|
#
|
|
# --- Include common makefile definitions --------------------------------------
|
|
#
|
|
|
|
# Include the common makefile fragment.
|
|
-include $(SHARE_PATH)/common.mk
|
|
|
|
|
|
|
|
#
|
|
# --- BLAS and LAPACK implementations ------------------------------------------
|
|
#
|
|
|
|
# BLIS library and header path. This is simply wherever it was installed.
|
|
#BLIS_LIB_PATH := $(INSTALL_PREFIX)/lib
|
|
#BLIS_INC_PATH := $(INSTALL_PREFIX)/include/blis
|
|
|
|
# BLIS library.
|
|
#BLIS_LIB := $(BLIS_LIB_PATH)/libblis.a
|
|
|
|
# BLAS library path(s). This is where the BLAS libraries reside.
|
|
HOME_LIB_PATH := $(HOME)/flame/lib
|
|
MKL_LIB_PATH := $(HOME)/intel/mkl/lib/intel64
|
|
|
|
# OpenBLAS
|
|
OPENBLAS_LIB := $(HOME_LIB_PATH)/libopenblas.a
|
|
OPENBLASP_LIB := $(HOME_LIB_PATH)/libopenblasp.a
|
|
|
|
# ATLAS
|
|
ATLAS_LIB := $(HOME_LIB_PATH)/libf77blas.a \
|
|
$(HOME_LIB_PATH)/libatlas.a
|
|
|
|
# Eigen
|
|
EIGEN_INC := $(HOME)/flame/eigen/include/eigen3
|
|
EIGEN_LIB := $(HOME_LIB_PATH)/libeigen_blas_static.a
|
|
EIGENP_LIB := $(EIGEN_LIB)
|
|
|
|
# MKL
|
|
MKL_LIB := -L$(MKL_LIB_PATH) \
|
|
-lmkl_intel_lp64 \
|
|
-lmkl_core \
|
|
-lmkl_sequential \
|
|
-lpthread -lm -ldl
|
|
MKLP_LIB := -L$(MKL_LIB_PATH) \
|
|
-lmkl_intel_lp64 \
|
|
-lmkl_core \
|
|
-lmkl_gnu_thread \
|
|
-lpthread -lm -ldl -fopenmp
|
|
#-L$(ICC_LIB_PATH) \
|
|
#-lgomp
|
|
|
|
VENDOR_LIB := $(MKL_LIB)
|
|
VENDORP_LIB := $(MKLP_LIB)
|
|
|
|
|
|
#
|
|
# --- Problem size definitions -------------------------------------------------
|
|
#
|
|
|
|
# Single core
|
|
PS_BEGIN := 16
|
|
PS_MAX := 800
|
|
PS_INC := 16
|
|
|
|
# Multicore
|
|
P1_BEGIN := 120
|
|
P1_MAX := 6000
|
|
P1_INC := 120
|
|
|
|
|
|
#
|
|
# --- General build definitions ------------------------------------------------
|
|
#
|
|
|
|
TEST_SRC_PATH := .
|
|
TEST_OBJ_PATH := .
|
|
|
|
# Gather all local object files.
|
|
TEST_OBJS := $(sort $(patsubst $(TEST_SRC_PATH)/%.c, \
|
|
$(TEST_OBJ_PATH)/%.o, \
|
|
$(wildcard $(TEST_SRC_PATH)/*.c)))
|
|
|
|
# Override the value of CINCFLAGS so that the value of CFLAGS returned by
|
|
# get-frame-cflags-for() is not cluttered up with include paths needed only
|
|
# while building BLIS.
|
|
CINCFLAGS := -I$(INC_PATH)
|
|
|
|
# Use the "framework" CFLAGS for the configuration family.
|
|
CFLAGS := $(call get-user-cflags-for,$(CONFIG_NAME))
|
|
|
|
# Add local header paths to CFLAGS.
|
|
CFLAGS += -I$(TEST_SRC_PATH)
|
|
|
|
# Locate the libblis library to which we will link.
|
|
LIBBLIS_LINK := $(LIB_PATH)/$(LIBBLIS_L)
|
|
|
|
# Define a set of CFLAGS for use with C++ and Eigen.
|
|
CXXFLAGS := $(subst -std=c99,-std=c++11,$(CFLAGS))
|
|
CXXFLAGS += -I$(EIGEN_INC)
|
|
|
|
# Create a copy of CXXFLAGS without -fopenmp in order to disable multithreading.
|
|
CXXFLAGS_ST := -march=native $(subst -fopenmp,,$(CXXFLAGS))
|
|
CXXFLAGS_MT := -march=native $(CXXFLAGS)
|
|
|
|
# Single or multithreaded string
|
|
STR_ST := -DTHR_STR=\"st\"
|
|
STR_MT := -DTHR_STR=\"mt\"
|
|
|
|
# Number of trials per problem size.
|
|
N_TRIALS := -DN_TRIALS=3
|
|
|
|
# Problem size specification
|
|
PDEF_ST := -DP_BEGIN=$(PS_BEGIN) \
|
|
-DP_MAX=$(PS_MAX) \
|
|
-DP_INC=$(PS_INC)
|
|
|
|
PDEF_MT := -DP_BEGIN=$(P1_BEGIN) \
|
|
-DP_MAX=$(P1_MAX) \
|
|
-DP_INC=$(P1_INC)
|
|
|
|
ifeq ($(E),1)
|
|
ERRCHK := -DERROR_CHECK
|
|
else
|
|
ERRCHK := -DNO_ERROR_CHECK
|
|
endif
|
|
|
|
# Enumerate possible datatypes and computation precisions.
|
|
#dts := s d c z
|
|
DTS := d
|
|
|
|
TRANS := n_n \
|
|
n_t \
|
|
t_n \
|
|
t_t
|
|
|
|
STORS := r_r_r \
|
|
r_r_c \
|
|
r_c_r \
|
|
r_c_c \
|
|
c_r_r \
|
|
c_r_c \
|
|
c_c_r \
|
|
c_c_c
|
|
|
|
SHAPES := l_l_s \
|
|
l_s_l \
|
|
s_l_l \
|
|
s_s_l \
|
|
s_l_s \
|
|
l_s_s
|
|
|
|
SMS := 6
|
|
SNS := 8
|
|
SKS := 4
|
|
|
|
|
|
#
|
|
# --- Function definitions -----------------------------------------------------
|
|
#
|
|
|
|
# A function to strip the underscores from a list of strings.
|
|
stripu = $(subst _,,$(1))
|
|
|
|
# Various functions that help us construct the datatype combinations and then
|
|
# extract the needed datatype strings and C preprocessor define flags.
|
|
get-1of2 = $(word 1,$(subst _, ,$(1)))
|
|
get-2of2 = $(word 2,$(subst _, ,$(1)))
|
|
|
|
get-1of3 = $(word 1,$(subst _, ,$(1)))
|
|
get-2of3 = $(word 2,$(subst _, ,$(1)))
|
|
get-3of3 = $(word 3,$(subst _, ,$(1)))
|
|
|
|
# Datatype defs.
|
|
get-dt-cpp = $(strip \
|
|
$(if $(findstring s,$(1)),-DDT=BLIS_FLOAT -DIS_FLOAT,\
|
|
$(if $(findstring d,$(1)),-DDT=BLIS_DOUBLE -DIS_DOUBLE,\
|
|
$(if $(findstring c,$(1)),-DDT=BLIS_SCOMPLEX -DIS_SCOMPLEX,\
|
|
-DDT=BLIS_DCOMPLEX -DIS_DCOMPLEX))))
|
|
|
|
# Transpose defs.
|
|
get-tra-defs-a = $(strip $(subst n,-DTRANSA=BLIS_NO_TRANSPOSE -DA_NOTRANS, \
|
|
$(subst t,-DTRANSA=BLIS_TRANSPOSE -DA_TRANS,$(call get-1of2,$(1)))))
|
|
get-tra-defs-b = $(strip $(subst n,-DTRANSB=BLIS_NO_TRANSPOSE -DB_NOTRANS, \
|
|
$(subst t,-DTRANSB=BLIS_TRANSPOSE -DB_TRANS,$(call get-2of2,$(1)))))
|
|
get-tra-defs = $(call get-tra-defs-a,$(1)) $(call get-tra-defs-b,$(1))
|
|
|
|
# Storage defs.
|
|
get-sto-uch-a = $(strip $(subst r,R, \
|
|
$(subst c,C,$(call get-1of3,$(1)))))
|
|
get-sto-uch-b = $(strip $(subst r,R, \
|
|
$(subst c,C,$(call get-2of3,$(1)))))
|
|
get-sto-uch-c = $(strip $(subst r,R, \
|
|
$(subst c,C,$(call get-3of3,$(1)))))
|
|
get-sto-defs = $(strip \
|
|
-DSTOR3=BLIS_$(call get-sto-uch-a,$(1))$(call get-sto-uch-b,$(1))$(call get-sto-uch-c,$(1)) \
|
|
-DA_STOR_$(call get-sto-uch-a,$(1)) \
|
|
-DB_STOR_$(call get-sto-uch-b,$(1)) \
|
|
-DC_STOR_$(call get-sto-uch-c,$(1)))
|
|
|
|
# Dimension defs.
|
|
get-shape-defs-cm = $(if $(findstring l,$(1)),-DM_DIM=-1,-DM_DIM=$(2))
|
|
get-shape-defs-cn = $(if $(findstring l,$(1)),-DN_DIM=-1,-DN_DIM=$(2))
|
|
get-shape-defs-ck = $(if $(findstring l,$(1)),-DK_DIM=-1,-DK_DIM=$(2))
|
|
get-shape-defs-m = $(call get-shape-defs-cm,$(call get-1of3,$(1)),$(2))
|
|
get-shape-defs-n = $(call get-shape-defs-cn,$(call get-2of3,$(1)),$(2))
|
|
get-shape-defs-k = $(call get-shape-defs-ck,$(call get-3of3,$(1)),$(2))
|
|
|
|
# arguments: 1: shape (w/ underscores) 2: smallm 3: smalln 4: smallk
|
|
get-shape-defs = $(strip $(call get-shape-defs-m,$(1),$(2)) \
|
|
$(call get-shape-defs-n,$(1),$(3)) \
|
|
$(call get-shape-defs-k,$(1),$(4)))
|
|
|
|
#$(error l_l_s 6 8 4 = $(call get-shape-defs,l_l_s,6,8,4))
|
|
|
|
# Shape-dimension string.
|
|
get-shape-str-ch = $(if $(findstring l,$(1)),p,$(2))
|
|
get-shape-str-m = $(call get-shape-str-ch,$(call get-1of3,$(1)),$(2))
|
|
get-shape-str-n = $(call get-shape-str-ch,$(call get-2of3,$(1)),$(2))
|
|
get-shape-str-k = $(call get-shape-str-ch,$(call get-3of3,$(1)),$(2))
|
|
|
|
# arguments: 1: shape (w/ underscores) 2: smallm 3: smalln 4: smallk
|
|
get-shape-dim-str = m$(call get-shape-str-m,$(1),$(2))n$(call get-shape-str-n,$(1),$(3))k$(call get-shape-str-k,$(1),$(4))
|
|
|
|
# Implementation defs.
|
|
# Define a function to return the appropriate -DSTR= and -D[BLIS|BLAS] flags.
|
|
get-imp-defs = $(strip $(subst blissup,-DSTR=\"$(1)\" -DBLIS -DSUP, \
|
|
$(subst blislpab,-DSTR=\"$(1)\" -DBLIS, \
|
|
$(subst eigen,-DSTR=\"$(1)\" -DEIGEN, \
|
|
$(subst openblas,-DSTR=\"$(1)\" -DCBLAS, \
|
|
$(subst vendor,-DSTR=\"$(1)\" -DCBLAS,$(1)))))))
|
|
|
|
TRANS0 = $(call stripu,$(TRANS))
|
|
STORS0 = $(call stripu,$(STORS))
|
|
|
|
# Limit BLAS and Eigen to only using all row-stored, or all column-stored matrices.
|
|
BSTORS0 = rrr ccc
|
|
ESTORS0 = rrr ccc
|
|
|
|
|
|
#
|
|
# --- Object and binary file definitons ----------------------------------------
|
|
#
|
|
|
|
get-st-objs = $(foreach dt,$(1),$(foreach tr,$(2),$(foreach st,$(3),$(foreach sh,$(4),$(foreach sm,$(5),$(foreach sn,$(6),$(foreach sk,$(7),test_$(dt)gemm_$(tr)_$(st)_$(call get-shape-dim-str,$(sh),$(sm),$(sn),$(sk))_$(8)_st.o)))))))
|
|
|
|
# Build a list of object files and binaries for each single-threaded
|
|
# implementation using the get-st-objs() function defined above.
|
|
BLISSUP_ST_OBJS := $(call get-st-objs,$(DTS),$(TRANS0),$(STORS0),$(SHAPES),$(SMS),$(SNS),$(SKS),blissup)
|
|
BLISSUP_ST_BINS := $(patsubst %.o,%.x,$(BLISSUP_ST_OBJS))
|
|
|
|
BLISLPAB_ST_OBJS := $(call get-st-objs,$(DTS),$(TRANS0),$(STORS0),$(SHAPES),$(SMS),$(SNS),$(SKS),blislpab)
|
|
BLISLPAB_ST_BINS := $(patsubst %.o,%.x,$(BLISLPAB_ST_OBJS))
|
|
|
|
EIGEN_ST_OBJS := $(call get-st-objs,$(DTS),$(TRANS0),$(ESTORS0),$(SHAPES),$(SMS),$(SNS),$(SKS),eigen)
|
|
EIGEN_ST_BINS := $(patsubst %.o,%.x,$(EIGEN_ST_OBJS))
|
|
|
|
OPENBLAS_ST_OBJS := $(call get-st-objs,$(DTS),$(TRANS0),$(BSTORS0),$(SHAPES),$(SMS),$(SNS),$(SKS),openblas)
|
|
OPENBLAS_ST_BINS := $(patsubst %.o,%.x,$(OPENBLAS_ST_OBJS))
|
|
|
|
VENDOR_ST_OBJS := $(call get-st-objs,$(DTS),$(TRANS0),$(BSTORS0),$(SHAPES),$(SMS),$(SNS),$(SKS),vendor)
|
|
VENDOR_ST_BINS := $(patsubst %.o,%.x,$(VENDOR_ST_OBJS))
|
|
|
|
#$(error "objs = $(EIGEN_ST_BINS)" )
|
|
|
|
# Mark the object files as intermediate so that make will remove them
|
|
# automatically after building the binaries on which they depend.
|
|
.INTERMEDIATE: $(BLISSUP_ST_OBJS) \
|
|
$(BLISLPAB_ST_OBJS) \
|
|
$(EIGEN_ST_OBJS) \
|
|
$(OPENBLAS_ST_OBJS) \
|
|
$(VENDOR_ST_OBJS)
|
|
|
|
|
|
#
|
|
# --- Targets/rules ------------------------------------------------------------
|
|
#
|
|
|
|
all: st
|
|
|
|
blissup: blissup-st
|
|
blislpab: blislpab-st
|
|
eigen: eigen-st
|
|
openblas: openblas-st
|
|
vendor: vendor-st
|
|
|
|
st: blissup-st blislpab-st eigen-st openblas-st vendor-st
|
|
blis: blissup-st blislpab-st
|
|
|
|
blissup-st: $(BLISSUP_ST_BINS)
|
|
blislpab-st: $(BLISLPAB_ST_BINS)
|
|
eigen-st: $(EIGEN_ST_BINS)
|
|
openblas-st: $(OPENBLAS_ST_BINS)
|
|
vendor-st: $(VENDOR_ST_BINS)
|
|
|
|
|
|
# --Object file rules --
|
|
|
|
# Define the implementations for which we will instantiate compilation rules.
|
|
BIMPLS := blissup blislpab openblas vendor
|
|
EIMPLS := eigen
|
|
|
|
# 1 2 3 4 567 8
|
|
# test_dgemm_nn_rrr_mpn6kp_blissup_st.x
|
|
|
|
# Define the function that will be used to instantiate compilation rules
|
|
# for the various implementations.
|
|
define make-st-rule
|
|
test_$(1)gemm_$(call stripu,$(2))_$(call stripu,$(3))_$(call get-shape-dim-str,$(4),$(5),$(6),$(7))_$(8)_st.o: test_gemm.c Makefile
|
|
$(CC) $(CFLAGS) $(ERRCHK) $(N_TRIALS) $(PDEF_ST) $(call get-dt-cpp,$(1)) $(call get-tra-defs,$(2)) $(call get-sto-defs,$(3)) $(call get-shape-defs,$(4),$(5),$(6),$(7)) $(call get-imp-defs,$(8)) $(STR_ST) -c $$< -o $$@
|
|
endef
|
|
|
|
# Instantiate the rule function make-st-rule() for each BLIS/BLAS/CBLAS
|
|
# implementation.
|
|
$(foreach dt,$(DTS), \
|
|
$(foreach tr,$(TRANS), \
|
|
$(foreach st,$(STORS), \
|
|
$(foreach sh,$(SHAPES), \
|
|
$(foreach sm,$(SMS), \
|
|
$(foreach sn,$(SNS), \
|
|
$(foreach sk,$(SKS), \
|
|
$(foreach impl,$(BIMPLS), \
|
|
$(eval $(call make-st-rule,$(dt),$(tr),$(st),$(sh),$(sm),$(sn),$(sk),$(impl)))))))))))
|
|
|
|
# Define the function that will be used to instantiate compilation rules
|
|
# for the various implementations.
|
|
define make-eigst-rule
|
|
test_$(1)gemm_$(call stripu,$(2))_$(call stripu,$(3))_$(call get-shape-dim-str,$(4),$(5),$(6),$(7))_$(8)_st.o: test_gemm.c Makefile
|
|
$(CXX) $(CXXFLAGS_ST) $(ERRCHK) $(N_TRIALS) $(PDEF_ST) $(call get-dt-cpp,$(1)) $(call get-tra-defs,$(2)) $(call get-sto-defs,$(3)) $(call get-shape-defs,$(4),$(5),$(6),$(7)) $(call get-imp-defs,$(8)) $(STR_ST) -c $$< -o $$@
|
|
endef
|
|
|
|
# Instantiate the rule function make-st-rule() for each Eigen implementation.
|
|
$(foreach dt,$(DTS), \
|
|
$(foreach tr,$(TRANS), \
|
|
$(foreach st,$(STORS), \
|
|
$(foreach sh,$(SHAPES), \
|
|
$(foreach sm,$(SMS), \
|
|
$(foreach sn,$(SNS), \
|
|
$(foreach sk,$(SKS), \
|
|
$(foreach impl,$(EIMPLS), \
|
|
$(eval $(call make-eigst-rule,$(dt),$(tr),$(st),$(sh),$(sm),$(sn),$(sk),$(impl)))))))))))
|
|
|
|
|
|
# -- Executable file rules --
|
|
|
|
# NOTE: For the BLAS test drivers, we place the BLAS libraries before BLIS
|
|
# on the link command line in case BLIS was configured with the BLAS
|
|
# compatibility layer. This prevents BLIS from inadvertently getting called
|
|
# for the BLAS routines we are trying to test with.
|
|
|
|
test_%_blissup_st.x: test_%_blissup_st.o $(LIBBLIS_LINK)
|
|
$(CC) $(strip $< $(LIBBLIS_LINK) $(LDFLAGS) -o $@)
|
|
|
|
test_%_blislpab_st.x: test_%_blislpab_st.o $(LIBBLIS_LINK)
|
|
$(CC) $(strip $< $(LIBBLIS_LINK) $(LDFLAGS) -o $@)
|
|
|
|
test_%_eigen_st.x: test_%_eigen_st.o $(LIBBLIS_LINK)
|
|
$(CXX) $(strip $< $(LIBBLIS_LINK) $(LDFLAGS) -o $@)
|
|
|
|
test_%_openblas_st.x: test_%_openblas_st.o $(LIBBLIS_LINK)
|
|
$(CC) $(strip $< $(OPENBLAS_LIB) $(LIBBLIS_LINK) $(LDFLAGS) -o $@)
|
|
|
|
test_%_vendor_st.x: test_%_vendor_st.o $(LIBBLIS_LINK)
|
|
$(CC) $(strip $< $(VENDOR_LIB) $(LIBBLIS_LINK) $(LDFLAGS) -o $@)
|
|
|
|
|
|
# -- Clean rules --
|
|
|
|
clean: cleanx
|
|
|
|
cleanx:
|
|
- $(RM_F) *.x
|
|
|