helper.hpp Source File

• include
• ck
• tensor_operation
• gpu
• device

helper.hpp

Go to the documentation of this file.

1// SPDX-License-Identifier: MIT

2// Copyright (c) 2024, Advanced Micro Devices, Inc. All rights reserved.

3

4#pragma once

5

6#include "ck/utility/common_header.hpp"

7#include "ck/tensor_description/multi_index_transform_helper.hpp"

8#include "ck/tensor_operation/gpu/grid/block_to_ctile_map.hpp"

9#include "ck/tensor_operation/operator_transform/transform_conv_fwd_to_gemm.hpp"

10#include "ck/tensor_operation/gpu/device/matrix_padder.hpp"

11#include <fstream>

12#include <variant>

13

14// functions to return the corresponding structs based on generated template parameters

15

16using layouts = std::variant<ck::tensor_layout::convolution::GNWK,

17 ck::tensor_layout::convolution::GNHWK,

18 ck::tensor_layout::convolution::NHWGK,

19 ck::tensor_layout::convolution::GNDHWK,

20 ck::tensor_layout::convolution::NDHWGK>;

21// return the layout type: currently this is the only type supported in MIOpen

22auto layout_type(std::string type)

23{

24 if(type == "ck::tensor_layout::convolution::NHWGK")

25 {

26 return ck::tensor_layout::convolution::NHWGK{};

27 }

28 throw std::runtime_error("Incorrect layout");

29}

30// return the right gemm spec based on the generated template parameters

31ck::tensor_operation::device::GemmSpecialization gemm_type(std::string type)

32{

33 if(type == "ck::tensor_operation::device::GemmSpecialization::Default")

34 {

35 return ck::tensor_operation::device::GemmSpecialization::Default;

36 }

37 if(type == "ck::tensor_operation::device::GemmSpecialization::MNKPadding")

38 {

39 return ck::tensor_operation::device::GemmSpecialization::MNKPadding;

40 }

41 throw std::runtime_error("Incorrect gemm spec: " + type);

42}

43

44// return the type of convolution

45ck::tensor_operation::device::ConvolutionForwardSpecialization conv_type(std::string type)

46{

47 if(type == "ck::tensor_operation::device::ConvolutionForwardSpecialization::Default")

48 {

49 return ck::tensor_operation::device::ConvolutionForwardSpecialization::Default;

50 }

51 if(type == "ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Pad0")

52 {

53 return ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Pad0;

54 }

55 if(type ==

56 "ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Stride1Pad0")

57 {

58 return ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Stride1Pad0;

59 }

60 if(type == "ck::tensor_operation::device::ConvolutionForwardSpecialization::OddC")

61 {

62 return ck::tensor_operation::device::ConvolutionForwardSpecialization::OddC;

63 }

64 throw std::runtime_error("Incorrect conv spec: " + type);

65}

66

67// Function to call on MatrixPadder via a wrapper struct

68// NOTE: CK only uses MNKPadding for forward convolution

69template <typename CDesc_MRaw_NRaw>

70auto pad(ck::index_t mpb,

71 ck::index_t npb,

72 ck::index_t kpb,

73 ck::tensor_operation::device::GemmSpecialization gemm,

74 CDesc_MRaw_NRaw conv)

75{

76 if(gemm == ck::tensor_operation::device::GemmSpecialization::MNKPadding)

77 {

78 ck::tensor_operation::device::MatrixPadder<

79 ck::tensor_operation::device::GemmSpecialization::MNKPadding,

80 ck::index_t,

81 ck::index_t,

82 ck::index_t>

83 a;

84 a.MPerTile_ = mpb;

85 a.NPerTile_ = npb;

86 a.KPerTile_ = kpb;

87 auto tmp = grid_desc(a, conv);

88 return tmp;

89 }

90 throw std::runtime_error("Incorrect template parameters, check gemm spec");

91}

92

93// Functions to call on TransformConvFwdToGemm through wrapper: different functions based on num

94// dims

95// FIXME: add a way to properly pass in the layout

96auto transform_conv(ck::index_t num_dim,

97 ck::tensor_operation::device::ConvolutionForwardSpecialization spec,

98 ck::Array<ck::index_t, 5> out_lengths,

99 ck::Array<ck::index_t, 5> out_strides)

