c++注册类方法实现单例映射

最新推荐文章于 2023-10-17 23:13:03 发布
最新推荐文章于 2023-10-17 23:13:03 发布
阅读量729 收藏 2
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Simplify_boy/article/details/106557265
版权

概述

在caffe和阿里MNN中，广泛使用了注册方法，简化了代码的复杂程度。下面我们简单梳理一下。

分析

  1. 要实现一套多种计算架构使用的代码，如cpu、gpu等。
  2. 要在每个计算架构下，实现各种算子。
  3. 使用一套接口实现。
    要达到以上要求，需要给各部分设置通用的接口，利用c++类的继承，能让所有的计算架构或算子具有相同的接口，接口一致，有利于代码的简化。

解析

异构平台后端Backend和{Devices}Backend分别拥有自己的生成器和单实例管理的map。

定义通用结构

  1. 平台
typedef enum {
    MNN_FORWARD_CPU = 0,
    /*
     Firtly find the first available backends not equal to CPU
     If no other backends, use cpu
     */
    MNN_FORWARD_AUTO = 4,
    /*Hand write metal*/
    MNN_FORWARD_METAL = 1,
    /*Use IOS's MPS instead of hand-write metal, Not Support yet*/
    MNN_FORWARD_MPS = 2,
    /*Android / Common Device GPU API*/
    MNN_FORWARD_OPENCL = 3,
    MNN_FORWARD_OPENGL = 6,
    MNN_FORWARD_VULKAN = 7,
    MNN_FORWARD_ALL
} MNNForwardType;
  1. 算子
enum OpType
{
    OpType_MatMul = 0，
    ......
};

接口类

  1. 单例基类
    NonCopyable.h
#ifndef NON_COPY_ABLE_H
#define NON_COPY_ABLE_H
class NonCopyable {
public:
    NonCopyable()                    = default;
    NonCopyable(const NonCopyable&)  = delete;
    NonCopyable(const NonCopyable&&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&&) = delete;
};

#endif // NON_COPY_ABLE_H

Execution.h

#ifndef Execution_hpp
#define Execution_hpp
#include "NonCopyable.h"
#include <vector>
class Backend;
// 实例通用接口类，里面封装了Backend，Backend为异构计算的通用接口类
class Execution : public NonCopyable
{
public:
    Execution() = delete;
    Execution(Backend *backend) : mBackEnd(backend)
    {
        // nothing to do
    }
    virtual ~Execution() = default;

    virtual int onExecute(const std::vector<float> &inputs, const std::vector<float> &outputs) = 0;
    
    Backend *backend() const
    {
        return mBackEnd;
    }

public:
    class Creator : public NonCopyable
    {
    public:
        virtual ~Creator() = default;
        virtual Execution *onCreate(Backend *backend) const = 0;
    };

private:
    Backend *mBackEnd;
};

#endif /* Execution_hpp */
  1. 后端接口类
    Backend.h
#ifndef Backend_hpp
#define Backend_hpp
#include "MNNForwardType.h"
#include "NonCopyable.h"
#include "Execution.h"
#include "MNN_generated.h"
#include <vector>
// 这个类是后端所有异构计算的通用接口类，后端的基类，是个抽象类
class Backend : NonCopyable
{
public:
    struct Info
    {
        /** forward type. */
        MNNForwardType type = MNN_FORWARD_CPU;
        /** for CPU only. number of threads. */
        int numThread = 4;
        enum Mode
        {
            // The Op will be run in execution->onExecute
            DIRECT = 0,
            // The Op will be recorded. Run in onExecuteBegin and Wait in onExecuteEnd
            INDIRECT = 1
        };
        Mode mode = DIRECT;
    };
public:
    Backend(MNNForwardType type) : mType(type) {}
    virtual ~Backend() = default;
public:
    virtual Execution *onCreate(const std::vector<float> &inputs, const std::vector<float> &outputs, OpType type) = 0;
public:
    inline MNNForwardType type() const {
        return mType;
    }
private:
    const MNNForwardType mType;
};
// 后端生成器类，是个抽象类
class BackendCreator
{
public:
    virtual ~BackendCreator() = default;

    virtual Backend *onCreate(const Backend::Info &info) const = 0;

    virtual bool onValid(Backend::Info &info) const
    {
        info.mode = Backend::Info::DIRECT;
        return true;
    }
protected:
    BackendCreator() = default;
};
const BackendCreator* MNNGetExtraBackendCreator(MNNForwardType type);

bool MNNInsertExtraBackendCreator(MNNForwardType type, const BackendCreator* creator,
                                             bool needCheck = false);
#endif /* Backend_hpp */

