name string | code string | asm string | file string |
|---|---|---|---|
ncnn::im2col_sgemm_pack8to1_int8_sse_xop(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | void im2col_sgemm_pack8to1_int8_sse_xop(const Mat& bottom_im2col, Mat& top_blob, const Mat& kernel, const Option& opt)
{
im2col_sgemm_pack8to1_int8_sse(bottom_im2col, top_blob, kernel, opt);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rax
movq %rdx, 0x10(%rsp)
movq %rdi, %r12
movslq 0x2c(%rdi), %r13
movl 0x30(%rdi), %ebx
movl 0x38(%rdi), %r15d
movq %rsi, 0x28(%rsp)
movslq 0x38(%rsi), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
andq $0x0, 0x40(%rdi)
mo... | /csukuangfj[P]ncnn/src/layer/x86/convolution_x86_xop.cpp |
ncnn::crop_pack4_sse(ncnn::Mat const&, ncnn::Mat&, int, int) | static void crop_pack4_sse(const Mat& src, Mat& dst, int top, int left)
{
int w = dst.w;
int h = dst.h;
int right = src.w - dst.w - left;
const float* ptr = src.row(top) + left * 4;
float* outptr = dst;
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
... | movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %r8d
movslq 0x2c(%rdi), %r9
movslq %edx, %rdx
imulq %r9, %rdx
subl %eax, %r9d
imulq 0x10(%rdi), %rdx
addq (%rdi), %rdx
shll $0x2, %ecx
movslq %ecx, %rcx
leaq (%rdx,%rcx,4), %rcx
movq (%rsi), %rdx
shll $0x2, %r9d
movslq %r9d, %rsi
xorl %edi, %edi
testl %eax, %eax
cmovlel %edi, %eax... | /csukuangfj[P]ncnn/src/layer/x86/crop_x86.cpp |
ncnn::Deconvolution_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Deconvolution_x86::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;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.elempack;
// NCNN_LOGE(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rdx, 0x160(%rsp)
movq %rdi, %r15
movq (%rdi), %rdi
movq -0x18(%rdi), %rax
movl 0xd4(%r15,%rax), %edx
decl %edx
imull 0xdc(%r15,%rax), %edx
movl %edx, 0x144(%rsp)
movl 0x2c(%rsi), %r13d
leal -0x1(%r13), %r1... | /csukuangfj[P]ncnn/src/layer/x86/deconvolution_x86.cpp |
virtual thunk to ncnn::Deconvolution_x86_avx::create_pipeline(ncnn::Option const&) | int Deconvolution_x86_avx::create_pipeline(const Option& opt)
{
activation = create_activation_layer(activation_type, activation_params, opt);
const int maxk = kernel_w * kernel_h;
int num_input = weight_data_size / maxk / num_output;
int elempack = 1;
int out_elempack = 1;
#if __SSE2__
if (op... | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0x164cde
xorl %eax, %eax
popq %rcx
retq
nop
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/deconvolution_x86_avx.cpp |
ncnn::Deconvolution_x86_avx::destroy_pipeline(ncnn::Option const&) | int Deconvolution_x86_avx::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
if (gemm)
{
gemm->destroy_pipeline(opt);
delete gemm;
gemm = 0;
}
return 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x165840
movq (%rdi), %rax
movq %r14, %rsi
callq *0x28(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x16583b
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x165... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/deconvolution_x86_avx.cpp |
ncnn::InnerProduct_x86::create_pipeline_int8_x86(ncnn::Option const&) | int InnerProduct_x86::create_pipeline_int8_x86(const Option& opt)
{
const int num_input = weight_data_size / num_output;
int out_elempack = 1;
#if __SSE2__
if (opt.use_packing_layout)
{
out_elempack = num_output % 8 == 0 ? 8 : 1;
}
#endif // __SSE2__
// src = inch-outch
// dst = pb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rax
leaq 0x130(%rdi,%rax), %rsi
movl -0x60(%rsi), %ecx
movl -0x58(%rsi), %eax
cltd
idivl %ecx
movl %eax, %r15d
testb $0x7, %cl
sete %bpl
andb 0x27(%rbx), %bpl
pushq $0x... | /csukuangfj[P]ncnn/src/layer/x86/innerproduct_x86.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 0x77e84
leaq 0x2a7e68(%rip), %rax # 0x4836d0
movq %rax, (%rbx)
movb $0x1, %al
movb %al, 0xf(%rbx)
movb %al, 0xc(%rbx)
movl $0x1010101, 0x8(%rbx) # imm = 0x1010101
popq %rbx
retq
| /csukuangfj[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 $0x18, %rsp
movq %rsi, %r13
movq %rdi, %rbx
movl 0x30(%rsi), %r15d
movl 0x38(%rsi), %r12d
imull 0x2c(%rsi), %r15d
movss 0xd0(%rdi), %xmm0
movss 0x21584b(%rip), %xmm1 # 0x3f11f0
ucomiss %xmm0, %xmm1
jne 0x1dba13
movq (%r13), %r14
movq 0x40(%r13), %... | /csukuangfj[P]ncnn/src/layer/log.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
movq %rsi, %rbp
movl 0x2c(%rsi), %esi
movl 0x30(%rbp), %ecx
movl 0x38(%rbp), %r13d
movq 0x10(%rbp), %r15
leaq 0x90(%rsp), %rax
andq $0x0, 0x40(%rax)
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm... | /csukuangfj[P]ncnn/src/layer/lrn.cpp |
virtual thunk to ncnn::LRN_x86::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN_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;
size_t elemsize = bottom_top_blob.elemsize;
int size = w * h;
// squared values with local_size padding
Mat square_blob;
... | movq (%rdi), %rax
addq -0x58(%rax), %rdi
jmp 0x1dc3b0
| /csukuangfj[P]ncnn/src/layer/x86/lrn_x86.cpp |
ncnn::LRN_x86_avx512::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN_x86_avx512::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_blo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rsi, %r15
movl 0x2c(%rsi), %esi
movl 0x30(%r15), %ecx
movl 0x38(%r15), %r12d
movq 0x10(%r15), %r13
leaq 0x90(%rsp), %rax
andq $0x0, 0x40(%rax)
movq %rdx, %r14
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmo... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/lrn_x86_avx512.cpp |
virtual thunk to ncnn::LRN_x86_avx512::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN_x86_avx512::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_blo... | movq (%rdi), %rax
addq -0x58(%rax), %rdi
jmp 0x1dcc74
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/lrn_x86_avx512.cpp |
ncnn::LRN_x86_fma::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN_x86_fma::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
movq %rsi, %r15
movl 0x2c(%rsi), %esi
movl 0x30(%r15), %ecx
movl 0x38(%r15), %r12d
movq 0x10(%r15), %r13
leaq 0x90(%rsp), %rax
andq $0x0, 0x40(%rax)
movq %rdx, %r14
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmo... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/lrn_x86_fma.cpp |
virtual thunk to ncnn::LRN_x86_fma::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN_x86_fma::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;
... | movq (%rdi), %rax
addq -0x58(%rax), %rdi
jmp 0x1dd838
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/lrn_x86_fma.cpp |
ncnn::MemoryData::load_model(ncnn::ModelBin const&) | int MemoryData::load_model(const ModelBin& mb)
{
if (d != 0)
{
data = mb.load(w, h, d, c, 1);
}
else if (c != 0)
{
data = mb.load(w, h, c, 1);
}
else if (h != 0)
{
data = mb.load(w, h, 1);
}
else if (w != 0)
{
data = mb.load(w, 1);
}
el... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movl 0xd8(%rdi), %r8d
testl %r8d, %r8d
je 0x1df233
movl 0xd0(%rbx), %edx
movl 0xd4(%rbx), %ecx
movl 0xdc(%rbx), %r9d
movq (%rsi), %rax
movl $0x1, (%rsp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq *0x28(%rax)
leaq 0xe0(%rbx), %rcx
movq 0x8(%r14), %rax
cmpq %r14, %r... | /csukuangfj[P]ncnn/src/layer/memorydata.cpp |
ncnn::MVN::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int MVN::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 size = w * h;
top_blob.create(w, h, channels, elemsize, opt.blob_allocator);
if (top_blo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
movl 0x2c(%rsi), %ebp
movl 0x30(%rsi), %r15d
movl 0x38(%rsi), %r13d
movq 0x10(%rsi), %rbx
movq %rcx, 0x10(%rsp)
movq 0x8(%rcx), %r9
movq %rdx, %rdi
movl %ebp, %esi
movl %r15d, %edx
mov... | /csukuangfj[P]ncnn/src/layer/mvn.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 0x718a6
movl %eax, 0xd0(%rbx)
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x718a6
movl %eax, 0xd4(%rbx)
pushq $0xb
popq %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x718a6... | /csukuangfj[P]ncnn/src/layer/pooling.cpp |
ncnn::Pooling_x86_fma::create_pipeline(ncnn::Option const&) | int Pooling_x86_fma::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;
}
return 0;
} | movq (%rdi), %rax
movq -0x18(%rax), %rcx
cmpl $0x0, 0x100(%rdi,%rcx)
je 0x1e431f
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), %rax
movb %dl, 0x10(%rdi,%rax)
xorl ... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/pooling_x86_fma.cpp |
ncnn::binary_op_broadcast_inner(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, int, ncnn::Option const&) | static int binary_op_broadcast_inner(const Mat& a, const Mat& b, Mat& c, int op_type, const Option& opt)
{
// squeeze inner axes
Mat b2 = b;
if (b.dims == 2 && b.w == 1)
b2 = b.reshape(b.h);
else if (b.dims == 3 && b.h == 1)
b2 = b.reshape(b.c);
else if (b.dims == 3 && b.w == 1)
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x1a0, %rsp # imm = 0x1A0
movl %ecx, %r13d
movq %rdx, 0x48(%rsp)
movq %rdi, 0x20(%rsp)
movq (%rsi), %rbx
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rax
movq %rax, 0x78(%rsp)
movq 0x20(%rsi), %rax
movq %rax, ... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/binaryop_x86_fma.cpp |
virtual thunk to ncnn::BinaryOp_x86_fma::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int BinaryOp_x86_fma::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const bool b_is_scalar = bottom_blobs[1].w * bottom_blobs[1].h * bottom_blobs[1].d * bottom_blobs[1].c * bottom_blobs[1].elempack == 1;
const bool a_rank_is_lower = bottom_blobs[0].dims < ... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x25fe94
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/binaryop_x86_fma.cpp |
ncnn::BinaryOp_x86_fma::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BinaryOp_x86_fma::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
using namespace BinaryOp_x86_fma_functor;
if (op_type == Operation_ADD) return binary_op_scalar_inplace<binary_op_add>(bottom_top_blob, b, opt);
if (op_type == Operation_SUB) return binary_op_scalar_inplace<binary_op_sub... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0xe0, %rsp
movq (%rdi), %rax
movq -0x18(%rax), %rdx
movl 0xd0(%rdi,%rdx), %eax
cmpq $0xb, %rax
ja 0x26c8c4
movq %rsi, %r14
leaq 0x18b6f8(%rip), %rcx # 0x3f749c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
movq %rs... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/binaryop_x86_fma.cpp |
virtual thunk to ncnn::BinaryOp_x86_fma::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BinaryOp_x86_fma::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
using namespace BinaryOp_x86_fma_functor;
if (op_type == Operation_ADD) return binary_op_scalar_inplace<binary_op_add>(bottom_top_blob, b, opt);
if (op_type == Operation_SUB) return binary_op_scalar_inplace<binary_op_sub... | pushq %rax
movq (%rdi), %rax
addq -0x58(%rax), %rdi
callq 0x26bd6a
xorl %eax, %eax
popq %rcx
retq
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/binaryop_x86_fma.cpp |
int ncnn::binary_op_no_broadcast<ncnn::BinaryOp_x86_fma_functor::binary_op_sub>(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | static int binary_op_no_broadcast(const Mat& a, const Mat& b, Mat& c, const Option& opt)
{
Op op;
const int channels = a.c;
const int size = a.w * a.h * a.d * a.elempack;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const float* ptr = a.cha... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl 0x30(%rdi), %eax
movl 0x38(%rdi), %ecx
imull 0x2c(%rdi), %eax
imull 0x34(%rdi), %eax
imull 0x18(%rdi), %eax
xorl %r8d, %r8d
testl %ecx, %ecx
cmovlel %r8d, %ecx
cmpq %rcx, %r8
je 0x26c9bc
movq 0x10(%rsi), %r9
imulq 0x40(%rsi), %r9
movq 0x10(%rdi), %r10
imulq %r8, %r9
addq... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/binaryop_x86_fma.cpp |
int ncnn::binary_op_no_broadcast<ncnn::BinaryOp_x86_fma_functor::binary_op_div>(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | static int binary_op_no_broadcast(const Mat& a, const Mat& b, Mat& c, const Option& opt)
{
Op op;
const int channels = a.c;
const int size = a.w * a.h * a.d * a.elempack;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const float* ptr = a.cha... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl 0x30(%rdi), %eax
movl 0x38(%rdi), %ecx
imull 0x2c(%rdi), %eax
imull 0x34(%rdi), %eax
imull 0x18(%rdi), %eax
xorl %r8d, %r8d
testl %ecx, %ecx
cmovlel %r8d, %ecx
cmpq %rcx, %r8
je 0x26cabd
movq 0x10(%rsi), %r9
imulq 0x40(%rsi), %r9
movq 0x10(%rdi), %r10
imulq %r8, %r9
addq... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/binaryop_x86_fma.cpp |
ncnn::UnaryOp_x86_fma::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int UnaryOp_x86_fma::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
using namespace UnaryOp_x86_fma_functor;
if (op_type == Operation_ABS)
return unary_op_inplace<unary_op_abs>(bottom_top_blob, opt);
if (op_type == Operation_NEG)
return unary_op_inplace<unary_op_neg>(botto... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x80, %rsp
movq %rsi, 0x18(%rsp)
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0xd0(%rdi,%rax), %eax
cmpq $0x11, %rax
ja 0x281716
leaq 0x177d68(%rip), %rcx # 0x3f8348
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
j... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/unaryop_x86_fma.cpp |
ncnn::UnaryOp_x86_fma_functor::unary_op_exp::func_pack8(float vector[8] const&) const | static NCNN_FORCEINLINE __m256 exp256_ps(__m256 x)
{
__m256 tmp = _mm256_setzero_ps(), fx;
__m256i imm0;
__m256 one = *(__m256*)_ps256_1;
x = _mm256_min_ps(x, *(__m256*)_ps256_exp_hi);
x = _mm256_max_ps(x, *(__m256*)_ps256_exp_lo);
/* express exp(x) as exp(g + n*log(2)) */
fx = _mm256_comp... | vbroadcastss 0x16fa73(%rip), %ymm0 # 0x3f11b8
vminps (%rsi), %ymm0, %ymm0
vbroadcastss 0x16fa6a(%rip), %ymm1 # 0x3f11bc
vmaxps %ymm1, %ymm0, %ymm1
vbroadcastss 0x16c8b5(%rip), %ymm0 # 0x3ee014
vbroadcastss 0x16fa58(%rip), %ymm2 # 0x3f11c0
vfmadd213ps %ymm0, %ymm1, %ymm2 # ymm2 = (ymm1 * ymm2) + ymm0
vroundps $0x1, %ymm... | /csukuangfj[P]ncnn/src/layer/x86/avx_mathfun.h |
ncnn::UnaryOp_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int UnaryOp_x86_avx::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
using namespace UnaryOp_x86_avx_functor;
if (op_type == Operation_ABS)
return unary_op_inplace<unary_op_abs>(bottom_top_blob, opt);
if (op_type == Operation_NEG)
return unary_op_inplace<unary_op_neg>(botto... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x80, %rsp
movq %rsi, 0x18(%rsp)
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0xd0(%rdi,%rax), %eax
cmpq $0x11, %rax
ja 0x283f35
leaq 0x1755e4(%rip), %rcx # 0x3f83c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
j... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/unaryop_x86_avx.cpp |
ncnn::UnaryOp_x86_avx_functor::unary_op_exp::func_pack8(float vector[8] const&) const | static NCNN_FORCEINLINE __m256 exp256_ps(__m256 x)
{
__m256 tmp = _mm256_setzero_ps(), fx;
__m256i imm0;
__m256 one = *(__m256*)_ps256_1;
x = _mm256_min_ps(x, *(__m256*)_ps256_exp_hi);
x = _mm256_max_ps(x, *(__m256*)_ps256_exp_lo);
/* express exp(x) as exp(g + n*log(2)) */
fx = _mm256_comp... | vbroadcastss 0x16d253(%rip), %ymm0 # 0x3f11b8
vminps (%rsi), %ymm0, %ymm0
vbroadcastss 0x16d24a(%rip), %ymm1 # 0x3f11bc
vmaxps %ymm1, %ymm0, %ymm0
vbroadcastss 0x16d241(%rip), %ymm1 # 0x3f11c0
vmulps %ymm1, %ymm0, %ymm1
vbroadcastss 0x16a088(%rip), %ymm2 # 0x3ee014
vaddps %ymm2, %ymm1, %ymm1
vroundps $0x1, %ymm1, %ymm3... | /csukuangfj[P]ncnn/src/layer/x86/avx_mathfun.h |
ncnn::UnaryOp_x86_avx_functor::unary_op_cos::func_pack8(float vector[8] const&) const | static NCNN_FORCEINLINE __m256 cos256_ps(__m256 x)
{ // any x
__m256 xmm1, xmm2 = _mm256_setzero_ps(), xmm3, y;
__m256i imm0, imm2;
#ifndef __AVX2__
__m128i imm0_1, imm0_2;
__m128i imm2_1, imm2_2;
#endif
/* take the absolute value */
x = _mm256_and_ps(x, *(__m256*)_ps256_inv_sign_mask);
... | vbroadcastss 0x16d2fd(%rip), %ymm0 # 0x3f1900
vandps (%rsi), %ymm0, %ymm2
vbroadcastss 0x173240(%rip), %ymm0 # 0x3f7850
vmulps %ymm0, %ymm2, %ymm0
vcvttps2dq %ymm0, %ymm0
vpcmpeqd %xmm1, %xmm1, %xmm1
vpsubd %xmm1, %xmm0, %xmm3
vextractf128 $0x1, %ymm0, %xmm0
vpsubd %xmm1, %xmm0, %xmm0
vmovddup 0x173d7e(%rip), %xmm1 #... | /csukuangfj[P]ncnn/src/layer/x86/avx_mathfun.h |
ncnn::UnaryOp_x86_avx_functor::unary_op_log10::func_pack8(float vector[8] const&) const | static NCNN_FORCEINLINE __m256 log256_ps(__m256 x)
{
__m256i imm0;
__m256 one = *(__m256*)_ps256_1;
//__m256 invalid_mask = _mm256_cmple_ps(x, _mm256_setzero_ps());
__m256 invalid_mask = _mm256_cmp_ps(x, _mm256_setzero_ps(), _CMP_LE_OS);
x = _mm256_max_ps(x, *(__m256*)_ps256_min_norm_pos); /* cut ... | vbroadcastss 0x16bdc3(%rip), %ymm0 # 0x3f11e0
vmaxps (%rsi), %ymm0, %ymm0
vpsrld $0x17, %xmm0, %xmm1
vextractf128 $0x1, %ymm0, %xmm2
vpsrld $0x17, %xmm2, %xmm2
vbroadcastss 0x16bdaa(%rip), %ymm3 # 0x3f11e4
vandps %ymm3, %ymm0, %ymm0
vbroadcastss 0x168bcd(%rip), %ymm3 # 0x3ee014
vorps %ymm3, %ymm0, %ymm0
vbroadcastss 0x... | /csukuangfj[P]ncnn/src/layer/x86/avx_mathfun.h |
ncnn::ConvolutionDepthWise::load_model(ncnn::ModelBin const&) | int ConvolutionDepthWise::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 ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
cmpl $0x0, 0x160(%rdi)
je 0x285b4c
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsi, %r15
movq %rdi, %rbx
movl 0x104(%rdi), %edx
movq (%rsi), %rax
leaq 0x10(%rsp), %r14
movq %r14, ... | /csukuangfj[P]ncnn/src/layer/convolutiondepthwise.cpp |
ncnn::ConvolutionDepthWise::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// convolv with NxN kernel
// value = value + bias
#if NCNN_INT8
if (opt.use_int8_inference && weight_data.elemsize == (size_t)1u)
{
return forward_int8(bottom_blob, top_blob, opt);
}
#endif
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, %r14
cmpb $0x1, 0x1e(%rcx)
jne 0x286fbf
cmpq $0x1, 0x178(%r14)
jne 0x286fbf
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
pop... | /csukuangfj[P]ncnn/src/layer/convolutiondepthwise.cpp |
ncnn::ConvolutionDepthWise::forward_int8(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise::forward_int8(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// convolv 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 % gro... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rcx, %r14
movq %rdx, %r8
movl 0x38(%rsi), %ebp
movl 0x108(%rdi), %ecx
movl %ebp, %eax
cltd
idivl %ecx
pushq $-0x64
popq %rbx
testl %edx, %edx
jne 0x2871a9
movl 0xd0(%rdi), %eax
cltd
idivl %ecx
testl %edx, ... | /csukuangfj[P]ncnn/src/layer/convolutiondepthwise.cpp |
ncnn::convolutiondepthwise(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, int, int, int, int, int, int, int, int, ncnn::Mat const&, ncnn::Option const&) | static int convolutiondepthwise(const Mat& bottom_blob, Mat& top_blob, const Mat& weight_data, const Mat& bias_data, int kernel_w, int kernel_h, int stride_w, int stride_h, int dilation_w, int dilation_h, int group, int activation_type, const Mat& activation_params, const Option& opt)
{
const int w = bottom_blob.w;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %r9d, %ebp
movl %r8d, %r15d
movq %rdx, 0xa0(%rsp)
movq %rsi, 0x58(%rsp)
movl 0x170(%rsp), %ebx
movq %rdi, 0x28(%rsp)
movl 0x2c(%rdi), %r12d
cmpq $0x0, (%rcx)
movq %rcx, 0xa8(%rsp)
je 0x287e14
movslq 0x38(%r... | /csukuangfj[P]ncnn/src/layer/convolutiondepthwise.cpp |
ncnn::ConvolutionDepthWise_x86::create_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86::create_pipeline(const Option& opt)
{
if (dynamic_weight)
return 0;
activation = create_activation_layer(activation_type, activation_params, opt);
#if NCNN_INT8
if (opt.use_int8_inference && weight_data.elemsize == (size_t)1u)
{
return create_pipeline_int8_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq (%rdi), %rax
movq -0x18(%rax), %r13
cmpl $0x0, 0x160(%rdi,%r13)
je 0x288dd5
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsi, %r14
movq %rdi, %rbx
movl 0x110(%rdi,%r13), %ecx
decl %ecx
cmpl $0x5... | /csukuangfj[P]ncnn/src/layer/x86/convolutiondepthwise_x86.cpp |
ncnn::ConvolutionDepthWise_x86::create_pipeline_int8_x86(ncnn::Option const&) | int ConvolutionDepthWise_x86::create_pipeline_int8_x86(const Option& opt)
{
const int maxk = kernel_w * kernel_h;
int channels = (weight_data_size / group) / maxk / (num_output / group) * group;
// depth-wise
if (channels == group && group == num_output)
{
int elempack = 1;
#if __SSE2__
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %r14
movl 0xd8(%rdi,%r14), %r8d
imull 0xd4(%rdi,%r14), %r8d
movl 0xd0(%rdi,%r14), %esi
movl 0x104(%rdi,%r14), %eax
movl 0x108(%rdi,%r14), %ecx
cltd
idivl %ecx
cltd
idivl %r8d
movl %eax, %edi
... | /csukuangfj[P]ncnn/src/layer/x86/convolutiondepthwise_x86.cpp |
ncnn::ConvolutionDepthWise_x86::create_group_ops(ncnn::Option const&) | int ConvolutionDepthWise_x86::create_group_ops(const Option& opt)
{
// create Convolution op for each group
const int maxk = kernel_w * kernel_h;
int channels = (weight_data_size / group) / maxk / (num_output / group) * group;
for (int i = 0; i < (int)group_ops.size(); i++)
delete group_ops[i];... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rsi, 0x250(%rsp)
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rdx
movl 0xd0(%rdi,%rdx), %ecx
movl 0xd8(%rdi,%rdx), %ebp
imull 0xd4(%rdi,%rdx), %ebp
movl 0x104(%rdi,%rdx), %eax
movl 0x108(%rdi,%rdx)... | /csukuangfj[P]ncnn/src/layer/x86/convolutiondepthwise_x86.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86::create_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86::create_pipeline(const Option& opt)
{
if (dynamic_weight)
return 0;
activation = create_activation_layer(activation_type, activation_params, opt);
#if NCNN_INT8
if (opt.use_int8_inference && weight_data.elemsize == (size_t)1u)
{
return create_pipeline_int8_... | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0x288da6
xorl %eax, %eax
popq %rcx
retq
nop
| /csukuangfj[P]ncnn/src/layer/x86/convolutiondepthwise_x86.cpp |
ncnn::ConvolutionDepthWise_x86::destroy_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
for (int i = 0; i < (int)group_ops.size(); i++)
{
group_ops[i]->destroy_pipeline(opt);
delete group_o... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x28a54b
movq (%rdi), %rax
movq %r14, %rsi
callq *0x28(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x28a546
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rbx)
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq 0x... | /csukuangfj[P]ncnn/src/layer/x86/convolutiondepthwise_x86.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86::destroy_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
for (int i = 0; i < (int)group_ops.size(); i++)
{
group_ops[i]->destroy_pipeline(opt);
delete group_o... | pushq %rax
movq (%rdi), %rax
addq -0x38(%rax), %rdi
callq 0x28a51a
xorl %eax, %eax
popq %rcx
retq
nop
| /csukuangfj[P]ncnn/src/layer/x86/convolutiondepthwise_x86.cpp |
ncnn::ConvolutionDepthWise_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
#if NCNN_INT8
if (opt.use_int8_inference && int8_scale_term)
{
return forward_int8_x86(bottom_blob, top_blob, opt);
}
#endif
int w = bottom_blob.w;
int h = bottom_blob.h;
int channels... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %rcx, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rcx
cmpb $0x1, 0x1e(%r14)
jne 0x28a5f5
cmpl $0x0, 0x10c(%rdi,%rcx)
je 0x28a5f5
movq %r14, %rcx
addq $0x2c8, %rsp # imm = 0x2C8
popq %rbx
popq %r12
... | /csukuangfj[P]ncnn/src/layer/x86/convolutiondepthwise_x86.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
#if NCNN_INT8
if (opt.use_int8_inference && int8_scale_term)
{
return forward_int8_x86(bottom_blob, top_blob, opt);
}
#endif
int w = bottom_blob.w;
int h = bottom_blob.h;
int channels... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0x28a5b0
| /csukuangfj[P]ncnn/src/layer/x86/convolutiondepthwise_x86.cpp |
ncnn::ConvolutionDepthWise_x86::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int ConvolutionDepthWise_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 _ker... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %rbp
movq %rdi, %r13
movq (%rsi), %r14
leaq 0x48(%r14), %rdi
movq (%rdx), %rax
movq %rax, 0xb8(%rsp)
movl 0x60(%r14), %ebx
movl 0x74(%r14), %eax
movl %eax, 0x1c(%rsp)
movl 0x78(%r14), %eax
movl %eax, ... | /csukuangfj[P]ncnn/src/layer/x86/convolutiondepthwise_x86.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int ConvolutionDepthWise_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 _ker... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x28febe
| /csukuangfj[P]ncnn/src/layer/x86/convolutiondepthwise_x86.cpp |
ncnn::ConvolutionDepthWise_x86_avx512::create_group_ops(ncnn::Option const&) | int ConvolutionDepthWise_x86_avx512::create_group_ops(const Option& opt)
{
// create Convolution op for each group
const int maxk = kernel_w * kernel_h;
int channels = (weight_data_size / group) / maxk / (num_output / group) * group;
for (int i = 0; i < (int)group_ops.size(); i++)
delete group_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rsi, 0x250(%rsp)
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rdx
movl 0xd0(%rdi,%rdx), %ecx
movl 0xd8(%rdi,%rdx), %ebp
imull 0xd4(%rdi,%rdx), %ebp
movl 0x104(%rdi,%rdx), %eax
movl 0x108(%rdi,%rdx)... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx512.cpp |
ncnn::ConvolutionDepthWise_x86_avx512::destroy_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86_avx512::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
for (int i = 0; i < (int)group_ops.size(); i++)
{
group_ops[i]->destroy_pipeline(opt);
delete ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x292071
movq (%rdi), %rax
movq %r14, %rsi
callq *0x28(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x29206c
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rbx)
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq 0x... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx512.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86_avx512::destroy_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86_avx512::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
for (int i = 0; i < (int)group_ops.size(); i++)
{
group_ops[i]->destroy_pipeline(opt);
delete ... | pushq %rax
movq (%rdi), %rax
addq -0x38(%rax), %rdi
callq 0x292040
xorl %eax, %eax
popq %rcx
retq
nop
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx512.cpp |
ncnn::ConvolutionDepthWise_x86_avx512::forward_int8_x86(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise_x86_avx512::forward_int8_x86(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;
int elempack = bottom_blob.elempack;
int elembits = bottom_blob.elembits();
const int kernel_exten... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x318, %rsp # imm = 0x318
movq %rcx, 0x30(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r15
movl 0x38(%rsi), %ecx
movl 0x18(%rsi), %r12d
movq 0x10(%rsi), %rsi
testl %r12d, %r12d
je 0x2975b9
leal (,%rsi,8), %eax
cltd
idivl %r12d
cmpl $0x8, %eax... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx512.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86_avx512::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise_x86_avx512::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
#if NCNN_INT8
if (opt.use_int8_inference && int8_scale_term)
{
return forward_int8_x86(bottom_blob, top_blob, opt);
}
#endif
int w = bottom_blob.w;
int h = bottom_blob.h;
int c... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0x2920d6
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx512.cpp |
ncnn::ConvolutionDepthWise_x86_avx512::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int ConvolutionDepthWise_x86_avx512::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 i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %rbp
movq %rdi, %r13
movq (%rsi), %r14
leaq 0x48(%r14), %rdi
movq (%rdx), %rax
movq %rax, 0xb8(%rsp)
movl 0x60(%r14), %ebx
movl 0x74(%r14), %eax
movl %eax, 0x1c(%rsp)
movl 0x78(%r14), %eax
movl %eax, ... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx512.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86_avx512::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int ConvolutionDepthWise_x86_avx512::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 i... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x299cb8
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx512.cpp |
ncnn::ConvolutionDepthWise_x86_fma::create_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86_fma::create_pipeline(const Option& opt)
{
if (dynamic_weight)
return 0;
activation = create_activation_layer(activation_type, activation_params, opt);
#if NCNN_INT8
if (opt.use_int8_inference && weight_data.elemsize == (size_t)1u)
{
return create_pipeline_i... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq (%rdi), %rax
movq -0x18(%rax), %r13
cmpl $0x0, 0x160(%rdi,%r13)
je 0x29a51d
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsi, %r14
movq %rdi, %rbx
movl 0x110(%rdi,%r13), %ecx
decl %ecx
cmpl $0x5... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_fma.cpp |
ncnn::ConvolutionDepthWise_x86_fma::create_group_ops(ncnn::Option const&) | int ConvolutionDepthWise_x86_fma::create_group_ops(const Option& opt)
{
// create Convolution op for each group
const int maxk = kernel_w * kernel_h;
int channels = (weight_data_size / group) / maxk / (num_output / group) * group;
for (int i = 0; i < (int)group_ops.size(); i++)
delete group_ops... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rsi, 0x250(%rsp)
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rdx
movl 0xd0(%rdi,%rdx), %ecx
movl 0xd8(%rdi,%rdx), %ebp
imull 0xd4(%rdi,%rdx), %ebp
movl 0x104(%rdi,%rdx), %eax
movl 0x108(%rdi,%rdx)... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_fma.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86_fma::create_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86_fma::create_pipeline(const Option& opt)
{
if (dynamic_weight)
return 0;
activation = create_activation_layer(activation_type, activation_params, opt);
#if NCNN_INT8
if (opt.use_int8_inference && weight_data.elemsize == (size_t)1u)
{
return create_pipeline_i... | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0x29a4ee
xorl %eax, %eax
popq %rcx
retq
nop
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_fma.cpp |
ncnn::ConvolutionDepthWise_x86_fma::destroy_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86_fma::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
for (int i = 0; i < (int)group_ops.size(); i++)
{
group_ops[i]->destroy_pipeline(opt);
delete gro... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x29bd9d
movq (%rdi), %rax
movq %r14, %rsi
callq *0x28(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x29bd98
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rbx)
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq 0x... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_fma.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86_fma::destroy_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86_fma::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
for (int i = 0; i < (int)group_ops.size(); i++)
{
group_ops[i]->destroy_pipeline(opt);
delete gro... | pushq %rax
movq (%rdi), %rax
addq -0x38(%rax), %rdi
callq 0x29bd6c
xorl %eax, %eax
popq %rcx
retq
nop
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_fma.cpp |
ncnn::ConvolutionDepthWise_x86_fma::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise_x86_fma::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
#if NCNN_INT8
if (opt.use_int8_inference && int8_scale_term)
{
return forward_int8_x86(bottom_blob, top_blob, opt);
}
#endif
int w = bottom_blob.w;
int h = bottom_blob.h;
int chan... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rdi
movq %rcx, 0x58(%rsp)
cmpb $0x1, 0x1e(%rcx)
jne 0x29be51
cmpl $0x0, 0x10c(%r14,%rdi)
je 0x29be51
movq %r14, %rdi
movq 0x58(%rsp), %rcx
addq $0x2e8, %rsp ... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_fma.cpp |
ncnn::ConvolutionDepthWise_x86_fma::forward_int8_x86(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise_x86_fma::forward_int8_x86(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;
int elempack = bottom_blob.elempack;
int elembits = bottom_blob.elembits();
const int kernel_extent_w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x318, %rsp # imm = 0x318
movq %rcx, 0x30(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r15
movl 0x38(%rsi), %ecx
movl 0x18(%rsi), %r12d
movq 0x10(%rsi), %rsi
testl %r12d, %r12d
je 0x29ffd3
leal (,%rsi,8), %eax
cltd
idivl %r12d
cmpl $0x8, %eax... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_fma.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86_fma::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise_x86_fma::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
#if NCNN_INT8
if (opt.use_int8_inference && int8_scale_term)
{
return forward_int8_x86(bottom_blob, top_blob, opt);
}
#endif
int w = bottom_blob.w;
int h = bottom_blob.h;
int chan... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0x29be02
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_fma.cpp |
ncnn::ConvolutionDepthWise_x86_fma::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int ConvolutionDepthWise_x86_fma::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 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %rbp
movq %rdi, %r13
movq (%rsi), %r14
leaq 0x48(%r14), %rdi
movq (%rdx), %rax
movq %rax, 0xb8(%rsp)
movl 0x60(%r14), %ebx
movl 0x74(%r14), %eax
movl %eax, 0x1c(%rsp)
movl 0x78(%r14), %eax
movl %eax, ... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_fma.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86_fma::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int ConvolutionDepthWise_x86_fma::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 ... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x2a2888
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_fma.cpp |
ncnn::ConvolutionDepthWise_x86_avx::create_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86_avx::create_pipeline(const Option& opt)
{
if (dynamic_weight)
return 0;
activation = create_activation_layer(activation_type, activation_params, opt);
#if NCNN_INT8
if (opt.use_int8_inference && weight_data.elemsize == (size_t)1u)
{
return create_pipeline_i... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq (%rdi), %rax
movq -0x18(%rax), %r13
cmpl $0x0, 0x160(%rdi,%r13)
je 0x2a30ed
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsi, %r14
movq %rdi, %rbx
movl 0x110(%rdi,%r13), %ecx
decl %ecx
cmpl $0x5... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx.cpp |
ncnn::ConvolutionDepthWise_x86_avx::create_pipeline_int8_x86(ncnn::Option const&) | int ConvolutionDepthWise_x86_avx::create_pipeline_int8_x86(const Option& opt)
{
const int maxk = kernel_w * kernel_h;
int channels = (weight_data_size / group) / maxk / (num_output / group) * group;
// depth-wise
if (channels == group && group == num_output)
{
int elempack = 1;
#if __SSE2__... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %r14
movl 0xd8(%rdi,%r14), %r8d
imull 0xd4(%rdi,%r14), %r8d
movl 0xd0(%rdi,%r14), %esi
movl 0x104(%rdi,%r14), %eax
movl 0x108(%rdi,%r14), %ecx
cltd
idivl %ecx
cltd
idivl %r8d
movl %eax, %edi
... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx.cpp |
ncnn::ConvolutionDepthWise_x86_avx::create_group_ops(ncnn::Option const&) | int ConvolutionDepthWise_x86_avx::create_group_ops(const Option& opt)
{
// create Convolution op for each group
const int maxk = kernel_w * kernel_h;
int channels = (weight_data_size / group) / maxk / (num_output / group) * group;
for (int i = 0; i < (int)group_ops.size(); i++)
delete group_ops... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rsi, 0x250(%rsp)
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rdx
movl 0xd0(%rdi,%rdx), %ecx
movl 0xd8(%rdi,%rdx), %ebp
imull 0xd4(%rdi,%rdx), %ebp
movl 0x104(%rdi,%rdx), %eax
movl 0x108(%rdi,%rdx)... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86_avx::create_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86_avx::create_pipeline(const Option& opt)
{
if (dynamic_weight)
return 0;
activation = create_activation_layer(activation_type, activation_params, opt);
#if NCNN_INT8
if (opt.use_int8_inference && weight_data.elemsize == (size_t)1u)
{
return create_pipeline_i... | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0x2a30be
xorl %eax, %eax
popq %rcx
retq
nop
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx.cpp |
ncnn::ConvolutionDepthWise_x86_avx::destroy_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86_avx::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
for (int i = 0; i < (int)group_ops.size(); i++)
{
group_ops[i]->destroy_pipeline(opt);
delete gro... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2a496d
movq (%rdi), %rax
movq %r14, %rsi
callq *0x28(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2a4968
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rbx)
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq 0x... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86_avx::destroy_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86_avx::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
for (int i = 0; i < (int)group_ops.size(); i++)
{
group_ops[i]->destroy_pipeline(opt);
delete gro... | pushq %rax
movq (%rdi), %rax
addq -0x38(%rax), %rdi
callq 0x2a493c
xorl %eax, %eax
popq %rcx
retq
nop
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx.cpp |
ncnn::ConvolutionDepthWise_x86_avx::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise_x86_avx::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
#if NCNN_INT8
if (opt.use_int8_inference && int8_scale_term)
{
return forward_int8_x86(bottom_blob, top_blob, opt);
}
#endif
int w = bottom_blob.w;
int h = bottom_blob.h;
int chan... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3b8, %rsp # imm = 0x3B8
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rdi
movq %rcx, 0x48(%rsp)
cmpb $0x1, 0x1e(%rcx)
jne 0x2a4a21
cmpl $0x0, 0x10c(%r14,%rdi)
je 0x2a4a21
movq %r14, %rdi
movq 0x48(%rsp), %rcx
addq $0x3b8, %rsp ... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx.cpp |
ncnn::ConvolutionDepthWise_x86_avx::forward_int8_x86(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise_x86_avx::forward_int8_x86(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;
int elempack = bottom_blob.elempack;
int elembits = bottom_blob.elembits();
const int kernel_extent_w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x318, %rsp # imm = 0x318
movq %rcx, 0x30(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r15
movl 0x38(%rsi), %ecx
movl 0x18(%rsi), %r12d
movq 0x10(%rsi), %rsi
testl %r12d, %r12d
je 0x2a9903
leal (,%rsi,8), %eax
cltd
idivl %r12d
cmpl $0x8, %eax... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86_avx::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int ConvolutionDepthWise_x86_avx::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
#if NCNN_INT8
if (opt.use_int8_inference && int8_scale_term)
{
return forward_int8_x86(bottom_blob, top_blob, opt);
}
#endif
int w = bottom_blob.w;
int h = bottom_blob.h;
int chan... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0x2a49d2
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx.cpp |
ncnn::ConvolutionDepthWise_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 ConvolutionDepthWise_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 Mat& _weight_data = bottom_blobs[1];
Mat& top_blob = top_blobs[0];
const int _kernel_w = _weight_data.w;
const int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %rbp
movq %rdi, %r13
movq (%rsi), %r14
leaq 0x48(%r14), %rdi
movq (%rdx), %rax
movq %rax, 0xb8(%rsp)
movl 0x60(%r14), %ebx
movl 0x74(%r14), %eax
movl %eax, 0x1c(%rsp)
movl 0x78(%r14), %eax
movl %eax, ... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_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 ConvolutionDepthWise_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 Mat& _weight_data = bottom_blobs[1];
Mat& top_blob = top_blobs[0];
const int _kernel_w = _weight_data.w;
const int ... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x2ac246
nop
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolutiondepthwise_x86_avx.cpp |
ncnn::Padding::load_param(ncnn::ParamDict const&) | int Padding::load_param(const ParamDict& pd)
{
top = pd.get(0, 0);
bottom = pd.get(1, 0);
left = pd.get(2, 0);
right = pd.get(3, 0);
type = pd.get(4, 0);
value = pd.get(5, 0.f);
per_channel_pad_data_size = pd.get(6, 0);
front = pd.get(7, 0);
behind = pd.get(8, 0);
return 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x718a6
movl %eax, 0xd0(%rbx)
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x718a6
movl %eax, 0xd4(%rbx)
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x718a6
movl %eax, 0xd8... | /csukuangfj[P]ncnn/src/layer/padding.cpp |
ncnn::Padding::load_model(ncnn::ModelBin const&) | int Padding::load_model(const ModelBin& mb)
{
if (per_channel_pad_data_size)
{
per_channel_pad_data = mb.load(per_channel_pad_data_size, 1);
}
return 0;
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movl 0xf0(%rdi), %edx
testl %edx, %edx
je 0x2acbe2
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsp, %r14
pushq $0x1
popq %rcx
movq %r14, %rdi
callq *0x10(%rax)
leaq 0xf8(%rbx), %rcx
movq 0x8(%r14), %rax
cmpq %r14, %rcx
je 0x2acbba
testq %rax, %rax
je 0x2acb2b
lock
incl (%rax)
movq 0x1... | /csukuangfj[P]ncnn/src/layer/padding.cpp |
ncnn::Padding::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Padding::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
if (top == 0 && bottom == 0 && left == 0 && right == 0 && front == 0 && behind == 0)
{
top_blob = bottom_blob;
return 0;
}
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rcx, 0x20(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movl 0xd0(%rdi), %eax
movl 0xd4(%rdi), %edx
testl %eax, %eax
sete %cl
testl %edx, %edx
sete %sil
movq 0xd8(%rdi), %xmm1
movq %rdi, 0x8(%rsp)
movq 0xe8(%rdi),... | /csukuangfj[P]ncnn/src/layer/padding.cpp |
void ncnn::copy_make_border_image<signed char>(ncnn::Mat const&, ncnn::Mat&, int, int, int, signed char) | static void copy_make_border_image(const Mat& src, Mat& dst, int top, int left, int type, T v)
{
int w = dst.w;
int h = dst.h;
const T* ptr = src;
T* outptr = dst;
if (type == 0)
{
int y = 0;
// fill top
for (; y < top; y++)
{
int x = 0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r13d
movl %ecx, %r9d
movq %rdi, %r14
movslq 0x2c(%rsi), %r12
movl 0x30(%rsi), %eax
movl %eax, 0x2c(%rsp)
movq (%rdi), %r15
movq (%rsi), %rbp
movslq %ecx, %rax
movq %rax, (%rsp)
testl %r8d, %r8d
movl %ecx, 0xc(%rsp)
movl %edx,... | /csukuangfj[P]ncnn/src/layer/padding.cpp |
void ncnn::copy_make_border_image<unsigned short>(ncnn::Mat const&, ncnn::Mat&, int, int, int, unsigned short) | static void copy_make_border_image(const Mat& src, Mat& dst, int top, int left, int type, T v)
{
int w = dst.w;
int h = dst.h;
const T* ptr = src;
T* outptr = dst;
if (type == 0)
{
int y = 0;
// fill top
for (; y < top; y++)
{
int x = 0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movslq 0x2c(%rsi), %rbx
movl 0x30(%rsi), %eax
movl %eax, 0x4c(%rsp)
movq (%rdi), %r12
movq (%rsi), %rbp
movq %rcx, 0x28(%rsp)
movslq %ecx, %rax
movq %rax, 0x18(%rsp)
testl %r8d, %r8d
movq %rdi, 0x40(%rsp)
movl %edx, 0xc(%rsp)
jne 0x2ae0d... | /csukuangfj[P]ncnn/src/layer/padding.cpp |
void ncnn::copy_make_border_image<float>(ncnn::Mat const&, ncnn::Mat&, int, int, int, float) | static void copy_make_border_image(const Mat& src, Mat& dst, int top, int left, int type, T v)
{
int w = dst.w;
int h = dst.h;
const T* ptr = src;
T* outptr = dst;
if (type == 0)
{
int y = 0;
// fill top
for (; y < top; y++)
{
int x = 0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movslq 0x2c(%rsi), %rbx
movl 0x30(%rsi), %eax
movl %eax, 0x4c(%rsp)
movq (%rdi), %r12
movq (%rsi), %rbp
movq %rcx, 0x30(%rsp)
movslq %ecx, %rax
movq %rax, 0x18(%rsp)
testl %r8d, %r8d
movq %rdi, 0x40(%rsp)
movl %edx, 0xc(%rsp)
jne 0x2ae81... | /csukuangfj[P]ncnn/src/layer/padding.cpp |
ncnn::Padding_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Padding_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
if (top == 0 && bottom == 0 && left == 0 && right == 0 && front == 0 && behind == 0)
{
top_blob = bottom_blob;
return 0;
}
int elembits = bottom_blob.elembits();
if (elembits == 8)
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rcx
movq (%rdi), %rax
movq -0x18(%rax), %rbp
movq %rdi, (%rsp)
movl 0xd0(%rdi,%rbp), %r10d
testl %r10d, %r10d
movq %rsi, 0x8(%rsp)
jne 0x2aeef1
movq (%rsp), %rax
cmpl $0x0, 0xd4(%rax,%rbp)
jne ... | /csukuangfj[P]ncnn/src/layer/x86/padding_x86.cpp |
ncnn::Padding_x86::forward_int8(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Padding_x86::forward_int8(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_blob.c;
int dims = bottom_blob.dims;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r13
movl 0x2c(%rsi), %esi
movl 0x30(%rax), %edx
movl 0x34(%rax), %ecx
movl %ecx, 0x18(%rsp)
movl 0x38(%rax), %ebp
movq 0x10(%rax), %r9
movl 0x18(%rax),... | /csukuangfj[P]ncnn/src/layer/x86/padding_x86.cpp |
virtual thunk to ncnn::Padding_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Padding_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
if (top == 0 && bottom == 0 && left == 0 && right == 0 && front == 0 && behind == 0)
{
top_blob = bottom_blob;
return 0;
}
int elembits = bottom_blob.elembits();
if (elembits == 8)
re... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0x2aee70
| /csukuangfj[P]ncnn/src/layer/x86/padding_x86.cpp |
ncnn::padding_constant_pack8_int8_sse(ncnn::Mat const&, ncnn::Mat&, int, int, int, int, long) | static void padding_constant_pack8_int8_sse(const Mat& src, Mat& dst, int top, int bottom, int left, int right, int64_t _v)
{
const int64_t* ptr = src;
int64_t* outptr = dst;
// fill top
for (int y = 0; y < top; y++)
{
for (int x = 0; x < dst.w; x++)
{
*outptr++ = _v;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x30(%rsp), %rax
movq (%rdi), %r11
movl 0x2c(%rsi), %ebx
xorl %ebp, %ebp
testl %ebx, %ebx
cmovlel %ebp, %ebx
movq (%rsi), %r10
testl %edx, %edx
cmovlel %ebp, %edx
cmpl %edx, %ebp
je 0x2b0cfa
movl %ebx, %r14d
subl $0x1, %r14d
jb 0x2b0cf6
movq %rax, (%r10)
addq ... | /csukuangfj[P]ncnn/src/layer/x86/padding_pack8_int8.h |
ncnn::Padding_x86_avx512::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Padding_x86_avx512::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
if (top == 0 && bottom == 0 && left == 0 && right == 0 && front == 0 && behind == 0)
{
top_blob = bottom_blob;
return 0;
}
int elembits = bottom_blob.elembits();
if (elembits == 8)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rcx, %rbp
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rax
leaq (%rdi,%rax), %r11
movq %rdi, 0x10(%rsp)
movl 0xd0(%rdi,%rax), %r10d
testl %r10d, %r10d
jne 0x2b0e4f
cmpl $0x0, 0... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/padding_x86_avx512.cpp |
ncnn::Padding_x86_avx512::forward_int8(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Padding_x86_avx512::forward_int8(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_blob.c;
int dims = bottom_blob.dims;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r14
movl 0x38(%rsi), %r15d
movq 0x10(%rsi), %r9
movl 0x18(%rsi), %edi
movq %rsi, 0x28(%rsp)
vmovdqu 0x28(%rsi), %xmm0
cmpl $0x8, %edi
jne 0x2b42dc
vmovd %xmm0, %eax
de... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/padding_x86_avx512.cpp |
virtual thunk to ncnn::Padding_x86_avx512::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Padding_x86_avx512::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
if (top == 0 && bottom == 0 && left == 0 && right == 0 && front == 0 && behind == 0)
{
top_blob = bottom_blob;
return 0;
}
int elembits = bottom_blob.elembits();
if (elembits == 8)
... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0x2b0de0
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/padding_x86_avx512.cpp |
ncnn::padding_constant_pack8_int8_sse(ncnn::Mat const&, ncnn::Mat&, int, int, int, int, long) | static void padding_constant_pack8_int8_sse(const Mat& src, Mat& dst, int top, int bottom, int left, int right, int64_t _v)
{
const int64_t* ptr = src;
int64_t* outptr = dst;
// fill top
for (int y = 0; y < top; y++)
{
for (int x = 0; x < dst.w; x++)
{
*outptr++ = _v;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x30(%rsp), %rax
movq (%rdi), %r11
movl 0x2c(%rsi), %ebx
xorl %ebp, %ebp
testl %ebx, %ebx
cmovlel %ebp, %ebx
movq (%rsi), %r10
testl %edx, %edx
cmovlel %ebp, %edx
cmpl %edx, %ebp
je 0x2b471c
movl %ebx, %r14d
subl $0x1, %r14d
jb 0x2b4718
movq %rax, (%r10)
addq ... | /csukuangfj[P]ncnn/src/layer/x86/padding_pack8_int8.h |
ncnn::Padding_x86_fma::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Padding_x86_fma::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
if (top == 0 && bottom == 0 && left == 0 && right == 0 && front == 0 && behind == 0)
{
top_blob = bottom_blob;
return 0;
}
int elembits = bottom_blob.elembits();
if (elembits == 8)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %rbp
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %r11
movl 0xd0(%rdi,%r11), %r10d
testl %r10d, %r10d
jne 0x2b486b
cmpl $0x0, 0xd4(%rdi,%r11)
jne 0x2b486b
cmpl $0x0, 0xd8(%rdi,%r11)
jne 0x2b486b
cmp... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/padding_x86_fma.cpp |
ncnn::Padding_x86_fma::forward_int8(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Padding_x86_fma::forward_int8(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_blob.c;
int dims = bottom_blob.dims;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_bl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r14
movl 0x38(%rsi), %r15d
movq 0x10(%rsi), %r9
movl 0x18(%rsi), %edi
movq %rsi, 0x28(%rsp)
vmovdqu 0x28(%rsi), %xmm0
cmpl $0x8, %edi
jne 0x2b70ac
vmovd %xmm0, %eax
de... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/padding_x86_fma.cpp |
virtual thunk to ncnn::Padding_x86_fma::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Padding_x86_fma::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
if (top == 0 && bottom == 0 && left == 0 && right == 0 && front == 0 && behind == 0)
{
top_blob = bottom_blob;
return 0;
}
int elembits = bottom_blob.elembits();
if (elembits == 8)
... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0x2b4800
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/padding_x86_fma.cpp |
ncnn::padding_constant_pack8_int8_sse(ncnn::Mat const&, ncnn::Mat&, int, int, int, int, long) | static void padding_constant_pack8_int8_sse(const Mat& src, Mat& dst, int top, int bottom, int left, int right, int64_t _v)
{
const int64_t* ptr = src;
int64_t* outptr = dst;
// fill top
for (int y = 0; y < top; y++)
{
for (int x = 0; x < dst.w; x++)
{
*outptr++ = _v;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x30(%rsp), %rax
movq (%rdi), %r11
movl 0x2c(%rsi), %ebx
xorl %ebp, %ebp
testl %ebx, %ebx
cmovlel %ebp, %ebx
movq (%rsi), %r10
testl %edx, %edx
cmovlel %ebp, %edx
cmpl %edx, %ebp
je 0x2b744a
movl %ebx, %r14d
subl $0x1, %r14d
jb 0x2b7446
movq %rax, (%r10)
addq ... | /csukuangfj[P]ncnn/src/layer/x86/padding_pack8_int8.h |
ncnn::ExpandDims::load_param(ncnn::ParamDict const&) | int ExpandDims::load_param(const ParamDict& pd)
{
expand_w = pd.get(0, 0);
expand_h = pd.get(1, 0);
expand_d = pd.get(11, 0);
expand_c = pd.get(2, 0);
axes = pd.get(3, Mat());
return 0;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x718a6
movl %eax, 0xd0(%rbx)
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x718a6
movl %eax, 0xd4(%rbx)
pushq $0xb
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x718a... | /csukuangfj[P]ncnn/src/layer/expanddims.cpp |
ncnn::PriorBox::load_param(ncnn::ParamDict const&) | int PriorBox::load_param(const ParamDict& pd)
{
min_sizes = pd.get(0, Mat());
max_sizes = pd.get(1, Mat());
aspect_ratios = pd.get(2, Mat());
variances[0] = pd.get(3, 0.1f);
variances[1] = pd.get(4, 0.1f);
variances[2] = pd.get(5, 0.2f);
variances[3] = pd.get(6, 0.2f);
flip = pd.get(7, 1... | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %rcx
andq $0x0, 0x40(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movups %xmm0, 0xc(%rcx)
movaps %xmm0, 0x20(%rcx)
movups %xmm0, 0x2c(%rcx)
movq %rsp, %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x718da
leaq 0xd0(%rbx), %... | /csukuangfj[P]ncnn/src/layer/priorbox.cpp |
ncnn::DetectionOutput::load_param(ncnn::ParamDict const&) | int DetectionOutput::load_param(const ParamDict& pd)
{
num_class = pd.get(0, 0);
nms_threshold = pd.get(1, 0.05f);
nms_top_k = pd.get(2, 300);
keep_top_k = pd.get(3, 100);
confidence_threshold = pd.get(4, 0.5f);
variances[0] = pd.get(5, 0.1f);
variances[1] = pd.get(6, 0.1f);
variances[2]... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x718a6
movl %eax, 0xd0(%rbx)
pushq $0x1
popq %rsi
movss 0x1371b7(%rip), %xmm0 # 0x3f88f0
movq %r14, %rdi
callq 0x718c0
movss %xmm0, 0xd4(%rbx)
pushq $0x2
popq %rsi
movq %r14, %rdi
movl $0x12c, %edx ... | /csukuangfj[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 0x718a6
movl %eax, 0xd0(%r14)
pushq $0x1
popq %rsi
movss 0x12bc91(%rip), %xmm0 # 0x3eec88
movq %r15, %rdi
callq 0x718c0
movss %xmm0, 0xd8(%r14)
pushq $0x2
popq %rsi
movq %r15, %rdi
mo... | /csukuangfj[P]ncnn/src/layer/interp.cpp |
ncnn::Interp::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Interp::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int outw = output_width;
int outh = output_height;
if (bottom_blob.dims == 1)
{
w = 1;
h = 1;
}
if (outw == 0 || outh == 0)
{
o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq 0xdc(%rdi), %xmm0
movdqa %xmm0, 0x40(%rsp)
pshufd $0x50, %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1]
pxor %xmm1, %xmm1
pcmpeqd %xmm0, %xmm1
movmskpd %xmm1, %eax
testl %eax,... | /csukuangfj[P]ncnn/src/layer/interp.cpp |
ncnn::linear_coeffs(int, int, int*, float*, int) | static void linear_coeffs(int w, int outw, int* xofs, float* alpha, int align_corner)
{
double scale = (double)w / outw;
if (align_corner)
{
scale = (double)(w - 1) / (outw - 1);
}
for (int dx = 0; dx < outw; dx++)
{
float fx = (float)((dx + 0.5) * scale - 0.5);
if (alig... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, 0x10(%rsp)
movl %esi, %r12d
movl %edi, %r13d
testl %r8d, %r8d
je 0x2c7078
leal -0x1(%r13), %ebp
cvtsi2sd %ebp, %xmm1
leal -0x1(%r12), %eax
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%... | /csukuangfj[P]ncnn/src/layer/x86/interp_bilinear.h |
ncnn::cubic_coeffs(int, int, int*, float*, int) | static void cubic_coeffs(int w, int outw, int* xofs, float* alpha, int align_corner)
{
double scale = (double)w / outw;
if (align_corner)
{
scale = (double)(w - 1) / (outw - 1);
}
for (int dx = 0; dx < outw; dx++)
{
float fx = (float)((dx + 0.5) * scale - 0.5);
if (align... | testl %r8d, %r8d
je 0x2d3720
leal -0x1(%rdi), %eax
vcvtsi2sd %eax, %xmm0, %xmm0
leal -0x1(%rsi), %r9d
vcvtsi2sd %r9d, %xmm1, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
jmp 0x2d372f
vcvtsi2sd %edi, %xmm0, %xmm0
vcvtsi2sd %esi, %xmm1, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
leal -0x1(%rdi), %eax
pushq %rbp
pushq %r14
pushq %rbx
leal -0x2... | /csukuangfj[P]ncnn/src/layer/x86/interp_bicubic.h |
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 %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x718a6
movl %eax, 0xd0(%rbx)
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x718a6
movl %eax, 0xd4(%rbx)
pushq $0xb
popq %rsi
movq %r14, %rdi
m... | /csukuangfj[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
{
int w = bottom_blob.w;
int h = bottom_blob.h;
size_t elemsize = bottom_blob.elemsize;
const int kernel_extent_w = dilation_w * (kernel_w - 1) + 1;
const int kernel_extent_h = dilation_h * (kernel_h... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movl 0x2c(%rsi), %r14d
movl 0x30(%rsi), %ebp
movl 0xd4(%rdi), %ebx
decl %ebx
imull 0xdc(%rdi), %ebx
movq %rsi, 0x20(%rsp)
movq 0x10(%rsi), %r8
decl %r14d
imull 0xe4(%rdi), %r14d
movl 0xd8(%rdi), %r12d
decl %r12d... | /csukuangfj[P]ncnn/src/layer/deconvolutiondepthwise.cpp |
ncnn::DeconvolutionDepthWise_x86::create_group_ops(ncnn::Option const&) | int DeconvolutionDepthWise_x86::create_group_ops(const Option& opt)
{
// create Deconvolution op for each group
const int maxk = kernel_w * kernel_h;
int channels = (weight_data_size / group) / maxk / (num_output / group) * group;
for (int i = 0; i < (int)group_ops.size(); i++)
delete group_ops... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, 0x120(%rsp)
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rdx
movl 0xd0(%rdi,%rdx), %ecx
movl 0xd8(%rdi,%rdx), %ebp
imull 0xd4(%rdi,%rdx), %ebp
movl 0x110(%rdi,%rdx), %eax
movl 0x114(%rdi,%rdx)... | /csukuangfj[P]ncnn/src/layer/x86/deconvolutiondepthwise_x86.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.