profile_reduce.cpp 17.7 KB
Newer Older
1
2
3
4
5
6
7
8
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <vector>
#include <stdexcept>
#include <sstream>
#include <getopt.h>

Chao Liu's avatar
Chao Liu committed
9
#include "ck/utility/reduction_enums.hpp"
10

Chao Liu's avatar
Chao Liu committed
11
12
13
14
#include "ck/library/host_tensor/host_common_util.hpp"

#include "profiler/include/profile_reduce_impl.hpp"
#include "profiler/include/data_type_enum.hpp"
15
16
17

using namespace std;

18
using ck::ReduceTensorOp;
19
20

static struct option long_options[] = {{"inLengths", required_argument, nullptr, 'D'},
Qianfeng's avatar
Qianfeng committed
21
                                       {"reduceDims", required_argument, nullptr, 'R'},
22
23
24
25
26
27
28
29
                                       {"reduceOp", required_argument, nullptr, 'O'},
                                       {"compType", required_argument, nullptr, 'C'},
                                       {"outType", required_argument, nullptr, 'W'},
                                       {"nanOpt", required_argument, nullptr, 'N'},
                                       {"indicesOpt", required_argument, nullptr, 'I'},
                                       {"scales", required_argument, nullptr, 'S'},
                                       {"half", no_argument, nullptr, '?'},
                                       {"double", no_argument, nullptr, '?'},
30
31
                                       {"int8", no_argument, nullptr, '?'},
                                       {"bf16", no_argument, nullptr, '?'},
32
33
34
35
36
                                       {"dumpout", required_argument, nullptr, 'o'},
                                       {"verify", required_argument, nullptr, 'v'},
                                       {"help", no_argument, nullptr, '?'},
                                       {nullptr, 0, nullptr, 0}};

Qianfeng's avatar
Qianfeng committed
37
static void check_reduce_dims(const int rank, const std::vector<int>& reduceDims)
38
{
Qianfeng's avatar
Qianfeng committed
39
    for(auto dim : reduceDims)
40
41
42
43
44
45
46
    {
        if(dim < 0 || dim >= rank)
            throw std::runtime_error("Invalid dimension index specified for Reducing");
    };

    unsigned int flag = 0;

Qianfeng's avatar
Qianfeng committed
47
    for(auto dim : reduceDims)
48
49
50
51
52
53
54
    {
        if(flag & (0x1 << dim))
            throw std::runtime_error("All toReduce dimensions should be different!");
        flag = flag | (0x1 << dim);
    };
};