100{

101 ck::Array<ck::index_t, 5> dummy_dims;

102 ck::Array<ck::index_t, 2> dummy_spatial_dims;

103 if(num_dim == 2 &&

104 spec == ck::tensor_operation::device::ConvolutionForwardSpecialization::Default)

105 {

106 ck::tensor_operation::TransformConvFwdToGemm<

107 2,

108 ck::tensor_operation::device::ConvolutionForwardSpecialization::Default>

109 conv_fwd{dummy_dims,

110 dummy_dims,

111 dummy_dims,

112 dummy_dims,

113 out_lengths,

114 out_strides,

115 dummy_spatial_dims,

116 dummy_spatial_dims,

117 dummy_spatial_dims,

118 dummy_spatial_dims};

119

120 auto res = ck::tensor_operation::TransformConv();

121 return res.transform_func(conv_fwd);

122 }

123 if(num_dim == 2 &&

124 spec == ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Pad0)

125 {

126 ck::tensor_operation::TransformConvFwdToGemm<

127 2,

128 ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Pad0>

129 conv_fwd{dummy_dims,

130 dummy_dims,

131 dummy_dims,

132 dummy_dims,

133 out_lengths,

134 out_strides,

135 dummy_spatial_dims,

136 dummy_spatial_dims,

137 dummy_spatial_dims,

138 dummy_spatial_dims};

139

140 auto res = ck::tensor_operation::TransformConv();

141 return res.transform_func(conv_fwd);

142 }

143 if(num_dim == 2 &&

144 spec == ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Stride1Pad0)

145 {

146 ck::tensor_operation::TransformConvFwdToGemm<

147 2,

148 ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Stride1Pad0>

149 conv_fwd{dummy_dims,

150 dummy_dims,

151 dummy_dims,

152 dummy_dims,

153 out_lengths,

154 out_strides,

155 dummy_spatial_dims,

156 dummy_spatial_dims,

157 dummy_spatial_dims,

158 dummy_spatial_dims};

159

160 auto res = ck::tensor_operation::TransformConv();

161 return res.transform_func(conv_fwd);

162 }

163 if(num_dim == 2 && spec == ck::tensor_operation::device::ConvolutionForwardSpecialization::OddC)

164 {

165 ck::tensor_operation::TransformConvFwdToGemm<

166 2,

167 ck::tensor_operation::device::ConvolutionForwardSpecialization::OddC>

168 conv_fwd{dummy_dims,

169 dummy_dims,

170 dummy_dims,

171 dummy_dims,

172 out_lengths,

173 out_strides,

174 dummy_spatial_dims,

175 dummy_spatial_dims,

176 dummy_spatial_dims,

177 dummy_spatial_dims};

178

179 auto res = ck::tensor_operation::TransformConv();

180 return res.transform_func(conv_fwd);

181 }

182 throw std::runtime_error("Incorrect conv spec");

183}

184

185auto transform_conv_3d(ck::index_t num_dim,

186 ck::tensor_operation::device::ConvolutionForwardSpecialization spec,

187 ck::Array<ck::index_t, 6> out_lengths,

188 ck::Array<ck::index_t, 6> out_strides)

