leavelet/cutlass
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Fix typos 2 (#842)

Browse Source 
Co-authored-by: Haicheng Wu <57973641+hwu36@users.noreply.github.com>
This commit is contained in:
Alexander Pivovarov
2023-03-09 20:22:56 -08:00
committed by GitHub
parent c4f6b8c6bc
commit 7e370c9637
161 changed files with 310 additions and 309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/cute/atom/copy_traits_sm90_tma.hpp
View File

@@ -718,7 +718,7 @@ make_tma_copy(CopyOp,
<< "\nswizzle " << smem_swizzle
<< "\nl2Promotion " << tma_l2Promotion
<< "\noobFill " << tma_oobFill << std::endl;
std::cerr << "Error: Failed to intialize the TMA descriptor " << result << std::endl;
std::cerr << "Error: Failed to initialize the TMA descriptor " << result << std::endl;
assert(false);
}
#endif // (__CUDACC_VER_MAJOR__ >= 12)

4
include/cutlass/arch/mma.h
View File

@@ -98,11 +98,11 @@ struct OpClassSimt {};
/////////////////////////////////////////////////////////////////////////////////////////////////
/// Tag classifing operators as Tensor Core operations.
/// Tag classifying operators as Tensor Core operations.
struct OpClassTensorOp {};
/////////////////////////////////////////////////////////////////////////////////////////////////
/// Tag classifing operators as WMMA Tensor Core operations
/// Tag classifying operators as WMMA Tensor Core operations
struct OpClassWmmaTensorOp {};
/////////////////////////////////////////////////////////////////////////////////////////////////

6
include/cutlass/conv/threadblock/conv2d_dgrad_output_gradient_tile_access_iterator_optimized.h
View File

@@ -230,7 +230,7 @@ public:
offset_p[s] = (mapped_h + problem_size_.pad_h - filter_r) / problem_size_.stride_h;
offset_q[s] = (mapped_w + problem_size_.pad_w - filter_s) / problem_size_.stride_w;
// Intialize pointers for gemm_k=0
// Initialize pointers for gemm_k=0
TensorCoord coord{offset_n[s], offset_p[s], offset_q[s], filter_k_};
pointer_[s] += params_.layout(coord) * sizeof_bits<Element>::value / 8;
@@ -341,7 +341,7 @@ public:
next_idx = 1;
// Restore bytes in q coordinate (Mma in filter s dimenstion)
// Restore bytes in q coordinate (Mma in filter s dimension)
reset_bytes = reset_bytes_s_;
} else {
@@ -351,7 +351,7 @@ public:
next_idx = 2;
// Restore bytes in p and q coordinate (Mma in filter s and r dimenstion)
// Restore bytes in p and q coordinate (Mma in filter s and r dimension)
reset_bytes = reset_bytes_r_;
}
#else

2
include/cutlass/conv/threadblock/conv2d_wgrad_activation_tile_access_iterator_analytic.h
View File

