58 Star 283 Fork 3

腾讯开源/ncnn

加入 Gitee
与超过 1200万 开发者一起发现、参与优秀开源项目,私有仓库也完全免费 :)
免费加入
文件
克隆/下载
testutil.cpp 47.32 KB
一键复制 编辑 原始数据 按行查看 历史
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806
// Copyright 2019 Tencent
// SPDX-License-Identifier: BSD-3-Clause
#include "testutil.h"
#include "cpu.h"
#include "layer.h"
#include "mat.h"
#include "prng.h"
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#if NCNN_VULKAN
#include "command.h"
#include "gpu.h"
#endif // NCNN_VULKAN
static struct prng_rand_t g_prng_rand_state;
void SRAND(int seed)
{
prng_srand(seed, &g_prng_rand_state);
}
uint64_t RAND()
{
return prng_rand(&g_prng_rand_state);
}
float RandomFloat(float a, float b)
{
float random = ((float)RAND()) / (float)uint64_t(-1); //RAND_MAX;
float diff = b - a;
float r = random * diff;
float v = a + r;
// generate denormal as zero
if (v < 0.0001 && v > -0.0001)
v = 0.f;
return v;
}
int RandomInt(int a, int b)
{
float random = ((float)RAND()) / (float)uint64_t(-1); //RAND_MAX;
int diff = b - a;
float r = random * diff;
return a + (int)r;
}
signed char RandomS8()
{
return (signed char)RandomInt(-127, 127);
}
void Randomize(ncnn::Mat& m, float a, float b)
{
for (size_t i = 0; i < m.total(); i++)
{
m[i] = RandomFloat(a, b);
}
}
void RandomizeInt(ncnn::Mat& m, int a, int b)
{
for (size_t i = 0; i < m.total(); i++)
{
((int*)m)[i] = RandomInt(a, b);
}
}
void RandomizeS8(ncnn::Mat& m)
{
for (size_t i = 0; i < m.total(); i++)
{
((signed char*)m)[i] = RandomS8();
}
}
ncnn::Mat RandomMat(int w, float a, float b)
{
ncnn::Mat m(w);
Randomize(m, a, b);
return m;
}
ncnn::Mat RandomMat(int w, int h, float a, float b)
{
ncnn::Mat m(w, h);
Randomize(m, a, b);
return m;
}
ncnn::Mat RandomMat(int w, int h, int c, float a, float b)
{
ncnn::Mat m(w, h, c);
Randomize(m, a, b);
return m;
}
ncnn::Mat RandomMat(int w, int h, int d, int c, float a, float b)
{
ncnn::Mat m(w, h, d, c);
Randomize(m, a, b);
return m;
}
ncnn::Mat RandomIntMat(int w)
{
ncnn::Mat m(w);
RandomizeInt(m);
return m;
}
ncnn::Mat RandomIntMat(int w, int h)
{
ncnn::Mat m(w, h);
RandomizeInt(m);
return m;
}
ncnn::Mat RandomIntMat(int w, int h, int c)
{
ncnn::Mat m(w, h, c);
RandomizeInt(m);
return m;
}
ncnn::Mat RandomIntMat(int w, int h, int d, int c)
{
ncnn::Mat m(w, h, d, c);
RandomizeInt(m);
return m;
}
ncnn::Mat RandomS8Mat(int w)
{
ncnn::Mat m(w, (size_t)1u);
RandomizeS8(m);
return m;
}
ncnn::Mat RandomS8Mat(int w, int h)
{
ncnn::Mat m(w, h, (size_t)1u);
RandomizeS8(m);
return m;
}
ncnn::Mat RandomS8Mat(int w, int h, int c)
{
ncnn::Mat m(w, h, c, (size_t)1u);
RandomizeS8(m);
return m;
}
ncnn::Mat RandomS8Mat(int w, int h, int d, int c)
{
ncnn::Mat m(w, h, d, c, (size_t)1u);
RandomizeS8(m);
return m;
}
ncnn::Mat scales_mat(const ncnn::Mat& mat, int m, int k, int ldx)
{
ncnn::Mat weight_scales(m);
for (int i = 0; i < m; ++i)
{
float min = mat[0], _max = mat[0];
const float* ptr = (const float*)(mat.data) + i * ldx;
for (int j = 0; j < k; ++j)
{
if (min > ptr[j])
{
min = ptr[j];
}
if (_max < ptr[j])
{
_max = ptr[j];
}
}
const float abs_min = abs(min), abs_max = abs(_max);
weight_scales[i] = 127.f / (abs_min > abs_max ? abs_min : abs_max);
}
return weight_scales;
}
bool NearlyEqual(float a, float b, float epsilon)
{
if (a == b)
return true;
float diff = (float)fabs(a - b);
if (diff <= epsilon)
return true;
// relative error
return diff < epsilon * std::max(fabs(a), fabs(b));
}
int Compare(const ncnn::Mat& a, const ncnn::Mat& b, float epsilon)
{
#define CHECK_MEMBER(m) \
if (a.m != b.m) \
{ \
fprintf(stderr, #m " not match expect %d but got %d\n", (int)a.m, (int)b.m); \
return -1; \
}
CHECK_MEMBER(dims)
CHECK_MEMBER(w)
CHECK_MEMBER(h)
CHECK_MEMBER(d)
CHECK_MEMBER(c)
CHECK_MEMBER(elemsize)
CHECK_MEMBER(elempack)
#undef CHECK_MEMBER
for (int q = 0; q < a.c; q++)
{
const ncnn::Mat ma = a.channel(q);
const ncnn::Mat mb = b.channel(q);
for (int z = 0; z < a.d; z++)
{
const ncnn::Mat da = ma.depth(z);
const ncnn::Mat db = mb.depth(z);
for (int i = 0; i < a.h; i++)
{
const float* pa = da.row(i);
const float* pb = db.row(i);
for (int j = 0; j < a.w; j++)
{
if (!NearlyEqual(pa[j], pb[j], epsilon))
{
fprintf(stderr, "value not match at c:%d d:%d h:%d w:%d expect %f but got %f\n", q, z, i, j, pa[j], pb[j]);
return -1;
}
}
}
}
}
return 0;
}
int CompareMat(const ncnn::Mat& a, const ncnn::Mat& b, float epsilon)
{
ncnn::Option opt;
opt.num_threads = 1;
if (a.elempack != 1)
{
ncnn::Mat a1;
ncnn::convert_packing(a, a1, 1, opt);
return CompareMat(a1, b, epsilon);
}
if (b.elempack != 1)
{
ncnn::Mat b1;
ncnn::convert_packing(b, b1, 1, opt);
return CompareMat(a, b1, epsilon);
}
if (a.elemsize == 2u)
{
ncnn::Mat a32;
cast_float16_to_float32(a, a32, opt);
return CompareMat(a32, b, epsilon);
}
if (a.elemsize == 1u)
{
ncnn::Mat a32;
cast_int8_to_float32(a, a32, opt);
return CompareMat(a32, b, epsilon);
}
if (b.elemsize == 2u)
{
ncnn::Mat b32;
cast_float16_to_float32(b, b32, opt);
return CompareMat(a, b32, epsilon);
}
if (b.elemsize == 1u)
{
ncnn::Mat b32;
cast_int8_to_float32(b, b32, opt);
return CompareMat(a, b32, epsilon);
}
return Compare(a, b, epsilon);
}
int CompareMat(const std::vector<ncnn::Mat>& a, const std::vector<ncnn::Mat>& b, float epsilon)
{
if (a.size() != b.size())
{
fprintf(stderr, "output blob count not match %zu %zu\n", a.size(), b.size());
return -1;
}
for (size_t i = 0; i < a.size(); i++)
{
if (CompareMat(a[i], b[i], epsilon))
{
fprintf(stderr, "output blob %zu not match\n", i);
return -1;
}
}
return 0;
}
static int convert_to_optimal_layout(const ncnn::Mat& a, ncnn::Mat& a4, const ncnn::Option& opt, const ncnn::Layer* op, int flag)
{
// clang-format off
// *INDENT-OFF*
#if NCNN_ARM82
if (opt.use_fp16_storage && ncnn::cpu_support_arm_asimdhp() && op->support_fp16_storage && !(flag & TEST_LAYER_DISABLE_AUTO_INPUT_CASTING))
{
ncnn::cast_float32_to_float16(a, a4, opt);
}
else
#endif // NCNN_ARM82
#if NCNN_VFPV4
if (opt.use_fp16_storage && !opt.use_bf16_storage && ncnn::cpu_support_arm_vfpv4() && op->support_fp16_storage && !(flag & TEST_LAYER_DISABLE_AUTO_INPUT_CASTING))
{
ncnn::cast_float32_to_float16(a, a4, opt);
}
else
#endif // NCNN_VFPV4
#if NCNN_ZFH
if (opt.use_fp16_storage && (ncnn::cpu_support_riscv_zvfh() || (!ncnn::cpu_support_riscv_v() && ncnn::cpu_support_riscv_zfh())) && op->support_fp16_storage && !(flag & TEST_LAYER_DISABLE_AUTO_INPUT_CASTING))
{
ncnn::cast_float32_to_float16(a, a4, opt);
}
else
#endif // NCNN_ZFH
#if NCNN_BF16
if (opt.use_bf16_storage && op->support_bf16_storage && !(flag & TEST_LAYER_DISABLE_AUTO_INPUT_CASTING))
{
ncnn::cast_float32_to_bfloat16(a, a4, opt);
}
else
#endif // NCNN_BF16
if (opt.use_fp16_storage && op->support_fp16_storage && !(flag & TEST_LAYER_DISABLE_AUTO_INPUT_CASTING))
{
ncnn::cast_float32_to_float16(a, a4, opt);
}
else
{
a4 = a;
}
// *INDENT-ON*
// clang-format on
if (opt.use_packing_layout && op->support_packing && !(flag & TEST_LAYER_DISABLE_AUTO_INPUT_PACKING))
{
// resolve dst_elempack
int dims = a4.dims;
int elemcount = 0;
if (dims == 1) elemcount = a4.elempack * a4.w;
if (dims == 2) elemcount = a4.elempack * a4.h;
if (dims == 3 || dims == 4) elemcount = a4.elempack * a4.c;
int elembits = a4.elembits();
int dst_elempack = 1;
if (elembits == 32)
{
#if NCNN_AVX512
if (elemcount % 16 == 0 && ncnn::cpu_support_x86_avx512())
dst_elempack = 16;
else if (elemcount % 8 == 0 && ncnn::cpu_support_x86_avx())
dst_elempack = 8;
else if (elemcount % 4 == 0)
dst_elempack = 4;
#elif NCNN_AVX
if (elemcount % 8 == 0 && ncnn::cpu_support_x86_avx())
dst_elempack = 8;
else if (elemcount % 4 == 0)
dst_elempack = 4;
#elif NCNN_RVV || NCNN_XTHEADVECTOR
const int packn = ncnn::cpu_riscv_vlenb() / 4;
if (elemcount % packn == 0)
dst_elempack = packn;
#else
if (elemcount % 4 == 0)
dst_elempack = 4;
#endif
}
if (elembits == 16)
{
#if NCNN_ARM82
if (elemcount % 8 == 0 && ncnn::cpu_support_arm_asimdhp() && opt.use_fp16_arithmetic && op->support_fp16_storage)
dst_elempack = 8;
else if (elemcount % 4 == 0)
dst_elempack = 4;
#elif NCNN_RVV || NCNN_XTHEADVECTOR
const int packn = ncnn::cpu_riscv_vlenb() / 2;
if (elemcount % packn == 0)
dst_elempack = packn;
#else
if (elemcount % 4 == 0)
dst_elempack = 4;
#endif
}
if (elembits == 8)
{
#if NCNN_RVV || NCNN_XTHEADVECTOR
const int packn = ncnn::cpu_riscv_vlenb() / 1;
if (elemcount % packn == 0)
dst_elempack = packn;
#else
if (elemcount % 8 == 0)
dst_elempack = 8;
#endif
}
if (flag & TEST_LAYER_ENABLE_FORCE_INPUT_PACK8)
dst_elempack = 8;
ncnn::Mat a4_packed;
ncnn::convert_packing(a4, a4_packed, dst_elempack, opt);
a4 = a4_packed;
}
return 0;
}
static int convert_to_vanilla_layout(const ncnn::Mat& c4, ncnn::Mat& c, const ncnn::Option& opt, const ncnn::Layer* op, int flag)
{
ncnn::Mat c4_unpacked;
if (c4.elempack != 1)
{
ncnn::convert_packing(c4, c4_unpacked, 1, opt);
}
else
{
c4_unpacked = c4;
}
// clang-format off
// *INDENT-OFF*
#if NCNN_ARM82
if (opt.use_fp16_storage && ncnn::cpu_support_arm_asimdhp() && op->support_fp16_storage && c4_unpacked.elembits() == 16)
{
ncnn::cast_float16_to_float32(c4_unpacked, c, opt);
}
else
#endif // NCNN_ARM82
#if NCNN_VFPV4
if (opt.use_fp16_storage && !opt.use_bf16_storage && ncnn::cpu_support_arm_vfpv4() && op->support_fp16_storage && c4_unpacked.elembits() == 16)
{
ncnn::cast_float16_to_float32(c4_unpacked, c, opt);
}
else
#endif // NCNN_VFPV4
#if NCNN_ZFH
if (opt.use_fp16_storage && (ncnn::cpu_support_riscv_zvfh() || (!ncnn::cpu_support_riscv_v() && ncnn::cpu_support_riscv_zfh())) && op->support_fp16_storage && c4_unpacked.elembits() == 16)
{
ncnn::cast_float16_to_float32(c4_unpacked, c, opt);
}
else
#endif // NCNN_ZFH
#if NCNN_BF16
if (opt.use_bf16_storage && op->support_bf16_storage && c4_unpacked.elembits() == 16)
{
ncnn::cast_bfloat16_to_float32(c4_unpacked, c, opt);
}
else
#endif // NCNN_BF16
if (opt.use_fp16_storage && op->support_fp16_storage && c4_unpacked.elembits() == 16)
{
ncnn::cast_float16_to_float32(c4_unpacked, c, opt);
}
else
{
c = c4_unpacked;
}
// *INDENT-ON*
// clang-format on
return 0;
}
int test_layer_naive(int typeindex, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const std::vector<ncnn::Mat>& a, int top_blob_count, std::vector<ncnn::Mat>& b, void (*func)(ncnn::Layer*), int flag)
{
ncnn::Layer* op = ncnn::create_layer_naive(typeindex);
if (func)
{
(*func)((ncnn::Layer*)op);
}
op->load_param(pd);
if (op->one_blob_only && a.size() != 1)
{
fprintf(stderr, "layer with one_blob_only but consume multiple inputs\n");
delete op;
return -1;
}
ncnn::ModelBinFromMatArray mb(weights.data());
op->load_model(mb);
ncnn::Option opt;
opt.num_threads = 1;
opt.lightmode = false;
opt.use_packing_layout = false;
opt.use_fp16_packed = false;
opt.use_fp16_storage = false;
opt.use_fp16_arithmetic = false;
opt.use_shader_pack8 = false;
opt.use_bf16_storage = false;
opt.use_vulkan_compute = false;
op->create_pipeline(opt);
b.resize(top_blob_count);
if (op->support_inplace)
{
for (size_t i = 0; i < a.size(); i++)
{
b[i] = a[i].clone();
}
op->forward_inplace(b, opt);
}
else
{
op->forward(a, b, opt);
}
op->destroy_pipeline(opt);
delete op;
return 0;
}
int test_layer_cpu(int typeindex, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Option& _opt, const std::vector<ncnn::Mat>& a, int top_blob_count, std::vector<ncnn::Mat>& c, const std::vector<ncnn::Mat>& top_shapes, void (*func)(ncnn::Layer*), int flag)
{
ncnn::Layer* op = ncnn::create_layer_cpu(typeindex);
if (!op->support_packing && _opt.use_packing_layout)
{
delete op;
return 233;
}
if (!op->support_bf16_storage && !op->support_fp16_storage && (_opt.use_bf16_storage || _opt.use_fp16_arithmetic))
{
delete op;
return 233;
}
if (func)
{
(*func)((ncnn::Layer*)op);
}
if (!top_shapes.empty())
{
op->bottom_shapes = a;
op->top_shapes = top_shapes;
}
op->load_param(pd);
if (op->one_blob_only && a.size() != 1)
{
fprintf(stderr, "layer with one_blob_only but consume multiple inputs\n");
delete op;
return -1;
}
ncnn::ModelBinFromMatArray mb(weights.data());
op->load_model(mb);
ncnn::Option opt = _opt;
opt.num_threads = 1;
opt.use_vulkan_compute = false;
op->create_pipeline(opt);
if (!op->support_packing && _opt.use_packing_layout)
{
op->destroy_pipeline(opt);
delete op;
return 233;
}
if (!op->support_bf16_storage && !op->support_fp16_storage && (_opt.use_bf16_storage || _opt.use_fp16_arithmetic))
{
op->destroy_pipeline(opt);
delete op;
return 233;
}
std::vector<ncnn::Mat> a4(a.size());
for (size_t i = 0; i < a4.size(); i++)
{
convert_to_optimal_layout(a[i], a4[i], opt, op, flag);
}
c.resize(top_blob_count);
if (op->support_inplace)
{
for (size_t i = 0; i < a4.size(); i++)
{
c[i] = a4[i].clone();
}
op->forward_inplace(c, opt);
}
else
{
op->forward(a4, c, opt);
}
for (size_t i = 0; i < c.size(); i++)
{
convert_to_vanilla_layout(c[i], c[i], opt, op, flag);
}
op->destroy_pipeline(opt);
delete op;
return 0;
}
#if NCNN_VULKAN
int test_layer_gpu(int typeindex, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Option& _opt, const std::vector<ncnn::Mat>& a, int top_blob_count, std::vector<ncnn::Mat>& d, const std::vector<ncnn::Mat>& top_shapes, void (*func)(ncnn::Layer*), int flag)
{
if (!_opt.use_packing_layout)
{
// pack1 test is useless for gpu
return 233;
}
ncnn::Layer* op = ncnn::create_layer_vulkan(typeindex);
if (!op)
{
return 233;
}
op->load_param(pd);
if (!op->support_vulkan)
{
delete op;
return 233;
}
ncnn::VulkanDevice* vkdev = ncnn::get_gpu_device();
op->vkdev = vkdev;
if (func)
{
(*func)((ncnn::Layer*)op);
}
if (!top_shapes.empty())
{
op->bottom_shapes = a;
op->top_shapes = top_shapes;
}
if (op->one_blob_only && a.size() != 1)
{
fprintf(stderr, "layer with one_blob_only but consume multiple inputs\n");
delete op;
return -1;
}
ncnn::ModelBinFromMatArray mb(weights.data());
op->load_model(mb);
ncnn::VkWeightAllocator g_weight_vkallocator(vkdev);
ncnn::VkWeightStagingAllocator g_weight_staging_vkallocator(vkdev);
ncnn::VkAllocator* blob_vkallocator = vkdev->acquire_blob_allocator();
ncnn::VkAllocator* staging_vkallocator = vkdev->acquire_staging_allocator();
ncnn::Option opt = _opt;
opt.num_threads = 1;
opt.use_vulkan_compute = true;
opt.blob_vkallocator = blob_vkallocator;
opt.workspace_vkallocator = blob_vkallocator;
opt.staging_vkallocator = staging_vkallocator;
if (!vkdev->info.support_fp16_packed()) opt.use_fp16_packed = false;
if (!vkdev->info.support_fp16_storage()) opt.use_fp16_storage = false;
if (!vkdev->info.support_fp16_uniform()) opt.use_fp16_uniform = false;
if (!vkdev->info.support_fp16_arithmetic()) opt.use_fp16_arithmetic = false;
if (!vkdev->info.support_int8_packed()) opt.use_int8_packed = false;
if (!vkdev->info.support_int8_storage()) opt.use_int8_storage = false;
if (!vkdev->info.support_int8_uniform()) opt.use_int8_uniform = false;
if (!vkdev->info.support_int8_arithmetic()) opt.use_int8_arithmetic = false;
if (!vkdev->info.support_cooperative_matrix()) opt.use_cooperative_matrix = false;
if (!vkdev->info.support_subgroup_ops()) opt.use_subgroup_ops = false;
// FIXME fp16a may produce large error
opt.use_fp16_arithmetic = false;
op->create_pipeline(opt);
if (!op->support_vulkan)
{
op->destroy_pipeline(opt);
delete op;
return 233;
}
{
ncnn::VkTransfer cmd(vkdev);
ncnn::Option opt_upload = opt;
opt_upload.blob_vkallocator = &g_weight_vkallocator;
opt_upload.workspace_vkallocator = &g_weight_vkallocator;
opt_upload.staging_vkallocator = &g_weight_staging_vkallocator;
op->upload_model(cmd, opt_upload);
cmd.submit_and_wait();
}
d.resize(top_blob_count);
{
// forward
ncnn::VkCompute cmd(vkdev);
{
// upload
std::vector<ncnn::VkMat> a_gpu(a.size());
for (size_t i = 0; i < a_gpu.size(); i++)
{
if (flag & TEST_LAYER_DISABLE_AUTO_INPUT_CASTING)
{
// resolve dst_elempack
int dims = a[i].dims;
int elemcount = 0;
if (dims == 1) elemcount = a[i].elempack * a[i].w;
if (dims == 2) elemcount = a[i].elempack * a[i].h;
if (dims == 3 || dims == 4) elemcount = a[i].elempack * a[i].c;
const int dst_elempack = (opt.use_shader_pack8 && elemcount % 8 == 0) ? 8 : elemcount % 4 == 0 ? 4 : 1;
ncnn::Mat a4;
ncnn::convert_packing(a[i], a4, dst_elempack, opt);
ncnn::Option opt_upload = opt;
opt_upload.use_fp16_packed = false;
opt_upload.use_fp16_storage = false;
opt_upload.use_int8_packed = false;
opt_upload.use_int8_storage = false;
cmd.record_clone(a4, a_gpu[i], opt_upload);
}
else
{
cmd.record_upload(a[i], a_gpu[i], opt);
}
}
std::vector<ncnn::VkMat> d_gpu(top_blob_count);
if (op->support_inplace)
{
op->forward_inplace(a_gpu, cmd, opt);
d_gpu = a_gpu;
}
else
{
op->forward(a_gpu, d_gpu, cmd, opt);
}
// download
for (size_t i = 0; i < d_gpu.size(); i++)
{
cmd.record_download(d_gpu[i], d[i], opt);
}
}
cmd.submit_and_wait();
}
op->destroy_pipeline(opt);
delete op;
vkdev->reclaim_blob_allocator(blob_vkallocator);
vkdev->reclaim_staging_allocator(staging_vkallocator);
g_weight_vkallocator.clear();
g_weight_staging_vkallocator.clear();
return 0;
}
#endif // NCNN_VULKAN
int test_layer(int typeindex, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Option& _opt, const std::vector<ncnn::Mat>& a, int top_blob_count, const std::vector<ncnn::Mat>& top_shapes, float epsilon, void (*func)(ncnn::Layer*), int flag)
{
// naive
std::vector<ncnn::Mat> b;
{
int ret = test_layer_naive(typeindex, pd, weights, a, top_blob_count, b, func, flag);
if (ret != 233 && ret != 0)
{
fprintf(stderr, "test_layer_naive failed\n");
return -1;
}
}
// cpu
{
std::vector<ncnn::Mat> c;
int ret = test_layer_cpu(typeindex, pd, weights, _opt, a, top_blob_count, c, std::vector<ncnn::Mat>(), func, flag);
if (ret != 233 && (ret != 0 || CompareMat(b, c, epsilon) != 0))
{
fprintf(stderr, "test_layer_cpu failed\n");
return -1;
}
}
// cpu shape hint
{
std::vector<ncnn::Mat> c;
int ret = test_layer_cpu(typeindex, pd, weights, _opt, a, top_blob_count, c, b, func, flag);
if (ret != 233 && (ret != 0 || CompareMat(b, c, epsilon) != 0))
{
fprintf(stderr, "test_layer_cpu failed with shape hint\n");
return -1;
}
}
#if NCNN_VULKAN
// gpu
if (!(flag & TEST_LAYER_DISABLE_GPU_TESTING))
{
std::vector<ncnn::Mat> d;
int ret = test_layer_gpu(typeindex, pd, weights, _opt, a, top_blob_count, d, std::vector<ncnn::Mat>(), func, flag);
if (ret != 233 && (ret != 0 || CompareMat(b, d, epsilon) != 0))
{
fprintf(stderr, "test_layer_gpu failed\n");
return -1;
}
}
// gpu shape hint
if (!(flag & TEST_LAYER_DISABLE_GPU_TESTING))
{
std::vector<ncnn::Mat> d;
int ret = test_layer_gpu(typeindex, pd, weights, _opt, a, top_blob_count, d, b, func, flag);
if (ret != 233 && (ret != 0 || CompareMat(b, d, epsilon) != 0))
{
fprintf(stderr, "test_layer_gpu failed with shape hint\n");
return -1;
}
}
#endif // NCNN_VULKAN
return 0;
}
int test_layer_naive(int typeindex, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Mat& a, ncnn::Mat& b, void (*func)(ncnn::Layer*), int flag)
{
ncnn::Layer* op = ncnn::create_layer_naive(typeindex);
if (func)
{
(*func)((ncnn::Layer*)op);
}
op->load_param(pd);
ncnn::ModelBinFromMatArray mb(weights.data());
op->load_model(mb);
ncnn::Option opt;
opt.num_threads = 1;
opt.lightmode = false;
opt.use_packing_layout = false;
opt.use_fp16_packed = false;
opt.use_fp16_storage = false;
opt.use_fp16_arithmetic = false;
opt.use_shader_pack8 = false;
opt.use_bf16_storage = false;
opt.use_vulkan_compute = false;
op->create_pipeline(opt);
if (op->support_inplace)
{
b = a.clone();
op->forward_inplace(b, opt);
}
else
{
op->forward(a, b, opt);
}
op->destroy_pipeline(opt);
delete op;
return 0;
}
int test_layer_cpu(int typeindex, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Option& _opt, const ncnn::Mat& a, ncnn::Mat& c, const ncnn::Mat& top_shape, void (*func)(ncnn::Layer*), int flag)
{
ncnn::Layer* op = ncnn::create_layer_cpu(typeindex);
if (!op->support_packing && _opt.use_packing_layout)
{
delete op;
return 233;
}
if (!op->support_bf16_storage && !op->support_fp16_storage && (_opt.use_bf16_storage || _opt.use_fp16_arithmetic))
{
delete op;
return 233;
}
if (func)
{
(*func)((ncnn::Layer*)op);
}
if (top_shape.dims)
{
op->bottom_shapes.resize(1);
op->top_shapes.resize(1);
op->bottom_shapes[0] = a;
op->top_shapes[0] = top_shape;
}
op->load_param(pd);
ncnn::ModelBinFromMatArray mb(weights.data());
op->load_model(mb);
ncnn::Option opt = _opt;
opt.num_threads = 1;
opt.use_vulkan_compute = false;
op->create_pipeline(opt);
if (!op->support_packing && _opt.use_packing_layout)
{
op->destroy_pipeline(opt);
delete op;
return 233;
}
if (!op->support_bf16_storage && !op->support_fp16_storage && (_opt.use_bf16_storage || _opt.use_fp16_arithmetic))
{
op->destroy_pipeline(opt);
delete op;
return 233;
}
ncnn::Mat a4;
convert_to_optimal_layout(a, a4, opt, op, flag);
if (op->support_inplace)
{
c = a4.clone();
op->forward_inplace(c, opt);
}
else
{
op->forward(a4, c, opt);
}
convert_to_vanilla_layout(c, c, opt, op, flag);
op->destroy_pipeline(opt);
delete op;
return 0;
}
#if NCNN_VULKAN
int test_layer_gpu(int typeindex, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Option& _opt, const ncnn::Mat& a, ncnn::Mat& d, const ncnn::Mat& top_shape, void (*func)(ncnn::Layer*), int flag)
{
if (!_opt.use_packing_layout)
{
// pack1 test is useless for gpu
return 233;
}
ncnn::Layer* op = ncnn::create_layer_vulkan(typeindex);
if (!op)
{
return 233;
}
op->load_param(pd);
if (!op->support_vulkan)
{
delete op;
return 233;
}
ncnn::VulkanDevice* vkdev = ncnn::get_gpu_device();
op->vkdev = vkdev;
if (func)
{
(*func)((ncnn::Layer*)op);
}
if (top_shape.dims)
{
op->bottom_shapes.resize(1);
op->top_shapes.resize(1);
op->bottom_shapes[0] = a;
op->top_shapes[0] = top_shape;
}
ncnn::ModelBinFromMatArray mb(weights.data());
op->load_model(mb);
ncnn::VkWeightAllocator g_weight_vkallocator(vkdev);
ncnn::VkWeightStagingAllocator g_weight_staging_vkallocator(vkdev);
ncnn::VkAllocator* blob_vkallocator = vkdev->acquire_blob_allocator();
ncnn::VkAllocator* staging_vkallocator = vkdev->acquire_staging_allocator();
ncnn::Option opt = _opt;
opt.num_threads = 1;
opt.use_vulkan_compute = true;
opt.blob_vkallocator = blob_vkallocator;
opt.workspace_vkallocator = blob_vkallocator;
opt.staging_vkallocator = staging_vkallocator;
if (!vkdev->info.support_fp16_packed()) opt.use_fp16_packed = false;
if (!vkdev->info.support_fp16_storage()) opt.use_fp16_storage = false;
if (!vkdev->info.support_fp16_uniform()) opt.use_fp16_uniform = false;
if (!vkdev->info.support_fp16_arithmetic()) opt.use_fp16_arithmetic = false;
if (!vkdev->info.support_int8_packed()) opt.use_int8_packed = false;
if (!vkdev->info.support_int8_storage()) opt.use_int8_storage = false;
if (!vkdev->info.support_int8_uniform()) opt.use_int8_uniform = false;
if (!vkdev->info.support_int8_arithmetic()) opt.use_int8_arithmetic = false;
if (!vkdev->info.support_cooperative_matrix()) opt.use_cooperative_matrix = false;
if (!vkdev->info.support_subgroup_ops()) opt.use_subgroup_ops = false;
// FIXME fp16a may produce large error
opt.use_fp16_arithmetic = false;
op->create_pipeline(opt);
if (!op->support_vulkan)
{
op->destroy_pipeline(opt);
delete op;
return 233;
}
{
ncnn::VkTransfer cmd(vkdev);
ncnn::Option opt_upload = opt;
opt_upload.blob_vkallocator = &g_weight_vkallocator;
opt_upload.workspace_vkallocator = &g_weight_vkallocator;
opt_upload.staging_vkallocator = &g_weight_staging_vkallocator;
op->upload_model(cmd, opt_upload);
cmd.submit_and_wait();
}
{
// forward
ncnn::VkCompute cmd(vkdev);
{
// upload
ncnn::VkMat a_gpu;
if (flag & TEST_LAYER_DISABLE_AUTO_INPUT_CASTING)
{
// resolve dst_elempack
int dims = a.dims;
int elemcount = 0;
if (dims == 1) elemcount = a.elempack * a.w;
if (dims == 2) elemcount = a.elempack * a.h;
if (dims == 3 || dims == 4) elemcount = a.elempack * a.c;
const int dst_elempack = (opt.use_shader_pack8 && elemcount % 8 == 0) ? 8 : elemcount % 4 == 0 ? 4 : 1;
ncnn::Mat a4;
ncnn::convert_packing(a, a4, dst_elempack, opt);
ncnn::Option opt_upload = opt;
opt_upload.use_fp16_packed = false;
opt_upload.use_fp16_storage = false;
opt_upload.use_int8_packed = false;
opt_upload.use_int8_storage = false;
cmd.record_clone(a4, a_gpu, opt_upload);
}
else
{
cmd.record_upload(a, a_gpu, opt);
}
ncnn::VkMat d_gpu;
if (op->support_inplace)
{
op->forward_inplace(a_gpu, cmd, opt);
d_gpu = a_gpu;
}
else
{
op->forward(a_gpu, d_gpu, cmd, opt);
}
// download
cmd.record_download(d_gpu, d, opt);
}
cmd.submit_and_wait();
}
op->destroy_pipeline(opt);
delete op;
vkdev->reclaim_blob_allocator(blob_vkallocator);
vkdev->reclaim_staging_allocator(staging_vkallocator);
g_weight_vkallocator.clear();
g_weight_staging_vkallocator.clear();
return 0;
}
#endif // NCNN_VULKAN
int test_layer(int typeindex, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Option& _opt, const ncnn::Mat& a, const ncnn::Mat& top_shape, float epsilon, void (*func)(ncnn::Layer*), int flag)
{
// naive
ncnn::Mat b;
{
int ret = test_layer_naive(typeindex, pd, weights, a, b, func, flag);
if (ret != 233 && ret != 0)
{
fprintf(stderr, "test_layer_naive failed\n");
return -1;
}
}
// cpu
{
ncnn::Mat c;
int ret = test_layer_cpu(typeindex, pd, weights, _opt, a, c, ncnn::Mat(), func, flag);
if (ret != 233 && (ret != 0 || CompareMat(b, c, epsilon) != 0))
{
fprintf(stderr, "test_layer_cpu failed\n");
return -1;
}
}
// cpu shape hint
{
ncnn::Mat c;
int ret = test_layer_cpu(typeindex, pd, weights, _opt, a, c, b, func, flag);
if (ret != 233 && (ret != 0 || CompareMat(b, c, epsilon) != 0))
{
fprintf(stderr, "test_layer_cpu failed with shape hint\n");
return -1;
}
}
#if NCNN_VULKAN
// gpu
if (!(flag & TEST_LAYER_DISABLE_GPU_TESTING))
{
ncnn::Mat d;
int ret = test_layer_gpu(typeindex, pd, weights, _opt, a, d, ncnn::Mat(), func, flag);
if (ret != 233 && (ret != 0 || CompareMat(b, d, epsilon) != 0))
{
fprintf(stderr, "test_layer_gpu failed\n");
return -1;
}
}
// gpu shape hint
if (!(flag & TEST_LAYER_DISABLE_GPU_TESTING))
{
ncnn::Mat d;
int ret = test_layer_gpu(typeindex, pd, weights, _opt, a, d, b, func, flag);
if (ret != 233 && (ret != 0 || CompareMat(b, d, epsilon) != 0))
{
fprintf(stderr, "test_layer_gpu failed with shape hint\n");
return -1;
}
}
#endif // NCNN_VULKAN
return 0;
}
int test_layer_opt(const char* layer_type, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Option& opt, const std::vector<ncnn::Mat>& a, int top_blob_count, float epsilon, void (*func)(ncnn::Layer*), int flag)
{
// fp16 representation
std::vector<ncnn::Mat> a_fp16;
if (opt.use_bf16_storage && !(flag & TEST_LAYER_DISABLE_AUTO_INPUT_CASTING))
{
a_fp16.resize(a.size());
for (size_t j = 0; j < a.size(); j++)
{
ncnn::Mat tmp;
ncnn::cast_float32_to_bfloat16(a[j], tmp, opt);
ncnn::cast_bfloat16_to_float32(tmp, a_fp16[j], opt);
}
}
else if ((opt.use_fp16_packed || opt.use_fp16_storage) && !(flag & TEST_LAYER_DISABLE_AUTO_INPUT_CASTING))
{
a_fp16.resize(a.size());
for (size_t j = 0; j < a.size(); j++)
{
ncnn::Mat tmp;
ncnn::cast_float32_to_float16(a[j], tmp, opt);
ncnn::cast_float16_to_float32(tmp, a_fp16[j], opt);
}
}
else
{
a_fp16 = a;
}
std::vector<ncnn::Mat> weights_fp16;
float epsilon_fp16;
if (opt.use_bf16_storage)
{
weights_fp16.resize(weights.size());
for (size_t j = 0; j < weights.size(); j++)
{
if (weights[j].elembits() != 32)
{
weights_fp16[j] = weights[j];
continue;
}
ncnn::Mat tmp;
ncnn::cast_float32_to_bfloat16(weights[j], tmp, opt);
ncnn::cast_bfloat16_to_float32(tmp, weights_fp16[j], opt);
}
epsilon_fp16 = epsilon * 100; // 0.1
}
else if (opt.use_fp16_packed || opt.use_fp16_storage)
{
weights_fp16.resize(weights.size());
for (size_t j = 0; j < weights.size(); j++)
{
if (weights[j].elembits() != 32)
{
weights_fp16[j] = weights[j];
continue;
}
ncnn::Mat tmp;
ncnn::cast_float32_to_float16(weights[j], tmp, opt);
ncnn::cast_float16_to_float32(tmp, weights_fp16[j], opt);
}
epsilon_fp16 = epsilon * 100; // 0.1
}
else
{
weights_fp16 = weights;
epsilon_fp16 = epsilon;
}
if (opt.use_fp16_arithmetic)
{
epsilon_fp16 = epsilon * 1000; // 1.0
}
std::vector<ncnn::Mat> top_shapes;
int ret = test_layer(ncnn::layer_to_index(layer_type), pd, weights_fp16, opt, a_fp16, top_blob_count, top_shapes, epsilon_fp16, func, flag);
if (ret != 0)
{
fprintf(stderr, "test_layer %s failed use_packing_layout=%d use_fp16_packed=%d use_fp16_storage=%d use_fp16_arithmetic=%d use_shader_pack8=%d use_bf16_storage=%d use_sgemm_convolution=%d use_winograd_convolution=%d\n", layer_type, opt.use_packing_layout, opt.use_fp16_packed, opt.use_fp16_storage, opt.use_fp16_arithmetic, opt.use_shader_pack8, opt.use_bf16_storage, opt.use_sgemm_convolution, opt.use_winograd_convolution);
return ret;
}
return 0;
}
int test_layer_opt(const char* layer_type, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Option& opt, const ncnn::Mat& a, float epsilon, void (*func)(ncnn::Layer*), int flag)
{
// fp16 representation
ncnn::Mat a_fp16;
if (opt.use_bf16_storage && !(flag & TEST_LAYER_DISABLE_AUTO_INPUT_CASTING))
{
ncnn::Mat tmp;
ncnn::cast_float32_to_bfloat16(a, tmp, opt);
ncnn::cast_bfloat16_to_float32(tmp, a_fp16, opt);
}
else if ((opt.use_fp16_packed || opt.use_fp16_storage) && !(flag & TEST_LAYER_DISABLE_AUTO_INPUT_CASTING))
{
ncnn::Mat tmp;
ncnn::cast_float32_to_float16(a, tmp, opt);
ncnn::cast_float16_to_float32(tmp, a_fp16, opt);
}
else
{
a_fp16 = a;
}
std::vector<ncnn::Mat> weights_fp16;
float epsilon_fp16;
if (opt.use_bf16_storage)
{
weights_fp16.resize(weights.size());
for (size_t j = 0; j < weights.size(); j++)
{
if (weights[j].elembits() != 32)
{
weights_fp16[j] = weights[j];
continue;
}
ncnn::Mat tmp;
ncnn::cast_float32_to_bfloat16(weights[j], tmp, opt);
ncnn::cast_bfloat16_to_float32(tmp, weights_fp16[j], opt);
}
epsilon_fp16 = epsilon * 100; // 0.1
}
else if (opt.use_fp16_packed || opt.use_fp16_storage)
{
weights_fp16.resize(weights.size());
for (size_t j = 0; j < weights.size(); j++)
{
if (weights[j].elembits() != 32)
{
weights_fp16[j] = weights[j];
continue;
}
ncnn::Mat tmp;
ncnn::cast_float32_to_float16(weights[j], tmp, opt);
ncnn::cast_float16_to_float32(tmp, weights_fp16[j], opt);
}
epsilon_fp16 = epsilon * 100; // 0.1
}
else
{
weights_fp16 = weights;
epsilon_fp16 = epsilon;
}
if (opt.use_fp16_arithmetic)
{
epsilon_fp16 = epsilon * 1000; // 1.0
}
ncnn::Mat top_shape;
int ret = test_layer(ncnn::layer_to_index(layer_type), pd, weights_fp16, opt, a_fp16, top_shape, epsilon_fp16, func, flag);
if (ret != 0)
{
fprintf(stderr, "test_layer %s failed use_packing_layout=%d use_fp16_packed=%d use_fp16_storage=%d use_fp16_arithmetic=%d use_shader_pack8=%d use_bf16_storage=%d use_sgemm_convolution=%d use_winograd_convolution=%d\n", layer_type, opt.use_packing_layout, opt.use_fp16_packed, opt.use_fp16_storage, opt.use_fp16_arithmetic, opt.use_shader_pack8, opt.use_bf16_storage, opt.use_sgemm_convolution, opt.use_winograd_convolution);
return ret;
}
return 0;
}
int test_layer(const char* layer_type, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const std::vector<ncnn::Mat>& a, int top_blob_count, float epsilon, void (*func)(ncnn::Layer*), int flag)
{
// pack fp16p fp16s fp16a bf16s shader8
const int options[][6] = {
{0, 0, 0, 0, 0, 0},
{0, 0, 1, 0, 0, 0},
{0, 0, 1, 1, 1, 0},
{1, 0, 0, 0, 0, 0},
{1, 1, 0, 0, 1, 0},
{1, 0, 1, 0, 0, 1},
{1, 1, 1, 1, 0, 0},
{1, 1, 1, 1, 1, 1},
};
const int opt_count = sizeof(options) / sizeof(options[0]);
for (int i = 0; i < opt_count; i++)
{
ncnn::Option opt;
opt.num_threads = 1;
opt.use_packing_layout = options[i][0];
opt.use_fp16_packed = options[i][1];
opt.use_fp16_storage = options[i][2];
opt.use_fp16_arithmetic = options[i][3];
opt.use_bf16_storage = options[i][4];
opt.use_shader_pack8 = options[i][5];
int ret = test_layer_opt(layer_type, pd, weights, opt, a, top_blob_count, epsilon, func, flag);
if (ret != 0)
return ret;
}
return 0;
}
int test_layer(const char* layer_type, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Mat& a, float epsilon, void (*func)(ncnn::Layer*), int flag)
{
// pack fp16p fp16s fp16a bf16s shader8
const int options[][6] = {
{0, 0, 0, 0, 0, 0},
{0, 0, 1, 0, 0, 0},
{0, 0, 1, 1, 1, 0},
{1, 0, 0, 0, 0, 0},
{1, 1, 0, 0, 1, 0},
{1, 0, 1, 0, 0, 1},
{1, 1, 1, 1, 0, 0},
{1, 1, 1, 1, 1, 1},
};
const int opt_count = sizeof(options) / sizeof(options[0]);
for (int i = 0; i < opt_count; i++)
{
ncnn::Option opt;
opt.num_threads = 1;
opt.use_packing_layout = options[i][0];
opt.use_fp16_packed = options[i][1];
opt.use_fp16_storage = options[i][2];
opt.use_fp16_arithmetic = options[i][3];
opt.use_bf16_storage = options[i][4];
opt.use_shader_pack8 = options[i][5];
int ret = test_layer_opt(layer_type, pd, weights, opt, a, epsilon, func, flag);
if (ret != 0)
return ret;
}
return 0;
}
class TestOOMAllocator : public ncnn::UnlockedPoolAllocator
{
public:
TestOOMAllocator();
virtual void* fastMalloc(size_t size);
virtual void fastFree(void* ptr);
ncnn::Mutex lock;
int counter;
int failid;
};
TestOOMAllocator::TestOOMAllocator()
{
counter = 0;
failid = INT_MAX;
}
void* TestOOMAllocator::fastMalloc(size_t size)
{
lock.lock();
void* ptr;
if (counter == failid)
{
ptr = 0;
}
else
{
ptr = ncnn::UnlockedPoolAllocator::fastMalloc(size);
}
counter++;
lock.unlock();
return ptr;
}
void TestOOMAllocator::fastFree(void* ptr)
{
lock.lock();
ncnn::UnlockedPoolAllocator::fastFree(ptr);
lock.unlock();
}
int test_layer_oom_opt(const char* layer_type, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Option& _opt, const std::vector<ncnn::Mat>& a, int top_blob_count, int flag)
{
int typeindex = ncnn::layer_to_index(layer_type);
if (typeindex == -1)
return -1;
ncnn::Layer* op = ncnn::create_layer_cpu(typeindex);
if (!op->support_packing && _opt.use_packing_layout)
{
delete op;
return 233;
}
if (!op->support_bf16_storage && !op->support_fp16_storage && (_opt.use_bf16_storage || _opt.use_fp16_arithmetic))
{
delete op;
return 233;
}
op->load_param(pd);
if (op->one_blob_only && a.size() != 1)
{
fprintf(stderr, "layer with one_blob_only but consume multiple inputs\n");
delete op;
return -1;
}
ncnn::ModelBinFromMatArray mb(weights.data());
op->load_model(mb);
ncnn::Option opt = _opt;
opt.num_threads = 1;
opt.use_vulkan_compute = false;
op->create_pipeline(opt);
if (!op->support_packing && _opt.use_packing_layout)
{
op->destroy_pipeline(opt);
delete op;
return 233;
}
if (!op->support_bf16_storage && !op->support_fp16_storage && (_opt.use_bf16_storage || _opt.use_fp16_arithmetic))
{
op->destroy_pipeline(opt);
delete op;
return 233;
}
std::vector<ncnn::Mat> a4(a.size());
for (size_t i = 0; i < a4.size(); i++)
{
convert_to_optimal_layout(a[i], a4[i], opt, op, flag);
}
TestOOMAllocator test_oom_allocator;
opt.blob_allocator = &test_oom_allocator;
opt.workspace_allocator = &test_oom_allocator;
std::vector<ncnn::Mat> c;
c.resize(top_blob_count);
if (op->support_inplace)
{
for (size_t i = 0; i < a4.size(); i++)
{
c[i] = a4[i].clone();
}
op->forward_inplace(c, opt);
}
else
{
op->forward(a4, c, opt);
}
for (int i = 0; i < top_blob_count; i++)
{
c[i].release();
}
const int alloc_count = test_oom_allocator.counter;
for (int i = 0; i < alloc_count; i++)
{
test_oom_allocator.counter = 0;
test_oom_allocator.failid = i;
int ret = 0;
if (op->support_inplace)
{
for (size_t i = 0; i < a4.size(); i++)
{
c[i] = a4[i].clone();
}
ret = op->forward_inplace(c, opt);
}
else
{
ret = op->forward(a4, c, opt);
}
for (int i = 0; i < top_blob_count; i++)
{
c[i].release();
}
if (ret != -100)
{
fprintf(stderr, "oom not catched %d/%d\n", i, alloc_count);
op->destroy_pipeline(opt);
delete op;
return -1;
}
}
op->destroy_pipeline(opt);
delete op;
return 0;
}
int test_layer_oom_opt(const char* layer_type, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Option& _opt, const ncnn::Mat& a, int flag)
{
int typeindex = ncnn::layer_to_index(layer_type);
if (typeindex == -1)
return -1;
ncnn::Layer* op = ncnn::create_layer_cpu(typeindex);
if (!op->support_packing && _opt.use_packing_layout)
{
delete op;
return 233;
}
if (!op->support_bf16_storage && !op->support_fp16_storage && (_opt.use_bf16_storage || _opt.use_fp16_arithmetic))
{
delete op;
return 233;
}
op->load_param(pd);
ncnn::ModelBinFromMatArray mb(weights.data());
op->load_model(mb);
ncnn::Option opt = _opt;
opt.num_threads = 1;
opt.use_vulkan_compute = false;
op->create_pipeline(opt);
if (!op->support_packing && _opt.use_packing_layout)
{
op->destroy_pipeline(opt);
delete op;
return 233;
}
if (!op->support_bf16_storage && !op->support_fp16_storage && (_opt.use_bf16_storage || _opt.use_fp16_arithmetic))
{
op->destroy_pipeline(opt);
delete op;
return 233;
}
ncnn::Mat a4;
convert_to_optimal_layout(a, a4, opt, op, flag);
TestOOMAllocator test_oom_allocator;
opt.blob_allocator = &test_oom_allocator;
opt.workspace_allocator = &test_oom_allocator;
ncnn::Mat c;
if (op->support_inplace)
{
c = a4.clone();
op->forward_inplace(c, opt);
}
else
{
op->forward(a4, c, opt);
}
c.release();
const int alloc_count = test_oom_allocator.counter;
for (int i = 0; i < alloc_count; i++)
{
test_oom_allocator.counter = 0;
test_oom_allocator.failid = i;
int ret = 0;
if (op->support_inplace)
{
c = a4.clone();
ret = op->forward_inplace(c, opt);
}
else
{
ret = op->forward(a4, c, opt);
}
c.release();
if (ret != -100)
{
fprintf(stderr, "oom not catched %d/%d\n", i, alloc_count);
op->destroy_pipeline(opt);
delete op;
return -1;
}
}
op->destroy_pipeline(opt);
delete op;
return 0;
}
int test_layer_oom(const char* layer_type, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const std::vector<ncnn::Mat>& a, int top_blob_count, int flag)
{
// pack fp16p fp16s fp16a bf16s shader8
const int options[][6] = {
{0, 0, 0, 0, 0, 0},
{0, 0, 1, 0, 0, 0},
{0, 0, 1, 1, 1, 0},
{1, 0, 0, 0, 0, 0},
{1, 1, 0, 0, 1, 0},
{1, 0, 1, 0, 0, 1},
{1, 1, 1, 1, 0, 0},
{1, 1, 1, 1, 1, 1},
};
const int opt_count = sizeof(options) / sizeof(options[0]);
for (int i = 0; i < opt_count; i++)
{
ncnn::Option opt;
opt.num_threads = 1;
opt.use_packing_layout = options[i][0];
opt.use_fp16_packed = options[i][1];
opt.use_fp16_storage = options[i][2];
opt.use_fp16_arithmetic = options[i][3];
opt.use_bf16_storage = options[i][4];
opt.use_shader_pack8 = options[i][5];
int ret = test_layer_oom_opt(layer_type, pd, weights, opt, a, top_blob_count, flag);
if (ret != 233 && ret != 0)
return ret;
}
return 0;
}
int test_layer_oom(const char* layer_type, const ncnn::ParamDict& pd, const std::vector<ncnn::Mat>& weights, const ncnn::Mat& a, int flag)
{
// pack fp16p fp16s fp16a bf16s shader8
const int options[][6] = {
{0, 0, 0, 0, 0, 0},
{0, 0, 1, 0, 0, 0},
{0, 0, 1, 1, 1, 0},
{1, 0, 0, 0, 0, 0},
{1, 1, 0, 0, 1, 0},
{1, 0, 1, 0, 0, 1},
{1, 1, 1, 1, 0, 0},
{1, 1, 1, 1, 1, 1},
};
const int opt_count = sizeof(options) / sizeof(options[0]);
for (int i = 0; i < opt_count; i++)
{
ncnn::Option opt;
opt.num_threads = 1;
opt.use_packing_layout = options[i][0];
opt.use_fp16_packed = options[i][1];
opt.use_fp16_storage = options[i][2];
opt.use_fp16_arithmetic = options[i][3];
opt.use_bf16_storage = options[i][4];
opt.use_shader_pack8 = options[i][5];
int ret = test_layer_oom_opt(layer_type, pd, weights, opt, a, flag);
if (ret != 233 && ret != 0)
return ret;
}
return 0;
}
Loading...
马建仓 AI 助手
尝试更多
代码解读
代码找茬
代码优化
C/C++
1
https://gitee.com/Tencent/ncnn.git
git@gitee.com:Tencent/ncnn.git
Tencent
ncnn
ncnn
master

搜索帮助