+++ /dev/null
-// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
-/*
- * Ceph distributed storage system
- *
- * Copyright (C) 2016 Red Hat
- *
- * Author: Sage Weil <sage@redhat.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- */
-
-#include <stdio.h>
-#include <numeric>
-
-#include "global/global_init.h"
-#include "common/ceph_argparse.h"
-#include "global/global_context.h"
-#include "gtest/gtest.h"
-
-#include "include/denc.h"
-
-// test helpers
-
-template<typename T>
-void test_encode_decode(T v) {
- bufferlist bl;
- ::encode(v, bl);
- bufferlist::iterator p = bl.begin();
- T out;
- ::decode(out, p);
- ASSERT_EQ(v, out);
-}
-
-template<typename T>
-void test_denc(T v) {
- // estimate
- size_t s = 0;
- denc(v, s);
- ASSERT_NE(s, 0u);
-
- // encode
- bufferlist bl;
- {
- auto a = bl.get_contiguous_appender(s);
- denc(v, a);
- }
- ASSERT_LE(bl.length(), s);
-
- // decode
- bl.rebuild();
- T out;
- auto bpi = bl.front().begin();
- denc(out, bpi);
- ASSERT_EQ(v, out);
- ASSERT_EQ(bpi.get_pos(), bl.c_str() + bl.length());
-
- // test glue
- test_encode_decode(v);
-}
-
-template<typename T>
-void test_encode_decode_featured(T v) {
- bufferlist bl;
- ::encode(v, bl, 123);
- bufferlist::iterator p = bl.begin();
- T out;
- ::decode(out, p);
- ASSERT_EQ(v, out);
-}
-
-template<typename T>
-void test_denc_featured(T v) {
- // estimate
- size_t s = 0;
- denc(v, s, 0);
- ASSERT_GT(s, 0u);
-
- // encode
- bufferlist bl;
- {
- auto a = bl.get_contiguous_appender(s);
- denc(v, a, 1);
- }
- ASSERT_LE(bl.length(), s);
-
- // decode
- bl.rebuild();
- T out;
- auto bpi = bl.front().begin();
- denc(out, bpi, 1);
- ASSERT_EQ(v, out);
- ASSERT_EQ(bpi.get_pos(), bl.c_str() + bl.length());
-
- // test glue
- test_encode_decode_featured(v);
-}
-
-
-// hooks to count bound calls
-
-struct counts_t {
- int num_bound_encode = 0;
- int num_encode = 0;
- int num_decode = 0;
- void reset() {
- num_bound_encode = 0;
- num_encode = 0;
- num_decode = 0;
- }
-} counts;
-
-struct denc_counter_t {
- void bound_encode(size_t& p) const {
- ++counts.num_bound_encode;
- ++p; // denc.h does not like 0-length objects
- }
- void encode(buffer::list::contiguous_appender& p) const {
- p.append("a", 1);
- ++counts.num_encode;
- }
- void decode(buffer::ptr::iterator &p) {
- p.advance(1);
- ++counts.num_decode;
- }
-};
-WRITE_CLASS_DENC(denc_counter_t)
-
-struct denc_counter_bounded_t {
- void bound_encode(size_t& p) const {
- ++counts.num_bound_encode;
- ++p; // denc.h does not like 0-length objects
- }
- void encode(buffer::list::contiguous_appender& p) const {
- p.append("a", 1);
- ++counts.num_encode;
- }
- void decode(buffer::ptr::iterator &p) {
- p.advance(1);
- ++counts.num_decode;
- }
-};
-WRITE_CLASS_DENC_BOUNDED(denc_counter_bounded_t)
-
-TEST(denc, denc_counter)
-{
- denc_counter_t single, single2;
- {
- bufferlist bl;
- ::encode(single, bl);
- ::decode(single2, bl);
- }
- ASSERT_EQ(counts.num_bound_encode, 1);
- ASSERT_EQ(counts.num_encode, 1);
- ASSERT_EQ(counts.num_decode, 1);
- counts.reset();
-}
-
-TEST(denc, simple)
-{
- test_denc((uint8_t)4);
- test_denc((int8_t)-5);
- test_denc((uint16_t)6);
- test_denc((int16_t)-7);
- test_denc((uint32_t)8);
- test_denc((int32_t)-9);
- test_denc((uint64_t)10);
- test_denc((int64_t)-11);
-}
-
-TEST(denc, string)
-{
- string a, b("hi"), c("multi\nline\n");
- test_denc(a);
- test_denc(b);
- test_denc(c);
-}
-
-struct legacy_t {
- int32_t a = 1;
- void encode(bufferlist& bl) const {
- ::encode(a, bl);
- }
- void decode(bufferlist::iterator& p) {
- ::decode(a, p);
- }
- legacy_t() {}
- legacy_t(int32_t i) : a(i) {}
- friend bool operator<(const legacy_t& l, const legacy_t& r) {
- return l.a < r.a;
- }
- friend bool operator==(const legacy_t& l, const legacy_t& r) {
- return l.a == r.a;
- }
-};
-WRITE_CLASS_ENCODER(legacy_t)
-
-template<template<class> class C>
-void test_common_veclist(const char* c) {
- {
- cout << c << "<std::string>" << std::endl;
- C<std::string> s;
- s.push_back("foo");
- s.push_back("bar");
- s.push_back("baz");
- counts.reset();
- test_denc(s);
- }
- {
- cout << c << "<int32_t>" << std::endl;
- C<int32_t> s;
- s.push_back(1);
- s.push_back(2);
- s.push_back(3);
- test_denc(s);
- }
- {
- cout << c << "<legacy_t>" << std::endl;
- C<legacy_t> s;
- s.push_back(legacy_t(1));
- s.push_back(legacy_t(2));
- test_encode_decode(s);
- }
-}
-
-// We only care about specializing the type, all other template
-// parameters should have the default values. (Like first-class
-// functions, first-class templates do not bring their defaults.)
-
-template<typename T>
-using default_vector = std::vector<T>;
-
-TEST(denc, vector)
-{
- test_common_veclist<default_vector>("std::vector");
- {
- counts.reset();
- vector<denc_counter_t> v, v2;
- v.resize(100);
- {
- bufferlist bl;
- ::encode(v, bl);
- ::decode(v2, bl);
- }
- ASSERT_EQ(counts.num_bound_encode, 100);
- ASSERT_EQ(counts.num_encode, 100);
- ASSERT_EQ(counts.num_decode, 100);
- }
- {
- counts.reset();
- vector<denc_counter_bounded_t> v, v2;
- v.resize(100);
- {
- bufferlist bl;
- ::encode(v, bl);
- ::decode(v2, bl);
- }
- ASSERT_EQ(counts.num_bound_encode, 1);
- ASSERT_EQ(counts.num_encode, 100);
- ASSERT_EQ(counts.num_decode, 100);
- }
-}
-
-template<typename T>
-using default_list = std::list<T>;
-
-TEST(denc, list)
-{
- test_common_veclist<default_list>("std::list");
- {
- counts.reset();
- list<denc_counter_bounded_t> l, l2;
- for (unsigned i=0; i<100; ++i) {
- l.emplace_back(denc_counter_bounded_t());
- }
- {
- bufferlist bl;
- ::encode(l, bl);
- ::decode(l2, bl);
- }
- ASSERT_EQ(counts.num_bound_encode, 1);
- ASSERT_EQ(counts.num_encode, 100);
- ASSERT_EQ(counts.num_decode, 100);
- }
-}
-
-template<template<class> class C>
-void test_setlike(const char* c) {
- {
- cout << c << "<std::string>" << std::endl;
- C<std::string> s;
- s.insert("foo");
- s.insert("bar");
- s.insert("baz");
- test_denc(s);
- }
- {
- cout << c << "<int32_t>" << std::endl;
- C<int32_t> s;
- s.insert(1);
- s.insert(2);
- s.insert(3);
- test_denc(s);
- }
- {
- cout << c << "<legacy_t>" << std::endl;
- C<legacy_t> s;
- s.insert(legacy_t(1));
- s.insert(legacy_t(2));
- test_encode_decode(s);
- }
-}
-
-template<typename T>
-using default_set = std::set<T>;
-
-TEST(denc, set)
-{
- test_setlike<default_set>("std::set");
-}
-
-template<typename T>
-using default_flat_set= boost::container::flat_set<T>;
-
-TEST(denc, flat_set)
-{
- test_setlike<default_flat_set>("std::set");
-}
-
-struct foo_t {
- int32_t a = 0;
- uint64_t b = 123;
-
- DENC(foo_t, v, p) {
- DENC_START(1, 1, p);
- ::denc(v.a, p);
- ::denc(v.b, p);
- DENC_FINISH(p);
- }
-
- friend bool operator==(const foo_t& l, const foo_t& r) {
- return l.a == r.a && l.b == r.b;
- }
-};
-WRITE_CLASS_DENC_BOUNDED(foo_t)
-
-struct foo2_t {
- int32_t c = 0;
- uint64_t d = 123;
-
- DENC(foo2_t, v, p) {
- DENC_START(1, 1, p);
- ::denc(v.c, p);
- ::denc(v.d, p);
- DENC_FINISH(p);
- }
-
- friend bool operator==(const foo2_t& l, const foo2_t& r) {
- return l.c == r.c && l.d == r.d;
- }
-};
-WRITE_CLASS_DENC_BOUNDED(foo2_t)
-
-
-struct bar_t {
- int32_t a = 0;
- uint64_t b = 123;
-
- DENC_FEATURED(bar_t, v, p, f) {
- ::denc(v.a, p, f);
- ::denc(v.b, p, f);
- }
-
- friend bool operator==(const bar_t& l, const bar_t& r) {
- return l.a == r.a && l.b == r.b;
- }
-};
-WRITE_CLASS_DENC_FEATURED_BOUNDED(bar_t)
-
-TEST(denc, foo)
-{
- foo_t a;
- test_denc(a);
- bufferlist bl;
- ::encode(a, bl);
- bl.hexdump(cout);
-}
-
-TEST(denc, bar)
-{
- bar_t a;
- test_denc_featured(a);
-}
-
-
-
-TEST(denc, pair)
-{
- pair<int32_t,std::string> p;
- bufferlist bl;
- {
- auto a = bl.get_contiguous_appender(1000);
- denc(p, a);
- ::encode(p, bl);
- }
-
- pair<int32_t,legacy_t> lp;
- ::encode(lp, bl);
-}
-
-template<template<class, class> class C>
-void test_common_maplike(const char* c) {
- {
- cout << c << "<std::string, foo_t>" << std::endl;
- C<string, foo_t> s;
- s["foo"] = foo_t();
- s["bar"] = foo_t();
- s["baz"] = foo_t();
- test_denc(s);
- }
- {
- cout << c << "<std::string, bar_t>" << std::endl;
- C<string, bar_t> s;
- s["foo"] = bar_t();
- s["bar"] = bar_t();
- s["baz"] = bar_t();
- test_denc_featured(s);
- }
- {
- cout << c << "<std::string, legacy_t>" << std::endl;
- C<std::string, legacy_t> s;
- s["foo"] = legacy_t(1);
- s["bar"] = legacy_t(2);
- test_encode_decode(s);
- }
-}
-
-template<typename U, typename V>
-using default_map = std::map<U, V>;
-
-TEST(denc, map)
-{
- test_common_maplike<default_map>("std::map");
-}
-
-template<typename U, typename V>
-using default_flat_map = boost::container::flat_map<U, V>;
-
-TEST(denc, flat_map)
-{
- test_common_maplike<default_flat_map>("boost::container::flat_map");
-}
-
-TEST(denc, bufferptr_shallow_and_deep) {
- // shallow encode
- int32_t i = 1;
- bufferptr p1("foo", 3);
- bufferlist bl;
- {
- auto a = bl.get_contiguous_appender(100);
- denc(i, a);
- denc(p1, a);
- denc(i, a);
- }
- cout << "bl is " << bl << std::endl;
- bl.hexdump(cout);
- ASSERT_EQ(3u, bl.get_num_buffers());
-
- bufferlist bl2 = bl;
- bl.rebuild();
- bl2.rebuild();
-
- // shallow decode
- {
- cout << "bl is " << bl << std::endl;
- bl.hexdump(cout);
- auto p = bl.front().begin();
- bufferptr op;
- int32_t i;
- denc(i, p);
- denc(op, p);
- denc(i, p);
- ASSERT_EQ(3u, op.length());
- ASSERT_EQ('f', op[0]);
- memset(bl.c_str(), 0, bl.length());
- ASSERT_EQ(0, op[0]);
- }
-
- // deep decode
- {
- cout << "bl is " << bl2 << std::endl;
- bl2.hexdump(cout);
- auto p = bl2.front().begin_deep();
- bufferptr op;
- int32_t i;
- denc(i, p);
- denc(op, p);
- denc(i, p);
- ASSERT_EQ('f', op[0]);
- memset(bl2.c_str(), 1, bl2.length());
- ASSERT_EQ('f', op[0]);
- }
-}
-
-TEST(denc, array)
-{
- {
- cout << "std::array<std::string, 3>" << std::endl;
- std::array<std::string, 3> s = { "foo", "bar", "baz" };
- counts.reset();
- test_denc(s);
- }
- {
- cout << "std::array<uint32_t, 3>" << std::endl;
- std::array<uint32_t, 3> s = { 1UL, 2UL, 3UL };
- test_denc(s);
- }
-}
-
-TEST(denc, tuple)
-{
- {
- cout << "std::tuple<uint64_t, uint32_t>" << std::endl;
- std::tuple<uint64_t, uint32_t> s(100ULL, 97UL);
- counts.reset();
- test_denc(s);
- }
- {
- cout << "std::tuple<std::string, uint3_t>" << std::endl;
- std::tuple<std::string, uint32_t> s("foo", 97);
- test_denc(s);
- }
- {
- cout << "std::tuple<std::string, std::set<uint32_t>>" << std::endl;
- std::tuple<std::string, std::set<uint32_t>> s(
- "bar", std::set<uint32_t>{uint32_t(1), uint32_t(2), uint32_t(3)});
- test_denc(s);
- }
-}
-
-TEST(denc, optional)
-{
- {
- cout << "boost::optional<uint64_t>" << std::endl;
- boost::optional<uint64_t> s = 97, t = boost::none;
- counts.reset();
- test_denc(s);
- test_denc(t);
- }
- {
- cout << "boost::optional<std::string>" << std::endl;
- boost::optional<std::string> s = std::string("Meow"), t = boost::none;
- counts.reset();
- test_denc(s);
- test_denc(t);
- }
- {
- size_t s = 0;
- denc(boost::none, s);
- ASSERT_NE(s, 0u);
-
- // encode
- bufferlist bl;
- {
- auto a = bl.get_contiguous_appender(s);
- denc(boost::none, a);
- }
- ASSERT_LE(bl.length(), s);
-
- bl.rebuild();
- boost::optional<uint32_t> out = 5;
- auto bpi = bl.front().begin();
- denc(out, bpi);
- ASSERT_FALSE(!!out);
- ASSERT_EQ(bpi.get_pos(), bl.c_str() + bl.length());
- }
-}
-
-// unlike legacy_t, Legacy supports denc() also.
-struct Legacy {
- static unsigned n_denc;
- static unsigned n_decode;
- uint8_t value = 0;
- DENC(Legacy, v, p) {
- n_denc++;
- denc(v.value, p);
- }
- void decode(buffer::list::iterator& p) {
- n_decode++;
- ::decode(value, p);
- }
- static void reset() {
- n_denc = n_decode = 0;
- }
- static bufferlist encode_n(unsigned n, const vector<unsigned>& segments);
-};
-WRITE_CLASS_DENC(Legacy)
-unsigned Legacy::n_denc = 0;
-unsigned Legacy::n_decode = 0;
-
-bufferlist Legacy::encode_n(unsigned n, const vector<unsigned>& segments) {
- vector<Legacy> v;
- for (unsigned i = 0; i < n; i++) {
- v.push_back(Legacy());
- }
- bufferlist bl(n * sizeof(uint8_t));
- ::encode(v, bl);
- bufferlist segmented;
- auto p = bl.begin();
-
- auto sum = std::accumulate(segments.begin(), segments.end(), 0u);
- assert(sum != 0u);
- for (auto i : segments) {
- buffer::ptr seg;
- p.copy_deep(bl.length() * i / sum, seg);
- segmented.push_back(seg);
- }
- p.copy_all(segmented);
- return segmented;
-}
-
-TEST(denc, no_copy_if_segmented_and_lengthy)
-{
- static_assert(_denc::has_legacy_denc<Legacy>::value,
- "Legacy do have legacy denc");
- {
- // use denc() which shallow_copy() if the buffer is small
- constexpr unsigned N_COPIES = 42;
- const vector<unsigned> segs{50, 50}; // half-half
- bufferlist segmented = Legacy::encode_n(N_COPIES, segs);
- ASSERT_GT(segmented.get_num_buffers(), 1u);
- ASSERT_LT(segmented.length(), CEPH_PAGE_SIZE);
- auto p = segmented.begin();
- vector<Legacy> v;
- // denc() is shared by encode() and decode(), so reset() right before
- // decode()
- Legacy::reset();
- ::decode(v, p);
- ASSERT_EQ(N_COPIES, v.size());
- ASSERT_EQ(N_COPIES, Legacy::n_denc);
- ASSERT_EQ(0u, Legacy::n_decode);
- }
- {
- // use denc() which shallow_copy() if the buffer is not segmented and large
- const unsigned N_COPIES = CEPH_PAGE_SIZE * 2;
- const vector<unsigned> segs{100};
- bufferlist segmented = Legacy::encode_n(N_COPIES, segs);
- ASSERT_EQ(segmented.get_num_buffers(), 1u);
- ASSERT_GT(segmented.length(), CEPH_PAGE_SIZE);
- auto p = segmented.begin();
- vector<Legacy> v;
- Legacy::reset();
- ::decode(v, p);
- ASSERT_EQ(N_COPIES, v.size());
- ASSERT_EQ(N_COPIES, Legacy::n_denc);
- ASSERT_EQ(0u, Legacy::n_decode);
- }
- {
- // use denc() which shallow_copy() if the buffer is segmented and large,
- // but the total size of the chunks to be decoded is smallish.
- bufferlist large_bl = Legacy::encode_n(CEPH_PAGE_SIZE * 2, {50, 50});
- bufferlist small_bl = Legacy::encode_n(100, {50, 50});
- bufferlist segmented;
- segmented.append(large_bl);
- segmented.append(small_bl);
- ASSERT_GT(segmented.get_num_buffers(), 1u);
- ASSERT_GT(segmented.length(), CEPH_PAGE_SIZE);
- auto p = segmented.begin();
- p.advance(large_bl.length());
- ASSERT_LT(segmented.length() - p.get_off(), CEPH_PAGE_SIZE);
- vector<Legacy> v;
- Legacy::reset();
- ::decode(v, p);
- ASSERT_EQ(Legacy::n_denc, 100u);
- ASSERT_EQ(0u, Legacy::n_decode);
- }
- {
- // use decode() which avoids deep copy if the buffer is segmented and large
- bufferlist small_bl = Legacy::encode_n(100, {50, 50});
- bufferlist large_bl = Legacy::encode_n(CEPH_PAGE_SIZE * 2, {50, 50});
- bufferlist segmented;
- segmented.append(small_bl);
- segmented.append(large_bl);
- ASSERT_GT(segmented.get_num_buffers(), 1u);
- ASSERT_GT(segmented.length(), CEPH_PAGE_SIZE);
- auto p = segmented.begin();
- p.advance(small_bl.length());
- ASSERT_GT(segmented.length() - p.get_off(), CEPH_PAGE_SIZE);
- vector<Legacy> v;
- Legacy::reset();
- ::decode(v, p);
- ASSERT_EQ(0u, Legacy::n_denc);
- ASSERT_EQ(CEPH_PAGE_SIZE * 2, Legacy::n_decode);
- }
-}
Code Review / stor4nfv.git / blobdiff