mirror of
https://github.com/ROCm/composable_kernel.git
synced 2026-05-12 09:16:52 +00:00
0d9118226b
* Add NumReduceDim template parameter to DeviceSoftmax and Softmax client API to simplify instances collecting * Move the generic kernel instance to be the first of the instance list for elementwise op of normalization * Add GetGenericInstance() interface for DeviceOperationInstanceFactory class of DeviceSoftmax * Add testing of GetGenericInstance() in client_example of Softmax * Revert "Add testing of GetGenericInstance() in client_example of Softmax" This reverts commitf629cd9a93. * Revert "Add GetGenericInstance() interface for DeviceOperationInstanceFactory class of DeviceSoftmax" This reverts commita9f0d000eb. * Support generic kernel instance to be the first instance returned by GetInstances() for GroupNorm * Move generic kernel instance to separate tuple for elementwise op of normalization * Remove un-used files for softmax instance * Store generic kernel instance to separate tuple for softmax * Add IsSupported checking for generic instance to client example of softmax * Replace the get_device_normalize_from_mean_meansquare_instances() by the DeviceOperationInstanceFactory class for elementwise-normalization * clang-format fix * Remove int8 from softmax instances --------- Co-authored-by: zjing14 <zhangjing14@gmail.com>
289 lines
13 KiB
C++
289 lines
13 KiB
C++
// SPDX-License-Identifier: MIT
|
|
// Copyright (c) 2018-2023, Advanced Micro Devices, Inc. All rights reserved.
|
|
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <unordered_map>
|
|
|
|
#include "profiler/profile_softmax_impl.hpp"
|
|
#include "profiler_operation_registry.hpp"
|
|
|
|
using ck::index_t;
|
|
using ck::profiler::SoftmaxDataType;
|
|
|
|
struct ArgParser
|
|
{
|
|
std::unordered_map<std::string, std::vector<int>> long_opts = {
|
|
{"length", {}}, {"stride", {}}, {"reduce", {}}, {"alpha", {}}, {"beta", {}}};
|
|
|
|
bool parse_opt(int argc, char* argv[], const std::string& key, int i)
|
|
{
|
|
if(std::string("--") + key == argv[i])
|
|
{
|
|
int pos = i;
|
|
while(++i < argc && argv[i][0] != '-') {}
|
|
int end = i;
|
|
for(int j = pos + 1; j < end; j++)
|
|
{
|
|
long_opts[key].push_back(std::stoi(argv[j]));
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void operator()(int argc, char* argv[])
|
|
{
|
|
for(auto& kv : long_opts)
|
|
{
|
|
for(int i = 1; i < argc; i++)
|
|
{
|
|
if(parse_opt(argc, argv, kv.first, i))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
void print_help()
|
|
{
|
|
std::cout << "arg1: tensor operation (softmax)\n"
|
|
<< "arg2: data type (0: fp32; 1: fp16; 2: bf16; 3: int8)\n"
|
|
<< "arg3: verification (0: no; 1: yes)\n"
|
|
<< "arg4: initialization (0: no init; 1: integer value; 2: decimal value)\n"
|
|
<< "arg5: print tensor value (0: no; 1: yes)\n"
|
|
<< "arg6: time kernel (0=n0, 1=yes)\n"
|
|
<< "--length: tensor extents (e.g, --length 8 4 256) \n"
|
|
<< "--stride: tensor strides (e.g, --stride 1024 256 1)\n"
|
|
<< "--reduce: to-reduce dimensions (e.g, --reduce 2)\n"
|
|
<< "--alpha: alpha scaling value\n"
|
|
<< "--beta: beta scaling value\n"
|
|
<< std::endl;
|
|
}
|
|
|
|
int profile_softmax(int argc, char* argv[])
|
|
{
|
|
if(argc <= 2)
|
|
{
|
|
print_help();
|
|
return 0;
|
|
}
|
|
|
|
ArgParser arg_parser;
|
|
|
|
// short unnamed options
|
|
const SoftmaxDataType data_type = static_cast<SoftmaxDataType>(std::stoi(argv[2]));
|
|
const bool do_verification = std::stoi(argv[3]);
|
|
const int init_method = std::stoi(argv[4]);
|
|
const bool do_log = std::stoi(argv[5]);
|
|
const bool time_kernel = std::stoi(argv[6]);
|
|
|
|
// parse the long options
|
|
arg_parser(argc, argv);
|
|
const std::vector<index_t> length = arg_parser.long_opts["length"];
|
|
const std::vector<index_t> stride = arg_parser.long_opts["stride"];
|
|
const std::vector<index_t> reduce = arg_parser.long_opts["reduce"];
|
|
const index_t alpha =
|
|
arg_parser.long_opts["alpha"].empty() ? 1 : arg_parser.long_opts["alpha"][0];
|
|
const index_t beta = arg_parser.long_opts["beta"].empty() ? 0 : arg_parser.long_opts["beta"][0];
|
|
|
|
// Rank 3
|
|
if(length.size() == 3)
|
|
{
|
|
if(data_type == SoftmaxDataType::F16_F16)
|
|
{
|
|
if(reduce.size() == 1)
|
|
ck::profiler::profile_softmax_impl<ck::half_t, float, ck::half_t, 3, 1>(
|
|
do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else if(reduce.size() == 2)
|
|
ck::profiler::profile_softmax_impl<ck::half_t, float, ck::half_t, 3, 2>(
|
|
do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else if(reduce.size() == 3)
|
|
ck::profiler::profile_softmax_impl<ck::half_t, float, ck::half_t, 3, 3>(
|
|
do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else
|
|
throw std::runtime_error("invalid number of dimensions to reduce");
|
|
}
|
|
else if(data_type == SoftmaxDataType::F32_F32)
|
|
{
|
|
if(reduce.size() == 1)
|
|
ck::profiler::profile_softmax_impl<float, float, float, 3, 1>(do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else if(reduce.size() == 2)
|
|
ck::profiler::profile_softmax_impl<float, float, float, 3, 2>(do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else if(reduce.size() == 3)
|
|
ck::profiler::profile_softmax_impl<float, float, float, 3, 3>(do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else
|
|
throw std::runtime_error("invalid number of dimensions to reduce");
|
|
}
|
|
else
|
|
{
|
|
throw std::runtime_error("not implemented yet");
|
|
}
|
|
}
|
|
// Rank 4
|
|
else if(length.size() == 4)
|
|
{
|
|
if(data_type == SoftmaxDataType::F16_F16)
|
|
{
|
|
if(reduce.size() == 1)
|
|
ck::profiler::profile_softmax_impl<ck::half_t, float, ck::half_t, 4, 1>(
|
|
do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else if(reduce.size() == 2)
|
|
ck::profiler::profile_softmax_impl<ck::half_t, float, ck::half_t, 4, 2>(
|
|
do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else if(reduce.size() == 3)
|
|
ck::profiler::profile_softmax_impl<ck::half_t, float, ck::half_t, 4, 3>(
|
|
do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else if(reduce.size() == 4)
|
|
ck::profiler::profile_softmax_impl<ck::half_t, float, ck::half_t, 4, 4>(
|
|
do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else
|
|
throw std::runtime_error("invalid number of dimensions to reduce");
|
|
}
|
|
else if(data_type == SoftmaxDataType::F32_F32)
|
|
{
|
|
if(reduce.size() == 1)
|
|
ck::profiler::profile_softmax_impl<float, float, float, 4, 1>(do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else if(reduce.size() == 2)
|
|
ck::profiler::profile_softmax_impl<float, float, float, 4, 2>(do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else if(reduce.size() == 3)
|
|
ck::profiler::profile_softmax_impl<float, float, float, 4, 3>(do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else if(reduce.size() == 4)
|
|
ck::profiler::profile_softmax_impl<float, float, float, 4, 4>(do_verification,
|
|
init_method,
|
|
do_log,
|
|
time_kernel,
|
|
length,
|
|
stride,
|
|
reduce,
|
|
double(alpha),
|
|
double(beta));
|
|
else
|
|
throw std::runtime_error("invalid number of dimensions to reduce");
|
|
}
|
|
else
|
|
{
|
|
throw std::runtime_error("not implemented yet");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw std::runtime_error("not implemented yet");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// hijack main() for quick debugging
|
|
// int main(int argc, char* argv[])
|
|
// {
|
|
// profile_normalization(argc, argv);
|
|
// return 0;
|
|
// }
|
|
|
|
REGISTER_PROFILER_OPERATION("softmax", "Softmax", profile_softmax);
|