189{

190 ck::Array<ck::index_t, 6> dummy_dims;

191 ck::Array<ck::index_t, 3> dummy_spatial_dims;

192

193 if(num_dim == 3 &&

194 spec == ck::tensor_operation::device::ConvolutionForwardSpecialization::Default)

195 {

196 ck::tensor_operation::TransformConvFwdToGemm<

197 3,

198 ck::tensor_operation::device::ConvolutionForwardSpecialization::Default>

199 conv_fwd{dummy_dims,

200 dummy_dims,

201 dummy_dims,

202 dummy_dims,

203 out_lengths,

204 out_strides,

205 dummy_spatial_dims,

206 dummy_spatial_dims,

207 dummy_spatial_dims,

208 dummy_spatial_dims};

209

210 auto res = ck::tensor_operation::TransformConv();

211 return res.transform_func(conv_fwd);

212 }

213 if(num_dim == 3 &&

214 spec == ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Pad0)

215 {

216 ck::tensor_operation::TransformConvFwdToGemm<

217 3,

218 ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Pad0>

219 conv_fwd{dummy_dims,

220 dummy_dims,

221 dummy_dims,

222 dummy_dims,

223 out_lengths,

224 out_strides,

225 dummy_spatial_dims,

226 dummy_spatial_dims,

227 dummy_spatial_dims,

228 dummy_spatial_dims};

229

230 auto res = ck::tensor_operation::TransformConv();

231 return res.transform_func(conv_fwd);

232 }

233 if(num_dim == 3 &&

234 spec == ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Stride1Pad0)

235 {

236 ck::tensor_operation::TransformConvFwdToGemm<

237 3,

238 ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Stride1Pad0>

239 conv_fwd{dummy_dims,

240 dummy_dims,

241 dummy_dims,

242 dummy_dims,

243 out_lengths,

244 out_strides,

245 dummy_spatial_dims,

246 dummy_spatial_dims,

247 dummy_spatial_dims,

248 dummy_spatial_dims};

249

250 auto res = ck::tensor_operation::TransformConv();

251 return res.transform_func(conv_fwd);

252 }

253 if(num_dim == 3 && spec == ck::tensor_operation::device::ConvolutionForwardSpecialization::OddC)

254 {

255 ck::tensor_operation::TransformConvFwdToGemm<

256 3,

257 ck::tensor_operation::device::ConvolutionForwardSpecialization::OddC>

258 conv_fwd{dummy_dims,

259 dummy_dims,

260 dummy_dims,

261 dummy_dims,

262 out_lengths,

263 out_strides,

264 dummy_spatial_dims,

265 dummy_spatial_dims,

266 dummy_spatial_dims,

267 dummy_spatial_dims};

268

269 auto res = ck::tensor_operation::TransformConv();

270 return res.transform_func(conv_fwd);

271 }

272 throw std::runtime_error("Incorrect conv spec");

273}

274

275auto transform_conv_1d(ck::index_t num_dim,

276 ck::tensor_operation::device::ConvolutionForwardSpecialization spec,

277 ck::Array<ck::index_t, 4> out_lengths,

278 ck::Array<ck::index_t, 4> out_strides)

279{

280 ck::Array<ck::index_t, 4> dummy_dims;

281 ck::Array<ck::index_t, 1> dummy_spatial_dims;

282

283 if(num_dim == 1 &&

284 spec == ck::tensor_operation::device::ConvolutionForwardSpecialization::Default)

285 {

286 ck::tensor_operation::TransformConvFwdToGemm<

287 1,

288 ck::tensor_operation::device::ConvolutionForwardSpecialization::Default>

289 conv_fwd{dummy_dims,

290 dummy_dims,

291 dummy_dims,

292 dummy_dims,

293 out_lengths,

294 out_strides,

295 dummy_spatial_dims,

296 dummy_spatial_dims,

297 dummy_spatial_dims,

298 dummy_spatial_dims};

299

300 auto res = ck::tensor_operation::TransformConv();

301 return res.transform_func(conv_fwd);

302 }

303 if(num_dim == 1 &&

304 spec == ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Pad0)

305 {

306 ck::tensor_operation::TransformConvFwdToGemm<

307 1,

308 ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Pad0>

309 conv_fwd{dummy_dims,

310 dummy_dims,

311 dummy_dims,

312 dummy_dims,

313 out_lengths,

314 out_strides,

315 dummy_spatial_dims,

316 dummy_spatial_dims,

317 dummy_spatial_dims,

318 dummy_spatial_dims};

319

320 auto res = ck::tensor_operation::TransformConv();

321 return res.transform_func(conv_fwd);

322 }

323 if(num_dim == 1 &&

324 spec == ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Stride1Pad0)

325 {

326 ck::tensor_operation::TransformConvFwdToGemm<

327 1,

328 ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Stride1Pad0>

329 conv_fwd{dummy_dims,

330 dummy_dims,

331 dummy_dims,

332 dummy_dims,

333 out_lengths,

334 out_strides,

335 dummy_spatial_dims,

336 dummy_spatial_dims,

337 dummy_spatial_dims,

338 dummy_spatial_dims};

339

340 auto res = ck::tensor_operation::TransformConv();

341 return res.transform_func(conv_fwd);

342 }

343 if(num_dim == 1 && spec == ck::tensor_operation::device::ConvolutionForwardSpecialization::OddC)

344 {

345 ck::tensor_operation::TransformConvFwdToGemm<

346 1,

347 ck::tensor_operation::device::ConvolutionForwardSpecialization::OddC>

348 conv_fwd{dummy_dims,

349 dummy_dims,

350 dummy_dims,

351 dummy_dims,

352 out_lengths,

353 out_strides,

354 dummy_spatial_dims,

355 dummy_spatial_dims,

356 dummy_spatial_dims,

357 dummy_spatial_dims};

358

359 auto res = ck::tensor_operation::TransformConv();

360 return res.transform_func(conv_fwd);

361 }

362 throw std::runtime_error("Incorrect dims or conv spec");

363}

