易用的C++ RPC服务框架 - pioneer - 5 - 技术实现：函数的序列化

最新推荐文章于 2023-11-20 17:31:26 发布

星河眼

最新推荐文章于 2023-11-20 17:31:26 发布

阅读量1.2k

点赞数

CC 4.0 BY-SA版权

文章标签： C++11 RPC 分布式网络框架

本文链接：https://blog.youkuaiyun.com/galaxyeye/article/details/9941557

本文介绍了一个使用C++11编写的RPC服务框架pioneer，重点探讨了如何通过std::tuple和可变模板参数实现函数的序列化。文章详细讨论了如何解决序列化std::tuple的问题，提出了两种解决方案，并展示了如何从tuple中解包参数以供函数调用。此外，该框架支持同步和异步调用，异常处理，以及多种调用模式。源代码和测试示例可在作者的GitHub仓库中找到。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在过去的两年时间里，我一直在用C++11写分布式数据库。在分布式系统中，远程方法调用是一个大麻烦。能不能像本地方法一样调用远程方法？

能不能以异步的方式调用远程方法而调用线程不阻塞？能不能广播调用远程方法？能不能自动将异常信息带到客户端来处理？

于是我写了一个RPC框架pioneer，支持以下特性：

1.针对集群来设计

2.和本地函数几乎一样的调用方法

3.没有IDL

4.支持同步调用和异步调用

5.支持有返回值/无返回值，对无返回值的调用进行优化

6.支持一对一、一对多、多播、广播、可靠广播调用

7.支持异常处理

8.不考虑跨语言

在上一篇文章中，我介绍了在C++11中，如何借助std::tuple和可变模板参数来序列化一个函数，并且给出了一个通用实现和测试代码：

实现细节见：https://github.com/galaxyeye/atlas/blob/master/atlas/serialization/function.h

测试程序：https://github.com/galaxyeye/atlas/blob/master/libs/serialization/test/function.cpp

使用atlas::serialization::function,可以很轻松地将一个函数序列化，反序列化以及反序列化后执行。

其秘诀在于使用了三个威力强大的武器：std::tuple, std::function和可变模板参数。

那么有几个问题：

1. 如何序列化std::tuple? 标准库中并没用对std::tuple的输入输出实现，也就是说，标准库中没有实现：

     template<typename... Args>
     std::ostream& operator<<(std::ostream& os, const std::tuple<Args...>& t);

和：

     template<typename... Args>
     std::istream& operator>>(std::istream& is, std::tuple<Args...>& t);

boost::serialization中也没有对应实现。唉，得自己动手了。

2. 我们找到了序列化可变参数包的方法，就是引入一个中间变量std::tuple来保存这个参数包，那么我们知道函数function, 和一个参数包tuple，怎么样把tuple里的参数解出来供函数function调用？

对于第一个问题，通常有两种解决方法：第一种是{我的解决方法}，另一种是～{我的解决方法}。

我的解决方法纯粹使用函数进行编译期模板推导，代码平白如话：

    template<size_t idx, typename Archive, typename ... Elements>
    void aux_serialize(Archive& ar, std::tuple<Elements...>& t, single_parameter_pack_tag) {
      ar & std::get<idx>(t);
    }

    template<size_t idx, typename Archive, typename ... Elements>
    void aux_serialize(Archive& ar, std::tuple<Elements...>& t, not_single_parameter_pack_tag) {
      ar & std::get<idx>(t);

      aux_serialize<idx + 1>(ar, t, atlas::is_last_parameter<idx, Elements...>());
    }

    template<typename Archive, typename ... Elements>
    void serialize(Archive& ar, std::tuple<Elements...>& t, last_parameter_tag) {
      ar & std::get<0>(t);
    }

    template<typename Archive, typename ... Elements>
    void serialize(Archive& ar, std::tuple<Elements...>& t, not_last_parameter_tag) {
      aux_serialize<0>(ar, t, std::false_type());
    }

boost兼容的序列化函数：

namespace boost {
  namespace serialization {

    template<typename Archive, typename ... Elements>
    Archive& serialize(Archive& ar, std::tuple<Elements...>& t, const unsigned int version) {
      atlas::serialize(ar, t, atlas::is_single_parameter_pack<Elements...>());

      return ar;
    }

  } // serialization
} // boost

完整的代码在这里。这里用到几个编译期函数：

is_single_parameter判断一个参数包是否为单个参数

is_last_parameter判断一个参数是否为参数包中最后一个参数

用这套方案，可以解决很多编译期问题，譬如打印出一个std::tuple，代码几乎一模一样。

其他的解决方案，一般是基于class的模板参数推导，不赘述。

对于第二个问题，facebook的folly提出来一个方案，apply_tuple。folly::apply_tuple是这么用的：

int x = atlas::apply_tuple(std::plus<int>(), std::make_tuple(12, 12));
assert(x == 24);

你可以看到，这就是给定一个函数，以及包含函数的参数的打包的std::tuple，怎么调用这个函数。所以在前面的文章里的function_wrapper的operator就可以这么实现：

    template<typename Res, typename ... Args>
    class function_wrapper<Res(Args...)> {
    public:
      Res operator()() const { return apply_tuple(_f, _args); }
    public:
      std::function<Res(Args...)> _f;
      std::tuple<Args...> _args;
    };

至此，一个可序列化的函数包装器就成型了。