name string | code string | asm string | file string |
|---|---|---|---|
ncnn::BatchNorm_x86_avx2::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BatchNorm_x86_avx2::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int dims = bottom_top_blob.dims;
int elempack = bottom_top_blob.elempack;
#if __SSE2__
#if __AVX__
if (elempack == 8)
{
if (dims == 1)
{
int w = bottom_top_blob.w;
#pragma ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rsi), %ecx
movl 0x28(%rsi), %eax
cmpl $0x4, %ecx
je 0x4ae3a
cmpl $0x8, %ecx
jne 0x4ae99
cmpl $0x2, %eax
je 0x4afa5
cmpl $0x1, %eax
jne 0x4b019
movl 0x2c(%rbx), %ecx
movq (%r14), %rdx
xorl %esi, ... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/batchnorm_x86_avx2.cpp |
virtual thunk to ncnn::BatchNorm_x86_avx2::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BatchNorm_x86_avx2::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int dims = bottom_top_blob.dims;
int elempack = bottom_top_blob.elempack;
#if __SSE2__
#if __AVX__
if (elempack == 8)
{
if (dims == 1)
{
int w = bottom_top_blob.w;
#pragma ... | movq (%rdi), %rax
addq -0x58(%rax), %rdi
jmp 0x4adb0
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/batchnorm_x86_avx2.cpp |
ncnn::Convolution_x86::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Convolution_x86::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const Mat& _weight_data = bottom_blobs[1];
Mat& top_blob = top_blobs[0];
const int _kernel_w = _weight_data.w;
const int _kernel_h = _... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %r12
movq %rdi, %r13
movq (%rsi), %r14
leaq 0x48(%r14), %rdi
movq (%rdx), %rax
movq %rax, 0x68(%rsp)
movl 0x60(%r14), %ebx
movl 0x74(%r14), %eax
movl %eax, 0x1c(%rsp)
movl 0x78(%r14), %eax
movl %eax, ... | /tpoisonooo[P]ncnn/src/layer/x86/convolution_x86.cpp |
ncnn::Convolution_x86_avx::Convolution_x86_avx() | Convolution_x86_avx::Convolution_x86_avx()
{
#if __SSE2__
support_packing = true;
#if __AVX2__
support_weight_fp16_storage = true;
#endif
#endif // __SSE2__
activation = 0;
convolution_dilation1 = 0;
} | pushq %rbx
movq %rdi, %rbx
addq $0x180, %rdi # imm = 0x180
callq 0x4f6a4
leaq 0x19b295(%rip), %rax # 0x21b400
movq %rax, (%rbx)
leaq 0x19b313(%rip), %rax # 0x21b488
movq %rax, 0x180(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x10(%rbx)
vmovups %xmm0, 0x1c(%rbx)
vmovups %xmm0, 0x30(%rbx)
vmovups %x... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/convolution_x86_avx.cpp |
ncnn::conv_im2col_sgemm_transform_kernel_sse(ncnn::Mat const&, ncnn::Mat&, int, int, int) | static void conv_im2col_sgemm_transform_kernel_sse(const Mat& _kernel, Mat& kernel_tm, int inch, int outch, int kernel_size)
{
const float* kernel = _kernel;
// kernel memory packed 8 x 8
kernel_tm.create(8 * kernel_size, inch, outch / 8 + (outch % 8) / 4 + outch % 4);
int nn_outch = 0;
int remain... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r9
movq (%rdi), %rax
movq %rax, 0x48(%rsp)
leal (,%rbx,8), %esi
pushq $0x8
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, %ecx
movsbl %dl, %eax
movb $0x4, %dl
idivb %dl
m... | /tpoisonooo[P]ncnn/src/layer/x86/convolution_sgemm.h |
ncnn::InnerProduct_x86::forward_int8_x86(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int InnerProduct_x86::forward_int8_x86(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
const int num_input = weight_data_size / num_output;
if (bottom_blob.dims == 2 && bottom_blob.w == num_input && bottom_blob.h * bottom_blob.elempack > 1)
{
// gemm
Mat bottom_blob_unpack... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, %r15
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movl 0xd8(%rdi,%rcx), %eax
cltd
idivl 0xd0(%rdi,%rcx)
movl %eax, %r12d
movq %rsi, %r13
cmpl $0x2, 0x28(%rsi)
j... | /tpoisonooo[P]ncnn/src/layer/x86/innerproduct_x86.cpp |
ncnn::InnerProduct_x86_avx2::InnerProduct_x86_avx2() | InnerProduct_x86_avx2::InnerProduct_x86_avx2()
{
#if __SSE2__
support_packing = true;
#if __AVX2__
support_weight_fp16_storage = true;
#endif
#endif // __SSE2__
flatten = 0;
activation = 0;
} | movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rcx
movq -0x18(%rax), %rax
movq %rcx, (%rdi,%rax)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x24(%rdi)
vmovups %xmm0, 0x18(%rdi)
vmovups %xmm0, 0x38(%rdi)
vmovups %xmm0, 0x44(%rdi)
vmovups %xmm0, 0x80(%rdi)
vmovups %xmm0, 0x8c(%rdi)
vmovups %xmm0, 0xc8(%rdi)
vmovups ... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx2.cpp |
ncnn::InnerProduct_x86_avx2::InnerProduct_x86_avx2() | InnerProduct_x86_avx2::InnerProduct_x86_avx2()
{
#if __SSE2__
support_packing = true;
#if __AVX2__
support_weight_fp16_storage = true;
#endif
#endif // __SSE2__
flatten = 0;
activation = 0;
} | pushq %rbx
movq %rdi, %rbx
addq $0x138, %rdi # imm = 0x138
callq 0xac000
leaq 0x16bd49(%rip), %rax # 0x21c758
movq %rax, (%rbx)
leaq 0x16bdbf(%rip), %rax # 0x21c7d8
movq %rax, 0x138(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x18(%rbx)
vmovups %xmm0, 0x24(%rbx)
vmovups %xmm0, 0x38(%rbx)
vmovups %x... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx2.cpp |
ncnn::InnerProduct_x86_avx2::create_pipeline(ncnn::Option const&) | int InnerProduct_x86_avx2::create_pipeline(const Option& opt)
{
// if (opt.use_packing_layout)
{
flatten = ncnn::create_layer(ncnn::LayerType::Flatten);
ncnn::ParamDict pd;
flatten->load_param(pd);
flatten->create_pipeline(opt);
}
#if NCNN_INT8
if (opt.use_int8_in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0xe
popq %rdi
callq 0x3d2f3
movq %rax, 0x8(%r14)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x49b10
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x10(%rax)
movq 0x8(%r14), %rdi
mov... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx2.cpp |
ncnn::InnerProduct_x86_avx2::create_pipeline_int8_x86(ncnn::Option const&) | int InnerProduct_x86_avx2::create_pipeline_int8_x86(const Option& opt)
{
activation = create_activation_layer(activation_type, activation_params, opt);
const int num_input = weight_data_size / num_output;
int out_elempack = 1;
#if __SSE2__
if (opt.use_packing_layout)
{
out_elempack = num_o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %r13
movl 0xe0(%rdi,%r13), %ecx
decl %ecx
cmpl $0x5, %ecx
ja 0xb0f75
leaq 0x11e963(%rip), %rax # 0x1cf654
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
pushq ... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx2.cpp |
virtual thunk to ncnn::InnerProduct_x86_avx2::create_pipeline(ncnn::Option const&) | int InnerProduct_x86_avx2::create_pipeline(const Option& opt)
{
// if (opt.use_packing_layout)
{
flatten = ncnn::create_layer(ncnn::LayerType::Flatten);
ncnn::ParamDict pd;
flatten->load_param(pd);
flatten->create_pipeline(opt);
}
#if NCNN_INT8
if (opt.use_int8_in... | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0xb0ab4
xorl %eax, %eax
popq %rcx
retq
nop
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx2.cpp |
ncnn::InnerProduct_x86_avx2::forward_int8_x86(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int InnerProduct_x86_avx2::forward_int8_x86(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
const int num_input = weight_data_size / num_output;
if (bottom_blob.dims == 2 && bottom_blob.w == num_input && bottom_blob.h * bottom_blob.elempack > 1)
{
// gemm
Mat bottom_blob_u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, %r15
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movl 0xd8(%rdi,%rcx), %eax
cltd
idivl 0xd0(%rdi,%rcx)
movl %eax, %r12d
movq %rsi, %r13
cmpl $0x2, 0x28(%rsi)
j... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx2.cpp |
ncnn::InnerProduct_x86_avx2::forward_fp16(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int InnerProduct_x86_avx2::forward_fp16(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// flatten
Mat bottom_blob_flattened = bottom_blob;
if (bottom_blob.dims != 1)
{
Option opt_flatten = opt;
opt_flatten.blob_allocator = opt.workspace_allocator;
flatten->for... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x178(%rsp), %rdi
callq 0x462b0
cmpl $0x1, 0x28(%r12)
je 0xbb1ba
vmovups (%r14), %ymm0
vmovups 0x20(%r14), %ymm1
leaq 0xf0(%rsp), %rcx
vmovups... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx2.cpp |
ncnn::InnerProduct_x86_avx::InnerProduct_x86_avx() | InnerProduct_x86_avx::InnerProduct_x86_avx()
{
#if __SSE2__
support_packing = true;
#if __AVX2__
support_weight_fp16_storage = true;
#endif
#endif // __SSE2__
flatten = 0;
activation = 0;
} | movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rcx
movq -0x18(%rax), %rax
movq %rcx, (%rdi,%rax)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x24(%rdi)
vmovups %xmm0, 0x18(%rdi)
vmovups %xmm0, 0x38(%rdi)
vmovups %xmm0, 0x44(%rdi)
vmovups %xmm0, 0x80(%rdi)
vmovups %xmm0, 0x8c(%rdi)
vmovups %xmm0, 0xc8(%rdi)
vmovups ... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx.cpp |
ncnn::InnerProduct_x86_avx::InnerProduct_x86_avx() | InnerProduct_x86_avx::InnerProduct_x86_avx()
{
#if __SSE2__
support_packing = true;
#if __AVX2__
support_weight_fp16_storage = true;
#endif
#endif // __SSE2__
flatten = 0;
activation = 0;
} | pushq %rbx
movq %rdi, %rbx
addq $0x138, %rdi # imm = 0x138
callq 0xac000
leaq 0x1603eb(%rip), %rax # 0x21c878
movq %rax, (%rbx)
leaq 0x160461(%rip), %rax # 0x21c8f8
movq %rax, 0x138(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x18(%rbx)
vmovups %xmm0, 0x24(%rbx)
vmovups %xmm0, 0x38(%rbx)
vmovups %x... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx.cpp |
ncnn::InnerProduct_x86_avx::create_pipeline(ncnn::Option const&) | int InnerProduct_x86_avx::create_pipeline(const Option& opt)
{
// if (opt.use_packing_layout)
{
flatten = ncnn::create_layer(ncnn::LayerType::Flatten);
ncnn::ParamDict pd;
flatten->load_param(pd);
flatten->create_pipeline(opt);
}
#if NCNN_INT8
if (opt.use_int8_inf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
pushq $0xe
popq %rdi
callq 0x3d2f3
movq %rax, 0x8(%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x49b10
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq 0x8(%rbx), %rdi
movq (%rd... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx.cpp |
ncnn::InnerProduct_x86_avx::create_pipeline_int8_x86(ncnn::Option const&) | int InnerProduct_x86_avx::create_pipeline_int8_x86(const Option& opt)
{
activation = create_activation_layer(activation_type, activation_params, opt);
const int num_input = weight_data_size / num_output;
int out_elempack = 1;
#if __SSE2__
if (opt.use_packing_layout)
{
out_elempack = num_ou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %r13
movl 0xe0(%rdi,%r13), %ecx
decl %ecx
cmpl $0x5, %ecx
ja 0xbc99d
leaq 0x11310b(%rip), %rax # 0x1cf824
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
pushq ... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx.cpp |
virtual thunk to ncnn::InnerProduct_x86_avx::create_pipeline(ncnn::Option const&) | int InnerProduct_x86_avx::create_pipeline(const Option& opt)
{
// if (opt.use_packing_layout)
{
flatten = ncnn::create_layer(ncnn::LayerType::Flatten);
ncnn::ParamDict pd;
flatten->load_param(pd);
flatten->create_pipeline(opt);
}
#if NCNN_INT8
if (opt.use_int8_inf... | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0xbc52a
xorl %eax, %eax
popq %rcx
retq
nop
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx.cpp |
ncnn::InnerProduct_x86_avx::forward_int8_x86(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int InnerProduct_x86_avx::forward_int8_x86(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
const int num_input = weight_data_size / num_output;
if (bottom_blob.dims == 2 && bottom_blob.w == num_input && bottom_blob.h * bottom_blob.elempack > 1)
{
// gemm
Mat bottom_blob_un... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, %r15
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movl 0xd8(%rdi,%rcx), %eax
cltd
idivl 0xd0(%rdi,%rcx)
movl %eax, %r12d
movq %rsi, %r13
cmpl $0x2, 0x28(%rsi)
j... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/innerproduct_x86_avx.cpp |
ncnn::Input::Input() | Input::Input()
{
one_blob_only = true;
support_inplace = true;
support_vulkan = true;
support_packing = true;
support_bf16_storage = true;
support_image_storage = true;
} | pushq %rbx
movq %rdi, %rbx
callq 0x3d09a
leaq 0x15477c(%rip), %rax # 0x21c990
movq %rax, (%rbx)
movb $0x1, %al
movb %al, 0xf(%rbx)
movb %al, 0xc(%rbx)
movl $0x1010101, 0x8(%rbx) # imm = 0x1010101
popq %rbx
retq
| /tpoisonooo[P]ncnn/src/layer/input.cpp |
ncnn::Log::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Log::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
if (base == -1.f)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < chann... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movl 0x30(%rsi), %r13d
movl 0x38(%rsi), %ebp
movq %rsi, 0x8(%rsp)
imull 0x2c(%rsi), %r13d
movss 0xd0(%rdi), %xmm0
movss 0x106cda(%rip), %xmm1 # 0x1cf02c
ucomiss %xmm0, %xmm1
jne 0xc83ca
xorl %r15d, %r15d
testl %r13d, %r... | /tpoisonooo[P]ncnn/src/layer/log.cpp |
ncnn::LRN::load_param(ncnn::ParamDict const&) | int LRN::load_param(const ParamDict& pd)
{
region_type = pd.get(0, 0);
local_size = pd.get(1, 5);
alpha = pd.get(2, 1.f);
beta = pd.get(3, 0.75f);
bias = pd.get(4, 1.f);
return 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x49d20
movl %eax, 0xd0(%rbx)
pushq $0x1
popq %rsi
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x49d20
movl %eax, 0xd4(%rbx)
pushq $0x2
popq %rsi
movss 0x1065b5(%rip), %xmm0 # 0x1cea88
movq %r14, %rdi... | /tpoisonooo[P]ncnn/src/layer/lrn.cpp |
ncnn::LRN::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
size_t elemsize = bottom_top_blob.elemsize;
int size = w * h;
// squared values with local_size padding
Mat square_blob;
squa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movl 0x2c(%rsi), %r11d
movl 0x30(%rsi), %r10d
movl 0x38(%rsi), %ecx
movq %rsi, 0x38(%rsp)
movq 0x10(%rsi), %r8
leaq 0xa0(%rsp), %rax
andq $0x0, 0x40(%rax)
movq %rdx, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movap... | /tpoisonooo[P]ncnn/src/layer/lrn.cpp |
ncnn::LRN_x86_avx2::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN_x86_avx2::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
size_t elemsize = bottom_top_blob.elemsize;
int size = w * h;
// squared values with local_size padding
Mat square_blob;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movl 0x2c(%rsi), %r10d
movl 0x30(%rsi), %r8d
movl 0x38(%rsi), %ecx
movq %rsi, 0x38(%rsp)
movq 0x10(%rsi), %r13
leaq 0xc0(%rsp), %rax
andq $0x0, 0x40(%rax)
movq %rdx, %r15
movq %rdi, %r14
vxorps %xmm0, %xmm0, %xm... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/lrn_x86_avx2.cpp |
ncnn::LRN_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN_x86_avx::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
size_t elemsize = bottom_top_blob.elemsize;
int size = w * h;
// squared values with local_size padding
Mat square_blob;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movl 0x2c(%rsi), %r10d
movl 0x30(%rsi), %r8d
movl 0x38(%rsi), %ecx
movq %rsi, 0x38(%rsp)
movq 0x10(%rsi), %r13
leaq 0xa0(%rsp), %rax
andq $0x0, 0x40(%rax)
movq %rdx, %r15
movq %rdi, %r14
vxorps %xmm0, %xmm0, %xm... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/lrn_x86_avx.cpp |
ncnn::Pooling::load_param(ncnn::ParamDict const&) | int Pooling::load_param(const ParamDict& pd)
{
pooling_type = pd.get(0, 0);
kernel_w = pd.get(1, 0);
kernel_h = pd.get(11, kernel_w);
stride_w = pd.get(2, 1);
stride_h = pd.get(12, stride_w);
pad_left = pd.get(3, 0);
pad_right = pd.get(14, pad_left);
pad_top = pd.get(13, pad_left);
p... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x49d20
movl %eax, 0xd0(%rbx)
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x49d20
movl %eax, 0xd4(%rbx)
pushq $0xb
popq %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x49d20... | /tpoisonooo[P]ncnn/src/layer/pooling.cpp |
ncnn::Pooling::make_padding(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | void Pooling::make_padding(const Mat& bottom_blob, Mat& bottom_blob_bordered, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
bottom_blob_bordered = bottom_blob;
float pad_value = 0.f;
if (pooling_type == PoolMethod_MAX)
{
pad_value = bottom_blob.elemsize == 1 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl 0x2c(%rsi), %r13d
movl 0x30(%rsi), %ebp
movq %rdx, %rdi
callq 0x3fd2a
xorps %xmm0, %xmm0
cmpl $0x0, 0xd0(%r12)
jne 0xcbe25
xorl %eax, %eax
cmpq $0x1, 0x10(%r14)
sete %a... | /tpoisonooo[P]ncnn/src/layer/pooling.cpp |
virtual thunk to ncnn::Pooling_x86::create_pipeline(ncnn::Option const&) | int Pooling_x86::create_pipeline(const Option& /*opt*/)
{
if (adaptive_pooling)
{
support_packing = false;
support_bf16_storage = false;
support_fp16_storage = false;
support_int8_storage = false;
support_tensor_storage = false;
support_weight_fp16_storage = fal... | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0xcc0f8
xorl %eax, %eax
popq %rcx
retq
nop
| /tpoisonooo[P]ncnn/src/layer/x86/pooling_x86.cpp |
virtual thunk to ncnn::Pooling_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Pooling_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// max value in NxN window
// avg value in NxN window
if (adaptive_pooling)
{
return Pooling::forward(bottom_blob, top_blob, opt);
}
#if __SSE2__
int elempack = bottom_blob.elempack;
int w = ... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0xcc14c
nop
| /tpoisonooo[P]ncnn/src/layer/x86/pooling_x86.cpp |
ncnn::Pooling_x86_avx2::create_pipeline(ncnn::Option const&) | int Pooling_x86_avx2::create_pipeline(const Option& /*opt*/)
{
if (adaptive_pooling)
{
support_packing = false;
support_bf16_storage = false;
support_fp16_storage = false;
support_int8_storage = false;
support_tensor_storage = false;
support_weight_fp16_storage ... | movq (%rdi), %rax
movq -0x18(%rax), %rcx
cmpl $0x0, 0x100(%rdi,%rcx)
je 0xcce73
xorl %edx, %edx
movb %dl, 0xb(%rdi,%rcx)
movq -0x18(%rax), %rcx
movb %dl, 0xc(%rdi,%rcx)
movq -0x18(%rax), %rcx
movb %dl, 0xd(%rdi,%rcx)
movq -0x18(%rax), %rcx
movb %dl, 0xe(%rdi,%rcx)
movq -0x18(%rax), %rcx
movb %dl, 0x10(%rdi,%rcx)
movq -... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/pooling_x86_avx2.cpp |
virtual thunk to ncnn::Pooling_x86_avx2::create_pipeline(ncnn::Option const&) | int Pooling_x86_avx2::create_pipeline(const Option& /*opt*/)
{
if (adaptive_pooling)
{
support_packing = false;
support_bf16_storage = false;
support_fp16_storage = false;
support_int8_storage = false;
support_tensor_storage = false;
support_weight_fp16_storage ... | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0xcce34
xorl %eax, %eax
popq %rcx
retq
nop
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/pooling_x86_avx2.cpp |
virtual thunk to ncnn::Pooling_x86_avx2::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Pooling_x86_avx2::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// max value in NxN window
// avg value in NxN window
if (adaptive_pooling)
{
return Pooling::forward(bottom_blob, top_blob, opt);
}
#if __SSE2__
int elempack = bottom_blob.elempack;
int... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0xcce88
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/pooling_x86_avx2.cpp |
virtual thunk to ncnn::Pooling_x86_avx::create_pipeline(ncnn::Option const&) | int Pooling_x86_avx::create_pipeline(const Option& /*opt*/)
{
if (adaptive_pooling)
{
support_packing = false;
support_bf16_storage = false;
support_fp16_storage = false;
support_int8_storage = false;
support_tensor_storage = false;
support_weight_fp16_storage =... | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0xceb34
xorl %eax, %eax
popq %rcx
retq
nop
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/pooling_x86_avx.cpp |
ncnn::Pooling_x86_avx::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Pooling_x86_avx::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// max value in NxN window
// avg value in NxN window
if (adaptive_pooling)
{
return Pooling::forward(bottom_blob, top_blob, opt);
}
#if __SSE2__
int elempack = bottom_blob.elempack;
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
cmpl $0x0, 0x100(%r15,%rax)
je 0xcebd3
movq %r12, %rsi
movq %r14, %rcx
addq $0x178, %rsp # imm ... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/pooling_x86_avx.cpp |
virtual thunk to ncnn::Pooling_x86_avx::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Pooling_x86_avx::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// max value in NxN window
// avg value in NxN window
if (adaptive_pooling)
{
return Pooling::forward(bottom_blob, top_blob, opt);
}
#if __SSE2__
int elempack = bottom_blob.elempack;
int ... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0xceb88
nop
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/pooling_x86_avx.cpp |
int ncnn::reduction<ncnn::reduction_op_add<float>, ncnn::reduction_op_add<float>, ncnn::post_process_identity<float>>(ncnn::Mat const&, ncnn::Mat&, float, bool, bool, bool, bool, float, int, ncnn::Option const&) | static int reduction(const Mat& a, Mat& b, float v0, bool reduce_w, bool reduce_h, bool reduce_c, bool post_process, float coeff, int keepdims, const Option& opt)
{
int ret;
if (keepdims)
ret = reduction_op_keepdims<Op, Op2>(a, b, v0, reduce_w, reduce_h, reduce_c, opt);
else
ret = reduction_... | pushq %rbp
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movl %r9d, %ebp
movq %rsi, %rbx
movq 0x28(%rsp), %r9
movzbl %dl, %edx
movzbl %cl, %ecx
movzbl %r8b, %r8d
cmpl $0x0, 0x20(%rsp)
je 0xd8911
callq 0xd9ce2
jmp 0xd8916
callq 0xda6b4
testl %eax, %eax
je 0xd891f
pushq $-0x64
popq %rax
jmp 0xd8952
testb %bpl, %bpl
movss ... | /tpoisonooo[P]ncnn/src/layer/reduction.cpp |
ncnn::ReLU_x86_avx2::forward_inplace_int8(ncnn::Mat&, ncnn::Option const&) const | int ReLU_x86_avx2::forward_inplace_int8(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int d = bottom_top_blob.d;
int channels = bottom_top_blob.c;
int size = w * h * d;
int elempack = bottom_top_blob.elempack;
#if __SSE2__
if (elempac... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl 0x30(%rsi), %r12d
imull 0x2c(%rsi), %r12d
imull 0x34(%rsi), %r12d
cmpl $0x8, 0x18(%rsi)
movl 0x38(%rsi), %ebp
movq (%rdi), %rax
movq -0x18(%rax), %rax
vmovss 0xd0(%rdi,%rax), %xmm0
vxorps %xmm1, %xmm1, %xmm1
jne 0xdd... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/relu_x86_avx2.cpp |
ncnn::ReLU_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int ReLU_x86_avx::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int elembits = bottom_top_blob.elembits();
if (elembits == 8)
return forward_inplace_int8(bottom_top_blob, opt);
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int d = bottom_top_blob.d;
int chann... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r12
movq %rdi, %r14
movl 0x18(%rsi), %ecx
testl %ecx, %ecx
movq %rsi, 0x8(%rsp)
je 0xdd113
movl 0x10(%r12), %eax
shll $0x3, %eax
cltd
idivl %ecx
cmpl $0x8, %eax
jne 0xdd12e
movq %r14, %rdi
movq %r12, %rsi
callq 0xdd41c
xorl %... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/relu_x86_avx.cpp |
ncnn::ReLU_x86_avx::forward_inplace_int8(ncnn::Mat&, ncnn::Option const&) const | int ReLU_x86_avx::forward_inplace_int8(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int d = bottom_top_blob.d;
int channels = bottom_top_blob.c;
int size = w * h * d;
int elempack = bottom_top_blob.elempack;
#if __SSE2__
if (elempack... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl 0x30(%rsi), %r12d
imull 0x2c(%rsi), %r12d
imull 0x34(%rsi), %r12d
cmpl $0x8, 0x18(%rsi)
movl 0x38(%rsi), %ebp
movq (%rdi), %rax
movq -0x18(%rax), %rax
vmovss 0xd0(%rdi,%rax), %xmm0
vxorps %xmm1, %xmm1, %xmm1
jne 0xdd... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/relu_x86_avx.cpp |
virtual thunk to ncnn::ReLU_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int ReLU_x86_avx::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int elembits = bottom_top_blob.elembits();
if (elembits == 8)
return forward_inplace_int8(bottom_top_blob, opt);
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int d = bottom_top_blob.d;
int chann... | pushq %rax
movq (%rdi), %rax
addq -0x58(%rax), %rdi
callq 0xdd0c4
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/relu_x86_avx.cpp |
ncnn::Reshape::load_param(ncnn::ParamDict const&) | int Reshape::load_param(const ParamDict& pd)
{
w = pd.get(0, -233);
h = pd.get(1, -233);
d = pd.get(11, -233);
c = pd.get(2, -233);
permute = pd.get(3, 0);
ndim = 4;
if (d == -233)
ndim = 3;
if (c == -233)
ndim = 2;
if (h == -233)
ndim = 1;
if (w == -233)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
movq %rsi, %rdi
xorl %esi, %esi
movl $0xffffff17, %edx # imm = 0xFFFFFF17
callq 0x49d20
movl %eax, 0xd0(%rbx)
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
movl $0xffffff17, %edx # imm = 0xFFFFFF1... | /tpoisonooo[P]ncnn/src/layer/reshape.cpp |
ncnn::Reshape::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Reshape::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
size_t elemsize = bottom_blob.elemsize;
int total = bottom_blob.w * bottom_blob.h * bottom_blob.d * bottom_blob.c;
int dims = bottom_blob.dims;
// resolve out shape
int outw = w;
int outh = h;
int outd ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rcx, 0x30(%rsp)
movq %rdx, %rbx
movq 0x10(%rsi), %rax
movq %rax, 0x48(%rsp)
movl 0x2c(%rsi), %r9d
movl 0x30(%rsi), %r8d
movl %r8d, %eax
imull %r9d, %eax
movl 0x34(%rsi), %r14d
movl 0x38(%rsi), %r11d
movl %... | /tpoisonooo[P]ncnn/src/layer/reshape.cpp |
ncnn::Reshape_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Reshape_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int elempack = bottom_blob.elempack;
if (permute == 1)
{
// TODO implement permute on-the-fly
Option opt_pack = opt;
opt_pack.blob_allocator = opt.workspace_allocator;
Mat bottom_blob... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
movq (%rdi), %rax
movq -0x18(%rax), %rcx
cmpl $0x1, 0xe0(%rdi,%rcx)
jne 0xde61d
movdqu (%r14), %xmm0
movdqu 0x10(%r14), %xmm1
movups 0x20(%r14), %x... | /tpoisonooo[P]ncnn/src/layer/x86/reshape_x86.cpp |
ncnn::Scale::load_model(ncnn::ModelBin const&) | int Scale::load_model(const ModelBin& mb)
{
if (scale_data_size == -233)
return 0;
scale_data = mb.load(scale_data_size, 1);
if (scale_data.empty())
return -100;
if (bias_term)
{
bias_data = mb.load(scale_data_size, 1);
if (bias_data.empty())
return -100... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl 0xd0(%rdi), %edx
xorl %ebp, %ebp
cmpl $0xffffff17, %edx # imm = 0xFFFFFF17
je 0xe16ef
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %r12
pushq $0x1
popq %rcx
movq %r12, %rdi
callq *0x10(%rax)
leaq 0xd8(%rbx), %r15
mov... | /tpoisonooo[P]ncnn/src/layer/scale.cpp |
ncnn::Scale::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Scale::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
std::vector<Mat> bottom_top_blobs(2);
bottom_top_blobs[0] = bottom_top_blob;
bottom_top_blobs[1] = scale_data;
return forward_inplace(bottom_top_blobs, opt);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r12
pushq $0x2
popq %rsi
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
callq 0xa0090
movq (%r12), %rdi
movq %r15, %rsi
callq 0x3fd2a
leaq 0xd8(%r14), %rsi
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
callq 0x... | /tpoisonooo[P]ncnn/src/layer/scale.cpp |
ncnn::Scale_x86::forward_inplace(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Scale_x86::forward_inplace(std::vector<Mat>& bottom_top_blobs, const Option& opt) const
{
Mat& bottom_top_blob = bottom_top_blobs[0];
const Mat& scale_blob = bottom_top_blobs[1];
int dims = bottom_top_blob.dims;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack == ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbp
movq (%rsi), %rbx
movl 0x28(%rbx), %eax
cmpl $0x4, 0x18(%rbx)
jne 0xe1b10
cmpl $0x3, %eax
je 0xe1c59
cmpl $0x2, %eax
je 0xe1bd7
cmpl $0x1, %eax
jne 0xe1e48
movl 0x2c(%rbx), %eax
movq 0x48(%rbx), %rcx
movq (%rbp), %rdx
mov... | /tpoisonooo[P]ncnn/src/layer/x86/scale_x86.cpp |
virtual thunk to ncnn::Scale_x86::forward_inplace(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Scale_x86::forward_inplace(std::vector<Mat>& bottom_top_blobs, const Option& opt) const
{
Mat& bottom_top_blob = bottom_top_blobs[0];
const Mat& scale_blob = bottom_top_blobs[1];
int dims = bottom_top_blob.dims;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack == ... | movq (%rdi), %rax
addq -0x50(%rax), %rdi
jmp 0xe1a80
nop
| /tpoisonooo[P]ncnn/src/layer/x86/scale_x86.cpp |
ncnn::Scale_x86_avx2::forward_inplace(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Scale_x86_avx2::forward_inplace(std::vector<Mat>& bottom_top_blobs, const Option& opt) const
{
Mat& bottom_top_blob = bottom_top_blobs[0];
const Mat& scale_blob = bottom_top_blobs[1];
int dims = bottom_top_blob.dims;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempac... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq (%rsi), %rbx
movl 0x18(%rbx), %ecx
movl 0x28(%rbx), %eax
cmpl $0x4, %ecx
je 0xe1f59
cmpl $0x8, %ecx
jne 0xe1fd4
cmpl $0x3, %eax
je 0xe21f8
cmpl $0x2, %eax
je 0xe20dc
cmpl $0x1, %eax
jne 0xe25c4
movl 0x2c(%rbx), ... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/scale_x86_avx2.cpp |
virtual thunk to ncnn::Scale_x86_avx2::forward_inplace(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Scale_x86_avx2::forward_inplace(std::vector<Mat>& bottom_top_blobs, const Option& opt) const
{
Mat& bottom_top_blob = bottom_top_blobs[0];
const Mat& scale_blob = bottom_top_blobs[1];
int dims = bottom_top_blob.dims;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempac... | movq (%rdi), %rax
addq -0x50(%rax), %rdi
jmp 0xe1eb0
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/scale_x86_avx2.cpp |
ncnn::Scale_x86_avx::forward_inplace(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Scale_x86_avx::forward_inplace(std::vector<Mat>& bottom_top_blobs, const Option& opt) const
{
Mat& bottom_top_blob = bottom_top_blobs[0];
const Mat& scale_blob = bottom_top_blobs[1];
int dims = bottom_top_blob.dims;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq (%rsi), %rbx
movl 0x18(%rbx), %ecx
movl 0x28(%rbx), %eax
cmpl $0x4, %ecx
je 0xe26d4
cmpl $0x8, %ecx
jne 0xe274e
cmpl $0x3, %eax
je 0xe296b
cmpl $0x2, %eax
je 0xe2851
cmpl $0x1, %eax
jne 0xe2d32
movl 0x2c(%rbx), ... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/scale_x86_avx.cpp |
virtual thunk to ncnn::Scale_x86_avx::forward_inplace(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Scale_x86_avx::forward_inplace(std::vector<Mat>& bottom_top_blobs, const Option& opt) const
{
Mat& bottom_top_blob = bottom_top_blobs[0];
const Mat& scale_blob = bottom_top_blobs[1];
int dims = bottom_top_blob.dims;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack... | movq (%rdi), %rax
addq -0x50(%rax), %rdi
jmp 0xe262c
nop
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/scale_x86_avx.cpp |
ncnn::Sigmoid::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Sigmoid::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
float* p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl 0x30(%rsi), %r12d
imull 0x2c(%rsi), %r12d
xorl %r14d, %r14d
testl %r12d, %r12d
cmovlel %r14d, %r12d
movq %rsi, 0x8(%rsp)
movl 0x38(%rsi), %ebp
testl %ebp, %ebp
cmovlel %r14d, %ebp
leaq 0x10(%rsp), %r15
cmpl %ebp, %r14d
je 0xe2e01
mo... | /tpoisonooo[P]ncnn/src/layer/sigmoid.cpp |
ncnn::Sigmoid_x86::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Sigmoid_x86::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack == 8)
{
#pragma ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl 0x30(%rsi), %r15d
movl 0x38(%rsi), %r12d
imull 0x2c(%rsi), %r15d
cmpl $0x4, 0x18(%rsi)
jne 0xe2fde
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
testl %r12d, %r12d
cmovlel %ebp, %r12d
movq %rsp, %r14
cmpl %r... | /tpoisonooo[P]ncnn/src/layer/x86/sigmoid_x86.cpp |
virtual thunk to ncnn::Sigmoid_x86::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Sigmoid_x86::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack == 8)
{
#pragma ... | pushq %rax
callq 0xe2e74
xorl %eax, %eax
popq %rcx
retq
nop
| /tpoisonooo[P]ncnn/src/layer/x86/sigmoid_x86.cpp |
void ncnn::qsort_descent_inplace<ncnn::BBoxRect>(std::vector<ncnn::BBoxRect, std::allocator<ncnn::BBoxRect>>&, std::vector<float, std::allocator<float>>&, int, int) | static void qsort_descent_inplace(std::vector<T>& datas, std::vector<float>& scores, int left, int right)
{
int i = left;
int j = right;
float p = scores[(left + right) / 2];
while (i <= j)
{
while (scores[i] > p)
i++;
while (scores[j] < p)
j--;
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rsi
pushq $0x2
popq %r12
movl %ebp, %r8d
leal (%r8,%rbx), %eax
cltd
idivl %r12d
cltq
movss (%rsi,%rax,4), %xmm0
movl %ebx, %r9d
movl %ebp, %eax
movl %r9d, %ecx
movl %eax,... | /tpoisonooo[P]ncnn/src/layer/detectionoutput.cpp |
ncnn::Interp::load_param(ncnn::ParamDict const&) | int Interp::load_param(const ParamDict& pd)
{
resize_type = pd.get(0, 0);
height_scale = pd.get(1, 1.f);
width_scale = pd.get(2, 1.f);
output_height = pd.get(3, 0);
output_width = pd.get(4, 0);
dynamic_target_size = pd.get(5, 0);
align_corner = pd.get(6, 0);
if (resize_type < 0 || resiz... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x49d20
movl %eax, 0xd0(%r14)
pushq $0x1
popq %rsi
movss 0x67e21(%rip), %xmm0 # 0x1cea88
movq %r15, %rdi
callq 0x49d3a
movss %xmm0, 0xd8(%r14)
pushq $0x2
popq %rsi
movq %r15, %rdi
mo... | /tpoisonooo[P]ncnn/src/layer/interp.cpp |
ncnn::Interp::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Interp::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const Mat& reference_blob = bottom_blobs[1];
Mat& top_blob = top_blobs[0];
int w = bottom_blob.w;
int h = bottom_blob.h;
int channels = bot... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rdi, %r14
movq (%rsi), %rsi
movq (%rdx), %r12
movl 0x2c(%rsi), %r10d
movl 0x30(%rsi), %ebx
movl 0x28(%rsi), %eax
movq 0x10(%rsi), %r8
movslq 0x74(%rsi), %r11
pushq $-0x64
popq %r15
cmpl $0x2, %eax
movq %rs... | /tpoisonooo[P]ncnn/src/layer/interp.cpp |
ncnn::DeconvolutionDepthWise::load_param(ncnn::ParamDict const&) | int DeconvolutionDepthWise::load_param(const ParamDict& pd)
{
num_output = pd.get(0, 0);
kernel_w = pd.get(1, 0);
kernel_h = pd.get(11, kernel_w);
dilation_w = pd.get(2, 1);
dilation_h = pd.get(12, dilation_w);
stride_w = pd.get(3, 1);
stride_h = pd.get(13, stride_w);
pad_left = pd.get(4... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x49d20
movl %eax, 0xd0(%rbx)
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x49d20
movl %eax, 0xd4(%rbx)
pushq $0xb
popq %rsi
movq %r14, %rdi
movl %eax, %... | /tpoisonooo[P]ncnn/src/layer/deconvolutiondepthwise.cpp |
ncnn::DeconvolutionDepthWise::load_model(ncnn::ModelBin const&) | int DeconvolutionDepthWise::load_model(const ModelBin& mb)
{
weight_data = mb.load(weight_data_size, 0);
if (weight_data.empty())
return -100;
if (bias_term)
{
bias_data = mb.load(num_output, 1);
if (bias_data.empty())
return -100;
}
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x110(%rdi), %edx
movq (%rsi), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x168(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x3fd2a
leaq 0x8(%rsp), %rdi
callq 0x3fd8e
... | /tpoisonooo[P]ncnn/src/layer/deconvolutiondepthwise.cpp |
ncnn::DeconvolutionDepthWise::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int DeconvolutionDepthWise::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// deconvolv with NxN kernel
// value = value + bias
int w = bottom_blob.w;
int h = bottom_blob.h;
int channels = bottom_blob.c;
size_t elemsize = bottom_blob.elemsize;
if (channels % grou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdx, %r8
movl 0x38(%rsi), %r10d
movl 0x114(%rdi), %r9d
movl %r10d, %eax
cltd
idivl %r9d
pushq $-0x64
popq %rbp
testl %edx, %edx
jne 0x168db1
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movl 0xd0(%rdi), %ecx... | /tpoisonooo[P]ncnn/src/layer/deconvolutiondepthwise.cpp |
ncnn::DeconvolutionDepthWise::cut_padding(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | void DeconvolutionDepthWise::cut_padding(const Mat& top_blob_bordered, Mat& top_blob, const Option& opt) const
{
if (pad_left > 0 || pad_right > 0 || pad_top > 0 || pad_bottom > 0)
{
copy_cut_border(top_blob_bordered, top_blob, pad_top, pad_bottom, pad_left, pad_right, opt);
}
else if (output_w ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl 0xec(%rdi), %r8d
movl 0xf0(%rdi), %r9d
testl %r8d, %r8d
setg %al
testl %r9d, %r9d
setg %dl
orb %al, %dl
jne 0x168e43
movl 0xf4(%rdi), %eax
testl %eax, %eax
jg 0x168e43
movl 0xf8(%rdi), %edx
testl %edx, %edx
jle 0x168e69
movl 0xf4(%rdi), %edx
movl 0x... | /tpoisonooo[P]ncnn/src/layer/deconvolutiondepthwise.cpp |
ncnn::ShuffleChannel::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ShuffleChannel::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int channels = bottom_blob.c;
size_t elemsize = bottom_blob.elemsize;
if (channels % group != 0)
{
// reject invalid group
return -100;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movl 0x38(%rsi), %r8d
movl 0xd0(%rdi), %esi
movl %r8d, %eax
cltd
idivl %esi
pushq $-0x64
popq %rbp
testl %edx, %edx
je 0x169008
movl %ebp, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq... | /tpoisonooo[P]ncnn/src/layer/shufflechannel.cpp |
ncnn::InstanceNorm::load_model(ncnn::ModelBin const&) | int InstanceNorm::load_model(const ModelBin& mb)
{
if (affine == 0)
return 0;
gamma_data = mb.load(channels, 1);
if (gamma_data.empty())
return -100;
beta_data = mb.load(channels, 1);
if (beta_data.empty())
return -100;
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorl %ebx, %ebx
cmpl $0x0, 0xd8(%rdi)
je 0x1692ef
movq %rsi, %r15
movq %rdi, %r14
movl 0xd0(%rdi), %edx
movq (%rsi), %rax
movq %rsp, %r13
pushq $0x1
popq %rcx
movq %r13, %rdi
callq *0x10(%rax)
leaq 0xe0(%r14), %r12
movq %r12, %rdi
movq %... | /tpoisonooo[P]ncnn/src/layer/instancenorm.cpp |
ncnn::InstanceNorm::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int InstanceNorm::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
// x = (x - mean) / (sqrt(var + eps)) * gamma + beta
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int c = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movl 0x30(%rsi), %r13d
movl 0x38(%rsi), %ebp
movq %rsi, 0x8(%rsp)
imull 0x2c(%rsi), %r13d
cvtsi2ss %r13d, %xmm0
xorl %r15d, %r15d
testl %r13d, %r13d
cmovlel %r15d, %r13d
testl %ebp, %ebp
cmovlel %r15d, %ebp
movss 0x65733(... | /tpoisonooo[P]ncnn/src/layer/instancenorm.cpp |
ncnn::Clip::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Clip::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
float* ptr ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movl 0x30(%rsi), %r13d
movl 0x38(%rsi), %ebp
movq %rsi, 0x8(%rsp)
imull 0x2c(%rsi), %r13d
xorl %r15d, %r15d
testl %r13d, %r13d
cmovlel %r15d, %r13d
testl %ebp, %ebp
cmovlel %r15d, %ebp
leaq 0x10(%rsp), %r12
cmpl %ebp, %r1... | /tpoisonooo[P]ncnn/src/layer/clip.cpp |
ncnn::Clip_x86::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Clip_x86::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack == 8)
{
#pragma omp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movl 0x30(%rsi), %r12d
movl 0x38(%rsi), %r13d
imull 0x2c(%rsi), %r12d
movq %rsi, 0x8(%rsp)
cmpl $0x4, 0x18(%rsi)
jne 0x1696c6
xorl %ebp, %ebp
testl %r12d, %r12d
cmovlel %ebp, %r12d
testl %r13d, %r13d
cmovlel %ebp, %r13d
l... | /tpoisonooo[P]ncnn/src/layer/x86/clip_x86.cpp |
virtual thunk to ncnn::Clip_x86::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Clip_x86::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack == 8)
{
#pragma omp... | pushq %rax
movq (%rdi), %rax
addq -0x58(%rax), %rdi
callq 0x169620
xorl %eax, %eax
popq %rcx
retq
nop
| /tpoisonooo[P]ncnn/src/layer/x86/clip_x86.cpp |
ncnn::Clip_x86_avx2::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Clip_x86_avx2::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack == 8)
{
#pragm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movl 0x18(%rsi), %eax
movl 0x30(%rsi), %r12d
movl 0x38(%rsi), %r13d
movq %rsi, 0x8(%rsp)
imull 0x2c(%rsi), %r12d
xorl %ebp, %ebp
cmpl $0x8, %eax
je 0x16985d
cmpl $0x4, %eax
jne 0x1698d3
testl %r12d, %r12d
cmovlel %ebp, %r... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/clip_x86_avx2.cpp |
virtual thunk to ncnn::Clip_x86_avx2::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Clip_x86_avx2::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack == 8)
{
#pragm... | pushq %rax
movq (%rdi), %rax
addq -0x58(%rax), %rdi
callq 0x1697b4
xorl %eax, %eax
popq %rcx
retq
nop
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/clip_x86_avx2.cpp |
ncnn::Clip_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Clip_x86_avx::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack == 8)
{
#pragma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movl 0x18(%rsi), %eax
movl 0x30(%rsi), %r12d
movl 0x38(%rsi), %r13d
movq %rsi, 0x8(%rsp)
imull 0x2c(%rsi), %r12d
xorl %ebp, %ebp
cmpl $0x8, %eax
je 0x169a69
cmpl $0x4, %eax
jne 0x169adf
testl %r12d, %r12d
cmovlel %ebp, %r... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/clip_x86_avx.cpp |
virtual thunk to ncnn::Clip_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Clip_x86_avx::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack == 8)
{
#pragma... | pushq %rax
movq (%rdi), %rax
addq -0x58(%rax), %rdi
callq 0x1699c0
xorl %eax, %eax
popq %rcx
retq
nop
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/clip_x86_avx.cpp |
ncnn::Reorg::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Reorg::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int channels = bottom_blob.c;
size_t elemsize = bottom_blob.elemsize;
int outw = w / stride;
int outh = h / stride;
int outc = channels * stride * stride;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r15
movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %r9d
movl 0x38(%rsi), %r10d
movq %rsi, 0x30(%rsp)
movq 0x10(%rsi), %r8
movq %rdi, 0x10(%rsp)
movl 0xd0(%rdi), %edi
cltd
idivl %edi
movl %eax, %ebp
movl %r9d, %eax
cltd
idivl %edi
mov... | /tpoisonooo[P]ncnn/src/layer/reorg.cpp |
ncnn::YoloDetectionOutput::forward_inplace(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int YoloDetectionOutput::forward_inplace(std::vector<Mat>& bottom_top_blobs, const Option& opt) const
{
// gather all box
std::vector<BBoxRect> all_bbox_rects;
std::vector<float> all_bbox_scores;
for (size_t b = 0; b < bottom_top_blobs.size(); b++)
{
Mat& bottom_top_blob = bottom_top_blobs[... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, 0xb0(%rsp)
movq %rdi, %rbp
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rax
andq $0x0, 0x10(%rax)
leaq 0x90(%rsp), %rcx
andq $0x0, 0x10(%rcx)
movaps %xmm0, (%rax)
movaps %xmm0, (%rcx)
pushq $0x48
popq %rcx
le... | /tpoisonooo[P]ncnn/src/layer/yolodetectionoutput.cpp |
void ncnn::qsort_descent_inplace<ncnn::BBoxRect>(std::vector<ncnn::BBoxRect, std::allocator<ncnn::BBoxRect>>&, std::vector<float, std::allocator<float>>&, int, int) | static void qsort_descent_inplace(std::vector<T>& datas, std::vector<float>& scores, int left, int right)
{
int i = left;
int j = right;
float p = scores[(left + right) / 2];
while (i <= j)
{
while (scores[i] > p)
i++;
while (scores[j] < p)
j--;
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rsi
pushq $0x2
popq %r12
movl %ebp, %r8d
leal (%r8,%rbx), %eax
cltd
idivl %r12d
cltq
movss (%rsi,%rax,4), %xmm0
movl %ebx, %r9d
movl %ebp, %eax
movl %r9d, %ecx
movl %eax,... | /tpoisonooo[P]ncnn/src/layer/yolodetectionoutput.cpp |
ncnn::Quantize::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Quantize::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int dims = bottom_blob.dims;
if (dims == 1)
{
int w = bottom_blob.w;
top_blob.create(w, (size_t)1u, opt.blob_allocator);
if (top_blob.empty())
return -100;
const float* ptr ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rsi, 0x18(%rsp)
movl 0x28(%rsi), %eax
cmpl $0x3, %eax
movq %rdi, 0x38(%rsp)
je 0x16ae2a
movq %rdi, %r12
cmpl $0x2, %eax
je 0x16ad09
movq $0x0, 0x10(%rsp)
cmpl $0x1, %eax
jne 0x16afba
movq 0x18(%rsp), %rax
movl 0x2c(... | /tpoisonooo[P]ncnn/src/layer/quantize.cpp |
ncnn::Dequantize::load_model(ncnn::ModelBin const&) | int Dequantize::load_model(const ModelBin& mb)
{
scale_data = mb.load(scale_data_size, 1);
if (scale_data.empty())
return -100;
if (bias_data_size)
{
bias_data = mb.load(bias_data_size, 1);
if (bias_data.empty())
return -100;
}
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0xd0(%rdi), %edx
movq (%rsi), %rax
leaq 0x8(%rsp), %r12
pushq $0x1
popq %rcx
movq %r12, %rdi
callq *0x10(%rax)
leaq 0xd8(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x3fd2a
leaq 0x8(%rsp), %rdi
callq 0x3fd... | /tpoisonooo[P]ncnn/src/layer/dequantize.cpp |
ncnn::Yolov3DetectionOutput::load_param(ncnn::ParamDict const&) | int Yolov3DetectionOutput::load_param(const ParamDict& pd)
{
num_class = pd.get(0, 20);
num_box = pd.get(1, 5);
confidence_threshold = pd.get(2, 0.01f);
nms_threshold = pd.get(3, 0.45f);
biases = pd.get(4, Mat());
mask = pd.get(5, Mat());
anchors_scale = pd.get(6, Mat());
return 0;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x14
popq %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x49d20
movl %eax, 0xd0(%rbx)
pushq $0x1
popq %rsi
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x49d20
movl %eax, 0xd4(%rbx)
pushq $0x2
popq %rsi
movss 0x5b9c2(%rip), %xmm0 # 0... | /tpoisonooo[P]ncnn/src/layer/yolov3detectionoutput.cpp |
virtual thunk to ncnn::Yolov3DetectionOutput_x86_avx2::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Yolov3DetectionOutput_x86_avx2::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
// gather all box
std::vector<BBoxRect> all_bbox_rects;
for (size_t b = 0; b < bottom_blobs.size(); b++)
{
std::vector<std::vector<BBoxRect> > all_box_bbox_r... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x176828
nop
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/yolov3detectionoutput_x86_avx2.cpp |
virtual thunk to ncnn::Yolov3DetectionOutput_x86_avx::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Yolov3DetectionOutput_x86_avx::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
// gather all box
std::vector<BBoxRect> all_bbox_rects;
for (size_t b = 0; b < bottom_blobs.size(); b++)
{
std::vector<std::vector<BBoxRect> > all_box_bbox_re... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x1771f8
nop
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/yolov3detectionoutput_x86_avx.cpp |
ncnn::ROIAlign_x86::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int ROIAlign_x86::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const int width = bottom_blob.w;
const int height = bottom_blob.h;
const size_t elemsize = bottom_blob.elemsize;
const int channels = bott... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdi, %r14
movq (%rsi), %rax
movl 0x2c(%rax), %ebp
movl 0x30(%rax), %r12d
movq 0x10(%rax), %r8
movq %rax, 0x60(%rsp)
movl 0x38(%rax), %r10d
movq (%rdx), %r15
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x... | /tpoisonooo[P]ncnn/src/layer/x86/roialign_x86.cpp |
virtual thunk to ncnn::ROIAlign_x86_avx::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int ROIAlign_x86_avx::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const int width = bottom_blob.w;
const int height = bottom_blob.h;
const size_t elemsize = bottom_blob.elemsize;
const int channels = ... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x17a040
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/roialign_x86_avx.cpp |
ncnn::Packing_x86_avx::forward_int8(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Packing_x86_avx::forward_int8(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
if (use_padding)
{
return Packing::forward(bottom_blob, top_blob, opt);
}
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.elempack;
if (elempack == out_elempack)
{... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r11
movq %rsi, %r14
movq %rdi, %r13
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
cmpl $0x0, 0xd4(%r13,%rax)
je 0x180645
movq %r14, %rsi
movq %r11, %rdx
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq... | /tpoisonooo[P]ncnn/build_O2/src/layer/x86/packing_x86_avx.cpp |
ncnn::Requantize::load_param(ncnn::ParamDict const&) | int Requantize::load_param(const ParamDict& pd)
{
// scale_in = pd.get(0, 1.f); // bottom_blob_scale * weight_scale
// scale_out = pd.get(1, 1.f); // top_blob_scale
// bias_term = pd.get(2, 0);
// bias_data_size = pd.get(3, 0);
scale_in_data_size = pd.get(0, 1);
scale_out_data_... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rbp
movq %rsi, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x49d20
movl %eax, 0xd0(%rbx)
movq %r14, %rdi
movl %ebp, %esi
movl %ebp, %edx
callq 0x49d20
movl %eax, 0xd4(%rbx)
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %... | /tpoisonooo[P]ncnn/src/layer/requantize.cpp |
ncnn::Requantize::load_model(ncnn::ModelBin const&) | int Requantize::load_model(const ModelBin& mb)
{
scale_in_data = mb.load(scale_in_data_size, 1);
if (scale_in_data.empty())
return -100;
scale_out_data = mb.load(scale_out_data_size, 1);
if (scale_out_data.empty())
return -100;
if (bias_data_size)
{
bias_data = mb.load(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0xd0(%rdi), %edx
movq (%rsi), %rax
leaq 0x8(%rsp), %r12
pushq $0x1
popq %rcx
movq %r12, %rdi
callq *0x10(%rax)
leaq 0x128(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x3fd2a
leaq 0x8(%rsp), %rdi
callq 0x3f... | /tpoisonooo[P]ncnn/src/layer/requantize.cpp |
ncnn::Requantize::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Requantize::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int dims = bottom_blob.dims;
if (dims == 1)
{
int w = bottom_blob.w;
top_blob.create(w, (size_t)1u, opt.blob_allocator);
if (top_blob.empty())
return -100;
const int* intp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r12
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movl 0x28(%rsi), %edx
pushq $-0x64
popq %r14
cmpl $0x3, %edx
movq %r12, 0x20(%rsp)
je 0x18155f
cmpl $0x2, %edx
je 0x1813ed
xorl %eax, %eax
cmpl $0x1, %edx
jne 0x181e63
movq 0x10(%rsp)... | /tpoisonooo[P]ncnn/src/layer/requantize.cpp |
ncnn::Cast::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Cast::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
if (type_from == type_to)
{
top_blob = bottom_blob;
return 0;
}
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_blob.c;
int dims = bottom_blob.d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movl 0xd4(%rdi), %edx
cmpl %edx, 0xd0(%rdi)
jne 0x1b6185
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3fd2a
movq $0x0, 0x10(%rsp)
jmp 0x1b6624
movq %rcx, %rax
movq %rdi, %r12
movl 0x28(%rbx), %ecx
movslq 0x18(%... | /tpoisonooo[P]ncnn/src/layer/cast.cpp |
ncnn::HardSigmoid_x86::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int HardSigmoid_x86::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack == 8)
{
#pra... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movl 0x30(%rsi), %r12d
movl 0x38(%rsi), %r13d
imull 0x2c(%rsi), %r12d
xorl %r15d, %r15d
testl %r12d, %r12d
cmovlel %r15d, %r12d
testl %r13d, %r13d
cmovlel %r15d, %r13d
movq %rsi, 0x8(%rsp)
cmpl $0x4, 0x18(%rsi)
jne 0x1b70... | /tpoisonooo[P]ncnn/src/layer/x86/hardsigmoid_x86.cpp |
ncnn::Swish::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Swish::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
float* ptr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl 0x30(%rsi), %r12d
imull 0x2c(%rsi), %r12d
xorl %r14d, %r14d
testl %r12d, %r12d
cmovlel %r14d, %r12d
movq %rsi, 0x8(%rsp)
movl 0x38(%rsi), %ebp
testl %ebp, %ebp
cmovlel %r14d, %ebp
leaq 0x20(%rsp), %r15
cmpl %ebp, %r14d
je 0x1ba7b3
m... | /tpoisonooo[P]ncnn/src/layer/swish.cpp |
virtual thunk to ncnn::Swish_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Swish_x86_avx::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#if __SSE2__
int elempack = bottom_top_blob.elempack;
#if __AVX__
if (elempack == 8)
{
#pragm... | pushq %rax
callq 0x1bb164
xorl %eax, %eax
popq %rcx
retq
nop
| /tpoisonooo[P]ncnn/build_O2/src/layer/x86/swish_x86_avx.cpp |
ncnn::LayerNorm::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LayerNorm::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
// x = (x - mean) / sqrt(var + eps) * gamma + beta
int dims = bottom_top_blob.dims;
if (dims == 2)
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
// assert affine_size == w
#pragma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x28(%rsi), %eax
cmpl $0x3, %eax
je 0x1bc3de
cmpl $0x2, %eax
jne 0x1bc521
movslq 0x2c(%r14), %rax
movl 0x30(%r14), %ecx
cvtsi2ss %eax, %xmm1
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %ea... | /tpoisonooo[P]ncnn/src/layer/layernorm.cpp |
ncnn::MultiHeadAttention::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int MultiHeadAttention::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& q_blob = bottom_blobs[0];
const Mat& k_blob = bottom_blobs.size() == 1 ? q_blob : bottom_blobs[1];
const Mat& v_blob = bottom_blobs.size() == 1 ? q_blob : bottom_blobs[2];... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rdx, %r8
movq (%rsi), %rbp
movq 0x8(%rsi), %rax
subq %rbp, %rax
xorl %edx, %edx
cmpq $0x48, %rax
pushq $0x48
popq %rax
cmoveq %rdx, %rax
movq %rax, 0xa8(%rsp)
movl $0x90, %r14d
cmoveq %rdx, %r14
movl 0x30(... | /tpoisonooo[P]ncnn/src/layer/multiheadattention.cpp |
ncnn::Convolution1D::load_model(ncnn::ModelBin const&) | int Convolution1D::load_model(const ModelBin& mb)
{
if (dynamic_weight)
return 0;
weight_data = mb.load(weight_data_size, 0);
if (weight_data.empty())
return -100;
if (bias_term)
{
bias_data = mb.load(num_output, 1);
if (bias_data.empty())
return -100;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
xorl %ebp, %ebp
cmpl $0x0, 0x140(%rdi)
je 0x1be98e
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movq %rdi, %rbx
movl 0xf0(%rdi), %edx
movq (%rsi), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
... | /tpoisonooo[P]ncnn/src/layer/convolution1d.cpp |
ncnn::Convolution1D::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Convolution1D::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
Mat bottom_blob_bordered;
make_padding(bottom_blob, bottom_blob_bordered, opt);
if (bottom_blob_bordered.empty())
return -100;
const int w = bottom_blob_bordered.w;
const size_t elemsize = bottom_bl... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %rdx
andq $0x0, 0x40(%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movups %xmm0, 0xc(%rdx)
movaps %xmm0, 0x20(%rdx)
movups %xmm0, 0x2c(%rdx)
callq 0x1beb7e
pushq $-0x64
popq %rbp
cmpq $0x0, (%rsp)
je ... | /tpoisonooo[P]ncnn/src/layer/convolution1d.cpp |
ncnn::convolution1d(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, int, int, int, int, ncnn::Mat const&, ncnn::Option const&) | static int convolution1d(const Mat& bottom_blob, Mat& top_blob, const Mat& weight_data, const Mat& bias_data, int kernel_w, int stride_w, int dilation_w, int activation_type, const Mat& activation_params, const Option& opt)
{
const int h = bottom_blob.h;
const int outw = top_blob.w;
const int outh = top_bl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x40(%rsp)
movl 0xd8(%rsp), %r10d
movl 0xd0(%rsp), %eax
movl 0x30(%rdi), %r11d
movslq 0x2c(%rsi), %rbx
movl 0x30(%rsi), %r14d
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
testq %rdx, %rdx
je 0x1bebdd
movslq 0x38(%rcx), %rdx
imulq 0... | /tpoisonooo[P]ncnn/src/layer/convolution1d.cpp |
ncnn::Convolution1D::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Convolution1D::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const Mat& _weight_data = bottom_blobs[1];
Mat& top_blob = top_blobs[0];
const int _kernel_w = _weight_data.w;
const int _num_output = _... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rbp
leaq 0x48(%rbp), %rdi
movq (%rdx), %rax
movq %rax, 0x8(%rsp)
movl 0x74(%rbp), %r14d
movl 0x80(%rbp), %eax
movl %eax, 0x4(%rsp)
leaq 0xb0(%rsp), %rsi
andq $0x0, 0x40(%rsi)
... | /tpoisonooo[P]ncnn/src/layer/convolution1d.cpp |
virtual thunk to ncnn::Convolution1D_x86::create_pipeline(ncnn::Option const&) | int Convolution1D_x86::create_pipeline(const Option& opt)
{
if (dynamic_weight)
return 0;
int num_input = weight_data_size / kernel_w / num_output;
int elempack = 1;
int out_elempack = 1;
#if __SSE2__
if (opt.use_packing_layout)
{
#if __AVX__
elempack = num_input % 8 == 0 ? 8 ... | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0x1bf318
xorl %eax, %eax
popq %rcx
retq
nop
| /tpoisonooo[P]ncnn/src/layer/x86/convolution1d_x86.cpp |
virtual thunk to ncnn::Convolution1D_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Convolution1D_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.elempack;
const int kernel_extent_w = dilation_w * (kernel_w - 1) + 1;
Mat bottom_bl... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0x1bf5e2
| /tpoisonooo[P]ncnn/src/layer/x86/convolution1d_x86.cpp |
ncnn::ConvolutionDepthWise1D::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise1D::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
Mat bottom_blob_bordered;
make_padding(bottom_blob, bottom_blob_bordered, opt);
if (bottom_blob_bordered.empty())
return -100;
const int w = bottom_blob_bordered.w;
const size_t elemsize = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %rdx
andq $0x0, 0x40(%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movups %xmm0, 0xc(%rdx)
movaps %xmm0, 0x20(%rdx)
movups %xmm0, 0x2c(%rdx)
callq 0x1c8976
pushq $-0x64
popq... | /tpoisonooo[P]ncnn/src/layer/convolutiondepthwise1d.cpp |
ncnn::get_cpu_thread_affinity_mask(int) | const CpuSet& get_cpu_thread_affinity_mask(int powersave)
{
setup_thread_affinity_masks();
if (powersave == 0)
return g_thread_affinity_mask_all;
if (powersave == 1)
return g_thread_affinity_mask_little;
if (powersave == 2)
return g_thread_affinity_mask_big;
NCNN_LOGE("po... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movl %edi, 0xc(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x57806(%rip) # 0x2242c8
movups %xmm0, 0x577ef(%rip) # 0x2242b8
movups %xmm0, 0x577d8(%rip) # 0x2242a8
movups %xmm0, 0x577c1(%rip) # 0x224298
mov... | /tpoisonooo[P]ncnn/src/cpu.cpp |
Coverage_mathCnWithNamespaceViolations_Test::TestBody() | TEST(Coverage, parserBranchesCMetaIdCellml2)
{
libcellml::ParserPtr parser = libcellml::Parser::create();
auto model = parser->parseModel(fileContents("coverage/cmeta_id_cellml2.xml"));
EXPECT_EQ(size_t(0), model->unitsCount());
EXPECT_EQ(size_t(0), model->componentCount());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x153b7(%rip), %rsi # 0x25a3e
leaq 0x155f3(%rip), %rdx # 0x25c81
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x21b06
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x1, %esi
callq 0xdd10
movq (%r14), %rsi
leaq 0x50(... | /cellml[P]libcellml/tests/coverage/coverage.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.