【ncnn】源码阅读理解（二）——layer层

可以参考：https://blog.csdn.net/sinat_31425585/article/details/100586033

这里是根据配置文件，创建相关的layer，就是定义相关的层，声明内存空间等。这里和darknet差别还是很大的。darknet的源码更容易阅读。ncnn做了几层封装，第一眼看到的时候，肯定是😵的。

整个流程：

第一部分

1. 通过类的名字const char* type

Layer* create_layer(const char* type)
{
    int index = layer_to_index(type);
    if (index == -1)
        return 0;

    return create_layer(index);
}

2. 转到用index创建网络

Layer* create_layer(int index)
{
    if (index < 0 || index >= layer_registry_entry_count)
        return 0;

    layer_creator_func layer_creator = layer_registry[index].creator;			// 返回一个函数指针
    if (!layer_creator)
        return 0;

    Layer* layer = layer_creator();		// 通过函数指针执行函数->会返回一个类指针
    layer->typeindex = index;
    return layer;						// 返回一个layer指针
}

后面就有点难理解了。第一眼肯定是😵的。推荐先看一下这个例子:https://blog.csdn.net/u011622208/article/details/105199372

第二部分

后面用两个分支来理解：
第一分支
解读这一句layer_creator_func layer_creator = layer_registry[index].creator;
layer_registry是layer_registry_entry结构体数组，第一个对象是字符指针，第二对象是函数指针。

typedef Layer* (*layer_creator_func)();			// 指向函数的指针，输入void，输出layer*指针

struct layer_registry_entry
{
#if NCNN_STRING
    // layer type name
    const char* name;
#endif // NCNN_STRING
    // layer factory entry
    layer_creator_func creator;					// 声明一个指针，后面还要赋值
};

layer_registry的初始化在:

static const layer_registry_entry layer_registry[] =			// 所有注册的网络，一个结构体数组
{
#include "layer_registry.h"										// 这里用了数组的初始化{}方法
};

这里相当于只是将一个字符串和一个函数名字（和函数一样） 赋值给layer_registry_entry 结构体。

然后layer_registry[index].creator就会返回layer_creator_func layer_creator函数指针

返回layer_creator_func layer_creator函数指针之后，通过：
Layer* layer = layer_creator()
执行函数

第二分支：遗留问题

1. layer_registry中函数指针对应的同名函数在哪里？
   在layer.h的最后有一个参数的宏定义

#define DEFINE_LAYER_CREATOR(name) \
    ::ncnn::Layer* name##_layer_creator() { return new name; }

于是执行DEFINE_LAYER_CREATOR(Input_final)就会定义一个Input_layer_creator函数（就是上面函数指针指向的函数）

但是DEFINE_LAYER_CREATOR(Input_final)又在哪里执行的呢？
在ncnn编译文件夹的$build/src下

#include "layer/input.h"
namespace ncnn {
class Input_final : virtual public Input
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Input::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Input::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Input_final)

2. 函数返回了Layer* layer类指针

#define DEFINE_LAYER_CREATOR(name) \
    ::ncnn::Layer* name##_layer_creator() { return new name; }

这里name就是一个可变的类，用new返回内存空间的指针。

总结

那么乱，难受😫。简单点

layer_creator_func layer_creator = layer_registry[index].creator;			// 返回一个函数指针
Layer* layer = layer_creator();		// 通过函数指针执行函数->会返回一个类指针
layer->typeindex = index;
return layer;						// 返回一个layer指针

这里就是根据index返回不同的类指针，那么具体类的定义在哪里呢？

答案：在build/src/layer_declaration.h中

#include "layer/input.h"
namespace ncnn {
class Input_final : virtual public Input
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Input::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Input::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Input_final)
} // namespace ncnn