C++注册op-创新互联

• • • paddle如何注册op
    • 注册op
    • 使用op
    • 说明
    • 写一个简单demo
    • • run.cc
      • single.h single.cc
      • use_op.h use_op.cc
    • pool.cc

//a.h
#define UNUSED __attribute__((unused))

class Factory {public:
  // 静态成员函数
  static Factory& Instance() {static Factory g_meta_fn_map; //单例模式
    return g_meta_fn_map;
  }

  void Insert(string op_name, Fn fn) {fn_map_.insert({std::move(op_name), std::move(fn)});
  }

  const Fn& Get(const string& op_name) const {auto it = fn_map_.find(op_name);
    return it->second;
  }
 private:
  Factory() = default;
  mapfn_map_;
  DISABLE_COPY_AND_ASSIGN(Factory);
};

struct OpRegistrar 
{OpRegistrar(const char* op_name, Fn function) 
  {Factory::Instance().Insert(op_name, std::move(function));
  }
  void Touch() {}
};

#define REGISTER_KERNEL(op_type, function)                                 \
  static OpRegistrar registrar_kernel_##op_type(#op_type, function);       \
  int TouchOpRegistrar_##op_type()                                         \
  {                                \
    registrar_kernel_##op_type.Touch();                                    \
    return 0;                                                              \
  }

#define USE_OP(op_type)                              \
  extern int TouchOpRegistrar_##op_type();            \
  static int use_op_##op_type  UNUSED = TouchOpRegistrar_##op_type();

//test_op.cc
#include "a.h"
REGISTER_KERNEL(test_op, func);

//use_op.h
#include "a.h"
USE_OP(test_op);

我们知道test_op.cc和use_op.h是不同的编译单元，静态变量的初始化顺序不能保证，所以为了能够在use_op的时候已经注册好了，
所以必须用函数调用来保证初始化顺序。

#include#include#include#include "use_op.h"

using namespace std;

int main()
{vectormodel;
        model.push_back("conv");
        model.push_back("pool");
        model.push_back("add");
		run(model);
		return 0;
}

//single.h
#ifndef __SINGLE_H_
#define __SINGLE_H_

#include

//use_op.h
#ifndef __USE_OP_H_
#define __USE_OP_H_
#include#includevoid run(std::vectormodel);
#endif

//use_op.cc
#include "single.h"
#include "use_op.h"

extern int reg_conv();
static int conv = reg_conv(); //之所以这样写是因为静态全局变量会在程序开始前初始化，保证了个这个函数一定会被调用，也就保证了kernel被注册
extern int reg_pool();
static int pool = reg_pool();
extern int reg_add();
static int add  = reg_add();

void run(std::vectormodel)
{for(auto x:model)
	{auto fn = single_instance()[x];
        fn();
	}
}

#include#include "single.h"

void show_pool()
{std::cout<<"pool_run"< std::cout<<"reg_pool"<