squall/cutlass
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
77d1e0ca81
cutlass/tools/test/unit/gemm/gemm_testbed.h
akerr 461f417b9d Checkpointing CUTLASS 1.1 release.
2018-09-18 16:58:03 -07:00

921 lines
33 KiB
C++
Raw Blame History

/***************************************************************************************************
* Copyright (c) 2017-2018, NVIDIA CORPORATION. All rights reserved.
*
* 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 of the NVIDIA CORPORATION 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 NVIDIA CORPORATION 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 TOR (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
**************************************************************************************************/
/*! \file
\brief Test environment for GEMM
*/
#pragma once
#include <fstream>
#include <iomanip>
#include <sstream>
#include <string>
#include <algorithm>
#include <cublas_v2.h>
#include "cutlass/matrix_traits.h"
#include "cutlass/util/platform.h"
#include "cutlass/gemm/gemm_coord.h"
#include "tools/util/host_matrix.h"
#include "tools/util/host_matrix_view.h"
#include "tools/util/tensor_view_io.h"
#include "tools/util/type_traits.h"
#include "tools/util/reference/host/gemm.h"
#include "tools/util/reference/host/tensor_elementwise.h"
//////////////////////////////////////////////////////////////////////////////////////////
namespace cutlass {
template <cutlass::GemmOperand::Kind kOperand_,
cutlass::MatrixLayout::Kind kLayout_,
typename Scalar_,
typename WmmaShape_>
struct WmmaMatrix;
} // namespace cutlass
//////////////////////////////////////////////////////////////////////////////////////////
namespace test {
//////////////////////////////////////////////////////////////////////////////////////////
template <typename T>
struct GemmTestbedTraits : public cutlass::TypeTraits<T> {};
template <cutlass::GemmOperand::Kind kOperand_,
cutlass::MatrixLayout::Kind kLayout_,
typename Scalar_,
typename WmmaShape_>
struct GemmTestbedTraits<cutlass::WmmaMatrix<kOperand_, kLayout_, Scalar_, WmmaShape_> > {
static cudaDataType_t const cublas_type = cutlass::TypeTraits<Scalar_>::cublas_type;
typedef typename cutlass::TypeTraits<Scalar_>::host_type host_type;
typedef typename cutlass::TypeTraits<Scalar_>::device_type device_type;
static inline double remove_negative_zero(double x) { return x == -0.0 ? 0.0 : x; }
static inline double to_print(double x) { return x; }
};
inline cublasOperation_t convert(cutlass::MatrixLayout::Kind layout) {
switch (layout) {
case cutlass::MatrixLayout::kRowMajor:
return CUBLAS_OP_T;
case cutlass::MatrixLayout::kColumnMajor:
return CUBLAS_OP_N;
default:
break;
}
return CUBLAS_OP_N;
}
inline cutlass::MatrixLayout::Kind convert(cublasOperation_t transform) {
switch (transform) {
case CUBLAS_OP_T:
return cutlass::MatrixLayout::kRowMajor;
case CUBLAS_OP_N:
return cutlass::MatrixLayout::kColumnMajor;
default:
break;
}
return cutlass::MatrixLayout::kColumnMajor;
}
//////////////////////////////////////////////////////////////////////////////////////////
/// Testbed for evaluating real-valued GEMMs
template <typename AType, typename BType, typename CType, typename Accumulator, typename Scalar>
struct GemmTestbed {
//
// Type definitions
//
/// Host tensor for operand A
typedef cutlass::HostMatrix<AType> HostMatrixA;
/// Host tensor for operand B
typedef cutlass::HostMatrix<BType> HostMatrixB;
/// Host tensor for operand C
typedef cutlass::HostMatrix<CType> HostMatrixC;
/// Functor to print errors
struct PrintErrors {
/// Equivalently sized integer type
typedef typename GemmTestbedTraits<CType>::integer_type integer_t;
/// Output stream to write to
std::ostream& out;
/// Reference tensor view
HostMatrixC const& reference;
/// Computed tensor view
HostMatrixC const& experimental;
/// Errors greater than or this amount result in printing
integer_t ulps_threshold;
///
PrintErrors(std::ostream& _out,
HostMatrixC const& _reference,
HostMatrixC const& _experimental,
integer_t _ulps_threshold = 1)
: out(_out),
reference(_reference),
experimental(_experimental),
ulps_threshold(_ulps_threshold) {}
/// Compares one element
void operator()(CType const& element, typename HostMatrixC::TensorCoord coord) {
CType exp = experimental.at(coord);
CType ref = reference.at(coord);
int64_t int_exp = 0;
int64_t int_ref = 0;
*reinterpret_cast<CType*>(&int_exp) = exp;
*reinterpret_cast<CType*>(&int_ref) = ref;
integer_t ulps = integer_t(int_exp - int_ref);
if (std::abs(ulps) >= ulps_threshold) {
// width in hexadecimal digits of value
int const width = sizeof(integer_t) * 2;
double relative = double(exp) - double(ref);
if (ref != CType(0)) {
relative /= double(ref);
}
out << "[" << coord << "] expected: " << GemmTestbedTraits<CType>::to_print(ref) << " (0x"
<< std::hex << std::setw(width) << std::setfill('0') << integer_t(int_ref) << std::dec
<< ")"
<< ", got: " << GemmTestbedTraits<CType>::to_print(exp) << " (0x" << std::hex
<< std::setw(width) << std::setfill('0') << integer_t(int_exp) << std::dec << ")"
<< " relative error: " << relative << ", ulps: " << ulps << "\n";
}
}
};
/// Generates random elements
template <typename T>
struct RandomGenerator {
RandomGenerator(int seed = -1, bool only_ones_ = false) : only_ones(only_ones_) { srand(seed); }
T operator()() {
if (only_ones) {
return T(1);
} else {
int val = (rand() % 16) - 8;
return T(val);
}
}
bool only_ones;
};
template <typename T>
struct RandomBitGenerator {
RandomBitGenerator(int seed = -1) { srand(seed); }
T operator()() {
uint32_t val = 0;
for (int i = 0; i < 32; i++) {
val |= rand() % 2;
val <<= 1;
}
return T(val);
}
};
//
// Data members
//
/// Status
cublasStatus_t status;
/// cuBLAS handle
cublasHandle_t handle;
/// cuBLAS GEMM algorithm selector
cublasGemmAlgo_t algorithm;
/// Problem size as a GemmCoord
cutlass::gemm::GemmCoord problem_size;
/// A matrix operand
HostMatrixA A;
/// Layout of A matrix
cublasOperation_t layout_A;
/// B matrix operand
HostMatrixB B;
/// Layout of B matrix
cublasOperation_t layout_B;
/// C matrix operand
HostMatrixC C_initial;
/// Reference result computed on the host
HostMatrixC ref_host;
/// Reference result computed with cublas
HostMatrixC ref_cublas;
/// Computed result
HostMatrixC computed;
/// Linear scalaring factor
Scalar alpha;
/// Linear scaling factor
Scalar beta;
/// batch count
int batch_count;
/// distance between A[i] and A[i+1] for strided batched gemm
long long int batch_stride_A;
/// distance between B[i] and B[i+1] for strided batched gemm
long long int batch_stride_B;
/// distance between C[i] and C[i+1] for strided batched gemm
long long int batch_stride_C;
//
// Static helpers
//
/// Helper to resize a matrix with a given size and layout
template <typename T>
static void resize(cutlass::HostMatrix<T>& tensor,
int rows,
int columns,
cublasOperation_t layout,
int ldm = 0) {
tensor.resize(cutlass::make_Coord(rows, columns), convert(layout), ldm);
}
//
// Methods
//
/// Constructs a workspace for verifying GEMM, assumes
/// dense packing.
GemmTestbed(int M_,
int N_,
int K_,
cublasOperation_t layout_a,
cublasOperation_t layout_b,
Scalar alpha_ = Scalar(1),
Scalar beta_ = Scalar(0),
cublasGemmAlgo_t algorithm_ = CUBLAS_GEMM_DEFAULT,
cublasOperation_t layout_c = CUBLAS_OP_N)
: problem_size(K_, N_, M_, 1),
layout_A(layout_a),
layout_B(layout_b),
alpha(alpha_),
beta(beta_),
algorithm(algorithm_),
batch_count(1),
batch_stride_A(static_cast<long long int>(0)),
batch_stride_B(static_cast<long long int>(0)),
batch_stride_C(static_cast<long long int>(0)) {
status = cublasCreate(&handle);
if (status != CUBLAS_STATUS_SUCCESS) {
throw cutlass::cuda_exception("Failed to create CUBLAS handle");
}
resize(A, M_, K_, layout_a);
resize(B, K_, N_, layout_b);
resize(C_initial, M_, N_, layout_c);
resize(ref_host, M_, N_, layout_c);
resize(ref_cublas, M_, N_, layout_c);
resize(computed, M_, N_, layout_c);
}
/// Constructs a workspace for verifying GEMM, assumes
/// dense packing.
GemmTestbed(cublasHandle_t handle_,
int M_,
int N_,
int K_,
cublasOperation_t layout_a,
cublasOperation_t layout_b,
Scalar alpha_ = Scalar(1),
Scalar beta_ = Scalar(0),
cublasGemmAlgo_t algorithm_ = CUBLAS_GEMM_DEFAULT,
cublasOperation_t layout_c = CUBLAS_OP_N)
: status(CUBLAS_STATUS_SUCCESS),
handle(handle_),
problem_size(K_, N_, M_, 1),
layout_A(layout_a),
layout_B(layout_b),
alpha(alpha_),
beta(beta_),
algorithm(algorithm_),
batch_count(1),
batch_stride_A(static_cast<long long int>(0)),
batch_stride_B(static_cast<long long int>(0)),
batch_stride_C(static_cast<long long int>(0)) {
resize(A, M_, K_ * batch_count, layout_a);
resize(B, K_ * batch_count, N_, layout_b);
resize(C_initial, M_, N_ * batch_count, layout_c);
resize(ref_host, M_, N_ * batch_count, layout_c);
resize(ref_cublas, M_, N_ * batch_count, layout_c);
resize(computed, M_, N_ * batch_count, layout_c);
}
/// Constructs a workspace for verifying GEMM with arbitrary strides
GemmTestbed(int M_,
int N_,
int K_,
int lda,
int ldb,
int ldc,
cublasOperation_t layout_a,
cublasOperation_t layout_b,
Scalar alpha_ = Scalar(1),
Scalar beta_ = Scalar(0),
cublasGemmAlgo_t algorithm_ = CUBLAS_GEMM_DEFAULT,
cublasOperation_t layout_c = CUBLAS_OP_N)
: problem_size(K_, N_, M_, 1),
layout_A(layout_a),
layout_B(layout_b),
alpha(alpha_),
beta(beta_),
algorithm(algorithm_),
batch_count(1),
batch_stride_A(static_cast<long long int>(0)),
batch_stride_B(static_cast<long long int>(0)),
batch_stride_C(static_cast<long long int>(0)) {
status = cublasCreate(&handle);
if (status != CUBLAS_STATUS_SUCCESS) {
throw cutlass::cuda_exception("Failed to create CUBLAS handle");
}
resize(A, M_, K_, layout_a, lda);
resize(B, K_, N_, layout_b, ldb);
resize(C_initial, M_, N_, layout_c, ldc);
resize(ref_host, M_, N_, layout_c, ldc);
resize(ref_cublas, M_, N_, layout_c, ldc);
resize(computed, M_, N_, layout_c, ldc);
}
/// Constructs a workspace for verifying GEMM with arbitrary strides
GemmTestbed(cublasHandle_t handle_,
int M_,
int N_,
int K_,
int ldc,
cublasOperation_t layout_a,
int lda,
cublasOperation_t layout_b,
int ldb,
Scalar alpha_ = Scalar(1),
Scalar beta_ = Scalar(0),
cublasGemmAlgo_t algorithm_ = CUBLAS_GEMM_DEFAULT,
cublasOperation_t layout_c = CUBLAS_OP_N)
: status(CUBLAS_STATUS_SUCCESS),
handle(handle_),
problem_size(K_, N_, M_, 1),
alpha(alpha_),
beta(beta_),
algorithm(algorithm_),
batch_count(1),
batch_stride_A(static_cast<long long int>(0)),
batch_stride_B(static_cast<long long int>(0)),
batch_stride_C(static_cast<long long int>(0)) {
resize(A, M_, K_ * batch_count, layout_a);
resize(B, K_ * batch_count, N_, layout_b);
resize(C_initial, M_, N_ * batch_count, layout_c);
resize(ref_host, M_, N_ * batch_count, layout_c);
resize(ref_cublas, M_, N_ * batch_count, layout_c);
resize(computed, M_, N_ * batch_count, layout_c);
}
/// Constructs a workspace for verifying strided batched GEMM, assumes
/// dense packing.
/// batches are "concated" along K for matrix A and matrix B, and along N for matrix C
/// a full implementation of strided batched GEMM should handle other corner cases
GemmTestbed(int M_,
int N_,
int K_,
int batch_count_,
cublasOperation_t layout_a,
cublasOperation_t layout_b,
Scalar alpha_ = Scalar(1),
Scalar beta_ = Scalar(0),
cublasGemmAlgo_t algorithm_ = CUBLAS_GEMM_DEFAULT,
cublasOperation_t layout_c = CUBLAS_OP_N)
: problem_size(K_, N_, M_, batch_count_),
layout_A(layout_a),
layout_B(layout_b),
alpha(alpha_),
beta(beta_),
algorithm(algorithm_),
batch_count(batch_count_) {
status = cublasCreate(&handle);
if (status != CUBLAS_STATUS_SUCCESS) {
throw cutlass::cuda_exception("Failed to create CUBLAS handle");
}
resize(A, M_, K_ * batch_count, layout_a);
resize(B, K_ * batch_count, N_, layout_b);
resize(C_initial, M_, N_ * batch_count, layout_c);
resize(ref_host, M_, N_ * batch_count, layout_c);
resize(ref_cublas, M_, N_ * batch_count, layout_c);
resize(computed, M_, N_ * batch_count, layout_c);
batch_stride_A = (layout_a == CUBLAS_OP_N) ? M_ * K_ : K_;
batch_stride_B = (layout_b == CUBLAS_OP_N) ? K_ : K_ * N_;
batch_stride_C = M_ * N_;
}
/// Destructs the GEMM testbed
~GemmTestbed() {
if (status != CUBLAS_STATUS_NOT_INITIALIZED) {
status = cublasDestroy(handle);
}
}
/// Returns true if the last CUBLAS call returned successfully
bool good() const { return status == CUBLAS_STATUS_SUCCESS; }
/// Returns a pointer to the A operand
typename HostMatrixA::DeviceType* ptr_A() const { return A.device_data(); }
/// Stride of A matrix
int lda() const { return A.leading_dim(); }
/// Returns a pointer to the B operand
typename HostMatrixB::DeviceType* ptr_B() const { return B.device_data(); }
/// Stride of B matrix
int ldb() const { return B.leading_dim(); }
/// Returns a pointer to the initial state of the result tensor in device memory
typename HostMatrixC::DeviceType* ptr_C_initial() const { return C_initial.device_data(); }
/// Returns a pointer to the result tensor in device memory
typename HostMatrixC::DeviceType* ptr_computed() const { return computed.device_data(); }
/// Returns a pointer to the result tensor in device memory
typename HostMatrixC::DeviceType* ptr_cublas() const { return ref_cublas.device_data(); }
/// Stride of C matrix
int ldc() const {
//return std::max(C_initial.stride(HostTensorC::Dim_H), C_initial.stride(HostTensorC::Dim_W));
return C_initial.leading_dim();
}
/// Returns the number of flops implied by the computation (1 multiply-accumulate = 2 flops)
uint64_t flops() const {
return uint64_t(batch_count) * uint64_t(M()) * uint64_t(N()) * uint64_t(K()) * 2ULL;
}
/// Computes the speed of the computation in GFLOPs/s
double GFLOPs_per_sec(double runtime_ms) const { return double(flops()) / runtime_ms / 1.0e6; }
/// Matrix layout of A
cublasOperation_t layout_a() const { return layout_A; }
/// Matrix layout of B
cublasOperation_t layout_b() const { return layout_B; }
/// Number of rows of problem, per batch; assumptions made here that we concat C by adding columns
int M() const {
return problem_size.m();
}
/// Number of columns of problem, per batch; assumptions made here that we concat C by adding
/// columns
int N() const {
return problem_size.n();
}
/// Number of columns of problem, per batch; assumptions made here that we concat A by adding
/// columns
int K() const {
return problem_size.k();
}
/// Number of batches
int get_batch_count() const {
return problem_size.batch();
}
///
long long int get_batch_stride_A() const { return batch_stride_A; }
///
long long int get_batch_stride_B() const { return batch_stride_B; }
///
long long int get_batch_stride_C() const { return batch_stride_C; }
///
/// Initializes data, randomly
void initialize(int seed = -1) {
// Initialize the source matrix with a uniform distribution
cutlass::Distribution dist;
dist.set_uniform(-8, 8);
cutlass::reference::host::TensorInitialize(A.host_view(), seed, dist);
cutlass::reference::host::TensorInitialize(B.host_view(), seed + 11, dist);
cutlass::reference::host::TensorInitialize(C_initial.host_view(), seed + 13, dist);
A.sync_device();
B.sync_device();
C_initial.sync_device();
}
/// Initializes binary data
void initialize_binary(int seed = -1) {
//A.fill_random(RandomBitGenerator<AType>(seed));
//B.fill_random(RandomBitGenerator<BType>(seed + 11));
//C_initial.fill_random(RandomGenerator<CType>(seed + 13));
A.fill_sequential();
B.fill_sequential();
C_initial.fill(0);
}
/// Initializes integer data (sequential for now)
void initialize_integer(int seed =-1) {
A.fill_sequential();
B.fill_sequential();
C_initial.fill(0);
}
/// Computes the matrix product on the host
void compute_host() {
ref_host.fill(C_initial);
cutlass::reference::host::Gemm(problem_size, alpha, A.host_ref(), B.host_ref(), beta, ref_host.host_ref(), Accumulator(0));
}
/// Excutes an equivalent GEMM using cuBLAS
bool execute_cublas() {
if (batch_count == 1) {
status = cublasGemmEx(handle,
layout_a(),
layout_b(),
M(),
N(),
K(),
&alpha,
ptr_A(),
cutlass::TypeTraits<AType>::cublas_type,
lda(),
ptr_B(),
cutlass::TypeTraits<BType>::cublas_type,
ldb(),
&beta,
ref_cublas.device_data(),
cutlass::TypeTraits<CType>::cublas_type,
ldc(),
cutlass::TypeTraits<Accumulator>::cublas_type,
algorithm);
return status == CUBLAS_STATUS_SUCCESS;
} else {
// call strided batched gemm
status = cublasGemmStridedBatchedTemplate(handle,
layout_a(),
layout_b(),
M(),
N(),
K(),
&alpha,
ptr_A(),
lda(),
batch_stride_A,
ptr_B(),
ldb(),
batch_stride_B,
&beta,
ref_cublas.device_data(),
ldc(),
batch_stride_C,
batch_count);
return status == CUBLAS_STATUS_SUCCESS;
}
}
/// Helper function to use cublasGemmStridedBatched
cublasStatus_t cublasGemmStridedBatchedTemplate(cublasHandle_t handle,
cublasOperation_t transa,
cublasOperation_t transb,
int M,
int N,
int K,
const Scalar *alpha,
const typename HostMatrixA::DeviceType *ptr_A,
int lda,
long long int stride_A,
const typename HostMatrixB::DeviceType *ptr_B,
int ldb,
long long int stride_B,
const Scalar *beta,
typename HostMatrixC::DeviceType *ptr_C,
int ldc,
long long int stride_C,
int batchCount) {
return CUBLAS_STATUS_NOT_SUPPORTED;
}
/// Computes the matrix product using cuBLAS
void compute_cublas() {
ref_cublas.fill(C_initial);
if (!execute_cublas()) {
throw std::runtime_error("compute_cublas() failed");
}
}
//
// Compute the GEMM yourself
//
/// Names a probelm based on data type and problem size
std::string workspace_name() const {
std::stringstream ss;
ss << "gemm_" << (layout_a() == CUBLAS_OP_N ? "n" : "t")
<< (layout_b() == CUBLAS_OP_N ? "n" : "t") << "_" << typeid(AType).name() << "_"
<< typeid(BType).name() << "_" << typeid(CType).name() << "_" << typeid(Accumulator).name()
<< "_" << typeid(Scalar).name() << "_" << M() << "x" << N() << "x" << K();
//make sure there is no space in the ss
std::string thisString = ss.str();
std::replace(thisString.begin(), thisString.end(), ' ', '_');
std::replace(thisString.begin(), thisString.end(), ':', '_');
return thisString;
}
/// Writes the workspace to an ostream
std::ostream& write(std::ostream& out) const {
out << "A = " << A << "\nB = " << B << "\nC_initial = " << C_initial
<< "\nref_host = " << ref_host << "\nref_cublas = " << ref_cublas
<< "\ncomputed = " << computed << std::endl;
return out;
}
/// Outputs each mismatching element
std::ostream& write_errors(std::ostream& out,
HostMatrixC const& experimental,
HostMatrixC const& ref) const {
PrintErrors printer(out, ref, experimental);
computed.visit(printer);
return out;
}
/// Sync's all input tensors to device
void sync_device() {
A.sync_device();
B.sync_device();
C_initial.sync_device();
ref_host.fill(C_initial);
ref_cublas.fill(C_initial);
computed.fill(C_initial);
ref_cublas.sync_device();
computed.sync_device();
}
/// Sync's all output tensors to host
void sync_host() {
computed.sync_host();
ref_cublas.sync_host();
}
/// Saves the workspace to files
void save_workspace(HostMatrixC const& experimental,
HostMatrixC const& ref) {
std::string name = workspace_name();
std::string results_name = name + "_results.txt";
std::string errors_name = name + "_errors.txt";
std::ofstream results(results_name.c_str());
std::ofstream errors(errors_name.c_str());
write(results);
write_errors(errors, experimental, ref);
}
/// Verifies the contents of C equal the host-side reference
bool verify_with_host(bool save_on_error = true, bool always_print = false) {
compute_host();
computed.sync_host();
bool passed = computed.bit_equals(ref_host);
if ((!passed && save_on_error) || always_print) {
save_workspace(computed, ref_host);
}
return passed;
}
/// Verifies the contents of computed equal cuBLAS
bool verify_with_cublas(bool save_on_error = true, bool always_print = false) {
compute_cublas();
ref_cublas.sync_host();
computed.sync_host();
bool passed = computed.bit_equals(ref_cublas);
if ((!passed && save_on_error) || always_print) {
save_workspace(computed, ref_cublas);
}
return passed;
}
/// Verifies the host computation with cuBLAS
bool verify_host_with_cublas(bool save_on_error = true, bool always_print = false) {
compute_host();
compute_cublas();
ref_cublas.sync_host();
bool passed = ref_host.bit_equals(ref_cublas);
if ((!passed && save_on_error) || always_print) {
save_workspace(ref_host, ref_cublas);
}
return passed;
}
/// Verifies with host-side and device-side computations
bool verify_with_all() {
bool passed = true;
computed.sync_host();
// verify on host
passed = (passed && verify_with_host());
// verify with cublas
passed = (passed && verify_with_cublas());
return passed;
}
bool has_cublas_support() const { return cutlass::platform::is_same<Accumulator, Scalar>::value; }
};
//
//specialization for cublasGemmStridedBatchedTemplate
template<> inline cublasStatus_t GemmTestbed<float, float, float, float, float>::cublasGemmStridedBatchedTemplate(cublasHandle_t handle,
cublasOperation_t transa,
cublasOperation_t transb,
int M,
int N,
int K,
const float *alpha,
const float *ptr_A,
int lda,
long long int stride_A,
const float *ptr_B,
int ldb,
long long int stride_B,
const float *beta,
float *ptr_C,
int ldc,
long long int stride_C,
int batchCount) {
return cublasSgemmStridedBatched(handle,
transa,
transb,
M, N, K,
alpha,
ptr_A,
lda,
stride_A,
ptr_B,
ldb,
stride_B,
beta,
ptr_C,
ldc,
stride_C,
batchCount);
}
template<> inline cublasStatus_t GemmTestbed<double, double, double, double, double>::cublasGemmStridedBatchedTemplate(cublasHandle_t handle,
cublasOperation_t transa,
cublasOperation_t transb,
int M,
int N,
int K,
const double *alpha,
const double *ptr_A,
int lda,
long long int stride_A,
const double *ptr_B,
int ldb,
long long int stride_B,
const double *beta,
double *ptr_C,
int ldc,
long long int stride_C,
int batchCount) {
return cublasDgemmStridedBatched(handle,
transa,
transb,
M, N, K,
alpha,
ptr_A,
lda,
stride_A,
ptr_B,
ldb,
stride_B,
beta,
ptr_C,
ldc,
stride_C,
batchCount);
}
template<> inline cublasStatus_t GemmTestbed<cutlass::half_t, cutlass::half_t, cutlass::half_t, cutlass::half_t, cutlass::half_t>::cublasGemmStridedBatchedTemplate(cublasHandle_t handle,
cublasOperation_t transa,
cublasOperation_t transb,
int M,
int N,
int K,
const cutlass::half_t *alpha,
const half *ptr_A,
int lda,
long long int stride_A,
const half *ptr_B,
int ldb,
long long int stride_B,
const cutlass::half_t *beta,
half *ptr_C,
int ldc,
long long int stride_C,
int batchCount) {
half temp_alpha = alpha->operator half();
half temp_beta = beta->operator half();
return cublasHgemmStridedBatched(handle,
transa,
transb,
M, N, K,
&temp_alpha,
ptr_A,
lda,
stride_A,
ptr_B,
ldb,
stride_B,
&temp_beta,
ptr_C,
ldc,
stride_C,
batchCount);
}
} // namespace test
Reference in New Issue View Git Blame Copy Permalink