55
class ReduceProfilerArgs
56
57
58
59
60
61
62
{
    private:
    int option_index = 0;

    public:
    bool use_half   = false;
    bool use_double = false;
63
64
    bool use_int8   = false;
    bool use_bf16   = false;
65
66
67

    std::vector<size_t> inLengths;
    std::vector<size_t> outLengths;
Qianfeng's avatar
Qianfeng committed
68
    std::vector<int> reduceDims;
69
70
71

    std::vector<float> scales;

72
73
74
    ReduceTensorOp reduceOp     = ReduceTensorOp::ADD;
    ck::DataTypeEnum compTypeId = ck::DataTypeEnum::Float;
    ck::DataTypeEnum outTypeId  = ck::DataTypeEnum::Float;
75
76
77
78

    bool compType_assigned = false;
    bool outType_assigned  = false;

79
80
81
82
    int nanOpt           = 0;
    int indicesOpt       = 0;
    bool do_verification = false;
    bool do_dumpout      = false;
83
84

    int init_method;
JD's avatar
JD committed
85
    bool time_kernel;
86

87
88
    ReduceProfilerArgs()  = default;
    ~ReduceProfilerArgs() = default;
89
90
91
92
93
94

    void show_usage(const char* cmd)
    {
        std::cout << "Usage of " << cmd << std::endl;
        std::cout << "--inLengths or -D, comma separated list of input tensor dimension lengths"
                  << std::endl;
Qianfeng's avatar
Qianfeng committed
95
        std::cout << "--reduceDims or -R, comma separated list of to-reduce dimensions"
96
97
98
99
100
101
102
103
104
                  << std::endl;
        std::cout << "--reduceOp or -O, enum value indicating the reduction operations"
                  << std::endl;
        std::cout << "--compType or -C, enum value indicating the type of accumulated values used "
                     "during the reduction"
                  << std::endl;
        std::cout << "--outType or -W, optional enum value indicating the type of the reduced "
                     "output, which could be float when the input data is half"
                  << std::endl;
105
106
107
108
109
        std::cout
            << "--nanOpt or -N, 1/0 value indicates the selection to use or not use Nan-Propagation"
            << std::endl;
        std::cout << "--indicesOpt or -I, 1/0 value indicates the selection to use or not use "
                     "index in reduction"
110
111
112
113
114
                  << std::endl;
        std::cout << "--scales or -S, comma separated two float values for alpha and beta"
                  << std::endl;
        std::cout << "--half, use fp16 for the input and output tensor data types" << std::endl;
        std::cout << "--double, use fp64 for the input and output tensor data types" << std::endl;
115
116
        std::cout << "--int8, use int8 for the input and output tensor data types" << std::endl;
        std::cout << "--bf16, use bfloat16 for the input and output tensor data types" << std::endl;
117
118
119
120
121
122
123
124
125
126
        std::cout << "--verify or -v, 1/0 to indicate whether to verify the reduction result by "
                     "comparing with the host-based reduction"
                  << std::endl;
        std::cout << "--dumpout or -o, 1/0 to indicate where to save the reduction result to files "
                     "for further analysis"
                  << std::endl;
    };

    int processArgs(int argc, char* argv[])
    {
127
128
        using ck::host_common::getTypeValuesFromString;

129
        int ch;
130
131
132
133
134

        optind++; // to skip the "reduce" module name

        while(1)
        {
135
            ch = getopt_long(argc, argv, "D:R:O:C:W:N:I:S:v:o:", long_options, &option_index);
136
137
138
139
140
141
142
143
144
145
146
147
148
149
            if(ch == -1)
                break;
            switch(ch)
            {
            case 'D':
                if(!optarg)
                    throw std::runtime_error("Invalid option format!");

                inLengths = getTypeValuesFromString<size_t>(optarg);
                break;
            case 'R':
                if(!optarg)
                    throw std::runtime_error("Invalid option format!");

Qianfeng's avatar
Qianfeng committed
150
                reduceDims = getTypeValuesFromString<int>(optarg);
151
152
153
154
155
                break;
            case 'O':
                if(!optarg)
                    throw std::runtime_error("Invalid option format!");

156
                reduceOp = static_cast<ReduceTensorOp>(std::atoi(optarg));
157
158
159
160
161
                break;
            case 'C':
                if(!optarg)
                    throw std::runtime_error("Invalid option format!");

162
                compTypeId        = static_cast<ck::DataTypeEnum>(std::atoi(optarg));
163
164
165
166
167
168
                compType_assigned = true;
                break;
            case 'W':
                if(!optarg)
                    throw std::runtime_error("Invalid option format!");

169
                outTypeId        = static_cast<ck::DataTypeEnum>(std::atoi(optarg));
170
171
172
173
174
175
                outType_assigned = true;
                break;
            case 'N':
                if(!optarg)
                    throw std::runtime_error("Invalid option format!");

176
                nanOpt = std::atoi(optarg);
177
178
179
180
181
                break;
            case 'I':
                if(!optarg)
                    throw std::runtime_error("Invalid option format!");

182
                indicesOpt = std::atoi(optarg);
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
                break;
            case 'S':
                if(!optarg)
                    throw std::runtime_error("Invalid option format!");

                scales = getTypeValuesFromString<float>(optarg);

                if(scales.size() != 2)
                    throw std::runtime_error("Invalid option format!");
                break;
            case 'v':
                if(!optarg)
                    throw std::runtime_error("Invalid option format!");

                do_verification = static_cast<bool>(std::atoi(optarg));
                break;
            case 'o':
                if(!optarg)
                    throw std::runtime_error("Invalid option format!");

                do_dumpout = static_cast<bool>(std::atoi(optarg));
                break;
            case '?':
                if(std::string(long_options[option_index].name) == "half")
                    use_half = true;
                else if(std::string(long_options[option_index].name) == "double")
                    use_double = true;
210
211
212
213
                else if(std::string(long_options[option_index].name) == "int8")
                    use_int8 = true;
                else if(std::string(long_options[option_index].name) == "bf16")
                    use_bf16 = true;
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
                else if(std::string(long_options[option_index].name) == "help")
                {
                    show_usage(argv[0]);
                    return (-1);
                };
                break;

            default:
                show_usage(argv[0]);
                std::cerr << "Invalid cmd-line options!" << std::endl;
                return (-1);
            };
        };

        if(optind + 2 > argc)
            throw std::runtime_error("Invalid cmd-line arguments, more argumetns are needed!");

        init_method = std::atoi(argv[optind++]);
232
        time_kernel = static_cast<bool>(std::atoi(argv[optind]));
233
234
235
236
237
238
239

        if(scales.empty())
        {
            scales.push_back(1.0f);
            scales.push_back(0.0f);
        };

240
241
        if(reduceOp == ReduceTensorOp::MIN || reduceOp == ReduceTensorOp::MAX ||
           reduceOp == ReduceTensorOp::AMAX)
242
243
244
245
246
247
248
249
250
251
252
253
254
255
        {
            // for indexable operations, no need to assign compType and outType, just let them be
            // same as inType
            compType_assigned = false;
            outType_assigned  = false;
        };

        return (0);
    };

}; // end of class AppArgs

