check_err.hpp 11 KB
Newer Older
Chao Liu's avatar
Chao Liu committed
1
// SPDX-License-Identifier: MIT
Illia Silin's avatar
Illia Silin committed
2
// Copyright (c) 2018-2023, Advanced Micro Devices, Inc. All rights reserved.
Chao Liu's avatar
Chao Liu committed
3
4
5
6
7
8
9
10
11
12
13
14
15

#pragma once

#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <iterator>
#include <limits>
#include <type_traits>
#include <vector>

16
#include "ck/ck.hpp"
Chao Liu's avatar
Chao Liu committed
17
#include "ck/utility/data_type.hpp"
18
#include "ck/utility/type.hpp"
19
#include "ck/host_utility/io.hpp"
Chao Liu's avatar
Chao Liu committed
20

21
22
#include "ck/library/utility/ranges.hpp"

Chao Liu's avatar
Chao Liu committed
23
24
25
namespace ck {
namespace utils {

26
27
28
29
30
31
32
33
template <typename Range, typename RefRange>
typename std::enable_if<
    std::is_same_v<ranges::range_value_t<Range>, ranges::range_value_t<RefRange>> &&
        std::is_floating_point_v<ranges::range_value_t<Range>> &&
        !std::is_same_v<ranges::range_value_t<Range>, half_t>,
    bool>::type
check_err(const Range& out,
          const RefRange& ref,
Chao Liu's avatar
Chao Liu committed
34
35
36
37
38
39
          const std::string& msg = "Error: Incorrect results!",
          double rtol            = 1e-5,
          double atol            = 3e-6)
{
    if(out.size() != ref.size())
    {
40
        std::cerr << msg << " out.size() != ref.size(), :" << out.size() << " != " << ref.size()
41
                  << std::endl;
Chao Liu's avatar
Chao Liu committed
42
43
44
45
46
47
48
49
50
        return false;
    }

    bool res{true};
    int err_count  = 0;
    double err     = 0;
    double max_err = std::numeric_limits<double>::min();
    for(std::size_t i = 0; i < ref.size(); ++i)
    {
51
52
53
54
        const double o = *std::next(std::begin(out), i);
        const double r = *std::next(std::begin(ref), i);
        err            = std::abs(o - r);
        if(err > atol + rtol * std::abs(r) || !std::isfinite(o) || !std::isfinite(r))
Chao Liu's avatar
Chao Liu committed
55
56
57
58
59
        {
            max_err = err > max_err ? err : max_err;
            err_count++;
            if(err_count < 5)
            {
60
                std::cerr << msg << std::setw(12) << std::setprecision(7) << " out[" << i
61
                          << "] != ref[" << i << "]: " << o << " != " << r << std::endl;
Chao Liu's avatar
Chao Liu committed
62
63
64
65
66
67
            }
            res = false;
        }
    }
    if(!res)
    {
68
69
70
71
72
        const float error_percent =
            static_cast<float>(err_count) / static_cast<float>(out.size()) * 100.f;
        std::cerr << "max err: " << max_err;
        std::cerr << ", number of errors: " << err_count;
        std::cerr << ", " << error_percent << "% wrong values" << std::endl;
Chao Liu's avatar
Chao Liu committed
73
74
75
76
    }
    return res;
}

77
78
79
80
81
82
83
template <typename Range, typename RefRange>
typename std::enable_if<
    std::is_same_v<ranges::range_value_t<Range>, ranges::range_value_t<RefRange>> &&
        std::is_same_v<ranges::range_value_t<Range>, bhalf_t>,
    bool>::type
check_err(const Range& out,
          const RefRange& ref,
Chao Liu's avatar
Chao Liu committed
84
85
86
87
88
89
          const std::string& msg = "Error: Incorrect results!",
          double rtol            = 1e-3,
          double atol            = 1e-3)
{
    if(out.size() != ref.size())
    {
90
        std::cerr << msg << " out.size() != ref.size(), :" << out.size() << " != " << ref.size()
91
                  << std::endl;
Chao Liu's avatar
Chao Liu committed
92
93
94
95
96
97
98
99
100
101
        return false;
    }

    bool res{true};
    int err_count = 0;
    double err    = 0;
    // TODO: This is a hack. We should have proper specialization for bhalf_t data type.
    double max_err = std::numeric_limits<float>::min();
    for(std::size_t i = 0; i < ref.size(); ++i)
    {
102
103
104
        const double o = type_convert<float>(*std::next(std::begin(out), i));
        const double r = type_convert<float>(*std::next(std::begin(ref), i));
        err            = std::abs(o - r);
Chao Liu's avatar
Chao Liu committed
105
106
107
108
109
110
        if(err > atol + rtol * std::abs(r) || !std::isfinite(o) || !std::isfinite(r))
        {
            max_err = err > max_err ? err : max_err;
            err_count++;
            if(err_count < 5)
            {
111
                std::cerr << msg << std::setw(12) << std::setprecision(7) << " out[" << i
112
                          << "] != ref[" << i << "]: " << o << " != " << r << std::endl;
Chao Liu's avatar
Chao Liu committed
113
114
115
116
117
118
            }
            res = false;
        }
    }
    if(!res)
    {
119
120
121
122
123
        const float error_percent =
            static_cast<float>(err_count) / static_cast<float>(out.size()) * 100.f;
        std::cerr << "max err: " << max_err;
        std::cerr << ", number of errors: " << err_count;
        std::cerr << ", " << error_percent << "% wrong values" << std::endl;
Chao Liu's avatar
Chao Liu committed
124
125
126
127
    }
    return res;
}

128
129
130
131
132
133
134
template <typename Range, typename RefRange>
typename std::enable_if<
    std::is_same_v<ranges::range_value_t<Range>, ranges::range_value_t<RefRange>> &&
        std::is_same_v<ranges::range_value_t<Range>, half_t>,
    bool>::type
check_err(const Range& out,
          const RefRange& ref,
Chao Liu's avatar
Chao Liu committed
135
136
137
138
139
140
          const std::string& msg = "Error: Incorrect results!",
          double rtol            = 1e-3,
          double atol            = 1e-3)
{
    if(out.size() != ref.size())
    {
141
        std::cerr << msg << " out.size() != ref.size(), :" << out.size() << " != " << ref.size()
142
                  << std::endl;
Chao Liu's avatar
Chao Liu committed
143
144
145
146
147
148
        return false;
    }

    bool res{true};
    int err_count  = 0;
    double err     = 0;
149
    double max_err = std::numeric_limits<ranges::range_value_t<Range>>::min();
Chao Liu's avatar
Chao Liu committed
150
151
    for(std::size_t i = 0; i < ref.size(); ++i)
    {
152
153
154
        const double o = type_convert<float>(*std::next(std::begin(out), i));
        const double r = type_convert<float>(*std::next(std::begin(ref), i));
        err            = std::abs(o - r);
Chao Liu's avatar
Chao Liu committed
155
156
157
158
159
160
        if(err > atol + rtol * std::abs(r) || !std::isfinite(o) || !std::isfinite(r))
        {
            max_err = err > max_err ? err : max_err;
            err_count++;
            if(err_count < 5)
            {
161
                std::cerr << msg << std::setw(12) << std::setprecision(7) << " out[" << i
162
                          << "] != ref[" << i << "]: " << o << " != " << r << std::endl;
Chao Liu's avatar
Chao Liu committed
163
164
165
166
167
168
            }
            res = false;
        }
    }
    if(!res)
    {
169
170
171
172
173
        const float error_percent =
            static_cast<float>(err_count) / static_cast<float>(out.size()) * 100.f;
        std::cerr << "max err: " << max_err;
        std::cerr << ", number of errors: " << err_count;
        std::cerr << ", " << error_percent << "% wrong values" << std::endl;
Chao Liu's avatar
Chao Liu committed
174
175
176
177
    }
    return res;
}

178
179
180
181
template <typename Range, typename RefRange>
std::enable_if_t<(std::is_same_v<ranges::range_value_t<Range>, ranges::range_value_t<RefRange>> &&
                  std::is_integral_v<ranges::range_value_t<Range>> &&
                  !std::is_same_v<ranges::range_value_t<Range>, bhalf_t>)
182
#ifdef CK_EXPERIMENTAL_BIT_INT_EXTENSION_INT4
183
                     || std::is_same_v<ranges::range_value_t<Range>, int4_t>
184
185
186
#endif
                 ,
                 bool>
187
188
check_err(const Range& out,
          const RefRange& ref,
Chao Liu's avatar
Chao Liu committed
189
190
          const std::string& msg = "Error: Incorrect results!",
          double                 = 0,
191
          double atol            = 0)
Chao Liu's avatar
Chao Liu committed
192
193
194
{
    if(out.size() != ref.size())
    {
195
        std::cerr << msg << " out.size() != ref.size(), :" << out.size() << " != " << ref.size()
196
                  << std::endl;
Chao Liu's avatar
Chao Liu committed
197
198
199
200
201
202
203
204
205
        return false;
    }

    bool res{true};
    int err_count   = 0;
    int64_t err     = 0;
    int64_t max_err = std::numeric_limits<int64_t>::min();
    for(std::size_t i = 0; i < ref.size(); ++i)
    {
206
207
208
        const int64_t o = *std::next(std::begin(out), i);
        const int64_t r = *std::next(std::begin(ref), i);
        err             = std::abs(o - r);
Chao Liu's avatar
Chao Liu committed
209

210
        if(err > atol)
Chao Liu's avatar
Chao Liu committed
211
212
213
214
215
        {
            max_err = err > max_err ? err : max_err;
            err_count++;
            if(err_count < 5)
            {
216
                std::cerr << msg << " out[" << i << "] != ref[" << i << "]: " << o << " != " << r
217
                          << std::endl;
Chao Liu's avatar
Chao Liu committed
218
219
220
221
222
223
            }
            res = false;
        }
    }
    if(!res)
    {
224
225
226
227
228
        const float error_percent =
            static_cast<float>(err_count) / static_cast<float>(out.size()) * 100.f;
        std::cerr << "max err: " << max_err;
        std::cerr << ", number of errors: " << err_count;
        std::cerr << ", " << error_percent << "% wrong values" << std::endl;
Chao Liu's avatar
Chao Liu committed
229
230
231
232
    }
    return res;
}

233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
template <typename Range, typename RefRange>
std::enable_if_t<(std::is_same_v<ranges::range_value_t<Range>, ranges::range_value_t<RefRange>> &&
                  std::is_same_v<ranges::range_value_t<Range>, f8_t>),
                 bool>
check_err(const Range& out,
          const RefRange& ref,
          const std::string& msg = "Error: Incorrect results!",
          double rtol            = 1e-3,
          double atol            = 1e-3)
{
    if(out.size() != ref.size())
    {
        std::cerr << msg << " out.size() != ref.size(), :" << out.size() << " != " << ref.size()
                  << std::endl;
        return false;
    }

    bool res{true};
    int err_count  = 0;
    double err     = 0;
    double max_err = std::numeric_limits<float>::min();
    for(std::size_t i = 0; i < ref.size(); ++i)
    {
        const double o = type_convert<float>(*std::next(std::begin(out), i));
        const double r = type_convert<float>(*std::next(std::begin(ref), i));
        err            = std::abs(o - r);
        if(err > atol + rtol * std::abs(r) || !std::isfinite(o) || !std::isfinite(r))
        {
            max_err = err > max_err ? err : max_err;
            err_count++;
            if(err_count < 5)
            {
                std::cerr << msg << std::setw(12) << std::setprecision(7) << " out[" << i
                          << "] != ref[" << i << "]: " << o << " != " << r << std::endl;
            }
            res = false;
        }
    }
    if(!res)
    {
        std::cerr << std::setw(12) << std::setprecision(7) << "max err: " << max_err << std::endl;
    }
    return res;
}

template <typename Range, typename RefRange>
std::enable_if_t<(std::is_same_v<ranges::range_value_t<Range>, ranges::range_value_t<RefRange>> &&
                  std::is_same_v<ranges::range_value_t<Range>, bf8_t>),
                 bool>
check_err(const Range& out,
          const RefRange& ref,
          const std::string& msg = "Error: Incorrect results!",
          double rtol            = 1e-3,
          double atol            = 1e-3)
{
    if(out.size() != ref.size())
    {
        std::cerr << msg << " out.size() != ref.size(), :" << out.size() << " != " << ref.size()
                  << std::endl;
        return false;
    }

    bool res{true};
    int err_count  = 0;
    double err     = 0;
    double max_err = std::numeric_limits<float>::min();
    for(std::size_t i = 0; i < ref.size(); ++i)
    {
        const double o = type_convert<float>(*std::next(std::begin(out), i));
        const double r = type_convert<float>(*std::next(std::begin(ref), i));
        err            = std::abs(o - r);
        if(err > atol + rtol * std::abs(r) || !std::isfinite(o) || !std::isfinite(r))
        {
            max_err = err > max_err ? err : max_err;
            err_count++;
            if(err_count < 5)
            {
                std::cerr << msg << std::setw(12) << std::setprecision(7) << " out[" << i
                          << "] != ref[" << i << "]: " << o << " != " << r << std::endl;
            }
            res = false;
        }
    }
    if(!res)
    {
        std::cerr << std::setw(12) << std::setprecision(7) << "max err: " << max_err << std::endl;
    }
    return res;
}

Chao Liu's avatar
Chao Liu committed
323
324
} // namespace utils
} // namespace ck