CUTLASS 2.1 (#83)
CUTLASS 2.1 contributes: - BLAS-style host-side API added to CUTLASS Library - Planar Complex GEMM kernels targeting Volta and Turing Tensor Cores - Minor enhancements and bug fixes
This commit is contained in:
Andrew Kerr
284
tools/library/include/cutlass/library/handle.h
Normal file
284
tools/library/include/cutlass/library/handle.h
Normal file
@@ -0,0 +1,284 @@
|
||||
/***************************************************************************************************
|
||||
* Copyright (c) 2017-2020, 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 BLAS-like handle used to launch operations on the CUDA device.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <memory>
|
||||
#include "cutlass/library/library.h"
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace cutlass {
|
||||
namespace library {
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Handle object
|
||||
class Handle {
|
||||
private:
|
||||
|
||||
/// Host workspace
|
||||
static int const kHostWorkspaceSize = (4 << 10);
|
||||
|
||||
/// CUDA device properties
|
||||
cudaDeviceProp device_;
|
||||
|
||||
/// CUDA stream
|
||||
cudaStream_t stream_;
|
||||
|
||||
/// Device workspace
|
||||
void *workspace_;
|
||||
|
||||
/// Size of device workspace in bytes
|
||||
size_t workspace_size_;
|
||||
|
||||
/// Indicates whether scalars are host or device pointers
|
||||
ScalarPointerMode scalar_pointer_mode_;
|
||||
|
||||
/// Pointer to the most recently executed operation
|
||||
Operation const *last_operation_;
|
||||
|
||||
public:
|
||||
|
||||
/// Constructor
|
||||
Handle(cudaStream_t stream = nullptr, size_t workspace_size = (4<<20));
|
||||
|
||||
/// Destructor
|
||||
~Handle();
|
||||
|
||||
/// Move constructor
|
||||
Handle(Handle && handle);
|
||||
|
||||
/// Move assignment operator
|
||||
Handle &operator=(Handle && handle);
|
||||
|
||||
//
|
||||
// Persistent state accessors
|
||||
//
|
||||
|
||||
/// Returns compute capability of the selected device
|
||||
int compute_capability() const;
|
||||
|
||||
/// Sets the current CUDA stream
|
||||
void set_stream(cudaStream_t stream);
|
||||
|
||||
/// Gets the current CUDA stream
|
||||
cudaStream_t get_stream() const;
|
||||
|
||||
/// Gets the device workspace size
|
||||
size_t get_workspace_size() const;
|
||||
|
||||
/// Gets a pointer to the device workspace allocation in Global Memory
|
||||
void *get_workspace() const;
|
||||
|
||||
/// Sets the size of device workspace, invalidating calls to get_device_workspace()
|
||||
void set_workspace_size(size_t bytes);
|
||||
|
||||
/// Gets the scalar pointer mode
|
||||
ScalarPointerMode get_scalar_pointer_mode() const;
|
||||
|
||||
/// Sets the scalar pointer mode
|
||||
void set_scalar_pointer_mode(ScalarPointerMode mode);
|
||||
|
||||
/// Gets the most recently executed operation
|
||||
Operation const *get_last_operation() const;
|
||||
|
||||
//
|
||||
// Computations
|
||||
//
|
||||
|
||||
/// Executes a GEMM computation: D <= alpha * A*B + beta * C
|
||||
Status gemm(
|
||||
|
||||
int M, /// GEMM M dimension
|
||||
int N, /// GEMM N dimension
|
||||
int K, /// GEMM K dimension
|
||||
|
||||
NumericTypeID element_compute, /// Data type of internal accumulation
|
||||
|
||||
NumericTypeID element_scalar, /// Data type of alpha/beta scalars
|
||||
|
||||
void const *alpha, /// Pointer to alpha scalar
|
||||
|
||||
NumericTypeID element_A, /// Data type of A matrix elements
|
||||
LayoutTypeID layout_A, /// Layout of A matrix
|
||||
ComplexTransform transform_A, /// Complex transformation applied to A matrix - ignored for real-valued matrices
|
||||
|
||||
void const * ptr_A, /// Pointer to A matrix in Global Memory
|
||||
int lda, /// Leading dimension of A matrix
|
||||
|
||||
NumericTypeID element_B, /// Data type of B matrix elements
|
||||
LayoutTypeID layout_B, /// Layout of B matrix
|
||||
ComplexTransform transform_B, /// Complex transformation applied to B matrix - ignored for real-valued matrices
|
||||
|
||||
void const * ptr_B, /// Pointer to B matrix in Global Memory
|
||||
int ldb, /// Leading dimension of B matrix
|
||||
|
||||
void const * beta, /// Pointer to beta scalar
|
||||
|
||||
NumericTypeID element_C, /// Data type of C and D matrices
|
||||
|
||||
void const * ptr_C, /// Pointer to C matrix
|
||||
int ldc, /// Leading dimension of C matrix
|
||||
|
||||
void * ptr_D, /// Pointer to D matrix
|
||||
int ldd /// Leading dimension of D matrix
|
||||
);
|
||||
|
||||
/// Planar complex GEMM
|
||||
///
|
||||
/// Note, all data types are the real-valued base types used by the planar-complex GEMM kernel.
|
||||
///
|
||||
Status gemm_planar_complex(
|
||||
|
||||
int M, /// GEMM M dimension
|
||||
int N, /// GEMM N dimension
|
||||
int K, /// GEMM K dimension
|
||||
|
||||
NumericTypeID element_compute, /// Data type of internal accumulation
|
||||
|
||||
NumericTypeID element_scalar, /// Data type of alpha/beta scalars
|
||||
|
||||
void const *alpha, /// Pointer to alpha scalar
|
||||
|
||||
NumericTypeID element_A, /// Data type of A matrix elements
|
||||
LayoutTypeID layout_A, /// Layout of A matrix
|
||||
ComplexTransform transform_A, /// Complex transformation applied to A matrix
|
||||
|
||||
void const * ptr_A_real, /// Pointer to real part of A matrix
|
||||
void const * ptr_A_imag, /// Pointer to imaginary part of A matrix
|
||||
int lda_real, /// Leading dimension of real part of A matrix
|
||||
int lda_imag, /// Leading dimension of imaginary part of A matrix
|
||||
|
||||
NumericTypeID element_B, /// Data type of B matrix elements
|
||||
LayoutTypeID layout_B, /// Layout of B matrix
|
||||
ComplexTransform transform_B, /// Complex transformation applied to B matrix
|
||||
|
||||
void const * ptr_B_real, /// Pointer to real part of B matrix
|
||||
void const * ptr_B_imag, /// Pointer to imaginary part of B matrix
|
||||
int ldb_real, /// Leading dimension of real part of B matrix
|
||||
int ldb_imag, /// Leading dimension of imaginary part of B matrix
|
||||
|
||||
void const * beta, /// Pointer to beta scalar
|
||||
|
||||
NumericTypeID element_C, /// Data type of C and D matrix
|
||||
|
||||
void const * ptr_C_real, /// Pointer to real part of C matrix
|
||||
void const * ptr_C_imag, /// Pointer to imaginary part of C matrix
|
||||
int ldc_real, /// Leading dimension of real part of C matrix
|
||||
int ldc_imag, /// Leading dimension of imaginary part of C matrix
|
||||
|
||||
void * ptr_D_real, /// Pointer to real part of D matrix
|
||||
void * ptr_D_imag, /// Pointer to imaginary part of D matrix
|
||||
int ldd_real, /// Leading dimension of real part of D matrix
|
||||
int ldd_imag, /// Leading dimension of imaginary part of D matrix
|
||||
|
||||
int batch_count = 1, /// Number of batched GEMMs to execute
|
||||
|
||||
int64_t batch_stride_A_real = 0,
|
||||
int64_t batch_stride_A_imag = 0,
|
||||
|
||||
int64_t batch_stride_B_real = 0,
|
||||
int64_t batch_stride_B_imag = 0,
|
||||
|
||||
int64_t batch_stride_C_real = 0,
|
||||
int64_t batch_stride_C_imag = 0,
|
||||
|
||||
int64_t batch_stride_D_real = 0,
|
||||
int64_t batch_stride_D_imag = 0
|
||||
);
|
||||
|
||||
/// Planar complex GEMM loading pointers from arrays in global memory
|
||||
Status gemm_planar_complex_array(
|
||||
|
||||
int expected_M, /// Expected GEMM M dimension (used for sizing CUDA grid)
|
||||
int expected_N, /// Expected GEMM N dimension (used for sizing CUDA grid)
|
||||
int expected_K, /// Expected GEMM K dimension
|
||||
int batch_count, /// Number of independent GEMM computations to execute
|
||||
|
||||
int const *M, /// Array containing the GEMM M dimension for each batch index
|
||||
int const *N, /// Array containing the GEMM N dimension for each batch index
|
||||
int const *K, /// Array containing the GEMM K dimension for each batch index
|
||||
|
||||
NumericTypeID element_compute, /// Data type of internal accumulation
|
||||
|
||||
NumericTypeID element_scalar, /// Data type of alpha/beta scalars
|
||||
|
||||
void const *alpha, /// Pointer to alpha scalar
|
||||
|
||||
NumericTypeID element_A, /// Data type of A matrix elements
|
||||
LayoutTypeID layout_A, /// Layout of A matrix
|
||||
ComplexTransform transform_A, /// Complex transformation applied to A matrix
|
||||
|
||||
void const * const * ptr_A_real, /// Pointer to array containing pointers to real part of A matrices
|
||||
void const * const * ptr_A_imag, /// Pointer to array containing pointers to imaginary part of A matrices
|
||||
|
||||
int lda_real, /// Leading dimension of real part of A matrix
|
||||
int lda_imag, /// Leading dimension of imaginary part of A matrix
|
||||
|
||||
NumericTypeID element_B, /// Data type of B matrix elements
|
||||
LayoutTypeID layout_B, /// Layout of B matrix
|
||||
ComplexTransform transform_B, /// Complex transformation applied to B matrix
|
||||
|
||||
void const * const * ptr_B_real, /// Pointer to array containing pointers to real part of B matrices
|
||||
void const * const * ptr_B_imag, /// Pointer to array containing pointers to imaginary part of B matrices
|
||||
|
||||
int ldb_real, /// Leading dimension of real part of B matrix
|
||||
int ldb_imag, /// Leading dimension of imaginary part of B matrix
|
||||
|
||||
void const * beta, /// Pointer to beta scalar
|
||||
|
||||
NumericTypeID element_C, /// Data type of C and D matrix
|
||||
|
||||
void const * const * ptr_C_real, /// Pointer to array containing pointers to real part of C matrices
|
||||
void const * const * ptr_C_imag, /// Pointer to array containing poitners to imaginary part of C matrices
|
||||
|
||||
int ldc_real, /// Leading dimension of real part of C matrix
|
||||
int ldc_imag, /// Leading dimension of imaginary part of C matrix
|
||||
|
||||
void * const * ptr_D_real, /// Pointer to array containing pointers to real part of D matrices
|
||||
void * const * ptr_D_imag, /// Pointer to array containing poitners to imaginary part of D matrices
|
||||
|
||||
int ldd_real, /// Leading dimension of real part of D matrix
|
||||
int ldd_imag /// Leading dimension of imaginary part of D matrix
|
||||
);
|
||||
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Unique pointer storing the handle
|
||||
using HandlePtr = std::unique_ptr<Handle>;
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
} // namespace library
|
||||
} // namespace cutlass
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/***************************************************************************************************
|
||||
* Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
|
||||
* Copyright (c) 2020, 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:
|
||||
@@ -68,6 +68,10 @@ enum class LayoutTypeID {
|
||||
kRowMajorInterleavedK4,
|
||||
kColumnMajorInterleavedK16,
|
||||
kRowMajorInterleavedK16,
|
||||
kColumnMajorInterleavedK32,
|
||||
kRowMajorInterleavedK32,
|
||||
kColumnMajorInterleavedK64,
|
||||
kRowMajorInterleavedK64,
|
||||
kTensorNCHW,
|
||||
kTensorNHWC,
|
||||
kInvalid
|
||||
@@ -110,9 +114,21 @@ enum class NumericTypeID {
|
||||
/// Enumeraed type describing a transformation on a complex value.
|
||||
enum class ComplexTransform {
|
||||
kNone,
|
||||
kConjugate
|
||||
kConjugate,
|
||||
kInvalid
|
||||
};
|
||||
|
||||
/// Providers
|
||||
enum class Provider {
|
||||
kCUTLASS,
|
||||
kReferenceHost,
|
||||
kReferenceDevice,
|
||||
kCUBLAS,
|
||||
kInvalid
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Enumeration indicating the kind of operation
|
||||
enum class OperationKind {
|
||||
kGemm,
|
||||
@@ -143,6 +159,14 @@ enum class OpcodeClassID {
|
||||
kInvalid
|
||||
};
|
||||
|
||||
enum class MathOperationID {
|
||||
kMultiplyAdd,
|
||||
kMultiplyAddSaturate,
|
||||
kMultiplyAddComplex,
|
||||
kXorPopc,
|
||||
kInvalid
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Enumeration indicating what kind of GEMM operation to perform
|
||||
@@ -150,88 +174,20 @@ enum class GemmKind {
|
||||
kGemm,
|
||||
kBatched,
|
||||
kArray,
|
||||
kUniversal,
|
||||
kPlanarComplex,
|
||||
kPlanarComplexBatched,
|
||||
kPlanarComplexArray,
|
||||
kInvalid
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Lexical cast from string
|
||||
template <typename T> T from_string(std::string const &);
|
||||
|
||||
/// Converts a NumericType enumerant to a string
|
||||
char const *to_string(OperationKind type, bool pretty = false);
|
||||
|
||||
/// Parses a NumericType enumerant from a string
|
||||
template <> OperationKind from_string<OperationKind>(std::string const &str);
|
||||
|
||||
/// Converts a NumericType enumerant to a string
|
||||
char const *to_string(NumericTypeID type, bool pretty = false);
|
||||
|
||||
/// Parses a NumericType enumerant from a string
|
||||
template <> NumericTypeID from_string<NumericTypeID>(std::string const &str);
|
||||
|
||||
/// Returns the size of a data type in bits
|
||||
int sizeof_bits(NumericTypeID type);
|
||||
|
||||
/// Returns true if the numeric type is a complex data type or false if real-valued.
|
||||
bool is_complex_type(NumericTypeID type);
|
||||
|
||||
/// Returns the real-valued type underlying a type (only different from 'type' if complex)
|
||||
NumericTypeID get_real_type(NumericTypeID type);
|
||||
|
||||
/// Returns true if numeric type is integer
|
||||
bool is_integer_type(NumericTypeID type);
|
||||
|
||||
/// Returns true if numeric type is signed
|
||||
bool is_signed_type(NumericTypeID type);
|
||||
|
||||
/// Returns true if numeric type is a signed integer
|
||||
bool is_signed_integer(NumericTypeID type);
|
||||
|
||||
/// returns true if numeric type is an unsigned integer
|
||||
bool is_unsigned_integer(NumericTypeID type);
|
||||
|
||||
/// Returns true if numeric type is floating-point type
|
||||
bool is_float_type(NumericTypeID type);
|
||||
|
||||
/// To string method for cutlass::Status
|
||||
char const *to_string(Status status, bool pretty = false);
|
||||
|
||||
/// Converts a LayoutTypeID enumerant to a string
|
||||
char const *to_string(LayoutTypeID layout, bool pretty = false);
|
||||
|
||||
/// Parses a LayoutType enumerant from a string
|
||||
template <> LayoutTypeID from_string<LayoutTypeID>(std::string const &str);
|
||||
|
||||
/// Returns the rank of a layout's stride base on the LayoutTypeID
|
||||
int get_layout_stride_rank(LayoutTypeID layout_id);
|
||||
|
||||
/// Converts a OpcodeClassID enumerant to a string
|
||||
char const *to_string(OpcodeClassID type, bool pretty = false);
|
||||
|
||||
/// Converts a OpcodeClassID enumerant from a string
|
||||
template <>
|
||||
OpcodeClassID from_string<OpcodeClassID>(std::string const &str);
|
||||
|
||||
/// Lexical cast from int64_t to string
|
||||
std::string lexical_cast(int64_t int_value);
|
||||
|
||||
/// Lexical cast a string to a byte array. Returns true if cast is successful or false if invalid.
|
||||
bool lexical_cast(std::vector<uint8_t> &bytes, NumericTypeID type, std::string const &str);
|
||||
|
||||
/// Lexical cast TO a string FROM a byte array. Returns true if cast is successful or false if invalid.
|
||||
std::string lexical_cast(std::vector<uint8_t> &bytes, NumericTypeID type);
|
||||
|
||||
/// Casts from a signed int64 to the destination type. Returns true if successful.
|
||||
bool cast_from_int64(std::vector<uint8_t> &bytes, NumericTypeID type, int64_t src);
|
||||
|
||||
/// Casts from an unsigned int64 to the destination type. Returns true if successful.
|
||||
bool cast_from_uint64(std::vector<uint8_t> &bytes, NumericTypeID type, uint64_t src);
|
||||
|
||||
/// Casts from a real value represented as a double to the destination type. Returns true if successful.
|
||||
bool cast_from_double(std::vector<uint8_t> &bytes, NumericTypeID type, double src);
|
||||
/// Mode of GEMM
|
||||
enum class GemmUniversalMode {
|
||||
kGemm,
|
||||
kGemmSplitKParallel,
|
||||
kBatched,
|
||||
kArray,
|
||||
kInvalid
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
@@ -246,6 +202,9 @@ struct MathInstructionDescription {
|
||||
/// Classification of math instruction
|
||||
OpcodeClassID opcode_class;
|
||||
|
||||
/// Type of math operation performed
|
||||
MathOperationID math_operation;
|
||||
|
||||
//
|
||||
// Methods
|
||||
//
|
||||
@@ -253,9 +212,13 @@ struct MathInstructionDescription {
|
||||
MathInstructionDescription(
|
||||
cutlass::gemm::GemmCoord instruction_shape = cutlass::gemm::GemmCoord(),
|
||||
NumericTypeID element_accumulator = NumericTypeID::kInvalid,
|
||||
OpcodeClassID opcode_class = OpcodeClassID::kInvalid
|
||||
OpcodeClassID opcode_class = OpcodeClassID::kInvalid,
|
||||
MathOperationID math_operation = MathOperationID::kMultiplyAdd
|
||||
):
|
||||
instruction_shape(instruction_shape), element_accumulator(element_accumulator), opcode_class(opcode_class) {}
|
||||
instruction_shape(instruction_shape),
|
||||
element_accumulator(element_accumulator),
|
||||
opcode_class(opcode_class),
|
||||
math_operation(math_operation) {}
|
||||
|
||||
};
|
||||
|
||||
@@ -306,6 +269,9 @@ struct OperationDescription {
|
||||
/// Unique identifier describing the operation
|
||||
char const * name;
|
||||
|
||||
/// Operation provider
|
||||
Provider provider;
|
||||
|
||||
/// Kind of operation
|
||||
OperationKind kind;
|
||||
|
||||
@@ -317,6 +283,7 @@ struct OperationDescription {
|
||||
//
|
||||
OperationDescription(
|
||||
char const * name = "unknown",
|
||||
Provider Provider = Provider::kInvalid,
|
||||
OperationKind kind = OperationKind::kInvalid,
|
||||
TileDescription const & tile_description = TileDescription()
|
||||
):
|
||||
@@ -340,10 +307,11 @@ struct TensorDescription {
|
||||
|
||||
/// log2() of the maximum value each relevant stride may have
|
||||
int log_stride_range;
|
||||
|
||||
|
||||
//
|
||||
// Methods
|
||||
//
|
||||
|
||||
TensorDescription(
|
||||
NumericTypeID element = NumericTypeID::kInvalid,
|
||||
LayoutTypeID layout = LayoutTypeID::kInvalid,
|
||||
@@ -355,7 +323,7 @@ struct TensorDescription {
|
||||
layout(layout),
|
||||
alignment(alignment),
|
||||
log_extent_range(log_extent_range),
|
||||
log_stride_range(log_stride_range) { }
|
||||
log_stride_range(log_stride_range) { }
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -414,7 +382,7 @@ struct GemmDescription : public OperationDescription {
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Base class for all device-wide operations
|
||||
/// Base class for all operations
|
||||
class Operation {
|
||||
public:
|
||||
|
||||
@@ -435,7 +403,7 @@ public:
|
||||
virtual Status initialize(
|
||||
void const *configuration,
|
||||
void *host_workspace,
|
||||
void *device_workspace,
|
||||
void *device_workspace = nullptr,
|
||||
cudaStream_t stream = nullptr) const = 0;
|
||||
|
||||
virtual Status run(
|
||||
@@ -443,6 +411,7 @@ public:
|
||||
void *host_workspace,
|
||||
void *device_workspace = nullptr,
|
||||
cudaStream_t stream = nullptr) const = 0;
|
||||
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -551,11 +520,18 @@ using GemmBatchedArguments = GemmArguments;
|
||||
struct GemmArrayConfiguration {
|
||||
|
||||
gemm::GemmCoord problem_size;
|
||||
|
||||
/// Leading dimension of A matrix
|
||||
int64_t lda;
|
||||
|
||||
int64_t const *lda;
|
||||
int64_t const *ldb;
|
||||
int64_t const *ldc;
|
||||
int64_t const *ldd;
|
||||
/// Leading dimension of B matrix
|
||||
int64_t ldb;
|
||||
|
||||
/// Leading dimension of C matrix
|
||||
int64_t ldc;
|
||||
|
||||
/// Leading dimension of D matrix
|
||||
int64_t ldd;
|
||||
|
||||
int batch_count;
|
||||
};
|
||||
@@ -580,49 +556,98 @@ struct GemmArrayArguments {
|
||||
|
||||
struct GemmPlanarComplexConfiguration {
|
||||
|
||||
GemmUniversalMode mode;
|
||||
gemm::GemmCoord problem_size;
|
||||
int batch_count;
|
||||
|
||||
int64_t lda;
|
||||
int64_t ldb;
|
||||
int64_t ldc;
|
||||
int64_t ldd;
|
||||
int64_t lda_real;
|
||||
int64_t lda_imag;
|
||||
|
||||
int64_t imag_stride_A;
|
||||
int64_t imag_stride_B;
|
||||
int64_t imag_stride_C;
|
||||
int64_t imag_stride_D;
|
||||
int64_t ldb_real;
|
||||
int64_t ldb_imag;
|
||||
|
||||
int64_t ldc_real;
|
||||
int64_t ldc_imag;
|
||||
|
||||
int64_t ldd_real;
|
||||
int64_t ldd_imag;
|
||||
};
|
||||
|
||||
using GemmPlanarComplexArgments = GemmArguments;
|
||||
/// Arguments for planar complex GEMMs
|
||||
struct GemmPlanarComplexArguments {
|
||||
|
||||
void const *A_real;
|
||||
void const *A_imag;
|
||||
|
||||
void const *B_real;
|
||||
void const *B_imag;
|
||||
|
||||
void const *C_real;
|
||||
void const *C_imag;
|
||||
|
||||
void *D_real;
|
||||
void *D_imag;
|
||||
|
||||
void const *alpha;
|
||||
void const *beta;
|
||||
ScalarPointerMode pointer_mode;
|
||||
|
||||
int64_t batch_stride_A_real;
|
||||
int64_t batch_stride_A_imag;
|
||||
|
||||
int64_t batch_stride_B_real;
|
||||
int64_t batch_stride_B_imag;
|
||||
|
||||
int64_t batch_stride_C_real;
|
||||
int64_t batch_stride_C_imag;
|
||||
|
||||
int64_t batch_stride_D_real;
|
||||
int64_t batch_stride_D_imag;
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Batched complex valued GEMM in which real and imaginary parts are separated by a stride
|
||||
//
|
||||
// OperationKind: Gemm
|
||||
// GemmKind: Planar complex batched
|
||||
//
|
||||
struct GemmPlanarComplexBatchedConfiguration {
|
||||
/// This is a special form of planar complex which loads pointers and problem size
|
||||
/// from memory.
|
||||
struct GemmPlanarComplexArrayConfiguration {
|
||||
|
||||
gemm::GemmCoord problem_size;
|
||||
int batch_count;
|
||||
|
||||
int64_t lda;
|
||||
int64_t ldb;
|
||||
int64_t ldc;
|
||||
int64_t ldd;
|
||||
int64_t lda_real;
|
||||
int64_t lda_imag;
|
||||
|
||||
int64_t imag_stride_A;
|
||||
int64_t imag_stride_B;
|
||||
int64_t imag_stride_C;
|
||||
int64_t imag_stride_D;
|
||||
int64_t ldb_real;
|
||||
int64_t ldb_imag;
|
||||
|
||||
int64_t batched_stride_A;
|
||||
int64_t batched_stride_B;
|
||||
int64_t batched_stride_C;
|
||||
int64_t batched_stride_D;
|
||||
int64_t ldc_real;
|
||||
int64_t ldc_imag;
|
||||
|
||||
int64_t ldd_real;
|
||||
int64_t ldd_imag;
|
||||
};
|
||||
|
||||
/// Arguments for planar complex GEMMs
|
||||
struct GemmPlanarComplexArrayArguments {
|
||||
|
||||
int const *M;
|
||||
int const *N;
|
||||
int const *K;
|
||||
|
||||
void const * const * A_real;
|
||||
void const * const * A_imag;
|
||||
void const * const * B_real;
|
||||
void const * const * B_imag;
|
||||
void const * const * C_real;
|
||||
void const * const * C_imag;
|
||||
void * const * D_real;
|
||||
void * const * D_imag;
|
||||
|
||||
void const * alpha;
|
||||
void const * beta;
|
||||
ScalarPointerMode pointer_mode;
|
||||
};
|
||||
|
||||
using GemmPlanarComplexBatchedArguments = GemmArguments;
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/***************************************************************************************************
|
||||
* Copyright (c) 2017-2019, NVIDIA CORPORATION. All rights reserved.
|
||||
* Copyright (c) 2017-2020, 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:
|
||||
@@ -55,10 +55,14 @@ using OperationVector = std::vector<std::unique_ptr<Operation>>;
|
||||
class Manifest {
|
||||
private:
|
||||
|
||||
/// Operation provider
|
||||
Provider provider_;
|
||||
|
||||
/// Global list of operations
|
||||
OperationVector operations_;
|
||||
|
||||
public:
|
||||
Manifest (Provider provider = library::Provider::kCUTLASS) : provider_(provider) { }
|
||||
|
||||
/// Top-level initialization
|
||||
Status initialize();
|
||||
|
||||
205
tools/library/include/cutlass/library/operation_table.h
Normal file
205
tools/library/include/cutlass/library/operation_table.h
Normal file
@@ -0,0 +1,205 @@
|
||||
/***************************************************************************************************
|
||||
* Copyright (c) 2020, 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 Defines a data structure in which a set of functionally equivalent library::Operation
|
||||
instances may be queried.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <iosfwd>
|
||||
#include <unordered_map>
|
||||
#include <algorithm>
|
||||
|
||||
#include "cutlass/library/library.h"
|
||||
#include "cutlass/library/manifest.h"
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace cutlass {
|
||||
namespace library {
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Tuple uniquely identifying functional behavior
|
||||
struct GemmFunctionalKey {
|
||||
|
||||
NumericTypeID element_compute;
|
||||
NumericTypeID element_scalar;
|
||||
NumericTypeID element_A;
|
||||
LayoutTypeID layout_A;
|
||||
ComplexTransform transform_A;
|
||||
NumericTypeID element_B;
|
||||
LayoutTypeID layout_B;
|
||||
ComplexTransform transform_B;
|
||||
NumericTypeID element_C;
|
||||
|
||||
//
|
||||
// Methods
|
||||
//
|
||||
|
||||
inline
|
||||
GemmFunctionalKey(
|
||||
NumericTypeID element_compute = NumericTypeID::kF32,
|
||||
NumericTypeID element_scalar = NumericTypeID::kF32,
|
||||
NumericTypeID element_A = NumericTypeID::kF16,
|
||||
LayoutTypeID layout_A = LayoutTypeID::kColumnMajor,
|
||||
ComplexTransform transform_A = ComplexTransform::kNone,
|
||||
NumericTypeID element_B = NumericTypeID::kF16,
|
||||
LayoutTypeID layout_B = LayoutTypeID::kColumnMajor,
|
||||
ComplexTransform transform_B = ComplexTransform::kNone,
|
||||
NumericTypeID element_C = NumericTypeID::kF16
|
||||
):
|
||||
element_compute(element_compute),
|
||||
element_scalar(element_scalar),
|
||||
element_A(element_A),
|
||||
layout_A(layout_A),
|
||||
transform_A(transform_A),
|
||||
element_B(element_B),
|
||||
layout_B(layout_B),
|
||||
transform_B(transform_B),
|
||||
element_C(element_C)
|
||||
{ }
|
||||
|
||||
inline
|
||||
bool operator==(GemmFunctionalKey const &rhs) const {
|
||||
return
|
||||
(element_compute == rhs.element_compute) &&
|
||||
(element_scalar == rhs.element_scalar) &&
|
||||
(element_A == rhs.element_A) &&
|
||||
(layout_A == rhs.layout_A) &&
|
||||
(transform_A == rhs.transform_A) &&
|
||||
(element_B == rhs.element_B) &&
|
||||
(layout_B == rhs.layout_B) &&
|
||||
(transform_B == rhs.transform_B) &&
|
||||
(element_C == rhs.element_C);
|
||||
}
|
||||
|
||||
inline
|
||||
bool operator!=(GemmFunctionalKey const &rhs) const {
|
||||
return !(*this == rhs);
|
||||
}
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Hash function for GemmFunctionalKey
|
||||
struct GemmFunctionalKeyHasher {
|
||||
using IntHash = std::hash<int>;
|
||||
|
||||
inline
|
||||
static size_t rotl(size_t key, int shl) {
|
||||
return (key << shl) | (key >> (sizeof(key)*8 - shl));
|
||||
}
|
||||
|
||||
inline
|
||||
size_t operator()(GemmFunctionalKey const &key) const {
|
||||
IntHash hash;
|
||||
|
||||
return
|
||||
rotl(hash(int(key.element_compute)), 2) ^
|
||||
rotl(hash(int(key.element_scalar)), 3) ^
|
||||
rotl(hash(int(key.element_A)), 4) ^
|
||||
rotl(hash(int(key.layout_A)), 5) ^
|
||||
rotl(hash(int(key.transform_A)), 6) ^
|
||||
rotl(hash(int(key.element_B)), 7) ^
|
||||
rotl(hash(int(key.layout_B)), 8) ^
|
||||
rotl(hash(int(key.transform_B)), 9) ^
|
||||
rotl(hash(int(key.element_C)), 10);
|
||||
}
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Establishes a partial ordering to search for GEMM operators
|
||||
struct GemmPreferenceKey {
|
||||
|
||||
int compute_capability;
|
||||
int alignment;
|
||||
|
||||
//
|
||||
// Methods
|
||||
//
|
||||
|
||||
GemmPreferenceKey(): compute_capability(), alignment() { }
|
||||
|
||||
GemmPreferenceKey(int cc, int alignment): compute_capability(cc), alignment(alignment) { }
|
||||
|
||||
bool operator<(GemmPreferenceKey const &rhs) const {
|
||||
return (compute_capability < rhs.compute_capability) ||
|
||||
((compute_capability == rhs.compute_capability) && (alignment < rhs.alignment));
|
||||
}
|
||||
|
||||
bool operator==(GemmPreferenceKey const &rhs) const {
|
||||
return compute_capability == rhs.compute_capability;
|
||||
}
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Maps minimum compute capability onto a vector of possible operations
|
||||
using GemmOperationVectorMap = std::map<
|
||||
GemmPreferenceKey,
|
||||
std::vector<Operation const *>
|
||||
>;
|
||||
|
||||
/// Maps a GemmFunctionalKey onto a vector of Operation * objects expected to be of kind kGemm
|
||||
using GemmOperationFunctionalMap = std::unordered_map<
|
||||
GemmFunctionalKey,
|
||||
GemmOperationVectorMap,
|
||||
GemmFunctionalKeyHasher
|
||||
>;
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Table of cutlass::library::Operation instances
|
||||
class OperationTable {
|
||||
public:
|
||||
|
||||
/// Map of all operations of type kGemm and gemm_kind of type kGemm
|
||||
GemmOperationFunctionalMap gemm_operations;
|
||||
|
||||
/// Map of all operations of type kGemm and gemm_kind of type kPlanarComplex
|
||||
GemmOperationFunctionalMap gemm_planar_complex_operations;
|
||||
|
||||
/// Map of all operations of type kGemm and gemm_kind of type kPlanarComplexArray
|
||||
GemmOperationFunctionalMap gemm_planar_complex_array_operations;
|
||||
|
||||
public:
|
||||
|
||||
void append(Manifest const &manifest);
|
||||
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
} // namespace library
|
||||
} // namespace cutlass
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
std::ostream & operator<<(std::ostream &out, cutlass::library::GemmFunctionalKey const &k);
|
||||
|
||||
62
tools/library/include/cutlass/library/singleton.h
Normal file
62
tools/library/include/cutlass/library/singleton.h
Normal file
@@ -0,0 +1,62 @@
|
||||
/***************************************************************************************************
|
||||
* Copyright (c) 2020, 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.
|
||||
*
|
||||
**************************************************************************************************/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "cutlass/library/library.h"
|
||||
#include "cutlass/library/manifest.h"
|
||||
#include "cutlass/library/operation_table.h"
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace cutlass {
|
||||
namespace library {
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Singleton instance stores a Manifest and Operation table
|
||||
class Singleton {
|
||||
public:
|
||||
|
||||
/// Manifest object
|
||||
Manifest manifest;
|
||||
|
||||
/// Operation table referencing the Manifest
|
||||
OperationTable operation_table;
|
||||
|
||||
public:
|
||||
|
||||
Singleton();
|
||||
|
||||
static Singleton const &get();
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
} // namespace library
|
||||
} // namespace cutlass
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
138
tools/library/include/cutlass/library/util.h
Normal file
138
tools/library/include/cutlass/library/util.h
Normal file
@@ -0,0 +1,138 @@
|
||||
/***************************************************************************************************
|
||||
* Copyright (c) 2020, 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 Utilities accompanying the CUTLASS library for interacting with Library types.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "cutlass/cutlass.h"
|
||||
#include "cutlass/library/library.h"
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace cutlass {
|
||||
namespace library {
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Lexical cast from string
|
||||
template <typename T> T from_string(std::string const &);
|
||||
|
||||
/// Converts a Provider enumerant to a string
|
||||
char const *to_string(Provider provider, bool pretty = false);
|
||||
|
||||
/// Parses a Provider enumerant from a string
|
||||
template <> Provider from_string<Provider>(std::string const &str);
|
||||
|
||||
/// Converts a NumericType enumerant to a string
|
||||
char const *to_string(OperationKind type, bool pretty = false);
|
||||
|
||||
/// Parses a NumericType enumerant from a string
|
||||
template <> OperationKind from_string<OperationKind>(std::string const &str);
|
||||
|
||||
/// Converts a NumericType enumerant to a string
|
||||
char const *to_string(NumericTypeID type, bool pretty = false);
|
||||
|
||||
/// Parses a NumericType enumerant from a string
|
||||
template <> NumericTypeID from_string<NumericTypeID>(std::string const &str);
|
||||
|
||||
/// Returns the size of a data type in bits
|
||||
int sizeof_bits(NumericTypeID type);
|
||||
|
||||
/// Returns true if the numeric type is a complex data type or false if real-valued.
|
||||
bool is_complex_type(NumericTypeID type);
|
||||
|
||||
/// Returns the real-valued type underlying a type (only different from 'type' if complex)
|
||||
NumericTypeID get_real_type(NumericTypeID type);
|
||||
|
||||
/// Returns true if numeric type is integer
|
||||
bool is_integer_type(NumericTypeID type);
|
||||
|
||||
/// Returns true if numeric type is signed
|
||||
bool is_signed_type(NumericTypeID type);
|
||||
|
||||
/// Returns true if numeric type is a signed integer
|
||||
bool is_signed_integer(NumericTypeID type);
|
||||
|
||||
/// returns true if numeric type is an unsigned integer
|
||||
bool is_unsigned_integer(NumericTypeID type);
|
||||
|
||||
/// Returns true if numeric type is floating-point type
|
||||
bool is_float_type(NumericTypeID type);
|
||||
|
||||
/// To string method for cutlass::Status
|
||||
char const *to_string(Status status, bool pretty = false);
|
||||
|
||||
/// Converts a LayoutTypeID enumerant to a string
|
||||
char const *to_string(LayoutTypeID layout, bool pretty = false);
|
||||
|
||||
/// Parses a LayoutType enumerant from a string
|
||||
template <> LayoutTypeID from_string<LayoutTypeID>(std::string const &str);
|
||||
|
||||
/// Returns the rank of a layout's stride base on the LayoutTypeID
|
||||
int get_layout_stride_rank(LayoutTypeID layout_id);
|
||||
|
||||
/// Converts a OpcodeClassID enumerant to a string
|
||||
char const *to_string(OpcodeClassID type, bool pretty = false);
|
||||
|
||||
/// Converts a OpcodeClassID enumerant from a string
|
||||
template <>
|
||||
OpcodeClassID from_string<OpcodeClassID>(std::string const &str);
|
||||
|
||||
/// Converts a ComplexTransform enumerant to a string
|
||||
char const *to_string(ComplexTransform type, bool pretty = false);
|
||||
|
||||
/// Converts a ComplexTransform enumerant from a string
|
||||
template <>
|
||||
ComplexTransform from_string<ComplexTransform>(std::string const &str);
|
||||
|
||||
/// Lexical cast from int64_t to string
|
||||
std::string lexical_cast(int64_t int_value);
|
||||
|
||||
/// Lexical cast a string to a byte array. Returns true if cast is successful or false if invalid.
|
||||
bool lexical_cast(std::vector<uint8_t> &bytes, NumericTypeID type, std::string const &str);
|
||||
|
||||
/// Lexical cast TO a string FROM a byte array. Returns true if cast is successful or false if invalid.
|
||||
std::string lexical_cast(std::vector<uint8_t> &bytes, NumericTypeID type);
|
||||
|
||||
/// Casts from a signed int64 to the destination type. Returns true if successful.
|
||||
bool cast_from_int64(std::vector<uint8_t> &bytes, NumericTypeID type, int64_t src);
|
||||
|
||||
/// Casts from an unsigned int64 to the destination type. Returns true if successful.
|
||||
bool cast_from_uint64(std::vector<uint8_t> &bytes, NumericTypeID type, uint64_t src);
|
||||
|
||||
/// Casts from a real value represented as a double to the destination type. Returns true if successful.
|
||||
bool cast_from_double(std::vector<uint8_t> &bytes, NumericTypeID type, double src);
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
} // namespace library
|
||||
} // namespace cutlass
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
Reference in New Issue
Block a user