@@ -195,7 +195,7 @@ public:
s = filter_s_[iteration_contiguous_];
}
else {
/// Multiple access to support non-128b alignment in contiguous dimenstion
/// Multiple access to support non-128b alignment in contiguous dimension
c = (filter_c_[iteration_contiguous_] + iteration_vector_ * AccessType::kElements) % problem_size_.C;
int wrap_c = (filter_c_[iteration_contiguous_] + iteration_vector_ * AccessType::kElements) / problem_size_.C;
s = (filter_s_[iteration_contiguous_] + wrap_c) % problem_size_.S;

2
include/cutlass/conv/threadblock/conv2d_wgrad_activation_tile_access_iterator_optimized.h
View File

@@ -212,7 +212,7 @@ public:
if (kAccessesPerVector > 1) {
// This code section is only to support non-128b alignment
// Multiple access to support non-128b alignment in contiguous dimenstion
// Multiple access to support non-128b alignment in contiguous dimension
int wrap_c;
params_.c_divmod(wrap_c, c, c + iteration_vector_ * AccessType::kElements);

2
include/cutlass/conv/threadblock/depthwise_fprop_pipelined.h
View File

@@ -241,7 +241,7 @@ public:
int rs_plane_idx = 0;
// Issue loads during the first warp-level matrix multiply-add *AFTER* issuing
// shared memory loads (which have the tighest latency requirement).
// shared memory loads (which have the tightest latency requirement).
//
// Mainloop

2
include/cutlass/conv/threadblock/implicit_gemm_pipelined.h
View File

@@ -238,7 +238,7 @@ public:
int smem_write_stage_idx = 1;
// Issue loads during the first warp-level matrix multiply-add *AFTER* issuing
// shared memory loads (which have the tighest latency requirement).
// shared memory loads (which have the tightest latency requirement).
//
// Mainloop

6
include/cutlass/conv/threadblock/threadblock_swizzle.h
View File

@@ -67,7 +67,7 @@ static int get_strided_dgrad_tile_m(
// CUTLASS strided dgrad performance for stride > filter, i.e., stride={2x2} and filter={1x1})
//
// * Optimization *
// Only launch CTAs in M dimenstion which contribute to a row in Dx output
// Only launch CTAs in M dimension which contribute to a row in Dx output
//
//
// * Constraints *
@@ -107,7 +107,7 @@ struct StridedDgradHorizontalThreadblockSwizzle :
// compute number of tiles in m dimension
int tile_m = get_strided_dgrad_tile_m(problem_size, tile_size.m());
// compute number of tiles in n dimenstion
// compute number of tiles in n dimension
int tile_n = (implicit_gemm_problem_size.n() + tile_size.n() - 1) / tile_size.n();
return gemm::GemmCoord(
@@ -148,7 +148,7 @@ struct StridedDgradIdentityThreadblockSwizzle :
// compute number of tiles in m dimension
int tile_m = get_strided_dgrad_tile_m(problem_size, tile_size.m());
// compute number of tiles in n dimenstion
// compute number of tiles in n dimension
int tile_n = (implicit_gemm_problem_size.n() + tile_size.n() - 1) / tile_size.n();
return gemm::GemmCoord(

2
include/cutlass/epilogue/threadblock/default_epilogue_complex_tensor_op.h
View File

@@ -77,7 +77,7 @@ namespace threadblock {
// D = dr + j di = (ar*br - ai*bi) + j (ar*bi + ai*br)
/////////////////////////////////////////////////////////////////////////////////////////////////
template <
/// Epilouge Shape
/// Epilogue Shape
typename Shape_,
/// Warp-level mma operator
typename WarpMmaTensorOp_,

2
include/cutlass/epilogue/threadblock/default_epilogue_complex_tensor_op_blas3.h
View File

@@ -78,7 +78,7 @@ namespace threadblock {
// D = dr + j di = (ar*br - ai*bi) + j (ar*bi + ai*br)
/////////////////////////////////////////////////////////////////////////////////////////////////
template <
/// Epilouge Shape
/// Epilogue Shape
typename Shape_,
/// Warp-level mma operator
typename WarpMmaTensorOp_,

2
include/cutlass/epilogue/threadblock/predicated_tile_iterator_direct_conv.h
View File

@@ -198,7 +198,7 @@ private:
/// A thread's starting column
Index thread_start_column_;
/// Initial thread ouput location
/// Initial thread output location
int thread_start_n_, thread_start_p_, thread_start_q_;
/// Current threadblock tile index

4
include/cutlass/epilogue/threadblock/predicated_tile_iterator_strided_dgrad.h
View File

@@ -186,10 +186,10 @@ private:
/// Extent of the matrix tile in rows
Index extent_row_;
/// Starting Dx h and w dimenstion for strided dgrad mapping
/// Starting Dx h and w dimension for strided dgrad mapping
int start_h_, start_w_;
/// Effective Dy P and Q dimenstions for strided dgrad mapping
/// Effective Dy P and Q dimensions for strided dgrad mapping
int p_, q_;
/// A thread's starting row position (assuming steady-state predicates have been computed)

2
include/cutlass/gemm/device/ell_gemm.h
View File

@@ -547,7 +547,7 @@ public:
////////////////////////////////////////////////////////////////////////////////
/// Parital specialization for column-major output exchanges problem size and operand.
/// Partial specialization for column-major output exchanges problem size and operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/device/gemm.h
View File

@@ -521,7 +521,7 @@ public:
////////////////////////////////////////////////////////////////////////////////
/// Parital specialization for column-major output exchanges problem size and operand.
/// Partial specialization for column-major output exchanges problem size and operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/device/gemm_array.h
View File

@@ -476,7 +476,7 @@ public:
////////////////////////////////////////////////////////////////////////////////
/// Parital specialization for column-major output exchanges problem size and operand.
/// Partial specialization for column-major output exchanges problem size and operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/device/gemm_batched.h
View File

@@ -454,7 +454,7 @@ public:
////////////////////////////////////////////////////////////////////////////////
/// Parital specialization for column-major output exchanges problem size and operand.
/// Partial specialization for column-major output exchanges problem size and operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/device/gemm_complex.h
View File

@@ -475,7 +475,7 @@ public:
////////////////////////////////////////////////////////////////////////////////
/// Parital specialization for column-major output exchanges problem size and operand.
/// Partial specialization for column-major output exchanges problem size and operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/device/gemm_layernorm_mainloop_fusion.h
View File

@@ -194,7 +194,7 @@ class GemmLayernormMainloopFusion :
////////////////////////////////////////////////////////////////////////////////
/// Parital specialization for column-major output exchanges problem size and operand.
/// Partial specialization for column-major output exchanges problem size and operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/device/gemm_universal.h
View File

@@ -219,7 +219,7 @@ class GemmUniversal :
////////////////////////////////////////////////////////////////////////////////
/// Parital specialization for column-major output exchanges problem size and operand.
/// Partial specialization for column-major output exchanges problem size and operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/device/gemm_universal_with_broadcast.h
View File

@@ -198,7 +198,7 @@ class GemmUniversalWithBroadcast :
////////////////////////////////////////////////////////////////////////////////
/// Parital specialization for column-major output exchanges problem size and operand.
/// Partial specialization for column-major output exchanges problem size and operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/device/gemm_with_k_reduction.h
View File

@@ -211,7 +211,7 @@ class GemmWithKReduction :
////////////////////////////////////////////////////////////////////////////////
/// Parital specialization for column-major output exchanges problem size and operand.
/// Partial specialization for column-major output exchanges problem size and operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/device/rank_2k.h
View File

@@ -348,7 +348,7 @@ public:
};
////////////////////////////////////////////////////////////////////////////////
/// Parital specialization for column-major output exchange operand.
/// Partial specialization for column-major output exchange operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/device/rank_k.h
View File

@@ -325,7 +325,7 @@ public:
};
////////////////////////////////////////////////////////////////////////////////
/// Parital specialization for column-major output exchange operand.
/// Partial specialization for column-major output exchange operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/device/symm.h
View File

@@ -408,7 +408,7 @@ public:
call GEMM mainloop for with RowMajor efficient-epilogue
********************************************************************************************************/
/// Parital specialization for column-major output exchanges problem size and operand.
/// Partial specialization for column-major output exchanges problem size and operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/device/trmm.h
View File

@@ -563,7 +563,7 @@ For the mainloop and trmm kernel, `A` and `B` points to left-side and right-side
call GEMM mainloop for with RowMajor efficient-epilogue
********************************************************************************************************/
/// Parital specialization for column-major output exchanges problem size and operand.
/// Partial specialization for column-major output exchanges problem size and operand.
template <
/// Element type for A matrix operand
typename ElementA_,

2
include/cutlass/gemm/kernel/default_gemm_with_broadcast.h
View File

@@ -137,7 +137,7 @@ struct DefaultGemmWithBroadcast {
/////////////////////////////////////////////////////////////////////////////////////////////////
/// Parital specialization: ArchTag = cutlass::arch::Sm70
/// Partial specialization: ArchTag = cutlass::arch::Sm70
///
///
template <

2
include/cutlass/gemm/kernel/default_gemm_with_reduction.h
View File

@@ -138,7 +138,7 @@ struct DefaultGemmWithReduction {
/////////////////////////////////////////////////////////////////////////////////////////////////
/// Parital specialization: ArchTag = cutlass::arch::Sm70
/// Partial specialization: ArchTag = cutlass::arch::Sm70
///
///
template <

2
include/cutlass/gemm/kernel/rank_2k_grouped_problem_visitor.h
View File

@@ -138,7 +138,7 @@
i = i_macro
j = j_macro
Handling cases with grid dimensions that aren't multiples of eachother
Handling cases with grid dimensions that aren't multiples of each other
----------------------------------------------------------------------
Even though threadblock shapes M and N are typically multiples of one another, the grid
for a given problem may not have dimensions of the same ratio as that of the threadblock.

2
include/cutlass/gemm/kernel/sm90_gemm_tma.hpp
View File

@@ -196,7 +196,7 @@ public:
// Any Tensor Op MMA Atom in the WGMMA ISA is arch conditional to sm90a.
#if ! defined(__CUDA_ARCH_FEAT_SM90_ALL)
if constexpr(size<0>(typename TiledMma::AtomShape_MNK{}) == 64) {
printf("ERROR : Arch conditional MMA instruction used without targetting sm90a compute capability. Aborting.\n");
printf("ERROR : Arch conditional MMA instruction used without targeting sm90a compute capability. Aborting.\n");
return;
}
#endif

2
include/cutlass/gemm/kernel/sm90_gemm_tma_warpspecialized.hpp
View File

@@ -186,7 +186,7 @@ public:
// Any Tensor Op MMA Atom in the WGMMA ISA is arch conditional to sm90a.
#if ! defined(__CUDA_ARCH_FEAT_SM90_ALL)
if constexpr(size<0>(typename TiledMma::AtomShape_MNK{}) == 64) {
printf("ERROR : Arch conditional MMA instruction used without targetting sm90a compute capability. Aborting.\n");
printf("ERROR : Arch conditional MMA instruction used without targeting sm90a compute capability. Aborting.\n");
return;
}
#endif

2
include/cutlass/gemm/kernel/sm90_gemm_tma_warpspecialized_persistent.hpp
View File

@@ -258,7 +258,7 @@ public:
// Any Tensor Op MMA Atom in the WGMMA ISA is arch conditional to sm90a.
#if ! defined(__CUDA_ARCH_FEAT_SM90_ALL)
if constexpr(size<0>(typename TiledMma::AtomShape_MNK{}) == 64) {
printf("ERROR : Arch conditional MMA instruction used without targetting sm90a compute capability. Aborting.\n");
printf("ERROR : Arch conditional MMA instruction used without targeting sm90a compute capability. Aborting.\n");
return;
}
#endif

2
include/cutlass/gemm/threadblock/ell_mma_pipelined.h
View File

@@ -271,7 +271,7 @@ public:
}
// Issue loads during the first warp-level matrix multiply-add *AFTER* issuing
// shared memory loads (which have the tighest latency requirement).
// shared memory loads (which have the tightest latency requirement).
//
// Mainloop

2
include/cutlass/gemm/threadblock/mma_planar_complex_pipelined.h
View File

@@ -321,7 +321,7 @@ public:
iterator_B_imag.clear_mask(gemm_k_iterations <= 1);
// Issue loads during the first warp-level matrix multiply-add *AFTER* issuing
// shared memory loads (which have the tighest latency requirement).
// shared memory loads (which have the tightest latency requirement).
//
// Mainloop

2
include/cutlass/reduction/kernel/tensor_reduce_affine_contiguous.h
View File

@@ -83,7 +83,7 @@ struct TensorReductionAffineContiguousParams {
uint64_t outer_count; /// Number of elements in outer index space
ElementOutput * destination; /// Pointer to output tensor of rank kReducedRank
ElementSource const * source; /// Poitner to source pointer of rank kRank
ElementSource const * source; /// Pointer to source pointer of rank kRank
ReductionOp reduction_op; /// Reduction operator
ElementCompute reduction_identity; /// Identity element used by reduction operator
ElementCompute *device_workspace; /// Pointer to device workspace for inter-CTA reductions

2
include/cutlass/reduction/kernel/tensor_reduce_affine_strided.h
View File

@@ -85,7 +85,7 @@ struct TensorReductionAffineStridedParams {
uint64_t outer_count; /// Number of elements in outer index space
ElementOutput * destination; /// Pointer to output tensor of rank kReducedRank
ElementSource const * source; /// Poitner to source pointer of rank kRank
ElementSource const * source; /// Pointer to source pointer of rank kRank
ReductionOp reduction_op; /// Reduction operator
ElementCompute reduction_identity; /// Identity element for reduction operator
ElementCompute *device_workspace; /// Pointer to device workspace for inter-CTA reductions

2
include/cutlass/transform/threadblock/predicated_tile_access_iterator.h
View File

@@ -399,7 +399,7 @@ class PredicatedTileAccessIterator<Shape_, Element_, layout::PitchLinear,
bool is_residue_tile_;
/// Below is used when Gather is turned on. We need to record strided_offset
/// and contiguous_offset seperated to compute the offset by using
/// and contiguous_offset separated to compute the offset by using
///
/// offset = contiguous_offset + indices[strided_offset]
///

2
include/cutlass/transform/threadblock/regular_tile_iterator_tensor_op_sm70.h
View File

@@ -1079,7 +1079,7 @@ class RegularTileIterator<
//
/// The crosswised elements will be stored in a line.
/// line_size is size of crosswised dimention plus padding.
/// line_size is size of crosswised dimension plus padding.
/// in units of AccessType
Index line_size;