boost sg msgpack

MessagePackとAPIバージョニング

近藤貴俊

2015/5/29 1 Copyright OGIS-RI 2015

• 近藤貴俊

• 株式会社オージス総研 – IoT分野でMessagePackを利用したデータの収集、制御を行うプラットフォームを開発している

• msgpack-c コミッタの一人 – 後述するMessagePackフォーマットを扱うための

C/C++ 実装

– C++版は Cのwrapperではない

• C++Nowにここ6年くらい連続参加中

2015/5/29 Copyright OGIS-RI 2015 2

自己紹介


MessagePackとは


MessagePackとは

https://github.com/msgpack/msgpack/blob/master/spec.md



• Website http://msgpack.org/

• JSONと同様

– ポータブル

– 基本的な型情報を内包

– コンポジットなデータ構造（詳細は次ページで）

• JSONとの違い

– サイズが小さい

– バイナリフォーマット

– バイナリデータもそのまま扱える

– 整数と浮動小数点数を区別

– Parseが容易で計算負荷が小さい


MessagePackとは？

http://msgpack.org/

http://msgpack.org/


MessagePackとは？

msgpack::object

nil boolean u64 i64 f64

str bin ext array map

*

*

double, float

object_kv

key val

※ クラス名は msgpack-c の名称で記載

MessagePackをサポートする言語


MessagePackをサポートする言語


このリストは github から自動収集して生成されているためどのレベルで実装されているかは要確認


msgpack-c 中でも、C++にフォーカスをあてた内容で、

Cには当てはまらない内容もあるので注意

Pack/Unpack

2015/5/29 15

#include <tuple> #include <string> #include <sstream> #include <msgpack.hpp> int main() { auto t1 = std::make_tuple("hello", true, 42, 12.3); std::stringstream ss; msgpack::pack(ss, t1); msgpack::unpacked unpacked = msgpack::unpack(ss.str().data(), ss.str().size()); msgpack::object obj = unpacked.get(); auto t2 = obj.as<std::tuple<std::string, bool, int, double>>(); assert(t1 == t2); }

write(const char*, std::size_t) メンバ関数を持つ、任意の型

Copyright OGIS-RI 2015

pack

unpack

convert

C++/object/byte stream


C++ Types

msgpack::object

Byte stream

pack object

pack unpack

convert

adaptor

Adaptor


https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_adaptor

C++ type msgpack::object type

bool bool

char* str

std::deque array

char positive/negative integer

signed ints *1 positive/negative integer

unsigned ints *2 positive integer

std::list array

std::map array

std::pair array

std::set array

std::string str

std::vector array

std::vector<char> bin

*1 signed ints signed char, signed short, signed int, signed long, signed long long *2 unsigned ints unsigned char, unsigned short, unsigned int, signed long, signed long long

C++11 type msgpack::object type

std::array array

std::array<char> bin

std::forward_list array

std::tuple array

std::array array

std::unordered_map array

std::unordered_set array

boost type msgpack::object type

boost::optional<T> T

boost::string_ref str





自前のクラスのmsgpack対応



#include <msgpack.hpp> struct your_class { int a; std::string b; MSGPACK_DEFINE(a, b); };

intrusive





自前のクラスのmsgpack対応



#include <msgpack.hpp> struct my { int a; std::string b; }; namespace msgpack { template <typename Stream> inline packer<Stream>& operator<< (packer<Stream>& o, const my& v) { o.pack_array(2); o << v.a; o << v.b; return o; } } // namespace msgpack

non-intrusive





ADLを用いたアダプタの実現