Backend.cpp

#include "Backend.h"
#include <map>
#include <mutex>
#include <memory>
extern void registerCPUBackendCreator();
// 默认注册CPU后端
void registerBackend()
{
    static std::once_flag s_flag;
    std::call_once(s_flag, [&]() { registerCPUBackendCreator(); });
}
// 生成后端生实例成器单实例
static std::map<MNNForwardType, std::pair<const BackendCreator *, bool>> &GetExtraCreator()
{
    static std::once_flag flag;
    static std::map<MNNForwardType, std::pair<const BackendCreator *, bool>> *gExtraCreator;
    std::call_once(flag,
                   [&]() { gExtraCreator = new std::map<MNNForwardType, std::pair<const BackendCreator *, bool>>; });
    return *gExtraCreator;
}
// 获取后端生成器
const BackendCreator *MNNGetExtraBackendCreator(MNNForwardType type)
{
    registerBackend();

    auto &gExtraCreator = GetExtraCreator();
    auto iter = gExtraCreator.find(type);
    if (iter == gExtraCreator.end())
    {
        return nullptr;
    }
    if (!iter->second.second)
    {
        return iter->second.first;
    }
    Backend::Info info;
    info.type = type;
    std::shared_ptr<Backend> bn(iter->second.first->onCreate(info));
    if (nullptr != bn.get())
    {
        return iter->second.first;
    }
    return nullptr;
}
// 添加后端生成器
bool MNNInsertExtraBackendCreator(MNNForwardType type, const BackendCreator* creator, bool needCheck) {
    auto& gExtraCreator = GetExtraCreator();
    if (gExtraCreator.find(type) != gExtraCreator.end()) {
        return false;
    }
    gExtraCreator.insert(std::make_pair(type, std::make_pair(creator, needCheck)));
    return true;
}

计算架构

下面以cpu为例
CPUBackend.h

#ifndef CPUBackend_hpp
#define CPUBackend_hpp
#include "Backend.h"
// CPU后端，集成与后端Backend
class CPUBackend final : public Backend
{
public:
    CPUBackend(int numberThread = 4);
    virtual ~CPUBackend();

    // 创建实例
    virtual Execution *onCreate(const std::vector<float> &inputs, const std::vector<float> &outputs, OpType type) override;

public:
	// 实例生成器，是个抽象基类，是ops的生成器基类，并设置想得创建接口
    class Creator 
    {
    public:
        virtual Execution *onCreate(const std::vector<float> &inputs, const std::vector<float> &outputs,
                                    OpType type, Backend *backend) const = 0;
    };
    // 向map中添加相应的ops
    static bool addCreator(OpType t, Creator *c);

private:
    int mThreadNumber;
};
// ops注册类，T为ops对应的类
template <class T>
class CPUCreatorRegister {
public:
    CPUCreatorRegister(OpType type) {
        CPUBackend::addCreator(type, new T);
    }
};
// 通过宏定义来注册
#define REGISTER_CPU_OP_CREATOR(name, opType) static CPUCreatorRegister<name> _Create##opType(opType)

#endif /* CPUBackend_hpp */

CPUBackend.cpp

#include "CPUBackend.h"
#include <stdio.h>
#include <map>
#include <mutex>
// 创建map，用于管理ops单实例
static inline std::map<OpType, CPUBackend::Creator *> *getCreatorMap()
{
    static std::once_flag of;
    static std::map<OpType, CPUBackend::Creator *> *ret = nullptr;
    std::call_once(of, [&]() { ret = new std::map<OpType, CPUBackend::Creator *>; });
    return ret;
}
// 向map中添加ops
bool CPUBackend::addCreator(OpType t, Creator *c)
{
    auto map = getCreatorMap();
    if (map->find(t) != map->end())
    {
        printf("Error: %d type has be added\n", t);
        return false;
    }
    map->insert(std::make_pair(t, c));
    return true;
}

CPUBackend::CPUBackend(int numberThread)
    : Backend(MNN_FORWARD_CPU), mThreadNumber(numberThread)
{
    mThreadNumber = std::max(1, mThreadNumber);
    ;
}

CPUBackend::~CPUBackend()
{
}
// 使用map中的生成器，创建对应的ops实例
Execution *CPUBackend::onCreate(const std::vector<float> &inputs, const std::vector<float> &outputs, OpType type)
{
    auto map = getCreatorMap();
    auto iter = map->find(type);
    if (iter == map->end())
    {
        printf("Don't support type\n");
        return nullptr;
    }

    auto exe = iter->second->onCreate(inputs, outputs, type, this);
    if (nullptr == exe)
    {
        printf("The Creator Don't support type\n");
        return nullptr;
    }
    return exe;
}
// CPU后端生成器
struct CPUBackendCreator : BackendCreator
{
    Backend *onCreate(const Backend::Info &info) const override
    {
        return new CPUBackend(info.numThread);
    }
};
// 注册CPU后端生成器到后端的map生成器管理器中
void registerCPUBackendCreator()
{
    MNNInsertExtraBackendCreator(MNN_FORWARD_CPU, new CPUBackendCreator);
};