364

365template <typename CGridDesc_M_N>

366auto block_2_etile(ck::index_t m_per_block, ck::index_t n_per_block, CGridDesc_M_N matrix_padder)

367{

368 if(m_per_block == 32 && n_per_block == 64)

369 {

370 auto b2e = ck::BlockToCTileMap_M00_N0_M01Adapt<32, 64, CGridDesc_M_N>(matrix_padder);

371 return b2e.CalculateGridSize(matrix_padder);

372 }

373 if(m_per_block == 32 && n_per_block == 128)

374 {

375 ck::BlockToCTileMap_M00_N0_M01Adapt<32, 128, CGridDesc_M_N> b2e(matrix_padder);

376 return b2e.CalculateGridSize(matrix_padder);

377 }

378 if(m_per_block == 64 && n_per_block == 32)

379 {

380 ck::BlockToCTileMap_M00_N0_M01Adapt<64, 32, CGridDesc_M_N> b2e(matrix_padder);

381 return b2e.CalculateGridSize(matrix_padder);

382 }

383 if(m_per_block == 64 && n_per_block == 64)

384 {

385 ck::BlockToCTileMap_M00_N0_M01Adapt<64, 64, CGridDesc_M_N> b2e(matrix_padder);

386 return b2e.CalculateGridSize(matrix_padder);

387 }

388 if(m_per_block == 64 && n_per_block == 128)

389 {

390 ck::BlockToCTileMap_M00_N0_M01Adapt<64, 128, CGridDesc_M_N> b2e(matrix_padder);

391 return b2e.CalculateGridSize(matrix_padder);

392 }

393 if(m_per_block == 128 && n_per_block == 32)

394 {

395 ck::BlockToCTileMap_M00_N0_M01Adapt<128, 32, CGridDesc_M_N> b2e(matrix_padder);

396 return b2e.CalculateGridSize(matrix_padder);

397 }

398 if(m_per_block == 128 && n_per_block == 64)

399 {

400 ck::BlockToCTileMap_M00_N0_M01Adapt<128, 64, CGridDesc_M_N> b2e(matrix_padder);

401 return b2e.CalculateGridSize(matrix_padder);

402 }

403 if(m_per_block == 128 && n_per_block == 128)

404 {

405 ck::BlockToCTileMap_M00_N0_M01Adapt<128, 128, CGridDesc_M_N> b2e(matrix_padder);

406 return b2e.CalculateGridSize(matrix_padder);

407 }

408 if(m_per_block == 128 && n_per_block == 256)

409 {

410 ck::BlockToCTileMap_M00_N0_M01Adapt<128, 256, CGridDesc_M_N> b2e(matrix_padder);

411 return b2e.CalculateGridSize(matrix_padder);

412 }

413 if(m_per_block == 256 && n_per_block == 128)

414 {

415 ck::BlockToCTileMap_M00_N0_M01Adapt<256, 128, CGridDesc_M_N> b2e(matrix_padder);

416 return b2e.CalculateGridSize(matrix_padder);

417 }

418 throw std::runtime_error("Incorrect template parameters");

419}

420

421// wrapper functions by dims to get grid size - uses above 3 functions

422// TODO: eventually remove the 1d/2d versions as CK will only support 3d convolutions

423auto get_launch_params_1d(ck::host::Solution solution,

424 ck::Array<ck::index_t, 4> out_lengths,

425 ck::Array<ck::index_t, 4> out_strides)

