linux的进程与库之间的通信两种方式

---

前言

像平常主要是做视觉算法开发的，有时候算法效果实现了，但是要想要用产品上需要工程的实践来串联起算法和整个产品的连接关系。大部分AI的产品，算法一般实现之后，对外只会留两个接口：1）输入图像、激光雷达、Imu等数据；2）输出算法的结果：机器人的状态估计位置、速度、方向、图像的检测推理后筛选的坐标等；但是这仅仅是视觉算法内部的计算，产品它需要与其它模块交互，像与控制器交互、与显示的app交互；算法与外部模块的交互就会涉及到，通信链路的工程化，你的数据要通过协议传给接受方，所以涉及到自己的算法如何与自己通信进程进行交互问题，下面列些自己常用的两种进程与算法库的通信交互方法，各有利弊。

---

一、进程A与算法库b的通信方式之一：动态dlopen加载算法库b，编译的时候是需要加载该头文件就可以，无需连接该算法库b

具体的实施细节：

1、构建进程A和算法库b之前的一个公用头文件，必须需要的三个函数以及两个数据结构、一个是进程传给算法库的数据结构，一个是算法库传给进程的数据结构
2、定义三个函数：初始化函数、进程A回调算法库b数据函数、算法库b回调进程A的数据函数
3、具体的头文件.h和具体的.cpp实现
4.公共头文件

公共头文件，代码如下：

//从进程A中获取，算法库b开关
typedef struct
{
    //enableState 为0 不开启算法库b； 为1开启算法库b
    int enableState;
}StateFromA;

//发送给进程A，算法库b内部运行的状态
typedef struct
{
    //sendState 1算法库b开启但未执行（检测）、2算法库b执行中（检测）、3算法库b执行完成 4、算法库b失败
    int sendState;
}StateToA;


//typedef int (*b_flyCtrl_cb_func) (void* pData,  int len);
//typedef int (*b_PodCtrl_cb_func) (void* pData,  int len);
typedef int (*b_SendState_cb_func) (void* pData,  int len);
typedef int (*b_getbStateFromA_fn)(StateFromA* State);
typedef int (*b_init_fn)(b_flyCtrl_cb_func cb_func1,b_PodCtrl_cb_func cb_func2,b_SendState_cb_func cb_func3);

//进程A调用算法库b检测算法库的初始化函数,并将算法库b状态和控制参数的回调函数的指针传入算法库中，
extern "C"
//进程A可以同时实现三个回调函数，将算法库的内部数据回调出去；
具体实现是在进程A中实现该三个函数，算法库b只需要调用typedef新定义的三个回调函数的指针函数别名就可以，把相应需要回调的函数结构数据填写进去就可以实现
//int b_init(b_flyCtrl_cb_func cb_func,b_PodCtrl_cb_func cb_func2,b_SendState_cb_func cb_func3);
int b_init(b_SendState_cb_func cb_func3);

//进程A调用，算法库b获取进程A是否开启算法库b的状态信息
extern "C"
int b_getbStateFromA(StateFromA* bState);

算法库b的.cpp，代码如下：

	//从进程A获取算法b开关状态信息，结构体
	StateFromA* g_bStateInfoFromA = NULL;
	//进程A从算法b获取算法b内部的运行状态信息，结构体
	StateToA* g_bStateInfoFromb = NULL;

    g_bCtrl_cb ;  //通过该控制1回调函数指针，将控制1的结构体数据传给进程A
    g_bCtrlPod_cb ;//通过该控制2回调函数指针，将控制2的结构体数据传给进程A
    StateFromA  g_ASendState_cb;//通过该进程A回调函数指针，将算法库b状态的结构体数据传给进程A
    
extern "C"
//int b_init(b_flyCtrl_cb_func cb_func,b_PodCtrl_cb_func cb_func2,b_SendState_cb_func //cb_func3);//进程A的回调函数入口，将回调函数指针通过初始化函数传入到算法库中
int b_init(b_SendState_cb_func cb_func3);
{
    //g_bCtrl_cb = cb_func1;  //通过该控制1回调函数指针，将控制1的结构体数据传给进程A
    //g_bCtrlPod_cb = cb_func2;//通过该控制2回调函数指针，将控制2的结构体数据传给进程A
    g_bSendState_cb = cb_func3;//通过该进程A回调函数指针，将算法库b状态的结构体数据传给进程A

    //算法库b，输入数据结构体申请内存空间
    //给全局算法库b的开启状态结构体申请内存空间，使用函数指针的别名来定义全局算法b是否能够开启状态的结构体
   b_SendState_cb_func g_ASendState_cb;
return 0
}

//相当于算法库b的输入口，获取了外部的状态
//算法库b获取进程A中是否需要开启算法b的状态，进程A只需要将算法b需要的结构体数据填写进去，算法b库这边的函数就会自动的更新该算法b的开启状态
extern "C"
int b_getbStateFromA(StateFromA* bState);
{
    if (StateToA== NULL)//所以进程A先调用，算法库b的初始化函数，里面会给指针申请内存
    {
        fprintf(stderr, "%s %d: ERROR! bStateFromb is NULL, return FAILURE.\n", __FUNCTION__, __LINE__);
        return -1;
    }
    else
    {
        //enableState: 为0 不开启算法库b； 为1开启算法库b
        g_bStateInfoFromA ->enableState = bState->enableState;
        return 0;
    }
}

