#include "LaunchDims.h" #if !defined(LAUNCH_DIMS_H) #pragma once #include #include #include #include #include #include std::unordered_map algoDimMap = { {"random", dim3(GRID_SIZE_RANDOM, BLOCK_SIZE_RANDOM, SHARED_MEM_SIZE_RANDOM)}, {"diagPart", dim3(GRID_SIZE_DIAG_PART, BLOCK_SIZE_DIAG_PART, SHARED_MEM_SIZE_DIAG_PART)}, {"logAbsDeterminant", dim3(GRID_SIZE_LOG_ABS_DETERMINANT, BLOCK_SIZE_LOG_ABS_DETERMINANT, SHARED_MEM_SIZE_LOG_ABS_DETERMINANT)}, {"adjustWeights", dim3(GRID_SIZE_ADJUST_WEIGHTS, BLOCK_SIZE_ADJUST_WEIGHTS, SHARED_MEM_SIZE_ADJUST_WEIGHTS)}, {"sequenceMask", dim3(GRID_SIZE_SEQUENCE_MASK, BLOCK_SIZE_SEQUENCE_MASK, SHARED_MEM_SIZE_SEQUENCE_MASK)}, {"segmentSum", dim3(GRID_SIZE_SEGMENT_SUM, BLOCK_SIZE_SEGMENT_SUM, SHARED_MEM_SIZE_SEGMENT_SUM)}, {"unsortedSegmentSum", dim3(GRID_SIZE_UNSORTED_SEGMENT_SUM, BLOCK_SIZE_UNSORTED_SEGMENT_SUM, SHARED_MEM_SIZE_UNSORTED_SEGMENT_SUM)}, {"segmentSqrtN", dim3(GRID_SIZE_SEGMENT_SQRTN, BLOCK_SIZE_SEGMENT_SQRTN, SHARED_MEM_SIZE_SEGMENT_SQRTN)}, {"segmentProd", dim3(GRID_SIZE_SEGMENT_PROD, BLOCK_SIZE_SEGMENT_PROD, SHARED_MEM_SIZE_SEGMENT_PROD)}, {"unsortedSegmentProd", dim3(GRID_SIZE_UNSORTED_SEGMENT_PROD, BLOCK_SIZE_UNSORTED_SEGMENT_PROD, SHARED_MEM_SIZE_UNSORTED_SEGMENT_PROD)}, {"segmentMin", dim3(GRID_SIZE_SEGMENT_MIN, BLOCK_SIZE_SEGMENT_MIN, SHARED_MEM_SIZE_SEGMENT_MIN)}, {"unsortedSegmentMin", dim3(GRID_SIZE_UNSORTED_SEGMENT_MIN, BLOCK_SIZE_UNSORTED_SEGMENT_MIN, SHARED_MEM_SIZE_UNSORTED_SEGMENT_MIN)}, {"segmentMean", dim3(GRID_SIZE_SEGMENT_MEAN, BLOCK_SIZE_SEGMENT_MEAN, SHARED_MEM_SIZE_SEGMENT_MEAN)}, {"unsortedSegmentMean", dim3(GRID_SIZE_UNSORTED_SEGMENT_MEAN, BLOCK_SIZE_UNSORTED_SEGMENT_MEAN, SHARED_MEM_SIZE_UNSORTED_SEGMENT_MEAN)}, {"segmentMax", dim3(GRID_SIZE_SEGMENT_MAX, BLOCK_SIZE_SEGMENT_MAX, SHARED_MEM_SIZE_SEGMENT_MAX)}, {"unsortedSegmentMax", dim3(GRID_SIZE_UNSORTED_SEGMENT_MAX, BLOCK_SIZE_UNSORTED_SEGMENT_MAX, SHARED_MEM_SIZE_UNSORTED_SEGMENT_MAX)}, {"matrixDiag", dim3(GRID_SIZE_MATRIX_DIAG, BLOCK_SIZE_MATRIX_DIAG, SHARED_MEM_SIZE_MATRIX_DIAG)}, {"segmentFillUpSegments", dim3(GRID_SIZE_SEGMENT_FILL_UP_SEGMENTS, BLOCK_SIZE_SEGMENT_FILL_UP_SEGMENTS, SHARED_MEM_SIZE_SEGMENT_FILL_UP_SEGMENTS)}, {"matrixBand", dim3(GRID_SIZE_MATRIX_BAND, BLOCK_SIZE_MATRIX_BAND, SHARED_MEM_SIZE_MATRIX_BAND)}, {"lup", dim3(GRID_SIZE_LUP, BLOCK_SIZE_LUP, SHARED_MEM_SIZE_LUP)}, {"ismax", dim3(GRID_SIZE_ISMAX, BLOCK_SIZE_ISMAX, SHARED_MEM_SIZE_ISMAX)}, {"ismaxFill", dim3(GRID_SIZE_ISMAX_FILL, BLOCK_SIZE_ISMAX_FILL, SHARED_MEM_SIZE_ISMAX_FILL)}, {"imageResize", dim3(GRID_SIZE_IMAGE_RESIZE, BLOCK_SIZE_IMAGE_RESIZE, SHARED_MEM_SIZE_IMAGE_RESIZE)}, {"diag", dim3(GRID_SIZE_DIAG, BLOCK_SIZE_DIAG, SHARED_MEM_SIZE_DIAG)}, {"confusionMatrix", dim3(GRID_SIZE_CONFUSION_MATRIX, BLOCK_SIZE_CONFUSION_MATRIX, SHARED_MEM_SIZE_CONFUSION_MATRIX)}, {"tile", dim3(GRID_SIZE_TILE, BLOCK_SIZE_TILE, SHARED_MEM_SIZE_TILE)}, {"diagonal", dim3(GRID_SIZE_DIAGONAL, BLOCK_SIZE_DIAGONAL, SHARED_MEM_SIZE_DIAGONAL)}, {"tear", dim3(GRID_SIZE_TEAR, BLOCK_SIZE_TEAR, SHARED_MEM_SIZE_TEAR)}, {"sortTensorByDimKey", dim3(GRID_SIZE_SORT_TENSOR_BY_DIM_KEY, BLOCK_SIZE_SORT_TENSOR_BY_DIM_KEY, SHARED_MEM_SIZE_SORT_TENSOR_BY_DIM_KEY)}, {"sortTensorAlongDimKey", dim3(GRID_SIZE_SORT_TENSOR_ALONG_DIM_KEY, BLOCK_SIZE_SORT_TENSOR_ALONG_DIM_KEY, SHARED_MEM_SIZE_SORT_TENSOR_ALONG_DIM_KEY)}, {"sortTensorAlongDimValue", dim3(GRID_SIZE_SORT_TENSOR_ALONG_DIM_VALUE, BLOCK_SIZE_SORT_TENSOR_ALONG_DIM_VALUE, SHARED_MEM_SIZE_SORT_TENSOR_ALONG_DIM_VALUE)}, {"shuffle", dim3(GRID_SIZE_SHUFFLE, BLOCK_SIZE_SHUFFLE, SHARED_MEM_SIZE_SHUFFLE)}, {"pullRows", dim3(GRID_SIZE_PULLROWS, BLOCK_SIZE_PULLROWS, SHARED_MEM_SIZE_PULLROWS)}, {"prescanArrayRecursive", dim3(GRID_SIZE_PRESCAN_ARRAY_RECURSIVE, BLOCK_SIZE_PRESCAN_ARRAY_RECURSIVE, SHARED_MEM_SIZE_PRESCAN_ARRAY_RECURSIVE)}, {"scalarTad", dim3(GRID_SIZE_SCALAR_TAD, BLOCK_SIZE_SCALAR_TAD, SHARED_MEM_SIZE_SCALAR_TAD)}, {"scalarScan", dim3(GRID_SIZE_SCALAR_SCAN, BLOCK_SIZE_SCALAR_SCAN, SHARED_MEM_SIZE_SCALAR_SCAN)}, {"reduceLong", dim3(GRID_SIZE_REDUCE_LONG, BLOCK_SIZE_REDUCE_LONG, SHARED_MEM_SIZE_REDUCE_LONG)}, {"reduceBool", dim3(GRID_SIZE_REDUCE_BOOL, BLOCK_SIZE_REDUCE_BOOL, SHARED_MEM_SIZE_REDUCE_BOOL)}, {"average", dim3(GRID_SIZE_AVERAGE, BLOCK_SIZE_AVERAGE, SHARED_MEM_SIZE_AVERAGE)}, {"accumulate", dim3(GRID_SIZE_ACCUMULATE, BLOCK_SIZE_ACCUMULATE, SHARED_MEM_SIZE_ACCUMULATE)}, {"transformScan", dim3(GRID_SIZE_TRANSFORM_SCAN, BLOCK_SIZE_TRANSFORM_SCAN, SHARED_MEM_SIZE_TRANSFORM_SCAN)}, {"summaryStats", dim3(GRID_SIZE_SUMMARY_STATS, BLOCK_SIZE_SUMMARY_STATS, SHARED_MEM_SIZE_SUMMARY_STATS)}, {"reduceFloat", dim3(GRID_SIZE_REDUCE_FLOAT, BLOCK_SIZE_REDUCE_FLOAT, SHARED_MEM_SIZE_REDUCE_FLOAT)}, {"scalarBool", dim3(GRID_SIZE_SCALAR_BOOL, BLOCK_SIZE_SCALAR_BOOL, SHARED_MEM_SIZE_SCALAR_BOOL)}, {"scalarSame", dim3(GRID_SIZE_SCALAR_SAME, BLOCK_SIZE_SCALAR_SAME, SHARED_MEM_SIZE_SCALAR_SAME)}, {"scalarLong", dim3(GRID_SIZE_SCALAR_LONG, BLOCK_SIZE_SCALAR_LONG, SHARED_MEM_SIZE_SCALAR_LONG)}, {"reduce3", dim3(GRID_SIZE_REDUCE_3, BLOCK_SIZE_REDUCE_3, SHARED_MEM_SIZE_REDUCE_3)}, {"pairwiseTransforms", dim3(GRID_SIZE_PAIRWISE_TRANSFORMS, BLOCK_SIZE_PAIRWISE_TRANSFORMS, SHARED_MEM_SIZE_PAIRWISE_TRANSFORMS)}, {"broadcast", dim3(GRID_SIZE_BROADCAST, BLOCK_SIZE_BROADCAST, SHARED_MEM_SIZE_BROADCAST)}, {"broadcastInt", dim3(GRID_SIZE_BROADCAST_INT, BLOCK_SIZE_BROADCAST_INT, SHARED_MEM_SIZE_BROADCAST_INT)}, {"broadcastBool", dim3(GRID_SIZE_BROADCAST_BOOL, BLOCK_SIZE_BROADCAST_BOOL, SHARED_MEM_SIZE_BROADCAST_BOOL)}, {"matrixMultiply", dim3(GRID_SIZE_MATRIX_MULTIPLY, BLOCK_SIZE_MATRIX_MULTIPLY, SHARED_MEM_SIZE_MATRIX_MULTIPLY)}, {"im2col", {dim3(GRID_SIZE_IM2COL, BLOCK_SIZE_IM2COL, SHARED_MEM_SIZE_IM2COL)}}, {"col2im", {dim3(GRID_SIZE_COL2IM, BLOCK_SIZE_COL2IM, SHARED_MEM_SIZE_COL2IM)}}, {"gemv", {dim3(GRID_SIZE_GEMV, BLOCK_SIZE_GEMV, SHARED_MEM_SIZE_GEMV)}}, {"addBias", {dim3(GRID_SIZE_ADDBIAS, BLOCK_SIZE_ADDBIAS, SHARED_MEM_SIZE_ADDBIAS)}}, {"pooling", {dim3(GRID_SIZE_POOLING, BLOCK_SIZE_POOLING, SHARED_MEM_SIZE_POOLING)}}, {"vol2col", {dim3(GRID_SIZE_VOL2COL, BLOCK_SIZE_VOL2COL, SHARED_MEM_SIZE_VOL2COL)}}, {"col2vol", {dim3(GRID_SIZE_COL2VOL, BLOCK_SIZE_COL2VOL, SHARED_MEM_SIZE_COL2VOL)}}, {"upsampling", {dim3(GRID_SIZE_UPSAMPLING, BLOCK_SIZE_UPSAMPLING, SHARED_MEM_SIZE_UPSAMPLING)}}, {"histogram", {dim3(GRID_SIZE_HISTOGRAM, BLOCK_SIZE_HISTOGRAM, SHARED_MEM_SIZE_HISTOGRAM)}}, {"prelu", {dim3(GRID_SIZE_PRELU, BLOCK_SIZE_PRELU, SHARED_MEM_SIZE_PRELU)}}, {"adjust", {dim3(GRID_SIZE_ADJUST, BLOCK_SIZE_ADJUST, SHARED_MEM_SIZE_ADJUST)}}, {"compare_and_bitpack", {dim3(GRID_SIZE_COMPARE_AND_BITPACK, BLOCK_SIZE_COMPARE_AND_BITPACK, SHARED_MEM_SIZE_COMPARE_AND_BITPACK)}}, {"concat", {dim3(GRID_SIZE_CONCAT, BLOCK_SIZE_CONCAT, SHARED_MEM_SIZE_CONCAT)}}, {"confusion_matrix", {dim3(GRID_SIZE_CONFUSION_MATRIX, BLOCK_SIZE_CONFUSION_MATRIX, SHARED_MEM_SIZE_CONFUSION_MATRIX)}}, {"beta_inc", {dim3(GRID_SIZE_BETA_INC, BLOCK_SIZE_BETA_INC, SHARED_MEM_SIZE_BETA_INC)}}, {"clip", {dim3(GRID_SIZE_CLIP, BLOCK_SIZE_CLIP, SHARED_MEM_SIZE_CLIP)}}, {"cross", {dim3(GRID_SIZE_CROSS, BLOCK_SIZE_CROSS, SHARED_MEM_SIZE_CROSS)}}, {"depth_to_space", {dim3(GRID_SIZE_DEPTH_TO_SPACE, BLOCK_SIZE_DEPTH_TO_SPACE, SHARED_MEM_SIZE_DEPTH_TO_SPACE)}}, {"dilation", {dim3(GRID_SIZE_DILATION, BLOCK_SIZE_DILATION, SHARED_MEM_SIZE_DILATION)}}, {"dropout", {dim3(GRID_SIZE_DROPOUT, BLOCK_SIZE_DROPOUT, SHARED_MEM_SIZE_DROPOUT)}}, {"extract_patches", {dim3(GRID_SIZE_EXTRACT_PATCHES, BLOCK_SIZE_EXTRACT_PATCHES, SHARED_MEM_SIZE_EXTRACT_PATCHES)}}, {"fake_quantization", {dim3(GRID_SIZE_FAKE_QUANTIZATION, BLOCK_SIZE_FAKE_QUANTIZATION, SHARED_MEM_SIZE_FAKE_QUANTIZATION)}}, {"flatten", {dim3(GRID_SIZE_FLATTEN, BLOCK_SIZE_FLATTEN, SHARED_MEM_SIZE_FLATTEN)}}, {"gather", {dim3(GRID_SIZE_GATHER, BLOCK_SIZE_GATHER, SHARED_MEM_SIZE_GATHER)}}, {"gather_linear", {dim3(GRID_SIZE_GATHER_LINEAR, BLOCK_SIZE_GATHER_LINEAR, SHARED_MEM_SIZE_GATHER_LINEAR)}}, {"gather_nd", {dim3(GRID_SIZE_GATHERND, BLOCK_SIZE_GATHERND, SHARED_MEM_SIZE_GATHERND)}}, {"hamming", {dim3(GRID_SIZE_HAMMING, BLOCK_SIZE_HAMMING, SHARED_MEM_SIZE_HAMMING)}}, {"hashcode_split", {dim3(GRID_SIZE_HASHCODE_SPLIT, BLOCK_SIZE_HASHCODE_SPLIT, SHARED_MEM_SIZE_HASHCODE_SPLIT)}}, {"hashcode_internal", {dim3(GRID_SIZE_HASHCODE_INTERNAL, BLOCK_SIZE_HASHCODE_INTERNAL, SHARED_MEM_SIZE_HASHCODE_INTERNAL)}}, {"hashcode_last", {dim3(GRID_SIZE_HASHCODE_LAST, BLOCK_SIZE_HASHCODE_LAST, SHARED_MEM_SIZE_HASHCODE_LAST)}}, {"histogram_fixed_width", {dim3(GRID_SIZE_HISTOGRAM_FIXED_WIDTH, BLOCK_SIZE_HISTOGRAM_FIXED_WIDTH, SHARED_MEM_SIZE_HISTOGRAM_FIXED_WIDTH)}}, {"draw_bounding_boxes", {dim3(GRID_SIZE_DRAW_BOUNDING_BOXES, BLOCK_SIZE_DRAW_BOUNDING_BOXES, SHARED_MEM_SIZE_DRAW_BOUNDING_BOXES)}}, {"image_resize", {dim3(GRID_SIZE_IMAGE_RESIZE, BLOCK_SIZE_IMAGE_RESIZE, SHARED_MEM_SIZE_IMAGE_RESIZE)}}, {"image_resize_interp_weights", {dim3(GRID_SIZE_IMAGE_RESIZE_INTERP_WEIGHTS, BLOCK_SIZE_IMAGE_RESIZE_INTERP_WEIGHTS, SHARED_MEM_SIZE_IMAGE_RESIZE_INTERP_WEIGHTS)}}, {"image_resize_init_coeffs", {dim3(GRID_SIZE_IMAGE_RESIZE_INIT_COEFFS, BLOCK_SIZE_IMAGE_RESIZE_INIT_COEFFS, SHARED_MEM_SIZE_IMAGE_RESIZE_INIT_COEFFS)}}, {"image_resize_coeffs_accum", {dim3(GRID_SIZE_IMAGE_RESIZE_COEFFS_ACCUM, BLOCK_SIZE_IMAGE_RESIZE_COEFFS_ACCUM, SHARED_MEM_SIZE_IMAGE_RESIZE_COEFFS_ACCUM)}}, {"image_resize_bicubic", {dim3(GRID_SIZE_IMAGE_RESIZE_BICUBIC, BLOCK_SIZE_IMAGE_RESIZE_BICUBIC, SHARED_MEM_SIZE_IMAGE_RESIZE_BICUBIC)}}, {"image_resize_fill_interp", {dim3(GRID_SIZE_IMAGE_RESIZE_FILL_INTERP, BLOCK_SIZE_IMAGE_RESIZE_FILL_INTERP, SHARED_MEM_SIZE_IMAGE_RESIZE_FILL_INTERP)}}, {"image_resize_crop_and_resize", {dim3(GRID_SIZE_IMAGE_RESIZE_CROP_AND_RESIZE, BLOCK_SIZE_IMAGE_RESIZE_CROP_AND_RESIZE, SHARED_MEM_SIZE_IMAGE_RESIZE_CROP_AND_RESIZE)}}, {"image_resize_v2_gather", {dim3(GRID_SIZE_IMAGE_RESIZE_V2_GATHER, BLOCK_SIZE_IMAGE_RESIZE_V2_GATHER, SHARED_MEM_SIZE_IMAGE_RESIZE_V2_GATHER)}}, {"image_suppress_scores", {dim3(GRID_SIZE_IMAGE_SUPPRESS_SCORES, BLOCK_SIZE_IMAGE_SUPPRESS_SCORES, SHARED_MEM_SIZE_IMAGE_SUPPRESS_SCORES)}}, {"image_suppress_select", {dim3(GRID_SIZE_IMAGE_SUPPRESS_SELECT, BLOCK_SIZE_IMAGE_SUPPRESS_SELECT, SHARED_MEM_SIZE_IMAGE_SUPPRESS_SELECT)}}, {"image_suppress_nonmax_overlap", {dim3(GRID_SIZE_IMAGE_SUPPRESS_NONMAX_OVERLAP, BLOCK_SIZE_IMAGE_SUPPRESS_NONMAX_OVERLAP, SHARED_MEM_SIZE_IMAGE_SUPPRESS_NONMAX_OVERLAP)}}, {"image_helpers_triple", {dim3(GRID_SIZE_IMAGE_HELPERS_TRIPLE, BLOCK_SIZE_IMAGE_HELPERS_TRIPLE, SHARED_MEM_SIZE_IMAGE_HELPERS_TRIPLE)}}, {"image_helpers", {dim3(GRID_SIZE_IMAGE_HELPERS, BLOCK_SIZE_IMAGE_HELPERS, SHARED_MEM_SIZE_GRID_SIZE_IMAGE_HELPERS)}}, {"lrn", {dim3(GRID_SIZE_LRN, BLOCK_SIZE_LRN, SHARED_MEM_SIZE_LRN)}}, {"lstsq_reg", {dim3(GRID_SIZE_LSTSQ_REG, BLOCK_SIZE_LSTSQ_REG, SHARED_MEM_SIZE_LSTSQ_REG)}}, {"lup", {dim3(GRID_SIZE_LUP, GRID_SIZE_LUP, SHARED_MEM_SIZE_LUP)}}, {"lup_low", {dim3(GRID_SIZE_LUP_LOW, BLOCK_SIZE_LUP_LOW, SHARED_MEM_SIZE_LUP_LOW)}}, {"matrix_set_diag", {dim3(GRID_SIZE_MATRIX_SET_DIAG, BLOCK_SIZE_MATRIX_SET_DIAG, SHARED_MEM_SIZE_MATRIX_SET_DIAG)}}, {"merge", {dim3(GRID_SIZE_MERGE, BLOCK_SIZE_MERGE, SHARED_MEM_SIZE_MERGE)}}, {"meshgrid", {dim3(GRID_SIZE_MESHGRID, BLOCK_SIZE_MESHGRID, SHARED_MEM_SIZE_MESHGRID)}}, {"nth_element_fill", {dim3(GRID_SIZE_NTH_ELEMENT_FILL, BLOCK_SIZE_NTH_ELEMENT_FILL, SHARED_MEM_SIZE_NTH_ELEMENT_FILL)}}, {"one_hot", {dim3(GRID_SIZE_ONE_HOT, BLOCK_SIZE_ONE_HOT, SHARED_MEM_SIZE_ONE_HOT)}}, {"pad", {dim3(GRID_SIZE_PAD, BLOCK_SIZE_PAD, SHARED_MEM_SIZE_PAD)}}, {"percentile", {dim3(GRID_SIZE_PERCENTILE, BLOCK_SIZE_PERCENTILE, SHARED_MEM_SIZE_PERCENTILE)}}, {"polygamma", {dim3(GRID_SIZE_POLYGAMMA, BLOCK_SIZE_POLYGAMMA, SHARED_MEM_SIZE_POLYGAMMA)}}, {"prefix", {dim3(GRID_SIZE_PREFIX, BLOCK_SIZE_PREFIX, SHARED_MEM_SIZE_PREFIX)}}, {"print", {dim3(GRID_SIZE_PRINT, BLOCK_SIZE_PRINT, SHARED_MEM_SIZE_PRINT)}}, {"qr", {dim3(GRID_SIZE_QR, BLOCK_SIZE_QR, SHARED_MEM_SIZE_QR)}}, {"random_gamma", {dim3(GRID_SIZE_RANDOM_GAMMA, BLOCK_SIZE_RANDOM_GAMMA, SHARED_MEM_SIZE_RANDOM_GAMMA)}}, {"random_poisson", {dim3(GRID_SIZE_RANDOM_POISSON, BLOCK_SIZE_RANDOM_POISSON, SHARED_MEM_SIZE_RANDOM_POISSON)}}, {"random_uniform", {dim3(GRID_SIZE_RANDOM_UNIFORM, BLOCK_SIZE_RANDOM_UNIFORM, SHARED_MEM_SIZE_RANDOM_UNIFORM)}}, {"random_shuffle_fisher", {dim3(GRID_SIZE_RANDOM_SHUFFLE_FISHER, BLOCK_SIZE_RANDOM_SHUFFLE_FISHER, SHARED_MEM_SIZE_RANDOM_SHUFFLE_FISHER)}}, {"random_shuffle_merge", {dim3(GRID_SIZE_RANDOM_SHUFFLE_MERGE, BLOCK_SIZE_RANDOM_SHUFFLE_MERGE, SHARED_MEM_SIZE_RANDOM_SHUFFLE_MERGE)}}, {"range", {dim3(GRID_SIZE_RANGE, BLOCK_SIZE_RANGE, SHARED_MEM_SIZE_RANGE)}}, {"reverse", {dim3(GRID_SIZE_REVERSE, BLOCK_SIZE_REVERSE, SHARED_MEM_SIZE_REVERSE)}}, {"roll", {dim3(GRID_SIZE_ROLL, BLOCK_SIZE_ROLL, SHARED_MEM_SIZE_ROLL)}}, {"batch_to_space_nd", {dim3(GRID_SIZE_BATCH_TO_SPACE_ND, BLOCK_SIZE_BATCH_TO_SPACE_ND, SHARED_MEM_SIZE_BATCH_TO_SPACE_ND)}}, {"space_to_batch", {dim3(GRID_SIZE_SPACE_TO_BATCH, BLOCK_SIZE_SPACE_TO_BATCH, SHARED_MEM_SIZE_SPACE_TO_BATCH)}}, {"space_to_batch_nd", {dim3(GRID_SIZE_SPACE_TO_BATCH_ND, BLOCK_SIZE_SPACE_TO_BATCH_ND, SHARED_MEM_SIZE_SPACE_TO_BATCH_ND)}}, {"space_to_depth", {dim3(GRID_SIZE_SPACE_TO_DEPTH, BLOCK_SIZE_SPACE_TO_DEPTH, SHARED_MEM_SIZE_SPACE_TO_DEPTH)}}, {"scatter", {dim3(GRID_SIZE_SCATTER, BLOCK_SIZE_SCATTER, SHARED_MEM_SIZE_SCATTER)}}, {"scatter_check_indices", {dim3(GRID_SIZE_SCATTER_CHECK_INDICES, BLOCK_SIZE_SCATTER_CHECK_INDICES, SHARED_MEM_SIZE_SCATTER_CHECK_INDICES)}}, {"scatter_nd", {dim3(GRID_SIZE_SCATTER_ND, BLOCK_SIZE_SCATTER_ND, SHARED_MEM_SIZE_SCATTER_ND)}}, {"scatter_simple", {dim3(GRID_SIZE_SCATTER_SIMPLE, BLOCK_SIZE_SCATTER_SIMPLE, SHARED_MEM_SIZE_SCATTER_SIMPLE)}}, {"scatter_update", {dim3(GRID_SIZE_SCATTER_UPDATE, BLOCK_SIZE_SCATTER_UPDATE, SHARED_MEM_SIZE_SCATTER_UPDATE)}}, {"segment_indices", {dim3(GRID_SIZE_SEGMENT_INDICES_VALIDATE, BLOCK_SIZE_SEGMENT_INDICES_VALIDATE, SHARED_MEM_SIZE_SEGMENT_INDICES_VALIDATE)}}, {"segment", {dim3(GRID_SIZE_SEGMENT, BLOCK_SIZE_SEGMENT, SHARED_MEM_SIZE_SEGMENT)}}, {"segment_tad", {dim3(GRID_SIZE_SEGMENT_TAD, BLOCK_SIZE_SEGMENT_TAD, SHARED_MEM_SIZE_SEGMENT_TAD)}}, {"unsorted_segment_prod_2", {dim3(GRID_SIZE_UNSORTEDSEGMENT_PROD_2, BLOCK_SIZE_UNSORTEDSEGMENT_PROD_2, SHARED_MEM_SIZE_UNSORTEDSEGMENT_PROD_2)}}, {"solve", {dim3(GRID_SIZE_SOLVE, BLOCK_SIZE_SOLVE, SHARED_MEM_SIZE_SOLVE)}}, {"sru_bi", {dim3(GRID_SIZE_SRU_BI, BLOCK_SIZE_SRU_BI, SHARED_MEM_SIZE_SRU_BI)}}, {"stack", {dim3(GRID_SIZE_STACK, BLOCK_SIZE_STACK, SHARED_MEM_SIZE_STACK)}}, {"top_k_mover", {dim3(GRID_SIZE_TOP_K_MOVER, BLOCK_SIZE_TOP_K_MOVER, SHARED_MEM_SIZE_TOP_K_MOVER)}}, {"top_k_indices", {dim3(GRID_SIZE_TOP_K_INDICES, BLOCK_SIZE_TOP_K_INDICES, SHARED_MEM_SIZE_TOP_K_INDICES)}}, {"invert_permute", {dim3(GRID_SIZE_INVERT_PERMUTE, BLOCK_SIZE_INVERT_PERMUTE, SHARED_MEM_SIZE_INVERT_PERMUTE)}}, {"trace", {dim3(GRID_SIZE_TRACE, BLOCK_SIZE_TRACE, SHARED_MEM_SIZE_TRACE)}}, {"triu", {dim3(GRID_SIZE_TRIU, BLOCK_SIZE_TRIU, SHARED_MEM_SIZE_TRIU)}}, {"tile", {dim3(GRID_SIZE_TILE, BLOCK_SIZE_TILE, SHARED_MEM_SIZE_TILE)}}, {"segment_bp", {dim3(GRID_SIZE_SEGMENT_BP, BLOCK_SIZE_SEGMENT_BP, SHARED_MEM_SIZE_SEGMENT_BP)}}, {"segment_bp_tad", {dim3(GRID_SIZE_SEGMENT_BP_TAD, BLOCK_SIZE_SEGMENT_BP_TAD, SHARED_MEM_SIZE_SEGMENT_BP_TAD)}}, {"segment_prod_2_linear", {dim3(GRID_SIZE_SEGMENT_PROD_2_LINEAR, BLOCK_SIZE_SEGMENT_PROD_2_LINEAR, SHARED_MEM_SIZE_SEGMENT_PROD_2_LINEAR)}}, {"segment_prod_2_tad", {dim3(GRID_SIZE_SEGMENT_PROD_2_TAD, BLOCK_SIZE_SEGMENT_PROD_2_TAD, SHARED_MEM_SIZE_SEGMENT_PROD_2_TAD)}}, {"triangular_solve", {dim3(GRID_SIZE_TRIANGULAR_SOLVE, BLOCK_SIZE_TRIANGULAR_SOLVE, SHARED_MEM_SIZE_TRIANGULAR_SOLVE)}}, {"updater", {dim3(GRID_SIZE_UPDATER, BLOCK_SIZE_UPDATER, SHARED_MEM_SIZE_UPDATER)}}, {"zeta", {dim3(GRID_SIZE_ZETA, BLOCK_SIZE_ZETA, SHARED_MEM_SIZE_ZETA)}}, {"batch_norm", {dim3(GRID_SIZE_BATCHNORM, BLOCK_SIZE_BATCHNORM, SHARED_MEM_SIZE_BATCHNORM)}}, {"avg_pooling", {dim3(GRID_SIZE_AVG_POOLING, BLOCK_SIZE_AVG_POOLING, SHARED_MEM_SIZE_POOLING)}}, {"mmul", {dim3(GRID_SIZE_MMUL, BLOCK_SIZE_MMUL, SHARED_MEM_SIZE_MMUL)}}, {"lambda", {dim3(GRID_SIZE_LAMBDA, BLOCK_SIZE_LAMBDA, SHARED_MEM_SIZE_LAMBDA)}}, {"image_resize_neighbor", {dim3(GRID_SIZE_IMAGE_RESIZE_NEIGHBOR, BLOCK_SIZE_IMAGE_RESIZE_NEIGHBOR, SHARED_MEM_SIZE_IMAGE_RESIZE_NEIGHBOR)}}, {"swap_unsafe", {dim3(GRID_SIZE_SWAP_UNSAFE, BLOCK_SIZE_SWAP_UNSAFE, SHARED_MEM_SIZE_SWAP_UNSAFE)}}, {"digamma", {dim3(GRID_SIZE_DIGAMMA, BLOCK_SIZE_DIGAMMA, SHARED_MEM_SIZE_DIGAMMA)}}, {"fill_tri", {dim3(GRID_SIZE_FILL_TRI, BLOCK_SIZE_FILL_TRI, SHARED_MEM_SIZE_FILL_TRI)}}, {"identity", {dim3(GRID_SIZE_IDENTITY, BLOCK_SIZE_IDENTITY, SHARED_MEM_SIZE_IDENTITY)}}, {"dynamic_stitch_tad", {dim3(GRID_SIZE_DYNAMIC_STITCH_TAD, BLOCK_SIZE_DYNAMIC_STITCH_TAD, SHARED_MEM_SIZE_DYNAMIC_STITCH_TAD)}}, {"dynamic_partition_tad", {dim3(GRID_SIZE_DYNAMIC_PARTITION_TAD, BLOCK_SIZE_DYNAMIC_PARTITION_TAD, SHARED_MEM_SIZE_DYNAMIC_PARTITION_TAD)}}, {"solve", {dim3(GRID_SIZE_SOLVE, BLOCK_SIZE_SOLVE, SHARED_MEM_SIZE_SOLVE)}}, {"softmax", {dim3(GRID_SIZE_SOFTMAX, BLOCK_SIZE_SOFTMAX, SHARED_MEM_SIZE_SOFTMAX)}}, }; std::unordered_map> algoDimMapString = { {"random", {"GRID_SIZE_RANDOM", "BLOCK_SIZE_RANDOM", "SHARED_MEM_SIZE_RANDOM"}}, {"diagPart", {"GRID_SIZE_DIAG_PART", "BLOCK_SIZE_DIAG_PART", "SHARED_MEM_SIZE_DIAG_PART"}}, {"logAbsDeterminant", {"GRID_SIZE_LOG_ABS_DETERMINANT", "BLOCK_SIZE_LOG_ABS_DETERMINANT", "SHARED_MEM_SIZE_LOG_ABS_DETERMINANT"}}, {"adjustWeights", {"GRID_SIZE_ADJUST_WEIGHTS", "BLOCK_SIZE_ADJUST_WEIGHTS", "SHARED_MEM_SIZE_ADJUST_WEIGHTS"}}, {"sequenceMask", {"GRID_SIZE_SEQUENCE_MASK", "BLOCK_SIZE_SEQUENCE_MASK", "SHARED_MEM_SIZE_SEQUENCE_MASK"}}, {"segmentSum", {"GRID_SIZE_SEGMENT_SUM", "BLOCK_SIZE_SEGMENT_SUM", "SHARED_MEM_SIZE_SEGMENT_SUM"}}, {"unsortedSegmentSum", {"GRID_SIZE_UNSORTED_SEGMENT_SUM", "BLOCK_SIZE_UNSORTED_SEGMENT_SUM", "SHARED_MEM_SIZE_UNSORTED_SEGMENT_SUM"}}, {"segmentSqrtN", {"GRID_SIZE_SEGMENT_SQRTN", "BLOCK_SIZE_SEGMENT_SQRTN", "SHARED_MEM_SIZE_SEGMENT_SQRTN"}}, {"segmentProd", {"GRID_SIZE_SEGMENT_PROD", "BLOCK_SIZE_SEGMENT_PROD", "SHARED_MEM_SIZE_SEGMENT_PROD"}}, {"unsortedSegmentProd", {"GRID_SIZE_UNSORTED_SEGMENT_PROD", "BLOCK_SIZE_UNSORTED_SEGMENT_PROD", "SHARED_MEM_SIZE_UNSORTED_SEGMENT_PROD"}}, {"segmentMin", {"GRID_SIZE_SEGMENT_MIN", "BLOCK_SIZE_SEGMENT_MIN", "SHARED_MEM_SIZE_SEGMENT_MIN"}}, {"unsortedSegmentMin", {"GRID_SIZE_UNSORTED_SEGMENT_MIN", "BLOCK_SIZE_UNSORTED_SEGMENT_MIN", "SHARED_MEM_SIZE_UNSORTED_SEGMENT_MIN"}}, {"segmentMean", {"GRID_SIZE_SEGMENT_MEAN", "BLOCK_SIZE_SEGMENT_MEAN", "SHARED_MEM_SIZE_SEGMENT_MEAN"}}, {"unsortedSegmentMean", {"GRID_SIZE_UNSORTED_SEGMENT_MEAN", "BLOCK_SIZE_UNSORTED_SEGMENT_MEAN", "SHARED_MEM_SIZE_UNSORTED_SEGMENT_MEAN"}}, {"segmentMax", {"GRID_SIZE_SEGMENT_MAX", "BLOCK_SIZE_SEGMENT_MAX", "SHARED_MEM_SIZE_SEGMENT_MAX"}}, {"unsortedSegmentMax", {"GRID_SIZE_UNSORTED_SEGMENT_MAX", "BLOCK_SIZE_UNSORTED_SEGMENT_MAX", "SHARED_MEM_SIZE_UNSORTED_SEGMENT_MAX"}}, {"matrixDiag", {"GRID_SIZE_MATRIX_DIAG", "BLOCK_SIZE_MATRIX_DIAG", "SHARED_MEM_SIZE_MATRIX_DIAG"}}, {"segmentFillUpSegments", {"GRID_SIZE_SEGMENT_FILL_UP_SEGMENTS", "BLOCK_SIZE_SEGMENT_FILL_UP_SEGMENTS", "SHARED_MEM_SIZE_SEGMENT_FILL_UP_SEGMENTS"}}, {"matrixBand", {"GRID_SIZE_MATRIX_BAND", "BLOCK_SIZE_MATRIX_BAND", "SHARED_MEM_SIZE_MATRIX_BAND"}}, {"lup", {"GRID_SIZE_LUP", "BLOCK_SIZE_LUP", "SHARED_MEM_SIZE_LUP"}}, {"ismax", {"GRID_SIZE_ISMAX", "BLOCK_SIZE_ISMAX", "SHARED_MEM_SIZE_ISMAX"}}, {"ismaxFill", {"GRID_SIZE_ISMAX_FILL", "BLOCK_SIZE_ISMAX_FILL", "SHARED_MEM_SIZE_ISMAX_FILL"}}, {"imageResize", {"GRID_SIZE_IMAGE_RESIZE", "BLOCK_SIZE_IMAGE_RESIZE", "SHARED_MEM_SIZE_IMAGE_RESIZE"}}, {"diag", {"GRID_SIZE_DIAG", "BLOCK_SIZE_DIAG", "SHARED_MEM_SIZE_DIAG"}}, {"confusionMatrix", {"GRID_SIZE_CONFUSION_MATRIX", "BLOCK_SIZE_CONFUSION_MATRIX", "SHARED_MEM_SIZE_CONFUSION_MATRIX"}}, {"tile", {"GRID_SIZE_TILE", "BLOCK_SIZE_TILE", "SHARED_MEM_SIZE_TILE"}}, {"extract_patches", {"GRID_SIZE_EXTRACT_PATCHES", "BLOCK_SIZE_EXTRACT_PATCHES", "SHARED_MEM_SIZE_EXTRACT_PATCHES"}}, {"diagonal", {"GRID_SIZE_DIAGONAL", "BLOCK_SIZE_DIAGONAL", "SHARED_MEM_SIZE_DIAGONAL"}}, {"tear", {"GRID_SIZE_TEAR", "BLOCK_SIZE_TEAR", "SHARED_MEM_SIZE_TEAR"}}, {"sortTensorByDimKey", {"GRID_SIZE_SORT_TENSOR_BY_DIM_KEY", "BLOCK_SIZE_SORT_TENSOR_BY_DIM_KEY", "SHARED_MEM_SIZE_SORT_TENSOR_BY_DIM_KEY"}}, {"sortTensorAlongDimKey", {"GRID_SIZE_SORT_TENSOR_ALONG_DIM_KEY", "BLOCK_SIZE_SORT_TENSOR_ALONG_DIM_KEY", "SHARED_MEM_SIZE_SORT_TENSOR_ALONG_DIM_KEY"}}, {"sortTensorAlongDimValue", {"GRID_SIZE_SORT_TENSOR_ALONG_DIM_VALUE", "BLOCK_SIZE_SORT_TENSOR_ALONG_DIM_VALUE", "SHARED_MEM_SIZE_SORT_TENSOR_ALONG_DIM_VALUE"}}, {"shuffle", {"GRID_SIZE_SHUFFLE", "BLOCK_SIZE_SHUFFLE", "SHARED_MEM_SIZE_SHUFFLE"}}, {"pullRows", {"GRID_SIZE_PULLROWS", "BLOCK_SIZE_PULLROWS", "SHARED_MEM_SIZE_PULLROWS"}}, {"prescanArrayRecursive", {"GRID_SIZE_PRESCAN_ARRAY_RECURSIVE", "BLOCK_SIZE_PRESCAN_ARRAY_RECURSIVE", "SHARED_MEM_SIZE_PRESCAN_ARRAY_RECURSIVE"}}, {"scalarTad", {"GRID_SIZE_SCALAR_TAD", "BLOCK_SIZE_SCALAR_TAD", "SHARED_MEM_SIZE_SCALAR_TAD"}}, {"scalarScan", {"GRID_SIZE_SCALAR_SCAN", "BLOCK_SIZE_SCALAR_SCAN", "SHARED_MEM_SIZE_SCALAR_SCAN"}}, {"reduceLong", {"GRID_SIZE_REDUCE_LONG", "BLOCK_SIZE_REDUCE_LONG", "SHARED_MEM_SIZE_REDUCE_LONG"}}, {"reduceBool", {"GRID_SIZE_REDUCE_BOOL", "BLOCK_SIZE_REDUCE_BOOL", "SHARED_MEM_SIZE_REDUCE_BOOL"}}, {"average", {"GRID_SIZE_AVERAGE", "BLOCK_SIZE_AVERAGE", "SHARED_MEM_SIZE_AVERAGE"}}, {"accumulate", {"GRID_SIZE_ACCUMULATE", "BLOCK_SIZE_ACCUMULATE", "SHARED_MEM_SIZE_ACCUMULATE"}}, {"transformScan", {"GRID_SIZE_TRANSFORM_SCAN", "BLOCK_SIZE_TRANSFORM_SCAN", "SHARED_MEM_SIZE_TRANSFORM_SCAN"}}, {"summaryStats", {"GRID_SIZE_SUMMARY_STATS", "BLOCK_SIZE_SUMMARY_STATS", "SHARED_MEM_SIZE_SUMMARY_STATS"}}, {"reduceFloat", {"GRID_SIZE_REDUCE_FLOAT", "BLOCK_SIZE_REDUCE_FLOAT", "SHARED_MEM_SIZE_REDUCE_FLOAT"}}, {"scalarBool", {"GRID_SIZE_SCALAR_BOOL", "BLOCK_SIZE_SCALAR_BOOL", "SHARED_MEM_SIZE_SCALAR_BOOL"}}, {"scalarSame", {"GRID_SIZE_SCALAR_SAME", "BLOCK_SIZE_SCALAR_SAME", "SHARED_MEM_SIZE_SCALAR_SAME"}}, {"scalarLong", {"GRID_SIZE_SCALAR_LONG", "BLOCK_SIZE_SCALAR_LONG", "SHARED_MEM_SIZE_SCALAR_LONG"}}, {"reduce3", {"GRID_SIZE_REDUCE_3", "BLOCK_SIZE_REDUCE_3", "SHARED_MEM_SIZE_REDUCE_3"}}, {"pairwiseTransforms", {"GRID_SIZE_PAIRWISE_TRANSFORMS", "BLOCK_SIZE_PAIRWISE_TRANSFORMS", "SHARED_MEM_SIZE_PAIRWISE_TRANSFORMS"}}, {"broadcast", {"GRID_SIZE_BROADCAST", "BLOCK_SIZE_BROADCAST", "SHARED_MEM_SIZE_BROADCAST"}}, {"broadcastInt", {"GRID_SIZE_BROADCAST_INT", "BLOCK_SIZE_BROADCAST_INT", "SHARED_MEM_SIZE_BROADCAST_INT"}}, {"broadcastBool", {"GRID_SIZE_BROADCAST_BOOL", "BLOCK_SIZE_BROADCAST_BOOL", "SHARED_MEM_SIZE_BROADCAST_BOOL"}}, {"matrixMultiply", {"GRID_SIZE_MATRIX_MULTIPLY", "BLOCK_SIZE_MATRIX_MULTIPLY", "SHARED_MEM_SIZE_MATRIX_MULTIPLY"}}, {"im2col", {"GRID_SIZE_IM2COL", "BLOCK_SIZE_IM2COL", "SHARED_MEM_SIZE_IM2COL"}}, {"col2im", {"GRID_SIZE_COL2IM", "BLOCK_SIZE_COL2IM", "SHARED_MEM_SIZE_COL2IM"}}, {"gemv", {"GRID_SIZE_GEMV", "BLOCK_SIZE_GEMV", "SHARED_MEM_SIZE_GEMV"}}, {"addBias", {"GRID_SIZE_ADDBIAS", "BLOCK_SIZE_ADDBIAS", "SHARED_MEM_SIZE_ADDBIAS"}}, {"pooling", {"GRID_SIZE_POOLING", "BLOCK_SIZE_POOLING", "SHARED_MEM_SIZE_POOLING"}}, {"vol2col", {"GRID_SIZE_VOL2COL", "BLOCK_SIZE_VOL2COL", "SHARED_MEM_SIZE_VOL2COL"}}, {"col2vol", {"GRID_SIZE_COL2VOL", "BLOCK_SIZE_COL2VOL", "SHARED_MEM_SIZE_COL2VOL"}}, {"upsampling", {"GRID_SIZE_UPSAMPLING", "BLOCK_SIZE_UPSAMPLING", "SHARED_MEM_SIZE_UPSAMPLING"}}, {"histogram", {"GRID_SIZE_HISTOGRAM", "BLOCK_SIZE_HISTOGRAM", "SHARED_MEM_SIZE_HISTOGRAM"}}, {"prelu", {"GRID_SIZE_PRELU", "BLOCK_SIZE_PRELU", "SHARED_MEM_SIZE_PRELU"}}, {"adjust", {"GRID_SIZE_ADJUST", "BLOCK_SIZE_ADJUST", "SHARED_MEM_SIZE_ADJUST"}}, {"compare_and_bitpack", {"GRID_SIZE_COMPARE_AND_BITPACK", "BLOCK_SIZE_COMPARE_AND_BITPACK", "SHARED_MEM_SIZE_COMPARE_AND_BITPACK"}}, {"concat", {"GRID_SIZE_CONCAT", "BLOCK_SIZE_CONCAT", "SHARED_MEM_SIZE_CONCAT"}}, {"confusion_matrix", {"GRID_SIZE_CONFUSION_MATRIX", "BLOCK_SIZE_CONFUSION_MATRIX", "SHARED_MEM_SIZE_CONFUSION_MATRIX"}}, {"beta_inc", {"GRID_SIZE_BETA_INC", "BLOCK_SIZE_BETA_INC", "SHARED_MEM_SIZE_BETA_INC"}}, {"clip", {"GRID_SIZE_CLIP", "BLOCK_SIZE_CLIP", "SHARED_MEM_SIZE_CLIP"}}, {"cross", {"GRID_SIZE_CROSS", "BLOCK_SIZE_CROSS", "SHARED_MEM_SIZE_CROSS"}}, {"depth_to_space", {"GRID_SIZE_DEPTH_TO_SPACE", "BLOCK_SIZE_DEPTH_TO_SPACE", "SHARED_MEM_SIZE_DEPTH_TO_SPACE"}}, {"dilation", {"GRID_SIZE_DILATION", "BLOCK_SIZE_DILATION", "SHARED_MEM_SIZE_DILATION"}}, {"dropout", {"GRID_SIZE_DROPOUT", "BLOCK_SIZE_DROPOUT", "SHARED_MEM_SIZE_DROPOUT"}}, {"fake_quantization", {"GRID_SIZE_FAKE_QUANTIZATION", "BLOCK_SIZE_FAKE_QUANTIZATION", "SHARED_MEM_SIZE_FAKE_QUANTIZATION"}}, {"flatten", {"GRID_SIZE_FLATTEN", "BLOCK_SIZE_FLATTEN", "SHARED_MEM_SIZE_FLATTEN"}}, {"gather_linear", {"GRID_SIZE_GATHER_LINEAR", "BLOCK_SIZE_GATHER_LINEAR", "SHARED_MEM_SIZE_GATHER_LINEAR"}}, {"gather", {"GRID_SIZE_GATHER", "BLOCK_SIZE_GATHER", "SHARED_MEM_SIZE_GATHER"}}, {"gather_nd", {"GRID_SIZE_GATHERND", "BLOCK_SIZE_GATHERND", "SHARED_MEM_SIZE_GATHERND"}}, {"hamming", {"GRID_SIZE_HAMMING", "BLOCK_SIZE_HAMMING", "SHARED_MEM_SIZE_HAMMING"}}, {"hashcode_split", {"GRID_SIZE_HASHCODE_SPLIT", "BLOCK_SIZE_HASHCODE_SPLIT", "SHARED_MEM_SIZE_HASHCODE_SPLIT"}}, {"hashcode_internal", {"GRID_SIZE_HASHCODE_INTERNAL", "BLOCK_SIZE_HASHCODE_INTERNAL", "SHARED_MEM_SIZE_HASHCODE_INTERNAL"}}, {"hashcode_last", {"GRID_SIZE_HASHCODE_LAST", "BLOCK_SIZE_HASHCODE_LAST", "SHARED_MEM_SIZE_HASHCODE_LAST"}}, {"histogram_fixed_width", {"GRID_SIZE_HISTOGRAM_FIXED_WIDTH", "BLOCK_SIZE_HISTOGRAM_FIXED_WIDTH", "SHARED_MEM_SIZE_HISTOGRAM_FIXED_WIDTH"}}, {"draw_bounding_boxes", {"GRID_SIZE_DRAW_BOUNDING_BOXES", "BLOCK_SIZE_DRAW_BOUNDING_BOXES", "SHARED_MEM_SIZE_DRAW_BOUNDING_BOXES"}}, {"image_resize", {"GRID_SIZE_IMAGE_RESIZE", "BLOCK_SIZE_IMAGE_RESIZE", "SHARED_MEM_SIZE_IMAGE_RESIZE"}}, {"image_resize_interp_weights", {"GRID_SIZE_IMAGE_RESIZE_INTERP_WEIGHTS", "BLOCK_SIZE_IMAGE_RESIZE_INTERP_WEIGHTS", "SHARED_MEM_SIZE_IMAGE_RESIZE_INTERP_WEIGHTS"}}, {"image_resize_init_coeffs", {"GRID_SIZE_IMAGE_RESIZE_INIT_COEFFS", "BLOCK_SIZE_IMAGE_RESIZE_INIT_COEFFS", "SHARED_MEM_SIZE_IMAGE_RESIZE_INIT_COEFFS"}}, {"image_resize_coeffs_accum", {"GRID_SIZE_IMAGE_RESIZE_COEFFS_ACCUM", "BLOCK_SIZE_IMAGE_RESIZE_COEFFS_ACCUM", "SHARED_MEM_SIZE_IMAGE_RESIZE_COEFFS_ACCUM"}}, {"image_resize_bicubic", {"GRID_SIZE_IMAGE_RESIZE_BICUBIC", "BLOCK_SIZE_IMAGE_RESIZE_BICUBIC", "SHARED_MEM_SIZE_IMAGE_RESIZE_BICUBIC"}}, {"image_resize_fill_interp", {"GRID_SIZE_IMAGE_RESIZE_FILL_INTERP", "BLOCK_SIZE_IMAGE_RESIZE_FILL_INTERP", "SHARED_MEM_SIZE_IMAGE_RESIZE_FILL_INTERP"}}, {"image_resize_crop_and_resize", {"GRID_SIZE_IMAGE_RESIZE_CROP_AND_RESIZE", "BLOCK_SIZE_IMAGE_RESIZE_CROP_AND_RESIZE", "SHARED_MEM_SIZE_IMAGE_RESIZE_CROP_AND_RESIZE"}}, {"image_resize_v2_gather", {"GRID_SIZE_IMAGE_RESIZE_V2_GATHER", "BLOCK_SIZE_IMAGE_RESIZE_V2_GATHER", "SHARED_MEM_SIZE_IMAGE_RESIZE_V2_GATHER"}}, {"image_suppress_scores", {"GRID_SIZE_IMAGE_SUPPRESS_SCORES", "BLOCK_SIZE_IMAGE_SUPPRESS_SCORES", "SHARED_MEM_SIZE_IMAGE_SUPPRESS_SCORES"}}, {"image_suppress_select", {"GRID_SIZE_IMAGE_SUPPRESS_SELECT", "BLOCK_SIZE_IMAGE_SUPPRESS_SELECT", "SHARED_MEM_SIZE_IMAGE_SUPPRESS_SELECT"}}, {"image_suppress_nonmax_overlap", {"GRID_SIZE_IMAGE_SUPPRESS_NONMAX_OVERLAP", "BLOCK_SIZE_IMAGE_SUPPRESS_NONMAX_OVERLAP", "SHARED_MEM_SIZE_IMAGE_SUPPRESS_NONMAX_OVERLAP"}}, {"image_helpers_triple", {"GRID_SIZE_IMAGE_HELPERS_TRIPLE", "BLOCK_SIZE_IMAGE_HELPERS_TRIPLE", "SHARED_MEM_SIZE_IMAGE_HELPERS_TRIPLE"}}, {"image_helpers", {"GRID_SIZE_IMAGE_HELPERS", "BLOCK_SIZE_IMAGE_HELPERS", "SHARED_MEM_SIZE_GRID_SIZE_IMAGE_HELPERS"}}, {"lrn", {"GRID_SIZE_LRN", "BLOCK_SIZE_LRN", "SHARED_MEM_SIZE_LRN"}}, {"lstsq_reg", {"GRID_SIZE_LSTSQ_REG", "BLOCK_SIZE_LSTSQ_REG", "SHARED_MEM_SIZE_LSTSQ_REG"}}, {"lup", {"GRID_SIZE_LUP", "BLOCK_SIZE_LUP", "SHARED_MEM_SIZE_LUP"}}, {"lup_low", {"GRID_SIZE_LUP_LOW", "BLOCK_SIZE_LUP_LOW", "SHARED_MEM_SIZE_LUP_LOW"}}, {"matrix_set_diag", {"GRID_SIZE_MATRIX_SET_DIAG", "BLOCK_MATRIX_SET_DIAG", "SHARED_MEM_SIZE_MATRIX_SET_DIAG"}}, {"merge", {"GRID_SIZE_MERGE", "BLOCK_SIZE_MERGE", "SHARED_MEM_SIZE_MERGE"}}, {"meshgrid", {"GRID_SIZE_MESHGRID", "BLOCK_SIZE_MESHGRID", "SHARED_MEM_SIZE_MESHGRID"}}, {"nth_element_fill", {"GRID_SIZE_NTH_ELEMENT_FILL", "BLOCK_SIZE_NTH_ELEMENT_FILL", "SHARED_MEM_SIZE_NTH_ELEMENT_FILL"}}, {"one_hot", {"GRID_SIZE_ONE_HOT", "BLOCK_SIZE_ONE_HOT", "SHARED_MEM_SIZE_ONE_HOT"}}, {"pad", {"GRID_SIZE_PAD", "BLOCK_SIZE_PAD", "SHARED_MEM_SIZE_PAD"}}, {"percentile", {"GRID_SIZE_PERCENTILE", "BLOCK_SIZE_PERCENTILE", "SHARED_MEM_SIZE_PERCENTILE"}}, {"polygamma", {"GRID_SIZE_POLYGAMMA", "BLOCK_SIZE_POLYGAMMA", "SHARED_MEM_SIZE_POLYGAMMA"}}, {"prefix", {"GRID_SIZE_PREFIX", "BLOCK_SIZE_PREFIX", "SHARED_MEM_SIZE_PREFIX"}}, {"print", {"GRID_SIZE_PRINT", "BLOCK_SIZE_PRINT", "SHARED_MEM_SIZE_PRINT"}}, {"qr", {"GRID_SIZE_QR", "BLOCK_SIZE_QR", "SHARED_MEM_SIZE_QR"}}, {"random_gamma", {"GRID_SIZE_RANDOM_GAMMA", "BLOCK_SIZE_RANDOM_GAMMA", "SHARED_MEM_SIZE_RANDOM_GAMMA"}}, {"random_poisson", {"GRID_SIZE_RANDOM_POISSON", "BLOCK_SIZE_RANDOM_POISSON", "SHARED_MEM_SIZE_RANDOM_POISSON"}}, {"random_uniform", {"GRID_SIZE_RANDOM_UNIFORM", "BLOCK_SIZE_RANDOM_UNIFORM", "SHARED_MEM_SIZE_RANDOM_UNIFORM"}}, {"random_shuffle_fisher", {"GRID_SIZE_RANDOM_SHUFFLE_FISHER", "BLOCK_SIZE_RANDOM_SHUFFLE_FISHER", "SHARED_MEM_SIZE_RANDOM_SHUFFLE_FISHER"}}, {"random_shuffle_merge", {"GRID_SIZE_RANDOM_SHUFFLE_MERGE", "BLOCK_SIZE_RANDOM_SHUFFLE_FISHER", "SHARED_MEM_SIZE_RANDOM_SHUFFLE_FISHER"}}, {"range", {"GRID_SIZE_RANGE", "BLOCK_SIZE_RANGE", "SHARED_MEM_SIZE_RANGE"}}, {"reverse", {"GRID_SIZE_REVERSE", "BLOCK_SIZE_REVERSE", "SHARED_MEM_SIZE_REVERSE"}}, {"roll", {"GRID_SIZE_ROLL", "BLOCK_SIZE_ROLL", "SHARED_MEM_SIZE_ROLL"}}, {"batch_to_space_nd", {"GRID_SIZE_BATCH_TO_SPACE_ND", "BLOCK_SIZE_BATCH_TO_SPACE_ND", "SHARED_MEM_SIZE_BATCH_TO_SPACE_ND"}}, {"space_to_batch", {"GRID_SIZE_SPACE_TO_BATCH", "BLOCK_SIZE_SPACE_TO_BATCH", "SHARED_MEM_SIZE_SPACE_TO_BATCH"}}, {"space_to_batch_nd", {"GRID_SIZE_SPACE_TO_BATCH_ND", "BLOCK_SIZE_SPACE_TO_BATCH_ND", "SHARED_MEM_SIZE_SPACE_TO_BATCH_ND"}}, {"space_to_depth", {"GRID_SIZE_SPACE_TO_DEPTH", "BLOCK_SIZE_SPACE_TO_DEPTH", "SHARED_MEM_SIZE_SPACE_TO_DEPTH"}}, {"scatter", {"GRID_SIZE_SCATTER", "BLOCK_SIZE_SCATTER", "SHARED_MEM_SIZE_SCATTER"}}, {"scatter_check_indices", {"GRID_SIZE_SCATTER_CHECK_INDICES", "BLOCK_SIZE_SCATTER_CHECK_INDICES", "SHARED_MEM_SIZE_SCATTER_CHECK_INDICES"}}, {"scatter_nd", {"GRID_SIZE_SCATTER_ND", "BLOCK_SIZE_SCATTER_ND", "SHARED_MEM_SIZE_SCATTER_ND"}}, {"scatter_simple", {"GRID_SIZE_SCATTER_SIMPLE", "BLOCK_SIZE_SCATTER_SIMPLE", "SHARED_MEM_SIZE_SCATTER_SIMPLE"}}, {"scatter_update", {"GRID_SIZE_SCATTER_UPDATE", "BLOCK_SIZE_SCATTER_UPDATE", "SHARED_MEM_SIZE_SCATTER_UPDATE"}}, {"segment_indices", {"GRID_SIZE_SEGMENT_INDICES_VALIDATE", "BLOCK_SIZE_SEGMENT_INDICES_VALIDATE", "SHARED_MEM_SIZE_SEGMENT_INDICES_VALIDATE"}}, {"segment", {"GRID_SIZE_SEGMENT", "BLOCK_SIZE_SEGMENT", "SHARED_MEM_SIZE_SEGMENT"}}, {"segment_tad", {"GRID_SIZE_SEGMENT_TAD", "BLOCK_SIZE_SEGMENT_TAD", "SHARED_MEM_SIZE_SEGMENT_TAD"}}, {"segment_prod_2", {"GRID_SIZE_SEGMENT_PROD_2_LINEAR", "BLOCK_SIZE_SEGMENT_PROD_2_LINEAR", "SHARED_MEM_SIZE_SEGMENT_PROD_2_LINEAR"}}, {"segment_prod_2_tad", {"GRID_SIZE_SEGMENT_PROD_2_TAD", "BLOCK_SIZE_SEGMENT_PROD_2_TAD", "SHARED_MEM_SIZE_SEGMENT_PROD_2_TAD"}}, {"unsorted_segment_prod_2", {"GRID_SIZE_UNSORTEDSEGMENT_PROD_2", "BLOCK_SIZE_UNSORTEDSEGMENT_PROD_2", "SHARED_MEM_SIZE_UNSORTEDSEGMENT_PROD_2"}}, {"solve", {"GRID_SIZE_SOLVE", "BLOCK_SIZE_SOLVE", "SHARED_MEM_SIZE_SOLVE"}}, {"sru_bi", {"GRID_SIZE_SRU_BI", "BLOCK_SIZE_SRU_BI", "SHARED_MEM_SIZE_SRU_BI"}}, {"stack", {"GRID_SIZE_STACK", "BLOCK_SIZE_STACK", "SHARED_MEM_SIZE_STACK"}}, {"top_k_mover", {"GRID_SIZE_TOP_K_MOVER", "BLOCK_SIZE_TOP_K_MOVER", "SHARED_MEM_SIZE_TOP_K_MOVER"}}, {"top_k_indices", {"GRID_SIZE_TOP_K_INDICES", "BLOCK_SIZE_TOP_K_INDICES", "SHARED_MEM_SIZE_TOP_K_INDICES"}}, {"invert_permute", {"GRID_SIZE_INVERT_PERMUTE", "BLOCK_SIZE_INVERT_PERMUTE", "SHARED_MEM_SIZE_INVERT_PERMUTE"}}, {"trace", {"GRID_SIZE_TRACE", "BLOCK_SIZE_TRACE", "SHARED_MEM_SIZE_TRACE"}}, {"triu", {"GRID_SIZE_TRIU", "BLOCK_SIZE_TRIU", "SHARED_MEM_SIZE_TRIU"}}, {"tile", {"GRID_SIZE_TILE", "BLOCK_SIZE_TILE", "SHARED_MEM_SIZE_TILE"}}, {"segment_bp", {"GRID_SIZE_SEGMENT_BP", "BLOCK_SIZE_SEGMENT_BP", "SHARED_MEM_SIZE_SEGMENT_BP"}}, {"segment_bp_tad", {"GRID_SIZE_SEGMENT_BP_TAD", "BLOCK_SIZE_SEGMENT_BP_TAD", "SHARED_MEM_SIZE_SEGMENT_BP_TAD"}}, {"segment_prod_2_linear", {"GRID_SIZE_SEGMENT_PROD_2_LINEAR", "BLOCK_SIZE_SEGMENT_PROD_2_LINEAR", "SHARED_MEM_SIZE_SEGMENT_PROD_2_LINEAR"}}, {"segment_prod_2_tad", {"GRID_SIZE_SEGMENT_PROD_2_TAD", "BLOCK_SIZE_SEGMENT_PROD_2_TAD", "SHARED_MEM_SIZE_SEGMENT_PROD_2_TAD"}}, {"triangular_solve", {"GRID_SIZE_TRIANGULAR_SOLVE", "BLOCK_SIZE_TRIANGULAR_SOLVE", "SHARED_MEM_SIZE_TRIANGULAR_SOLVE"}}, {"updater", {"GRID_SIZE_UPDATER", "BLOCK_SIZE_UPDATER", "SHARED_MEM_SIZE_UPDATER"}}, {"zeta", {"GRID_SIZE_ZETA", "BLOCK_SIZE_ZETA", "SHARED_MEM_SIZE_ZETA"}}, {"mmul", {"GRID_SIZE_MMUL", "BLOCK_SIZE_MMUL", "SHARED_MEM_SIZE_MMUL"}}, {"avg_pooling", {"GRID_SIZE_AVG_POOLING", "BLOCK_SIZE_AVG_POOLING", "SHARED_MEM_SIZE_POOLING"}}, {"lambda", {"GRID_SIZE_LAMBDA", "BLOCK_SIZE_LAMBDA", "SHARED_MEM_SIZE_LAMBDA"}}, {"image_resize_neighbor", {"GRID_SIZE_IMAGE_RESIZE_NEIGHBOR", "BLOCK_SIZE_IMAGE_RESIZE_NEIGHBOR", "SHARED_MEM_SIZE_IMAGE_RESIZE_NEIGHBOR"}}, {"swap_unsafe", {"GRID_SIZE_SWAP_UNSAFE", "BLOCK_SIZE_SWAP_UNSAFE", "SHARED_MEM_SIZE_SWAP_UNSAFE"}}, {"digamma", {"GRID_SIZE_DIGAMMA", "BLOCK_SIZE_DIGAMMA", "SHARED_MEM_SIZE_DIGAMMA"}}, {"fill_tri", {"GRID_SIZE_FILL_TRI", "BLOCK_SIZE_FILL_TRI", "SHARED_MEM_SIZE_FILL_TRI"}}, {"repeat", {"GRID_SIZE_FILL_REPEAT", "BLOCK_SIZE_FILL_REPEAT", "SHARED_MEM_SIZE_FILL_REPEAT"}}, {"identity", {"GRID_SIZE_FILL_IDENTITY", "BLOCK_SIZE_FILL_IDENTITY", "SHARED_MEM_SIZE_FILL_IDENTITY"}}, {"dynamic_stitch_tad", {"GRID_SIZE_DYNAMIC_STITCH_TAD", "BLOCK_SIZE_DYNAMIC_STITCH_TAD", "SHARED_MEM_SIZE_DYNAMIC_STITCH_TAD"}}, {"dynamic_partition_tad", {"GRID_SIZE_DYNAMIC_PARTITION_TAD", "BLOCK_SIZE_DYNAMIC_PARTITION_TAD", "SHARED_MEM_SIZE_DYNAMIC_PARTITION_TAD"}}, {"solve", {"GRID_SIZE_SOLVE", "BLOCK_SIZE_SOLVE", "SHARED_MEM_SIZE_SOLVE"}}, {"lup", {"GRID_SIZE_LUP", "BLOCK_SIZE_LUP", "SHARED_MEM_SIZE_LUP"}}, {"softmax", {"GRID_SIZE_SOFTMAX", "BLOCK_SIZE_SOFTMAX", "SHARED_MEM_SIZE_SOFTMAX"}}, {"softmax", {"GRID_SIZE_SOFTMAX", "BLOCK_SIZE_SOFTMAX", "SHARED_MEM_SIZE_SOFTMAX"}}, }; dim3 getSoftmaxDims(int numTads) { int threadsPerBlock = 256; int blocksPerGrid = numTads; int sharedMem = 1024; threadsPerBlock = getEnvVariable("GRID_SIZE_SOFTMAX",threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_SOFTMAX",blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_SOFTMAX",sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getLupDims(int batchSize) { int threadsPerBlock = 128; int blocksPerGrid = 1; int sharedMem = 256; threadsPerBlock = getEnvVariable("GRID_SIZE_LUP",threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_LUP",blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_LUP",sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getDynamicPartitionDims(int numThreads,int yDTypeSize) { auto shmemSize = numThreads *yDTypeSize * 2 + 1024; int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = 256; int sharedMem = numThreads * yDTypeSize * 2 + 1024; threadsPerBlock = getEnvVariable("GRID_SIZE_DYNAMIC_PARTITION_TAD",threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_DYNAMIC_PARTITION_TAD",blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_DYNAMIC_PARTITION_TAD",sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getIdentityLaunchDims(int len,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (len + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(int) *rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_FILL_IDENTITY",threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_FILL_IDENTITY",blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_FILL_IDENTITY",sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getRepeatLaunchDims(int len,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (len + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(sd::LongType) *rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_REPEAT",threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_FILL_REPEAT",blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_FILL_REPEAT",sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getFillTriLaunchDims(int len,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (len + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(int) *rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_FILL_TRI",threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_FILL_TRI",blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_FILL_TRI",sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } // Retrieve the environment variable value for the given variable name int getEnvVariable(const std::string& varName, int defaultValue) { const char* envValue = std::getenv(varName.c_str()); if (envValue != nullptr) { return std::atoi(envValue); } return defaultValue; } dim3 getLaunchDims(const std::string& key) { // Look for the key in the cache // Key not found in the cache // Check if there is an environment variable with this key if(!algoDimMapString.count(key.c_str())) { std::string errorMessage; errorMessage += "Key "; errorMessage += key; errorMessage += " not found in the launch dimensions environment variable map."; THROW_EXCEPTION(errorMessage.c_str()); } if(!algoDimMap.count(key.c_str())) { std::string errorMessage; errorMessage += "Key "; errorMessage += key; errorMessage += " not found in the launch dimensions map."; THROW_EXCEPTION(errorMessage.c_str()); } auto algoValue = algoDimMapString[key.c_str()]; dim3 returnValue; dim3 defaultValue = algoDimMap[key.c_str()]; auto xKey = algoValue[0].c_str(); auto yKey = algoValue[1].c_str(); auto zKey = algoValue[2].c_str(); char* envValueX = std::getenv(xKey); char* envValueY = std::getenv(yKey); char* envValueZ = std::getenv(zKey); //Set the return values //dynamically overriding whatever was compiled //with the environment variables if found if(envValueX) { returnValue.x = std::atoi(envValueX); } else { returnValue.x = defaultValue.x; } if(envValueY) { returnValue.y = std::atoi(envValueY); } else { returnValue.y = defaultValue.y; } if(envValueZ) { returnValue.z = std::atoi(envValueZ); } else { returnValue.z = defaultValue.z; } // Return the result return returnValue; } dim3 getMMulDims(int length,int sizeofDataType) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = ( length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(sd::LongType) * 6 + 128; // 6 = aRank + bRank + cRank threadsPerBlock = getEnvVariable("GRID_SIZE_MMUL",threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_MMUL",blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_MMUL",sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getAccumDims(int xLength) { dim3 launchDims = getLaunchDims("accumulate"); dim3 launchDims2(xLength, launchDims.y, launchDims.z); return launchDims2; } dim3 getReduceAllDims(int xLength) { auto blockWidth = 256; auto numBlocks = SD_CUDA_BLOCK_SIZE / 2; dim3 launchDims(numBlocks == 0 ? 1 : numBlocks, blockWidth, 8192); return launchDims; } dim3 getReduceDims(int xLength) { auto blockWidth = 256; auto numBlocks = sd::CudaLaunchHelper::getReductionBlocks(xLength, blockWidth); dim3 launchDims(numBlocks == 0 ? 1 : numBlocks, blockWidth, 8192); return launchDims; } dim3 getSortFullDims(int xLength) { int numThreads = sd::math::sd_min(512, xLength); int numBlocks = xLength / numThreads; if (xLength % numThreads > 0 || numBlocks == 0) numBlocks++; numBlocks = sd::math::sd_min(512, numBlocks); dim3 launchDims(numBlocks, numThreads, 32768); return launchDims; } dim3 getSortTadLarge(int numberTads) { return dim3(numberTads, 512,33768); } dim3 getSortTadDims(int numberTads) { return dim3(numberTads, 256,2048); } dim3 getFillUpSegmentsDims(int numClasses,int length) { return dim3(numClasses, length, numClasses * 32 + 32); } dim3 getSegmentSumDims(int numClasses,int length) { return dim3(numClasses, length, (numClasses + 1) * 64); } dim3 getSequenceMaskLaunchDims(int maxIndex,sd::NDArray input) { int maxThreads = maxIndex; int maxBlocks = input.lengthOf(); int sharedMem = 128; return dim3(maxBlocks, maxThreads, sharedMem); } dim3 getCol2imLaunchParams(sd::NDArray im,sd::NDArray col) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (im.lengthOf() + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = 256; threadsPerBlock = getEnvVariable("GRID_SIZE_COL2IM", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_COL2IM", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_COL2IM", sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getim2ColLaunchParams(sd::NDArray col) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (col.lengthOf() + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = 256; threadsPerBlock = getEnvVariable("GRID_SIZE_IM2COL", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_IM2COL", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_IM2COL", sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getGemVDims(int m) { int threadsPerBlock = SD_MAX_NUM_THREADS; int blocksPerGrid = (m + threadsPerBlock - 1) / threadsPerBlock; threadsPerBlock = getEnvVariable("GRID_SIZE_GEMV", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_GEMV", blocksPerGrid); //sharedMem isn't used return dim3(blocksPerGrid, threadsPerBlock, 0); } dim3 getAddBiasDims(int len,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (len + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = rank * sizeof(sd::LongType) * threadsPerBlock + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_ADDBIAS", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_ADDBIAS", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_ADDBIAS", sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getPoolingDims(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = rank * sizeof(sd::LongType) * threadsPerBlock + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_POOLING", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_POOLING", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_POOLING", sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getCol2VolDims(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = rank * sizeof(sd::LongType) * threadsPerBlock + 256; threadsPerBlock = getEnvVariable("GRID_SIZE_COL2VOL", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_COL2VOL", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_COL2VOL", sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getVol2ColDims(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = rank * sizeof(sd::LongType) * threadsPerBlock + 256; threadsPerBlock = getEnvVariable("GRID_SIZE_VOL2COL", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_VOL2COL", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_VOL2COL", sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getUpsamplingDims(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = rank * sizeof(sd::LongType) * threadsPerBlock + 256; threadsPerBlock = getEnvVariable("GRID_SIZE_UPSAMPLING", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_UPSAMPLING", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_UPSAMPLING", sharedMem); return dim3(blocksPerGrid, threadsPerBlock, sharedMem); } dim3 getHistogramDims(int length,int numBins) { int threadsPerBlock = 256; int blocksPerGrid = sd::math::sd_max(256, sd::math::sd_min(1, length / threadsPerBlock)); int workspaceSize = blocksPerGrid * numBins; threadsPerBlock = getEnvVariable("GRID_SIZE_HISTOGRAM", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_HISTOGRAM", blocksPerGrid); workspaceSize = getEnvVariable("SHARED_MEM_SIZE_HISTOGRAM", workspaceSize); return dim3(blocksPerGrid, threadsPerBlock, workspaceSize); } dim3 getAdjustDims(int numTads) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (numTads + threadsPerBlock - 1) / threadsPerBlock; int sharedMemory = 512; threadsPerBlock = getEnvVariable("GRID_SIZE_ADJUST", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_ADJUST", blocksPerGrid); sharedMemory = getEnvVariable("SHARED_MEM_SIZE_ADJUST", sharedMemory); //shared memory isn't used return dim3(blocksPerGrid, threadsPerBlock, sharedMemory); } dim3 getBatchNormDims(int length) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMemory = 1024; threadsPerBlock = getEnvVariable("GRID_SIZE_BATCHNORM", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_BATCHNORM", blocksPerGrid); sharedMemory = getEnvVariable("SHARED_MEM_SIZE_BATCHNORM", sharedMemory); return dim3(threadsPerBlock,blocksPerGrid,sharedMemory); } dim3 getCompareAndBitpackDims(int length) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMemory = 512; threadsPerBlock = getEnvVariable("GRID_SIZE_COMPARE_AND_BITPACK", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_COMPARE_AND_BITPACK", blocksPerGrid); sharedMemory = getEnvVariable("SHARED_MEM_SIZE_COMPARE_AND_BITPACK", sharedMemory); if(threadsPerBlock < 1) threadsPerBlock = 256; if(blocksPerGrid < 1) blocksPerGrid = 128; return dim3(threadsPerBlock,blocksPerGrid,sharedMemory); } dim3 getCompareElem(int length) { int threadsPerBlock = 256; int numBlocks = sd::math::sd_min(128, sd::math::sd_max(1, length / threadsPerBlock)); int sharedMemory = threadsPerBlock * 4 + 1024; threadsPerBlock = getEnvVariable("GRID_SIZE_COMPARE_AND_BITPACK", threadsPerBlock); numBlocks = getEnvVariable("BLOCK_SIZE_COMPARE_AND_BITPACK", numBlocks); sharedMemory = getEnvVariable("SHARED_MEM_SIZE_COMPARE_AND_BITPACK", sharedMemory); return dim3(threadsPerBlock,numBlocks,sharedMemory); } dim3 getConcat(int length) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = SD_CUDA_BLOCK_SIZE; int sharedMem = 256; threadsPerBlock = getEnvVariable("GRID_SIZE_CONCAT", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_CONCAT", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_CONCAT", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 getBetaInc(int maxIter,int length,int dataTypeSize) { int threadsPerBlock = maxIter; int blocksPerGrid = length; int sharedMem = 2 * dataTypeSize * threadsPerBlock + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_BETA_INC", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_BETA_INC", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_BETA_INC", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 getCross(int length,int rank,int lastSize) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length / lastSize + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = sizeof(sd::LongType) * threadsPerBlock * rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_CONCAT", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_CONCAT", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_CONCAT", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 getDilation(int outputLength,int weightRank,int outputRank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (outputLength + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = (weightRank + outputRank) * sizeof(sd::LongType) * threadsPerBlock + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_CONCAT", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_CONCAT", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_CONCAT", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 getGatherLinear(int numSubArrs) { int numBlocks = numSubArrs; int threadsPerBlock = SD_MAX_NUM_THREADS; int sharedMem = 1024; threadsPerBlock = getEnvVariable("GRID_SIZE_GATHER", threadsPerBlock); numBlocks = getEnvVariable("BLOCK_SIZE_GATHER", numBlocks); sharedMem = getEnvVariable("SHARED_MEM_SIZE_GATHER", sharedMem); return dim3(threadsPerBlock,numBlocks,sharedMem); } dim3 getGatherNd(int outputLength,int maxRank) { int threadsPerBlock = 256; int blocksPerGrid = (outputLength + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = 8 * threadsPerBlock * maxRank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_GATHER", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_GATHER", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_GATHER", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 getHashCodeSplit(int length,int blockSize) { int threadsPerBlock = 1; int blocksPerGrid = length / blockSize + ((length % blockSize == 0) ? 0 : 1); int sharedMem = 1024; threadsPerBlock = getEnvVariable("GRID_SIZE_HASHCODE_SPLIT", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_HASHCODE_SPLIT", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_HASHCODE_SPLIT", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 getHashCodeInternal(int numBlocks) { int threadsPerBlock = 1; int blocksPerGrid = numBlocks; int sharedMem = 1024; threadsPerBlock = getEnvVariable("GRID_SIZE_HASHCODE_INTERNAL", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_HASHCODE_INTERNAL", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_HASHCODE_INTERNAL", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 cropAndResize(int batchSize,int imageHeight,int imageWidth,int cropHeight,int cropWidth) { int threadsPerBlock = sd::math::sd_max(imageHeight * imageWidth, cropHeight * cropWidth); if (threadsPerBlock > SD_MAX_NUM_THREADS / 4) threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = batchSize; int sharedMem = 256; threadsPerBlock = getEnvVariable("GRID_SIZE_CROP_AND_RESIZE", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_CROP_AND_RESIZE", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_CROP_AND_RESIZE", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 imageHelper(int numTads) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (numTads + threadsPerBlock - 1) / threadsPerBlock; int sharedMemory = 256; threadsPerBlock = getEnvVariable("GRID_SIZE_IMAGE_HELPERS", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_GRID_SIZE_IMAGE_HELPERS", blocksPerGrid); sharedMemory = getEnvVariable("SHARED_MEM_SIZE_GRID_SIZE_IMAGE_HELPERS", sharedMemory); return dim3(threadsPerBlock,blocksPerGrid,sharedMemory); } dim3 lrnDims(int tadLength,int numTads, int xDTypeSize,int zDTypeSize) { int numBlocks = sd::math::sd_min(1024, numTads); int numThreads = tadLength; int sharedMem = numThreads * xDTypeSize + numThreads * zDTypeSize + 1024; numThreads = getEnvVariable("GRID_SIZE_LRN", numThreads); numBlocks = getEnvVariable("BLOCK_SIZE_LRN", numBlocks); sharedMem = getEnvVariable("SHARED_MEM_SIZE_LRN", sharedMem); return dim3(numThreads,numBlocks,sharedMem); } dim3 lupDims(int n) { int blockSize = 1; int numThreads = n; int sharedMem = 512; numThreads = getEnvVariable("GRID_SIZE_LUP", numThreads); blockSize = getEnvVariable("BLOCK_SIZE_LUP", blockSize); sharedMem = getEnvVariable("SHARED_MEM_SIZE_LUP", sharedMem); return dim3(numThreads,blockSize,sharedMem); } dim3 lupDimsLow(int n) { int blockSize = n; int numThreads = n; int sharedMem = 512; numThreads = getEnvVariable("GRID_SIZE_LUP_LOW", numThreads); blockSize = getEnvVariable("BLOCK_SIZE_LUP_LOW", blockSize); sharedMem = getEnvVariable("SHARED_MEM_SIZE_LUP_LOW", sharedMem); return dim3(numThreads,blockSize,sharedMem); } dim3 matrixSetDiagDims(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(sd::LongType) * rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_MATRIX_SET_DIAG", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_MATRIX_SET_DIAG", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_MATRIX_SET_DIAG", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 mergeDims(int length) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = 512; threadsPerBlock = getEnvVariable("GRID_SIZE_MERGE", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_MERGE", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_MERGE", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 oneHotDims(int length,int rank,int shapeSize) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * shapeSize * rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_ONE_HOT", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_ONE_HOT", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_ONE_HOT", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 padDims(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = 8 * threadsPerBlock * rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_PAD", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_PAD", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_PAD", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 polygammaDims(int length) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = 1024; threadsPerBlock = getEnvVariable("GRID_SIZE_POLYGAMMA", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_POLYGAMMA", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_POLYGAMMA", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 prefixDims(int numTads,int sizeOfDataType) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = numTads; int sharedMem = 2 * threadsPerBlock * sizeOfDataType + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_PREFIX", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_PREFIX", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_PREFIX", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 randomShuffleFisherDims(int power,int inputDataTypeSize) { int blocksPerGrid = 1 << power; int threadsPerBlock = SD_MAX_NUM_THREADS; int sharedMem = threadsPerBlock * inputDataTypeSize + 256; threadsPerBlock = getEnvVariable("GRID_SIZE_RANDOM_SHUFFLE_FISHER", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_RANDOM_SHUFFLE_FISHER", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_RANDOM_SHUFFLE_FISHER", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 randomShuffleMergeDims(int j,int length) { int threadsPerBlock = SD_MAX_NUM_THREADS; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int newBlocksPerGrid = blocksPerGrid / (2 * j); if(newBlocksPerGrid < 1) newBlocksPerGrid = blocksPerGrid; int sharedMem = 256; threadsPerBlock = getEnvVariable("GRID_SIZE_RANDOM_SHUFFLE_MERGE", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_RANDOM_SHUFFLE_MERGE", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_RANDOM_SHUFFLE_MERGE", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 batchToSpaceNdLaunch(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(sd::LongType) * rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_BATCH_TO_SPACE_ND", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_BATCH_TO_SPACE_ND", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_BATCH_TO_SPACE_ND", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 spaceToBatchLaunch(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(sd::LongType) * rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_SPACE_TO_BATCH", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_SPACE_TO_BATCH", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_SPACE_TO_BATCH", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 spaceToBatchNdLaunch(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(sd::LongType) * rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_SPACE_TO_BATCH", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_SPACE_TO_BATCH", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_SPACE_TO_BATCH", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 scatterDims(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = ((length) + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = sizeof(sd::LongType) * threadsPerBlock * (rank) + 256; threadsPerBlock = getEnvVariable("GRID_SIZE_SCATTER", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_SCATTER", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_SCATTER", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 scatterDimsCheckIndices(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(sd::LongType) * rank + 256; threadsPerBlock = getEnvVariable("GRID_SIZE_SCATTER_CHECK_INDICES", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_SCATTER_CHECK_INDICES", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_SCATTER_CHECK_INDICES", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 scatterNdDims(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = ((length) + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(sd::LongType) * rank + 512; threadsPerBlock = getEnvVariable("GRID_SIZE_SCATTER_ND", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_SCATTER_ND", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_SCATTER_ND", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 segmentValidateIndices(int length) { int threadsPerBlock = 1; int blocksPerGrid = length; int sharedMem = 128; threadsPerBlock = getEnvVariable("GRID_SIZE_SEGMENT_INDICES_VALIDATE", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_SEGMENT_INDICES_VALIDATE", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_SEGMENT_INDICES_VALIDATE", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 segmentDims(int numClasses,int length) { int blocks = numClasses; int threads = length; int sharedMem = numClasses * 32 + 32; threads = getEnvVariable("GRID_SIZE_SEGMENT", threads); blocks = getEnvVariable("BLOCK_SIZE_SEGMENT", blocks); sharedMem = getEnvVariable("SHARED_MEM_SIZE_SEGMENT", sharedMem); return dim3(threads,blocks,sharedMem); } dim3 segmentTad(int size) { int blocks = size; int threads = 512; int sharedMem = 2048; threads = getEnvVariable("GRID_SIZE_SEGMENT_TAD", threads); blocks = getEnvVariable("BLOCK_SIZE_SEGMENT_TAD", blocks); sharedMem = getEnvVariable("SHARED_MEM_SIZE_SEGMENT_TAD", sharedMem); return dim3(threads,blocks,sharedMem); } dim3 segmentBpDims(int gradOutLen,int inputLen) { int threads = gradOutLen; int blocks = inputLen; int sharedMem = 256; threads = getEnvVariable("GRID_SIZE_SEGMENT_BP", threads); blocks = getEnvVariable("BLOCK_SIZE_SEGMENT_BP", blocks); sharedMem = getEnvVariable("SHARED_MEM_SIZE_SEGMENT_BP", sharedMem); return dim3(threads,blocks,sharedMem); } dim3 segmentBpTad(int indicesLen,int inputLen) { int threads = indicesLen; int blocks = inputLen; int sharedMem = 256; threads = getEnvVariable("GRID_SIZE_SEGMENT_BP_TAD", threads); blocks = getEnvVariable("BLOCK_SIZE_SEGMENT_BP_TAD", blocks); sharedMem = getEnvVariable("SHARED_MEM_SIZE_SEGMENT_BP_TAD", sharedMem); return dim3(threads,blocks,sharedMem); } dim3 sruBiDims(int len,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = len + threadsPerBlock - 1 / threadsPerBlock; // loop through last two dimensions of x array -> bS, 2*K int sharedMem = threadsPerBlock * sizeof(sd::LongType) *rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_SRU_BI", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_SRU_BI", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_SRU_BI", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 stackDims(int length) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = 256; threadsPerBlock = getEnvVariable("GRID_SIZE_STACK", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_STACK", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_STACK", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 topkDims(int numTads) { int threadsPerBlock = SD_CUDA_BLOCK_SIZE; int blocksPerGrid = static_cast(numTads); int sharedMem = 1024; threadsPerBlock = getEnvVariable("GRID_SIZE_TOP_K", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_TOP_K", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_TOP_K", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 topKIndices(int scanWidth,int xDTypeSize,int yDTypeSize) { int numTreads = 256; int shMemSize = (numTreads * xDTypeSize * scanWidth) + (numTreads * yDTypeSize * scanWidth) + 512; int blockSize = 256; numTreads = getEnvVariable("GRID_SIZE_TOP_K_INDICES", numTreads); blockSize = getEnvVariable("BLOCK_SIZE_TOP_K_INDICES", blockSize); shMemSize = getEnvVariable("SHARED_MEM_SIZE_TOP_K_INDICES", shMemSize); return dim3(numTreads,blockSize,shMemSize); } dim3 invertPermutationDims(int length) { int threadsPerBlock = SD_MAX_NUM_THREADS; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMemory = 1024; threadsPerBlock = getEnvVariable("GRID_SIZE_INVERT_PERMUTATION", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_INVERT_PERMUTATION", blocksPerGrid); sharedMemory = getEnvVariable("SHARED_MEM_SIZE_INVERT_PERMUTATION", sharedMemory); return dim3(threadsPerBlock,blocksPerGrid,sharedMemory); } dim3 traceDims(int length) { int threadsPerBlock = SD_CUDA_BLOCK_SIZE; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = 1024; threadsPerBlock = getEnvVariable("GRID_SIZE_TRACE", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_TRACE", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_TRACE", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 triuDims(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(sd::LongType) * rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_TRIU", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_TRIU", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_TRIU", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 tileDims(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(sd::LongType) * 2 * rank + 128; threadsPerBlock = getEnvVariable("GRID_SIZE_TILE", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_TILE", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_TILE", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 updaterDims(int length) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMemory = 256; threadsPerBlock = getEnvVariable("GRID_SIZE_UPDATER", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_UPDATER", blocksPerGrid); sharedMemory = getEnvVariable("SHARED_MEM_SIZE_UPDATER", sharedMemory); return dim3(threadsPerBlock,blocksPerGrid,sharedMemory); } dim3 zetaDims(int length) { int threadsPerBlock = SD_MAX_NUM_THREADS / 4; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMemory = 1024; threadsPerBlock = getEnvVariable("GRID_SIZE_ZETA", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_ZETA", blocksPerGrid); sharedMemory = getEnvVariable("SHARED_MEM_SIZE_ZETA", sharedMemory); return dim3(threadsPerBlock,blocksPerGrid,sharedMemory); } dim3 resizeNeighborDims(int batchSize,int height,int width) { int blocksPerGrid = batchSize; int numThreads = height * width; int sharedMem = 512; numThreads = getEnvVariable("GRID_SIZE_IMAGE_RESIZE_NEIGHBOR", numThreads); blocksPerGrid = getEnvVariable("BLOCK_SIZE_IMAGE_RESIZE_NEIGHBOR", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_IMAGE_RESIZE_NEIGHBOR", sharedMem); return dim3(numThreads,blocksPerGrid,sharedMem); } dim3 clipDims(int length) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = 512; threadsPerBlock = getEnvVariable("GRID_SIZE_CLIP", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_CLIP", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_CLIP", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 mirrorPadLinearDims(int length) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = 512; threadsPerBlock = getEnvVariable("GRID_SIZE_MIRROR_PAD_LINEAR", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_MIRROR_PAD_LINEAR", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_MIRROR_PAD_LINEAR", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 mirrorPadTad(int length,int rank) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = threadsPerBlock * sizeof(sd::LongType) * rank + 256; threadsPerBlock = getEnvVariable("GRID_SIZE_MIRROR_PAD_TAD", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_MIRROR_PAD_TAD", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_MIRROR_PAD_TAD", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } dim3 digammaDims(int length) { int threadsPerBlock = SD_MAX_NUM_THREADS / 2; int blocksPerGrid = (length + threadsPerBlock - 1) / threadsPerBlock; int sharedMem = 512; threadsPerBlock = getEnvVariable("GRID_SIZE_DIGAMMA", threadsPerBlock); blocksPerGrid = getEnvVariable("BLOCK_SIZE_DIGAMMA", blocksPerGrid); sharedMem = getEnvVariable("SHARED_MEM_SIZE_DIGAMMA", sharedMem); return dim3(threadsPerBlock,blocksPerGrid,sharedMem); } //DeclarableOpsTests3.invertPermutation_test1 #endif //LIBND4J_LAUNCHCONTEXT_H