426{

427 auto num_dim = solution.GetTemplateParameter<ck::index_t>("NumDim");

428 auto m_per_block = solution.GetTemplateParameter<ck::index_t>("MPerBlock");

429 auto n_per_block = solution.GetTemplateParameter<ck::index_t>("NPerBlock");

430 auto k_per_block = solution.GetTemplateParameter<ck::index_t>("KPerBlock");

431 auto GemmType = solution.GetTemplateParameter<std::string>("GemmSpecialization");

432 auto ConvType = solution.GetTemplateParameter<std::string>("ConvSpecialization");

433 ck::tensor_operation::device::GemmSpecialization GemmSpec = gemm_type(GemmType);

434 ck::tensor_operation::device::ConvolutionForwardSpecialization ConvSpec = conv_type(ConvType);

435 auto conv_to_gemm_transformer = transform_conv_1d(num_dim, ConvSpec, out_lengths, out_strides);

436 auto matrix_padder =

437 pad(m_per_block, n_per_block, k_per_block, GemmSpec, conv_to_gemm_transformer);

438 auto b2e = block_2_etile(m_per_block, n_per_block, matrix_padder);

439 return b2e;

440}

441

442auto get_launch_params(ck::host::Solution solution,

443 ck::Array<ck::index_t, 5> out_lengths,

444 ck::Array<ck::index_t, 5> out_strides)

445{

446 auto num_dim = solution.GetTemplateParameter<ck::index_t>("NumDim");

447 auto m_per_block = solution.GetTemplateParameter<ck::index_t>("MPerBlock");

448 auto n_per_block = solution.GetTemplateParameter<ck::index_t>("NPerBlock");

449 auto k_per_block = solution.GetTemplateParameter<ck::index_t>("KPerBlock");

450 auto GemmType = solution.GetTemplateParameter<std::string>("GemmSpecialization");

451 auto ConvType = solution.GetTemplateParameter<std::string>("ConvSpecialization");

452 ck::tensor_operation::device::GemmSpecialization GemmSpec = gemm_type(GemmType);

453 ck::tensor_operation::device::ConvolutionForwardSpecialization ConvSpec = conv_type(ConvType);

454 auto conv_to_gemm_transformer = transform_conv(num_dim, ConvSpec, out_lengths, out_strides);

455 auto matrix_padder =

456 pad(m_per_block, n_per_block, k_per_block, GemmSpec, conv_to_gemm_transformer);

457 auto b2e = block_2_etile(m_per_block, n_per_block, matrix_padder);

458 return b2e;

459}

460

461auto get_launch_params_3d(ck::host::Solution solution,

462 ck::Array<ck::index_t, 6> out_lengths,

463 ck::Array<ck::index_t, 6> out_strides)

464{

465 auto num_dim = solution.GetTemplateParameter<ck::index_t>("NumDim");

466 auto m_per_block = solution.GetTemplateParameter<ck::index_t>("MPerBlock");

467 auto n_per_block = solution.GetTemplateParameter<ck::index_t>("NPerBlock");

468 auto k_per_block = solution.GetTemplateParameter<ck::index_t>("KPerBlock");

469 auto GemmType = solution.GetTemplateParameter<std::string>("GemmSpecialization");

470 auto ConvType = solution.GetTemplateParameter<std::string>("ConvSpecialization");

471 ck::tensor_operation::device::GemmSpecialization GemmSpec = gemm_type(GemmType);

472 ck::tensor_operation::device::ConvolutionForwardSpecialization ConvSpec = conv_type(ConvType);

473 auto conv_to_gemm_transformer = transform_conv_3d(num_dim, ConvSpec, out_lengths, out_strides);

474 auto matrix_padder =

475 pad(m_per_block, n_per_block, k_per_block, GemmSpec, conv_to_gemm_transformer);

476 auto b2e = block_2_etile(m_per_block, n_per_block, matrix_padder);

477 return b2e;

478}

block_to_ctile_map.hpp

common_header.hpp

transform_conv

auto transform_conv(ck::index_t num_dim, ck::tensor_operation::device::ConvolutionForwardSpecialization spec, ck::Array< ck::index_t, 5 > out_lengths, ck::Array< ck::index_t, 5 > out_strides)

Definition helper.hpp:96

block_2_etile

auto block_2_etile(ck::index_t m_per_block, ck::index_t n_per_block, CGridDesc_M_N matrix_padder)

Definition helper.hpp:366

layouts

std::variant< ck::tensor_layout::convolution::GNWK, ck::tensor_layout::convolution::GNHWK, ck::tensor_layout::convolution::NHWGK, ck::tensor_layout::convolution::GNDHWK, ck::tensor_layout::convolution::NDHWGK > layouts