int main()
{
	//相当于算法库b的输出口，发出去了了算法库b自己的运行状态	
	//发送算法b内部运行状态给进程A，通过A的回调函数接口（别名）去实现
	memset(g_bStateInfoFromb , 0, sizeof(StateToA));//发送算法b的内部运行状态之前，先			      结构体数据都清零
	//调用进程A的回调函数接口（回调函数别名），将算法库b内部的运行状态传给进程A
    g_bSendState_cb((void *)g_bStateInfoFromb , (int)sizeof(StateToA)); 
}

进程A的.cpp，代码如下：

int ALibLoad(struct *ip)
{
    //动态装载算法库b动态库 
    void *bHandle = dlopen("/usr/lib/libb.so",RTLD_LAZY);
    if(bHandle ==NULL)
    {
        printf("dlopen失败：%s.",dlerror());
        return -1;
    }

	ip->bInitFuncPtr     = (b_init_fn)dlsym(bHandle , "b_init");
    if( NULL == ip->bInitFuncPtr )
    {        
        pritnf("dlsym b_init 失败:%s.",dlerror());
        return -1;
    }

	ip->bGetStateFuncPtr           = (b_getbStateFromA_fn)dlsym(bHandle , "b_getbStateFromA");
	 if( NULL == ip->bGetStateFuncPtr           )
    {        
        printf("dlsym b_getbStateFromA失败:%s.",dlerror());
        return -1;
    }
}
int AInit(struct *ip)
{
	//进程A回调算法库b运行状态结构体初始化
    memset(&ip->bGetStateFuncPtr, 0x00, sizeof(b_getbStateFromA));
    
     if (sem_init(&g_sembSendStateEvent, 0, 0))
	{
		binocularlog("g_sembSendStateEventinit failed, %d: %s", errno, strerror(errno));
		return -1;
	}
	//将算法库b的初始化函数调用起来
//ip->bInitFuncPtr((b_flyCtrl_cb_func)bCtrlCbFun,(b_PodCtrl_cb_func)bPodCtrlCbFun,(b_SendState_cb_func)bStateCbFun);
ip->bInitFuncPtr((b_SendState_cb_func)bStateCbFun);
}

//进程A回调算法库b的运行状态函数实现
int bStateCbFun(void* pData,  int len)
{
    int rtn_cb = -1;

    StateToA*curbStateInfo = (StateToA*)pData;

    StateToA*tmpbStateInfo = new StateToA;
    memcpy(tmpbStateInfo , curbStateInfo , sizeof(StateToA));

    g_bSendStateDataQueue.push(tmpbStateInfo );
    sem_post(&g_sembSendStateEvent);
    rtn_cb = 0;
    return rtn_cb;
}

二、进程A与算法库b的通信方式之二：进程A编译的时候连接上算法库b和该头文件

具体的实施细节：

1、定义好进程A和算法库b使用的共同头文件
2、该头文件是以类的封装形式展现出来，包括类的初始化函数、类的输入数据接口、类的输出数据接口
3、具体实现如下
公共头文件，代码如下：

//从进程A中获取，算法库b开关
typedef struct
{
    //enableState 为0 不开启算法库b； 为1开启算法库b
    int enableState;
}StateFromA;

//发送给进程A，算法库b内部运行的状态
typedef struct
{
    //sendState 1算法库b开启但未执行（检测）、2算法库b执行中（检测）、3算法库b执行完成 4、算法库b失败
    int sendState;
}StateToA;

class B 
{
	B();
	~B();
public:
	int get (StateFromA bState);
	int output(StateToA &curbState);
private:
StateFromA  m_bState;
StateToA  m_curbState;

}

算法库b的.cpp，代码如下：

int B::get (StateFromA bState)
{
	m_bState = bState;//外部数据传给算法库b的内部私有变量
   m_curbState = 1；
    return 0;
}

int B::output(StateToA &curbState)
{
	 curbState = m_curbState;//将算法库b运行状态传输给外部调用者
     return 0;
}

进程A的.cpp，代码如下：

int main ()
{
	StateFromA g_bState;//定义进程开启算法库b的结构体数据变量
	g_bState = 0;//开启算法库b
	StateToA g_curbState;//定义进程获取算法库b的运行状态结构体数据变量
	B bobject;
	bobject.get (g_bState);//发送给算法库b的开启标志位
	bobject.output(g_curbState);//获取算法库b内部的运行状态
 
  return 0；
}

总结

进程与库通信两种方式的优缺点 1、进程与库编译相互依赖， 优点：库里面可以自行使用类的函数来完成整理系统的处理 缺点：库的头文件把整个类的处理函数都暴露给了进程，外部可以看到库的详细信息、编译需要依赖库的存在 2、进程编译不依赖库 优点：进程编译不依赖库的存在、库的内部处理函数不会暴露给进程 缺点：进程与库需要操作加载库，使用函数指针来调用库的数据，会形成很多单独的通信接口