int profile_reduce(int argc, char* argv[])
{
256
257
    using ck::DataTypeEnum;
    using ck::profiler::profile_reduce_impl;
258

259
    ReduceProfilerArgs args;
260
261
262
263
264
265

    if(args.processArgs(argc, argv) < 0)
        return (-1);

    int rank = args.inLengths.size();

Qianfeng's avatar
Qianfeng committed
266
    check_reduce_dims(rank, args.reduceDims);
267

268
    if(args.reduceOp == ReduceTensorOp::MUL || args.reduceOp == ReduceTensorOp::NORM1)
269
270
271
272
273
        throw std::runtime_error("MUL and NORM1 are not supported by composable kernel!");

    if(args.use_half)
    {
        if(!args.compType_assigned)
274
            args.compTypeId = DataTypeEnum::Half;
275

Chao Liu's avatar
Chao Liu committed
276
        if(args.outType_assigned &&
277
278
           (args.outTypeId != DataTypeEnum::Half && args.outTypeId != DataTypeEnum::Float))
            args.outTypeId = DataTypeEnum::Float;
279
280

        if(!args.outType_assigned)
281
            args.outTypeId = DataTypeEnum::Half;
282

283
        if(args.compTypeId == DataTypeEnum::Half)
284
        {
285
286
287
288
289
290
291
292
293
294
295
296
            profile_reduce_impl<ck::half_t, ck::half_t, ck::half_t>(
                args.do_verification,
                args.init_method,
                args.do_dumpout,
                args.time_kernel,
                args.inLengths,
                args.reduceDims,
                args.reduceOp,
                static_cast<bool>(args.nanOpt),
                static_cast<bool>(args.indicesOpt),
                args.scales[0],
                args.scales[1]);
297
        }
298
        else if(args.compTypeId == DataTypeEnum::Float)
299
300
301
302
        {
            profile_reduce_impl<ck::half_t, float, ck::half_t>(args.do_verification,
                                                               args.init_method,
                                                               args.do_dumpout,
JD's avatar
JD committed
303
                                                               args.time_kernel,
304
                                                               args.inLengths,
Qianfeng's avatar
Qianfeng committed
305
                                                               args.reduceDims,
306
                                                               args.reduceOp,
307
308
                                                               static_cast<bool>(args.nanOpt),
                                                               static_cast<bool>(args.indicesOpt),
309
310
311
312
313
314
315
316
317
318
319
                                                               args.scales[0],
                                                               args.scales[1]);
        }
        else
            throw std::runtime_error("Invalid compType assignment!");
    }
    else if(args.use_double)
    {
        profile_reduce_impl<double, double, double>(args.do_verification,
                                                    args.init_method,
                                                    args.do_dumpout,
JD's avatar
JD committed
320
                                                    args.time_kernel,
321
                                                    args.inLengths,
Qianfeng's avatar
Qianfeng committed
322
                                                    args.reduceDims,
323
                                                    args.reduceOp,
324
325
                                                    static_cast<bool>(args.nanOpt),
                                                    static_cast<bool>(args.indicesOpt),
326
327
328
                                                    args.scales[0],
                                                    args.scales[1]);
    }
329
330
331
    else if(args.use_int8)
    {
        if(!args.compType_assigned)
332
            args.compTypeId = DataTypeEnum::Int8;
333

Chao Liu's avatar
Chao Liu committed
334
        if(args.outType_assigned &&
335
336
           (args.outTypeId != DataTypeEnum::Int8 && args.outTypeId != DataTypeEnum::Int32))
            args.outTypeId = DataTypeEnum::Int32;
337
338

        if(!args.outType_assigned)
339
            args.outTypeId = DataTypeEnum::Int8;
340

341
        if(args.compTypeId == DataTypeEnum::Int8)
342
343
344
345
        {
            profile_reduce_impl<int8_t, int8_t, int8_t>(args.do_verification,
                                                        args.init_method,
                                                        args.do_dumpout,
JD's avatar
JD committed
346
                                                        args.time_kernel,
347
348
349
                                                        args.inLengths,
                                                        args.reduceDims,
                                                        args.reduceOp,
350
351
                                                        static_cast<bool>(args.nanOpt),
                                                        static_cast<bool>(args.indicesOpt),
352
353
354
                                                        args.scales[0],
                                                        args.scales[1]);
        }
355
        else if(args.compTypeId == DataTypeEnum::Int32)
356
357
358
359
        {
            profile_reduce_impl<int8_t, int32_t, int8_t>(args.do_verification,
                                                         args.init_method,
                                                         args.do_dumpout,
JD's avatar
JD committed
360
                                                         args.time_kernel,
361
362
363
                                                         args.inLengths,
                                                         args.reduceDims,
                                                         args.reduceOp,
364
365
                                                         static_cast<bool>(args.nanOpt),
                                                         static_cast<bool>(args.indicesOpt),
366
367
368
369
370
371
372
373
                                                         args.scales[0],
                                                         args.scales[1]);
        }
        else
            throw std::runtime_error("Invalid compType assignment!");
    }
    else if(args.use_bf16)
    {
374
        if(args.outType_assigned &&
375
376
           (args.outTypeId != DataTypeEnum::BFloat16 && args.outTypeId != DataTypeEnum::Float))
            args.outTypeId = DataTypeEnum::Float;
377
378

        if(!args.outType_assigned)
379
            args.outTypeId = DataTypeEnum::BFloat16;
380
381
382
383

        profile_reduce_impl<ck::bhalf_t, float, ck::bhalf_t>(args.do_verification,
                                                             args.init_method,
                                                             args.do_dumpout,
JD's avatar
JD committed
384
                                                             args.time_kernel,
385
386
387
                                                             args.inLengths,
                                                             args.reduceDims,
                                                             args.reduceOp,
388
389
                                                             static_cast<bool>(args.nanOpt),
                                                             static_cast<bool>(args.indicesOpt),
390
391
392
                                                             args.scales[0],
                                                             args.scales[1]);
    }
393
394
    else
    {
395
        if(args.compTypeId == DataTypeEnum::Float)
396
397
398
399
        {
            profile_reduce_impl<float, float, float>(args.do_verification,
                                                     args.init_method,
                                                     args.do_dumpout,
JD's avatar
JD committed
400
                                                     args.time_kernel,
401
                                                     args.inLengths,
Qianfeng's avatar
Qianfeng committed
402
                                                     args.reduceDims,
403
                                                     args.reduceOp,
404
405
                                                     static_cast<bool>(args.nanOpt),
                                                     static_cast<bool>(args.indicesOpt),
406
407
408
                                                     args.scales[0],
                                                     args.scales[1]);
        }
409
        else if(args.compTypeId == DataTypeEnum::Double)
410
411
412
413
        {
            profile_reduce_impl<float, double, float>(args.do_verification,
                                                      args.init_method,
                                                      args.do_dumpout,
JD's avatar
JD committed
414
                                                      args.time_kernel,
415
                                                      args.inLengths,
Qianfeng's avatar
Qianfeng committed
416
                                                      args.reduceDims,
417
                                                      args.reduceOp,
418
419
                                                      static_cast<bool>(args.nanOpt),
                                                      static_cast<bool>(args.indicesOpt),
420
421
422
423
424
425
426
427
428
                                                      args.scales[0],
                                                      args.scales[1]);
        }
        else
            throw std::runtime_error("Invalid compType assignment!");
    };

    return (0);
};