namespace msgpack { template <typename Stream> class packer { public: packer(Stream&) {} template <typename T> packer<Stream>& pack(const T& v) { *this << v; return *this; } }; // Default behavior template <typename Stream, typename T> inline packer<Stream>& operator<< (packer<Stream>& o, const T&) { std::cout << "Default serialize" << std::endl; return o; } // API template <typename Stream, typename T> inline void pack(Stream& s, const T& v) { packer<Stream>(s).pack(v); } } // namespace msgpack

int main() { std::stringstream ss; msgpack::pack(ss, 1); msgpack::pack(ss, 1.2); }

http://melpon.org/wandbox/permlink/L0WpfUz2hSUZ3ItM

version 0.5.9 まで



ADLを用いたアダプタの実現


namespace msgpack { template <typename Stream> class packer { public: packer(Stream&) {} template <typename T> packer<Stream>& pack(const T& v) { *this << v; return *this; } }; // Default behavior template <typename Stream, typename T> inline packer<Stream>& operator<< (packer<Stream>& o, const T&); // User defined adaptor template <typename Stream> inline packer<Stream>& operator<< (packer<Stream>& o, int) { std::cout << "Int serialize" << std::endl; return o; } } // namespace msgpack



version 0.5.9 まで

ユーザ定義のoperator<<オーバーロード



APIのバージョニング


• msgpack-c の C++版はヘッダオンリーライブラリとなった

• ヘッダオンリーライブラリであっても、古いABIのmsgpack-c をincludeして作ったライブラリ(.a , .LIBなど)を、新しいABIのmsgpack-cと合わせて使うと問題が生じる – std::listのサイズをO(1)で求めることになった際にも同様の問題が発生した

• これを防ぐために、ABIに変更が生じた場合、古いバージョンはそのまま使い続けられるようにしたい

• ABIに関わらないバグフィックスなどは古いバージョンにも反映していきたい

msgpack.hpp

userlib.cpp libuser.a

msgpack.hpp

client.cpp include

生成 include

link



Inline namespace The inline namespace mechanism is intended to support library evolution by providing a mechanism that support a form of versioning. Consider: inline namespace V99 { void f(int); // does something better than the V98 version void f(double); // new feature // ... } namespace V98 { void f(int); // does something // ... } namespace Mine { #include "V99.h" #include "V98.h" }

We here have a namespace Mine with both the latest release (V99) and the previous one (V98). If you want to be specific, you can: #include "Mine.h" using namespace Mine; V98::f(1); // old version V99::f(1); // new version f(1); // default version

The point is that the inline specifier makes the declarations from the nested namespace appear exactly as if they had been declared in the enclosing namespace.This is a very ``static'' and implementer-oriented facility in that the inline specifier has to be placed by the designer of the namespaces -- thus making the choice for all users. It is not possible for a user of Mine to say ``I want the default to be V98rather than V99.''

file V99.h

file V98.h

file Mine.h

http://www.stroustrup.com/C++11FAQ.html#inline-namespace







#include <iostream> namespace msgpack { // lib code v1 inline namespace v1 { inline void foo() { std::cout << "v1::foo()" << std::endl; } inline void bar() { std::cout << "v1::bar()" << std::endl; foo(); // A msgpack::foo(); // B msgpack::v1::foo(); // C } } } // client code int main() { std::cout << "msgpack::bar();" << std::endl; msgpack::bar(); std::cout << "msgpack::v1::bar();" << std::endl; msgpack::v1::bar(); } http://melpon.org/wandbox/permlink/ncTAeERuXByq80Y3

msgpack::bar(); v1::bar() v1::foo() v1::foo() v1::foo() msgpack::v1::bar(); v1::bar() v1::foo() v1::foo() v1::foo()

http://melpon.org/wandbox/permlink/ncTAeERuXByq80Y3

http://melpon.org/wandbox/permlink/ncTAeERuXByq80Y3



namespace msgpack { namespace v1 { void bar(); } inline namespace v2 { using v1::bar; void foo() { std::cout << "v2::foo()" << std::endl; } } namespace v1 { void foo() { std::cout << "v1::foo()" << std::endl; } void bar() { std::cout << "v1::bar()" << std::endl; foo(); // A bar()が定義されている名前空間v1のfoo()が呼び出される

msgpack::foo(); // B v2のfoo()が呼び出される

msgpack::v1::foo(); // C 明示的に指定された名前空間のfoo()が呼び出される

} } } http://melpon.org/wandbox/permlink/8HBPTxCmuTiuluaz

msgpack::bar(); v1::bar() v1::foo() v2::foo() v1::foo() msgpack::v1::bar(); v1::bar() v1::foo() v2::foo() v1::foo()

BとCを上手く使い分けることでバージョニングを実現

http://melpon.org/wandbox/permlink/8HBPTxCmuTiuluaz

http://melpon.org/wandbox/permlink/8HBPTxCmuTiuluaz



A

B

C

msgpack::B()

msgpack::C()

V1

D

msgpack::D()

inline namespace



A

B

C

A

ABI変更

msgpack::B()

msgpack::C()

V1 V2

D

msgpack::D()

msgpack::B()

inline namespace

using v1::B using V1::C using v1::D




A

B

C

A

C

ABI変更

msgpack::B()

msgpack::C()

V1 V2 V3

D

msgpack::D()

msgpack::B()

inline namespace

msgpack::D() using v2::D




A

B

C

A

C

ABI変更

msgpack::B()

msgpack::C()

V1 V2 V3

D

msgpack::D()

msgpack::B()

inline namespace





A

B'

C

A

C

ABI変更

msgpack::B()

msgpack::C()

V1 V2 V3

D

msgpack::D()

msgpack::B()

inline namespace


CのABI変更対応




A

B'

C

A

C

ABI変更

msgpack::B()

msgpack::C()

V1 V2 V3

D

msgpack::D()

msgpack::B()

inline namespace

msgpack::D()

using v2::A using v2::B using v2::D

CのABI変更対応

B'のABIに変更が無ければこれでOK




A

B'

C

A

C

ABI変更

msgpack::B()

msgpack::C()

V1 V2 V3

D

msgpack::D()

msgpack::B()

inline namespace

msgpack::D()

using v2::A using v2::B using v2::D

B'のABIに変更が生じる場合

CのABI変更対応




A

B''

C

A

C

ABI変更

msgpack::B()

msgpack::v1::C()

V1 V2 V3

D

msgpack::D()

msgpack::B()

inline namespace

msgpack::バージョン名前空間:: 修飾することで明示的に特定バージョンの名前空間を参照

msgpack::名前空間修飾することで inline namespaceを参照


CのABI変更対応をここでは行わない




A

B''

C

A

C

ABI変更

msgpack::B()

V1 V2 V3

D

msgpack::D()

B msgpack::B()

inline namespace

msgpack::v1::C()

msgpack::D()

msgpack::C()

using v2::D

CのABI変更対応

ABI変更




A

B''

C

A

C

ABI変更

msgpack::B()

V1 V2 V3

D

msgpack::D()

B

CのABI変更対応

msgpack::B()

inline namespace

msgpack::v1::C()

msgpack::D()

msgpack::C()

using v2::D

ABI変更




A'

B''

C

A'

C

ABI変更

msgpack::B()

V1 V2 V3

D

msgpack::D()

B

CのABI変更対応

msgpack::B()

inline namespace

msgpack::v1::C()

msgpack::D()

msgpack::C()

using v2::D

ABI変更 BのABI変更対応 BのABI変更対応




A'

B''

C

A'

C

ABI変更

msgpack::B()

V1 V2 V3

D

msgpack::D()

B

CのABI変更対応

msgpack::B()

inline namespace

msgpack::v1::C()

msgpack::D()

msgpack::C()

using v2::A using v2::D

ABI変更 BのABI変更対応 BのABI変更対応

A'のABIに変更が無ければこれでOK




A''

B'

C

A''

C

ABI変更

V1 V2 V3

D

msgpack::D()

B

ABI変更対応 A

inline namespace

msgpack::v1::C()

msgpack::v1::B()

msgpack::v1::B()

msgpack::D()

msgpack::C()

msgpack::B()

using v1::D

A'のABIに変更がある場合

ADL問題


namespace msgpack { template <typename Stream> class packer { public: packer(Stream&) {} template <typename T> packer<Stream>& pack(const T& v) { *this << v; return *this; } }; // Default behavior template <typename Stream, typename T> inline packer<Stream>& operator<< (packer<Stream>& o, const T&) { std::cout << "Default serialize" << std::endl; return o; } // API template <typename Stream, typename T> inline void pack(Stream& s, const T& v) { packer<Stream>(s).pack(v); } } // namespace msgpack



msgpack::operator(*this, v); と書かなければ、inline namespaceは参照されない



ADL問題


namespace msgpack { template <typename Stream> class packer { public: packer(Stream&) {} template <typename T> packer<Stream>& pack(const T& v) { msgpack::operator<<(*this, v); return *this; } }; // Default behavior template <typename Stream, typename T> inline packer<Stream>& operator<< (packer<Stream>& o, const T&) { std::cout << "Default serialize" << std::endl; return o; } // API template <typename Stream, typename T> inline void pack(Stream& s, const T& v) { packer<Stream>(s).pack(v); } } // namespace msgpack


http://melpon.org/wandbox/permlink/WlEDZo53McLh61AT

error: no member named 'operator<<' in namespace 'msgpack'



ADL問題


namespace msgpack { template <typename Stream> class packer { public: packer(Stream&) {} template <typename T> packer<Stream>& pack(const T& v) { msgpack::operator<<(*this, v); return *this; } }; // Default behavior template <typename Stream, typename T> inline packer<Stream>& operator<< (packer<Stream>& o, const T&) { std::cout << "Default serialize" << std::endl; return o; } // API template <typename Stream, typename T> inline void pack(Stream& s, const T& v) { packer<Stream>(s).pack(v); } } // namespace msgpack

template <typename Stream> class packer; template <typename Stream, typename T> packer<Stream>& operator<< (packer<Stream>& o, const T&);

http://melpon.org/wandbox/permlink/Mkp68SjWv9jsEqlD

先行宣言を入れてみると。。。



ADL問題


namespace msgpack { template <typename Stream> class packer { public: packer(Stream&) {} template <typename T> packer<Stream>& pack(const T& v) { msgpack::operator<<(*this, v); return *this; } }; // Default behavior template <typename Stream, typename T> inline packer<Stream>& operator<< (packer<Stream>& o, const T&){...} // User defined adaptor template <typename Stream> inline packer<Stream>& operator<< (packer<Stream>& o, int) { std::cout << "Int serialize" << std::endl; return o; } } // namespace msgpack




ユーザ定義のオーバーロードが呼ばれない



ADL問題


namespace msgpack { template <typename Stream> class packer { public: packer(Stream&) {} template <typename T> packer<Stream>& pack(const T& v) { msgpack::operator<<(*this, v); return *this; } }; // Default behavior template <typename Stream, typename T> inline packer<Stream>& operator<< (packer<Stream>& o, const T&){...} // User defined adaptor template <typename Stream> inline packer<Stream>& operator<< (packer<Stream>& o, int) { std::cout << "Int serialize" << std::endl; return o; } } // namespace msgpack

http://melpon.org/wandbox/permlink/tE5b4taP6cQPicXb

template <typename Stream> class packer; template <typename Stream, typename T> packer<Stream>& operator<< (packer<Stream>& o, const T&); template <typename Stream> packer<Stream>& operator<< (packer<Stream>& o, int);


ユーザ定義のオーバーロードの先行宣言を入れると期待通りディスパッチされる



ADL問題


msgpackの先行宣言群

ユーザの先行宣言群

msgpackのライブラリ本体

ユーザのコード本体

#include <msgpack_fwd.hpp>

#include <msgpack.hpp>

user.cpp

このアプローチの行き着く先にあるもの

ユーザコードの書き方に大きな制約を課してしまう

なにが問題なのか？


• オーバーロードによるアダプタの実現

– オーバーロードは、呼び出しコードがinstantiateした際、そこから見えている関数が候補となる

– ADLによって、呼び出しコードのinstantiate を遅延

– ADLを使うためには、名前空間修飾してはならない

• APIバージョニングの実現

– 名前空間修飾しないとAPIバージョニングできない

• この2つの相性が悪い

オーバーロードに変わる手段



class packer; template <typename T> packer& operator<< (packer& o, const T&); template <> packer& operator<< <int> (packer& o, const int&); http://melpon.org/wandbox/permlink/Jf9HNZaV8IFFE32W

template <typename Stream> packer<Stream>& operator<< <int> (packer<Stream>& o, const int&);

テンプレートの特殊化を使えばinstantiateは遅延される

しかし、関数テンプレートの部分特殊化はできない

もし、packerがクラステンプレートで無ければ、完全特殊化で対応できるのだが

部分特殊化するためには、関数テンプレートではなくクラステンプレートが必要

T を特殊化した int に置き換えるため、引数をconst int& にしなければならない

http://melpon.org/wandbox/permlink/Jf9HNZaV8IFFE32W

http://melpon.org/wandbox/permlink/Jf9HNZaV8IFFE32W



template <typename Stream, typename T> packer<Stream>& operator<< (packer<Stream>& o, const T&);

template <typename T> struct pack { template <typename Stream> msgpack::packer<Stream>& operator()(msgpack::packer<Stream>&, T const&) const; };

template <typename Stream> packer<Stream>& operator<< (packer<Stream>& o, int);

template <> struct pack<int> { template <typename Stream> msgpack::packer<Stream>& operator()(msgpack::packer<Stream>&, int) const; };

今回のケースでは、クラステンプレートの(完全)特殊化とメンバ関数テンプレートという構成で対応できた

いままでの、関数テンプレートオーバーロードによるAdaptor

クラステンプレートの特殊化によるAdaptor

http://melpon.org/wandbox/permlink/pcJUNyGh7zHMYLmS





#include <iostream> #include <sstream> namespace msgpack { template <typename Stream> class packer; namespace adaptor { template <typename T> struct pack { template <typename Stream> packer<Stream>& operator()(packer<Stream>& o, const T&) const { std::cout << "Default serialize" << std::endl; return o; } }; } // namespace adaptor template <typename Stream> class packer { public: packer(Stream&) {} template <typename T> packer<Stream>& pack(const T& v) { msgpack::adaptor::pack<T>()(*this, v); return *this; } }; // API template <typename Stream, typename T> inline void pack(Stream& s, const T& v) { packer<Stream>(s).pack(v); } } // namespace msgpack


// User defined adaptor namespace msgpack { namespace adaptor { template <> struct pack<int> { template <typename Stream> packer<Stream>& operator()(packer<Stream>& o, int) const { std::cout << "Int serialize" << std::endl; return o; } }; } // namespace adaptor } // namespace msgpack int main() { std::stringstream ss; msgpack::pack(ss, 1); msgpack::pack(ss, 1.2); }



まとめ


• ユーザ定義の型などに対して拡張性を持たせたい場合関数のオーバーロードよりもクラステンプレートの特殊化の方が柔軟に対応できる – 例：名前空間によるAPIバージョニングとの共存

• 将来が予測できない場合、最も柔軟なメカニズムで実装しておくと後々苦労しない – msgpack-cは、ライブラリが提供している、既存の全てのオーバーロードベースのアダプタをクラステンプレートに書き換えた

– 書き換えの際、当然ながら既存のユーザコードへの影響が出た

– msgpack-cではこれをメジャーバージョンアップに伴う破壊的変更とし、マイグレーションガイドなどのドキュメントも用意した

boost sg msgpack

Technology