算子

CPUMatMul.h


#ifndef CPUBatchMatMul_hpp
#define CPUBatchMatMul_hpp
#include "Execution.h"
// ops类
class CPUMatMul : public Execution
{
public:
    CPUMatMul(Backend *backend);
    virtual ~CPUMatMul() = default;

    virtual int onExecute(const std::vector<float> &inputs, const std::vector<float> &outputs) override;

private:
};

#endif /* CPUBatchMatMul_hpp */

CPUMatMul.cpp

#include "CPUMatMul.h"
#include "CPUBackend.h"

CPUMatMul::CPUMatMul(Backend *backend) : Execution(backend)
{
}
// 执行ops
int CPUMatMul::onExecute(const std::vector<float> &inputs, const std::vector<float> &outputs)
{//TODO
    return 0;
}
// ops生成器
class CPUMatMulCreator : public CPUBackend::Creator
{
public:
    virtual Execution *onCreate(const std::vector<float> &inputs, const std::vector<float> &outputs,
                                OpType type, Backend *backend) const override
    {
        return new CPUMatMul(backend);
    }
};
//注册ops
REGISTER_CPU_OP_CREATOR(CPUMatMulCreator, OpType_MatMul);
Dovy
关注
专栏目录
【C++ 项目设计】通过C++ 实现Qt的信号槽机制
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
01-12 303
Qt的信号槽机制以其强大的解耦合和灵活性而闻名。通过在STL中实现这一机制，我们可以为不使用Qt框架的项目提供相同级别的解耦合和灵活性。这种解耦合使得代码的各个部分可以独立变化和扩展，而不会对其他部分产生影响，从而提高了整个项目的可维护性和可扩展性。
【编程拾遗】C++的static成员函数与单例模式
Jason Ding的专栏
10-04 3683
static 是C++中很常用的修饰符，它被用来控制变量的存储方式和可见性。 函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题:如果想将函数中此变量的值保存至下一次调用时，如何实现？ 最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此函数控制）。而static变量可以保持该变量的值，使得函数在下次调用时还保持上次函数退出时的
C++ 强大的注册表操作类
06-28
C++ 强大的注册表操作类 测试可用 ！
C++ | STL 单映射容器map
ThinPikachu的博客
03-20 335
目录 一.何为单映射容器map 二.map容器的使用方法 一.何为单映射容器map 在简绍这map容器之前我们先来看另一个概念——键值对。 所谓的键值对是由 键（key） 和 值（value） 两部分组成的，一个键对应一个值，值可以重复，但是键不能重复。例如我们可以将身份证号对应为键（key），而某个身份证号对应的名字称为值（value），而我们都知道身份证号是不可以重复的，人手一个，但...
C++ 注册表操作类
10-02
非常好用的C++注册表操作类,看示例 // 使用示例: // RegistryKey hklm = Registry.LocalMachine; // RegistryKey aa = hklm.OpenSubKey("System\\CurrentControlSet\\Services\\Lanmanserver\\parameters", TRUE); // int bb = aa.GetIntValue("AutoShareServer"); // aa.SetValue("AutoShareServer", 0); //
【c++学习笔记】c++实现类的注册机制
zl3090的博客
09-15 1053
请见c++ 实现类注册机制的方法_think_think_think的博客-CSDN博客_c++ 注册类
C/C++ --- 动态注册类
Nireus的博客
09-01 5494
背景需要根据配置文件中的插件名字获取插件实例，从而需要维护<插件名字，插件实例>的映射关系。 当有新插件加入项目时，每次都需要在该映射关系中插入一条信息。为了避免避免此操作，通过定义宏 自动完成 新插件的注册功能。设计思想每个插件在全局域中定义一个注册类，在该注册类的构造函数中将<插件名字，插件实例>插入全局的map中， 在全局域定义该注册类的一个实例，从而调用构造函数，在map中插入该
c++ 实现类注册机制的方法
热门推荐
think_think_think的博客
09-25 1万+
最近学习c++ 的反射机制的实现方式， 想要达到仅通过使用类名的字符串就能方便地拿到该类实例的方法。要做到上述的目标，显而易见的，我们需要使用某种机制记录这种字符串保存的类名和类实例获取方法（函数）的映射关系。 我们首先想到的就是用一个std::map数据结构去存取这种映射关系。 这个map 存贮在一个工厂类中（这里和工厂模式有些不同，但大体上是用来直接获取实例的途径。和工厂类类似，因此采用工厂类
设计模式，单例模式，singleton，Instance，c++实现，一个国家一个国王
ganfanren00001的博客
11-07 724
单例模式singleton 定义： 确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。 翻译： 有一个类，在程序进程中只有一个，程序开始时自动初始化自己的实例，程序结束后被释放，程序员不用也无法手动new或delete那样一个类的对象，这个类的唯一的对象会在整个进程中发挥作用，可随时被进程中的任何函数访问。 类图摘自设计模式之禅 特点： 单例类只有一个实例化的对象，这个对象的获取往往通过在类中设置Instance()/GetInstance()等方法获取，这是一般单例模式的默认命名，而只要
Stats:一个简单的统计计数器，实现为单例
03-30
一个实现为单例的简单统计计数器。 概述 统计计数器在实时环境中用于映射行为以及对项目进行计数很有用。 它应该允许从系统中的任何位置添加或更新任何计数器。 这是一个实现为单例的简单统计计数器。 计数类型为...
C++实现完整的接口注册windows服务程序
06-16
压缩文件中有详细的方法和代码模板,注册服务的代码在一个单独的文件中，你自己的接口程序代码在一个单独的文件中，外部库比如occi在一个单独的文件中，其次是UAPI 静态连接中使用的库单独一个文件。 你只需要把自己代码main函数实现方法，放到windows注册服务的run函数里面然后添加相应原来main函数中的头文件就可以了，把注册服务名称从配置文件中修改。。然后其他的说明自己看压缩包中的readme,程序绝对可以用，自己要慢慢摸索。
工程模式(包括注册类)
03-03
工程模式实例代码，包括注册类的管理，数据的获取等信息。通过宏定义，简化代码逻辑。无限延展注册信息类。虚函数接口可以扩展。
c++ 注册表类
zhangxiaonanwin的专栏
11-19 1237
C/C++ code复制代码#if !defined(AFX_REGISTRY_H__E0610A5D_7166_4D02_9D7E_11AF7CF8E229__INCLUDED_) #define AFX_REGISTRY_H__E0610A5D_7166_4D02_9D7E_11AF7CF8E229__INCLUDED_ //#include /////////////////////////////////////////////////////////////////////////////
c++类动态注册摸索与理解
南沙的星星
04-21 669
#ifndef INC_MODULE_FACTORY2_H #define INC_MODULE_FACTORY2_H #include <string> #include <map> #include <functional> #include <utility> // std::pair #include <iostream> // std::cout #define MODULE_REG(class_name,id,d
c++工厂注册类
最新发布
weixin_43763292的博客
10-17 428
【代码】c++工厂注册类。
C++ 函数映射（即回调函数）和 变量映射
Nick_H 的专栏
08-26 3272
C++ 编程中，经常会用到函数映射（即回调函数）和变量映射方法。如下分别介绍： 类中定义回调函数： 在类中定义回调函数参数类型：typedef void (*CALLBACKFUNCOM) (DWORD port); 定义回调函数：CALLBACKFUNCOM m_pFunReceive; 定义设置回调函数的方法：void SetCallBack(CALLBACKFUNCOM pFu...
C++ 中泛型工厂注册类的实现
Wings的专栏
11-18 1553
//C++ 中泛型工厂注册类的实现//---------------------------------------------------------------------------#ifndef GenericFactoryH#define GenericFactoryH#include #include #define REGISTER_CLASS(BASE_CLASS, D
[迁移]注册类中的成员函数，在需要的时候调用(c++)
晓清风兮
01-30 274
声明：因网易博客将关闭，移到此 重新修改版本 #ifndef HANDLE_H #define HANDLE_H #include #include using namespace std; //---------------------------------------------------------------------- // class EventArgs { public: ...
注册表式单例模式详解java,C++单例模式之注册表方法
weixin_35681614的博客
03-27 136
#include #include #include using namespace std;class Singleton1{private:static map mapList;static Singleton1* _instance;public:static Singleton1* GetInstance(string name){_instance = LookUp(name);retu...
C++模板类型映射：深入探讨
3. **类成员模板方法（temp.memfunc）**：如`struct XX`中的`template<class T> void f(T*p)`，表示类`XX`中的成员函数`f`是一个模板，可以处理不同类型的指针。 模板参数的定义（temp.param）包括： - 类型参数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值