Definition helper.hpp:16

transform_conv_1d

auto transform_conv_1d(ck::index_t num_dim, ck::tensor_operation::device::ConvolutionForwardSpecialization spec, ck::Array< ck::index_t, 4 > out_lengths, ck::Array< ck::index_t, 4 > out_strides)

Definition helper.hpp:275

layout_type

auto layout_type(std::string type)

Definition helper.hpp:22

get_launch_params_3d

auto get_launch_params_3d(ck::host::Solution solution, ck::Array< ck::index_t, 6 > out_lengths, ck::Array< ck::index_t, 6 > out_strides)

Definition helper.hpp:461

get_launch_params

auto get_launch_params(ck::host::Solution solution, ck::Array< ck::index_t, 5 > out_lengths, ck::Array< ck::index_t, 5 > out_strides)

Definition helper.hpp:442

gemm_type

ck::tensor_operation::device::GemmSpecialization gemm_type(std::string type)

Definition helper.hpp:31

transform_conv_3d

auto transform_conv_3d(ck::index_t num_dim, ck::tensor_operation::device::ConvolutionForwardSpecialization spec, ck::Array< ck::index_t, 6 > out_lengths, ck::Array< ck::index_t, 6 > out_strides)

Definition helper.hpp:185

get_launch_params_1d

auto get_launch_params_1d(ck::host::Solution solution, ck::Array< ck::index_t, 4 > out_lengths, ck::Array< ck::index_t, 4 > out_strides)

Definition helper.hpp:423

pad

auto pad(ck::index_t mpb, ck::index_t npb, ck::index_t kpb, ck::tensor_operation::device::GemmSpecialization gemm, CDesc_MRaw_NRaw conv)

Definition helper.hpp:70

conv_type

ck::tensor_operation::device::ConvolutionForwardSpecialization conv_type(std::string type)

Definition helper.hpp:45

matrix_padder.hpp

multi_index_transform_helper.hpp

ck::tensor_operation::device::GemmSpecialization

GemmSpecialization

Definition gemm_specialization.hpp:11

ck::tensor_operation::device::GemmSpecialization::Default

@ Default

Definition gemm_specialization.hpp:13

ck::tensor_operation::device::GemmSpecialization::MNKPadding

@ MNKPadding

Definition gemm_specialization.hpp:20

ck::tensor_operation::device::ConvolutionForwardSpecialization

ConvolutionForwardSpecialization

Definition convolution_forward_specialization.hpp:15

ck::tensor_operation::device::ConvolutionForwardSpecialization::OddC

@ OddC

Definition convolution_forward_specialization.hpp:19

ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Stride1Pad0

@ Filter1x1Stride1Pad0

Definition convolution_forward_specialization.hpp:18

ck::tensor_operation::device::ConvolutionForwardSpecialization::Default

@ Default

Definition convolution_forward_specialization.hpp:16

ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Pad0

@ Filter1x1Pad0

Definition convolution_forward_specialization.hpp:17

ck::index_t

int32_t index_t

Definition ck.hpp:299

a

const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a

Definition pointer.h:1517

ck::Array

Definition utility/array.hpp:14

ck::BlockToCTileMap_M00_N0_M01Adapt

Definition block_to_ctile_map.hpp:261

ck::tensor_layout::convolution::GNDHWK

Definition tensor_operation/gpu/device/tensor_layout.hpp:345

ck::tensor_layout::convolution::GNHWK

Definition tensor_operation/gpu/device/tensor_layout.hpp:340

ck::tensor_layout::convolution::GNWK

Definition tensor_operation/gpu/device/tensor_layout.hpp:335

ck::tensor_layout::convolution::NDHWGK

Definition tensor_operation/gpu/device/tensor_layout.hpp:362

ck::tensor_layout::convolution::NHWGK

Definition tensor_operation/gpu/device/tensor_layout.hpp:357

ck::tensor_operation::TransformConvFwdToGemm

Definition tensor_operation/operator_transform/transform_conv_fwd_to_gemm.hpp:25

ck::tensor_operation::TransformConv

Definition tensor_operation/operator_transform/transform_conv_fwd_to_gemm.hpp:1768

ck::tensor_operation::device::MatrixPadder

Definition matrix_padder.hpp:180

transform_conv_fwd_to_gemm.hpp