BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-28 07:18:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Efficient Conversion of a FlatBufferBuilder to a MessageBuilder (#4980)

Browse Source 
* Efficient conversion of FlatBufferBuilder to grpc::MessageBuilder

* Added a variety of tests to validate correctness of the MessageBuilder move operations.
Disable MessageBuilder half-n-half tests on MacOS.

* Fix failing Android build

* Generalized the MessageBuilder move constructor to accept a deallocator
This commit is contained in:
Sumant Tambe
2018-10-18 10:32:59 -07:00
committed by Wouter van Oortmerssen
parent ad8b1e5dbd
commit 802639e40d
6 changed files with 441 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
grpc/tests/grpctest.cpp
View File

@@ -23,6 +23,9 @@
#include "test_assert.h" #include "test_assert.h"
using namespace MyGame::Example; using namespace MyGame::Example;
using flatbuffers::grpc::MessageBuilder;
using flatbuffers::FlatBufferBuilder;
void message_builder_tests(); void message_builder_tests();
// The callback implementation of our server, that derives from the generated // The callback implementation of our server, that derives from the generated
@@ -46,9 +49,9 @@ class ServiceImpl final : public MyGame::Example::MonsterStorage::Service {
const flatbuffers::grpc::Message<Stat> *request, const flatbuffers::grpc::Message<Stat> *request,
::grpc::ServerWriter<flatbuffers::grpc::Message<Monster>> *writer) ::grpc::ServerWriter<flatbuffers::grpc::Message<Monster>> *writer)
override { override {
for (int i = 0; i < 10; i++) { for (int i = 0; i < 5; i++) {
fbb_.Clear(); fbb_.Clear();
// Create 10 monsters for resposne. // Create 5 monsters for resposne.
auto monster_offset = auto monster_offset =
CreateMonster(fbb_, 0, 0, 0, CreateMonster(fbb_, 0, 0, 0,
fbb_.CreateString(request->GetRoot()->id()->str() + fbb_.CreateString(request->GetRoot()->id()->str() +
@@ -94,6 +97,45 @@ void RunServer() {
server_instance->Wait(); server_instance->Wait();
} }
template <class Builder>
void StoreRPC(MonsterStorage::Stub *stub) {
Builder fbb;
grpc::ClientContext context;
// Build a request with the name set.
auto monster_offset = CreateMonster(fbb, 0, 0, 0, fbb.CreateString("Fred"));
MessageBuilder mb(std::move(fbb));
mb.Finish(monster_offset);
auto request = mb.ReleaseMessage<Monster>();
flatbuffers::grpc::Message<Stat> response;
// The actual RPC.
auto status = stub->Store(&context, request, &response);
if (status.ok()) {
auto resp = response.GetRoot()->id();
std::cout << "RPC response: " << resp->str() << std::endl;
} else {
std::cout << "RPC failed" << std::endl;
}
}
template <class Builder>
void RetrieveRPC(MonsterStorage::Stub *stub) {
Builder fbb;
grpc::ClientContext context;
fbb.Clear();
auto stat_offset = CreateStat(fbb, fbb.CreateString("Fred"));
fbb.Finish(stat_offset);
auto request = MessageBuilder(std::move(fbb)).ReleaseMessage<Stat>();
flatbuffers::grpc::Message<Monster> response;
auto stream = stub->Retrieve(&context, request);
while (stream->Read(&response)) {
auto resp = response.GetRoot()->name();
std::cout << "RPC Streaming response: " << resp->str() << std::endl;
}
}
int grpc_server_test() { int grpc_server_test() {
// Launch server. // Launch server.
std::thread server_thread(RunServer); std::thread server_thread(RunServer);
@@ -107,39 +149,12 @@ int grpc_server_test() {
grpc::InsecureChannelCredentials()); grpc::InsecureChannelCredentials());
auto stub = MyGame::Example::MonsterStorage::NewStub(channel); auto stub = MyGame::Example::MonsterStorage::NewStub(channel);
flatbuffers::grpc::MessageBuilder fbb; StoreRPC<MessageBuilder>(stub.get());
{ StoreRPC<FlatBufferBuilder>(stub.get());
grpc::ClientContext context;
// Build a request with the name set.
auto monster_offset = CreateMonster(fbb, 0, 0, 0, fbb.CreateString("Fred"));
fbb.Finish(monster_offset);
auto request = fbb.ReleaseMessage<Monster>();
flatbuffers::grpc::Message<Stat> response;
// The actual RPC. RetrieveRPC<MessageBuilder>(stub.get());
auto status = stub->Store(&context, request, &response); RetrieveRPC<FlatBufferBuilder>(stub.get());
if (status.ok()) {
auto resp = response.GetRoot()->id();
std::cout << "RPC response: " << resp->str() << std::endl;
} else {
std::cout << "RPC failed" << std::endl;
}
}
{
grpc::ClientContext context;
fbb.Clear();
auto stat_offset = CreateStat(fbb, fbb.CreateString("Fred"));
fbb.Finish(stat_offset);
auto request = fbb.ReleaseMessage<Stat>();
flatbuffers::grpc::Message<Monster> response;
auto stream = stub->Retrieve(&context, request);
while (stream->Read(&response)) {
auto resp = response.GetRoot()->name();
std::cout << "RPC Streaming response: " << resp->str() << std::endl;
}
}
#if !FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION #if !FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION
{ {

246
grpc/tests/message_builder_test.cpp
View File

@@ -14,19 +14,37 @@ bool release_n_verify(flatbuffers::grpc::MessageBuilder &mbb, const std::string
return (monster->name()->str() == expected_name) && (monster->color() == color); return (monster->name()->str() == expected_name) && (monster->color() == color);
} }
template <> void builder_move_assign_after_releaseraw_test(flatbuffers::grpc::MessageBuilder dst) {
struct BuilderReuseTests<flatbuffers::grpc::MessageBuilder> { auto root_offset1 = populate1(dst);
dst.Finish(root_offset1);
size_t size, offset;
grpc_slice slice;
dst.ReleaseRaw(size, offset, slice);
flatbuffers::FlatBufferBuilder src;
auto root_offset2 = populate2(src);
src.Finish(root_offset2);
auto src_size = src.GetSize();
// Move into a released builder.
dst = std::move(src);
TEST_EQ(dst.GetSize(), src_size);
TEST_ASSERT(release_n_verify(dst, m2_name, m2_color));
TEST_EQ(src.GetSize(), 0);
grpc_slice_unref(slice);
}
template <class SrcBuilder>
struct BuilderReuseTests<flatbuffers::grpc::MessageBuilder, SrcBuilder> {
static void builder_reusable_after_release_message_test(TestSelector selector) { static void builder_reusable_after_release_message_test(TestSelector selector) {
if (!selector.count(REUSABLE_AFTER_RELEASE_MESSAGE)) { if (!selector.count(REUSABLE_AFTER_RELEASE_MESSAGE)) {
return; return;
} }
flatbuffers::grpc::MessageBuilder b1; flatbuffers::grpc::MessageBuilder mb;
std::vector<flatbuffers::grpc::Message<Monster>> buffers; std::vector<flatbuffers::grpc::Message<Monster>> buffers;
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(mb);
b1.Finish(root_offset1); mb.Finish(root_offset1);
buffers.push_back(b1.ReleaseMessage<Monster>()); buffers.push_back(mb.ReleaseMessage<Monster>());
TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color)); TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color));
} }
} }
@@ -36,14 +54,15 @@ struct BuilderReuseTests<flatbuffers::grpc::MessageBuilder> {
return; return;
} }
// FIXME: Populate-Release loop fails assert(GRPC_SLICE_IS_EMPTY(slice_)). // FIXME: Populate-Release loop fails assert(GRPC_SLICE_IS_EMPTY(slice_)) in SliceAllocator::allocate
// in the second iteration.
flatbuffers::grpc::MessageBuilder b1; flatbuffers::grpc::MessageBuilder mb;
std::vector<flatbuffers::DetachedBuffer> buffers; std::vector<flatbuffers::DetachedBuffer> buffers;
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 2; ++i) {
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(mb);
b1.Finish(root_offset1); mb.Finish(root_offset1);
buffers.push_back(b1.Release()); buffers.push_back(mb.Release());
TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color)); TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color));
} }
} }
@@ -53,13 +72,13 @@ struct BuilderReuseTests<flatbuffers::grpc::MessageBuilder> {
return; return;
} }
flatbuffers::grpc::MessageBuilder b1; flatbuffers::grpc::MessageBuilder mb;
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(mb);
b1.Finish(root_offset1); mb.Finish(root_offset1);
size_t size, offset; size_t size, offset;
grpc_slice slice; grpc_slice slice;
const uint8_t *buf = b1.ReleaseRaw(size, offset, slice); const uint8_t *buf = mb.ReleaseRaw(size, offset, slice);
TEST_ASSERT_FUNC(verify(buf, offset, m1_name, m1_color)); TEST_ASSERT_FUNC(verify(buf, offset, m1_name, m1_color));
grpc_slice_unref(slice); grpc_slice_unref(slice);
} }
@@ -70,22 +89,23 @@ struct BuilderReuseTests<flatbuffers::grpc::MessageBuilder> {
return; return;
} }
// FIXME: Release-move_assign loop fails assert(p == GRPC_SLICE_START_PTR(slice_)). // FIXME: Release-move_assign loop fails assert(p == GRPC_SLICE_START_PTR(slice_))
// in DetachedBuffer destructor after all the iterations
flatbuffers::grpc::MessageBuilder b1; flatbuffers::grpc::MessageBuilder dst;
std::vector<flatbuffers::DetachedBuffer> buffers; std::vector<flatbuffers::DetachedBuffer> buffers;
for (int i = 0; i < 1; ++i) { for (int i = 0; i < 2; ++i) {
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(dst);
b1.Finish(root_offset1); dst.Finish(root_offset1);
buffers.push_back(b1.Release()); buffers.push_back(dst.Release());
TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color)); TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color));
// bring b1 back to life. // bring dst back to life.
flatbuffers::grpc::MessageBuilder b2; SrcBuilder src;
b1 = std::move(b2); dst = std::move(src);
TEST_EQ_FUNC(b1.GetSize(), 0); TEST_EQ_FUNC(dst.GetSize(), 0);
TEST_EQ_FUNC(b2.GetSize(), 0); TEST_EQ_FUNC(src.GetSize(), 0);
} }
} }
@@ -94,20 +114,20 @@ struct BuilderReuseTests<flatbuffers::grpc::MessageBuilder> {
return; return;
} }
flatbuffers::grpc::MessageBuilder b1; flatbuffers::grpc::MessageBuilder dst;
std::vector<flatbuffers::grpc::Message<Monster>> buffers; std::vector<flatbuffers::grpc::Message<Monster>> buffers;
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(dst);
b1.Finish(root_offset1); dst.Finish(root_offset1);
buffers.push_back(b1.ReleaseMessage<Monster>()); buffers.push_back(dst.ReleaseMessage<Monster>());
TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color)); TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color));
// bring b1 back to life. // bring dst back to life.
flatbuffers::grpc::MessageBuilder b2; SrcBuilder src;
b1 = std::move(b2); dst = std::move(src);
TEST_EQ_FUNC(b1.GetSize(), 0); TEST_EQ_FUNC(dst.GetSize(), 0);
TEST_EQ_FUNC(b2.GetSize(), 0); TEST_EQ_FUNC(src.GetSize(), 0);
} }
} }
@@ -116,20 +136,20 @@ struct BuilderReuseTests<flatbuffers::grpc::MessageBuilder> {
return; return;
} }
flatbuffers::grpc::MessageBuilder b1; flatbuffers::grpc::MessageBuilder dst;
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(dst);
b1.Finish(root_offset1); dst.Finish(root_offset1);
size_t size, offset; size_t size, offset;
grpc_slice slice = grpc_empty_slice(); grpc_slice slice = grpc_empty_slice();
const uint8_t *buf = b1.ReleaseRaw(size, offset, slice); const uint8_t *buf = dst.ReleaseRaw(size, offset, slice);
TEST_ASSERT_FUNC(verify(buf, offset, m1_name, m1_color)); TEST_ASSERT_FUNC(verify(buf, offset, m1_name, m1_color));
grpc_slice_unref(slice); grpc_slice_unref(slice);
flatbuffers::grpc::MessageBuilder b2; SrcBuilder src;
b1 = std::move(b2); dst = std::move(src);
TEST_EQ_FUNC(b1.GetSize(), 0); TEST_EQ_FUNC(dst.GetSize(), 0);
TEST_EQ_FUNC(b2.GetSize(), 0); TEST_EQ_FUNC(src.GetSize(), 0);
} }
} }
@@ -153,7 +173,7 @@ void slice_allocator_tests() {
buf[0] = 100; buf[0] = 100;
buf[size-1] = 200; buf[size-1] = 200;
flatbuffers::grpc::SliceAllocator sa2(std::move(sa1)); flatbuffers::grpc::SliceAllocator sa2(std::move(sa1));
// buf should be deleted after move-construct // buf should not be deleted after move-construct
TEST_EQ_FUNC(buf[0], 100); TEST_EQ_FUNC(buf[0], 100);
TEST_EQ_FUNC(buf[size-1], 200); TEST_EQ_FUNC(buf[size-1], 200);
// buf is freed here // buf is freed here
@@ -170,13 +190,140 @@ void slice_allocator_tests() {
} }
} }
/// This function does not populate exactly the first half of the table. But it could.
void populate_first_half(MyGame::Example::MonsterBuilder &wrapper, flatbuffers::Offset<flatbuffers::String> name_offset) {
wrapper.add_name(name_offset);
wrapper.add_color(m1_color);
}
/// This function does not populate exactly the second half of the table. But it could.
void populate_second_half(MyGame::Example::MonsterBuilder &wrapper) {
wrapper.add_hp(77);
wrapper.add_mana(88);
Vec3 vec3;
wrapper.add_pos(&vec3);
}
/// This function is a hack to update the FlatBufferBuilder reference (fbb_) in the MonsterBuilder object.
/// This function will break if fbb_ is not the first member in MonsterBuilder. In that case, some offset must be added.
/// This function is used exclusively for testing correctness of move operations between FlatBufferBuilders.
/// If MonsterBuilder had a fbb_ pointer, this hack would be unnecessary. That involves a code-generator change though.
void test_only_hack_update_fbb_reference(MyGame::Example::MonsterBuilder &monsterBuilder,
flatbuffers::grpc::MessageBuilder &mb) {
*reinterpret_cast<flatbuffers::FlatBufferBuilder **>(&monsterBuilder) = &mb;
}
/// This test validates correctness of move conversion of FlatBufferBuilder to a MessageBuilder DURING
/// a table construction. Half of the table is constructed using FlatBufferBuilder and the other half
/// of the table is constructed using a MessageBuilder.
void builder_move_ctor_conversion_before_finish_half_n_half_table_test() {
for (size_t initial_size = 4 ; initial_size <= 2048; initial_size *= 2) {
flatbuffers::FlatBufferBuilder fbb(initial_size);
auto name_offset = fbb.CreateString(m1_name);
MyGame::Example::MonsterBuilder monsterBuilder(fbb); // starts a table in FlatBufferBuilder
populate_first_half(monsterBuilder, name_offset);
flatbuffers::grpc::MessageBuilder mb(std::move(fbb));
test_only_hack_update_fbb_reference(monsterBuilder, mb); // hack
populate_second_half(monsterBuilder);
mb.Finish(monsterBuilder.Finish()); // ends the table in MessageBuilder
TEST_ASSERT_FUNC(release_n_verify(mb, m1_name, m1_color));
TEST_EQ_FUNC(fbb.GetSize(), 0);
}
}
/// This test populates a COMPLETE inner table before move conversion and later populates more members in the outer table.
void builder_move_ctor_conversion_before_finish_test() {
for (size_t initial_size = 4 ; initial_size <= 2048; initial_size *= 2) {
flatbuffers::FlatBufferBuilder fbb(initial_size);
auto stat_offset = CreateStat(fbb, fbb.CreateString("SomeId"), 0, 0);
flatbuffers::grpc::MessageBuilder mb(std::move(fbb));
auto monster_offset = CreateMonster(mb, 0, 150, 100, mb.CreateString(m1_name), 0, m1_color, Any_NONE, 0, 0, 0, 0, 0, 0, stat_offset);
mb.Finish(monster_offset);
TEST_ASSERT_FUNC(release_n_verify(mb, m1_name, m1_color));
TEST_EQ_FUNC(fbb.GetSize(), 0);
}
}
/// This test validates correctness of move conversion of FlatBufferBuilder to a MessageBuilder DURING
/// a table construction. Half of the table is constructed using FlatBufferBuilder and the other half
/// of the table is constructed using a MessageBuilder.
void builder_move_assign_conversion_before_finish_half_n_half_table_test() {
flatbuffers::FlatBufferBuilder fbb;
flatbuffers::grpc::MessageBuilder mb;
for (int i = 0;i < 5; ++i) {
flatbuffers::FlatBufferBuilder fbb;
auto name_offset = fbb.CreateString(m1_name);
MyGame::Example::MonsterBuilder monsterBuilder(fbb); // starts a table in FlatBufferBuilder
populate_first_half(monsterBuilder, name_offset);
mb = std::move(fbb);
test_only_hack_update_fbb_reference(monsterBuilder, mb); // hack
populate_second_half(monsterBuilder);
mb.Finish(monsterBuilder.Finish()); // ends the table in MessageBuilder
TEST_ASSERT_FUNC(release_n_verify(mb, m1_name, m1_color));
TEST_EQ_FUNC(fbb.GetSize(), 0);
}
}
/// This test populates a COMPLETE inner table before move conversion and later populates more members in the outer table.
void builder_move_assign_conversion_before_finish_test() {
flatbuffers::FlatBufferBuilder fbb;
flatbuffers::grpc::MessageBuilder mb;
for (int i = 0;i < 5; ++i) {
auto stat_offset = CreateStat(fbb, fbb.CreateString("SomeId"), 0, 0);
mb = std::move(fbb);
auto monster_offset = CreateMonster(mb, 0, 150, 100, mb.CreateString(m1_name), 0, m1_color, Any_NONE, 0, 0, 0, 0, 0, 0, stat_offset);
mb.Finish(monster_offset);
TEST_ASSERT_FUNC(release_n_verify(mb, m1_name, m1_color));
TEST_EQ_FUNC(fbb.GetSize(), 0);
}
}
/// This test populates data, finishes the buffer, and does move conversion after.
void builder_move_ctor_conversion_after_finish_test() {
flatbuffers::FlatBufferBuilder fbb;
fbb.Finish(populate1(fbb));
flatbuffers::grpc::MessageBuilder mb(std::move(fbb));
TEST_ASSERT_FUNC(release_n_verify(mb, m1_name, m1_color));
TEST_EQ_FUNC(fbb.GetSize(), 0);
}
/// This test populates data, finishes the buffer, and does move conversion after.
void builder_move_assign_conversion_after_finish_test() {
flatbuffers::FlatBufferBuilder fbb;
flatbuffers::grpc::MessageBuilder mb;
for (int i = 0;i < 5; ++i) {
fbb.Finish(populate1(fbb));
mb = std::move(fbb);
TEST_ASSERT_FUNC(release_n_verify(mb, m1_name, m1_color));
TEST_EQ_FUNC(fbb.GetSize(), 0);
}
}
void message_builder_tests() { void message_builder_tests() {
using flatbuffers::grpc::MessageBuilder;
using flatbuffers::FlatBufferBuilder;
slice_allocator_tests(); slice_allocator_tests();
BuilderTests<flatbuffers::grpc::MessageBuilder>::all_tests();
#ifndef __APPLE__
builder_move_ctor_conversion_before_finish_half_n_half_table_test();
builder_move_assign_conversion_before_finish_half_n_half_table_test();
#endif // __APPLE__
builder_move_ctor_conversion_before_finish_test();
builder_move_assign_conversion_before_finish_test();
builder_move_ctor_conversion_after_finish_test();
builder_move_assign_conversion_after_finish_test();
BuilderTests<MessageBuilder, MessageBuilder>::all_tests();
BuilderTests<MessageBuilder, FlatBufferBuilder>::all_tests();
BuilderReuseTestSelector tests[6] = { BuilderReuseTestSelector tests[6] = {
// REUSABLE_AFTER_RELEASE, // Assertion failed: (GRPC_SLICE_IS_EMPTY(slice_)) //REUSABLE_AFTER_RELEASE, // Assertion failed: (GRPC_SLICE_IS_EMPTY(slice_))
// REUSABLE_AFTER_RELEASE_AND_MOVE_ASSIGN, // Assertion failed: (p == GRPC_SLICE_START_PTR(slice_) //REUSABLE_AFTER_RELEASE_AND_MOVE_ASSIGN, // Assertion failed: (p == GRPC_SLICE_START_PTR(slice_)
REUSABLE_AFTER_RELEASE_RAW, REUSABLE_AFTER_RELEASE_RAW,
REUSABLE_AFTER_RELEASE_MESSAGE, REUSABLE_AFTER_RELEASE_MESSAGE,
@@ -184,5 +331,6 @@ void message_builder_tests() {
REUSABLE_AFTER_RELEASE_RAW_AND_MOVE_ASSIGN REUSABLE_AFTER_RELEASE_RAW_AND_MOVE_ASSIGN
}; };
BuilderReuseTests<flatbuffers::grpc::MessageBuilder>::run_tests(TestSelector(tests, tests+6)); BuilderReuseTests<MessageBuilder, MessageBuilder>::run_tests(TestSelector(tests, tests+6));
BuilderReuseTests<MessageBuilder, FlatBufferBuilder>::run_tests(TestSelector(tests, tests+6));
} }

15
include/flatbuffers/flatbuffers.h
View File

@@ -425,6 +425,10 @@ class DefaultAllocator : public Allocator {
void deallocate(uint8_t *p, size_t) FLATBUFFERS_OVERRIDE { void deallocate(uint8_t *p, size_t) FLATBUFFERS_OVERRIDE {
delete[] p; delete[] p;
} }
static void dealloc(void *p, size_t) {
delete[] static_cast<uint8_t *>(p);
}
}; };
// These functions allow for a null allocator to mean use the default allocator, // These functions allow for a null allocator to mean use the default allocator,
@@ -549,7 +553,7 @@ class DetachedBuffer {
#endif // !defined(FLATBUFFERS_CPP98_STL) #endif // !defined(FLATBUFFERS_CPP98_STL)
// clang-format on // clang-format on
protected: protected:
Allocator *allocator_; Allocator *allocator_;
bool own_allocator_; bool own_allocator_;
uint8_t *buf_; uint8_t *buf_;
@@ -986,7 +990,7 @@ class FlatBufferBuilder {
/// `FlatBuffer` starts. /// `FlatBuffer` starts.
/// @return A raw pointer to the start of the memory block containing /// @return A raw pointer to the start of the memory block containing
/// the serialized `FlatBuffer`. /// the serialized `FlatBuffer`.
/// @remark If the allocator is owned, it gets deleted during this call. /// @remark If the allocator is owned, it gets deleted when the destructor is called..
uint8_t *ReleaseRaw(size_t &size, size_t &offset) { uint8_t *ReleaseRaw(size_t &size, size_t &offset) {
Finished(); Finished();
return buf_.release_raw(size, offset); return buf_.release_raw(size, offset);
@@ -1759,7 +1763,12 @@ class FlatBufferBuilder {
Finish(root.o, file_identifier, true); Finish(root.o, file_identifier, true);
} }
protected: void SwapBufAllocator(FlatBufferBuilder &other) {
buf_.swap_allocator(other.buf_);
}
protected:
// You shouldn't really be copying instances of this class. // You shouldn't really be copying instances of this class.
FlatBufferBuilder(const FlatBufferBuilder &); FlatBufferBuilder(const FlatBufferBuilder &);
FlatBufferBuilder &operator=(const FlatBufferBuilder &); FlatBufferBuilder &operator=(const FlatBufferBuilder &);

26
include/flatbuffers/grpc.h
View File

@@ -164,7 +164,7 @@ class MessageBuilder : private detail::SliceAllocatorMember,
public FlatBufferBuilder { public FlatBufferBuilder {
public: public:
explicit MessageBuilder(uoffset_t initial_size = 1024) explicit MessageBuilder(uoffset_t initial_size = 1024)
: FlatBufferBuilder(initial_size, &slice_allocator_, false) {} : FlatBufferBuilder(initial_size, &slice_allocator_, false) {}
MessageBuilder(const MessageBuilder &other) = delete; MessageBuilder(const MessageBuilder &other) = delete;
MessageBuilder &operator=(const MessageBuilder &other) = delete; MessageBuilder &operator=(const MessageBuilder &other) = delete;
@@ -175,6 +175,30 @@ class MessageBuilder : private detail::SliceAllocatorMember,
Swap(other); Swap(other);
} }
/// Create a MessageBuilder from a FlatBufferBuilder.
explicit MessageBuilder(FlatBufferBuilder &&src, void (*dealloc)(void*, size_t) = &DefaultAllocator::dealloc)
: FlatBufferBuilder(1024, &slice_allocator_, false) {
src.Swap(*this);
src.SwapBufAllocator(*this);
if (buf_.capacity()) {
uint8_t *buf = buf_.scratch_data(); // pointer to memory
size_t capacity = buf_.capacity(); // size of memory
slice_allocator_.slice_ = grpc_slice_new_with_len(buf, capacity, dealloc);
}
else {
slice_allocator_.slice_ = grpc_empty_slice();
}
}
/// Move-assign a FlatBufferBuilder to a MessageBuilder.
/// Only FlatBufferBuilder with default allocator (basically, nullptr) is supported.
MessageBuilder &operator=(FlatBufferBuilder &&src) {
// Move construct a temporary and swap
MessageBuilder temp(std::move(src));
Swap(temp);
return *this;
}
MessageBuilder &operator=(MessageBuilder &&other) { MessageBuilder &operator=(MessageBuilder &&other) {
// Move construct a temporary and swap // Move construct a temporary and swap
MessageBuilder temp(std::move(other)); MessageBuilder temp(std::move(other));

10
tests/test_builder.cpp
View File

@@ -129,7 +129,9 @@ bool release_n_verify(flatbuffers::FlatBufferBuilder &fbb, const std::string &ex
} }
void FlatBufferBuilderTest() { void FlatBufferBuilderTest() {
BuilderTests<flatbuffers::FlatBufferBuilder>::all_tests(); using flatbuffers::FlatBufferBuilder;
BuilderTests<FlatBufferBuilder>::all_tests();
BuilderTests<TestHeapBuilder>::all_tests(); BuilderTests<TestHeapBuilder>::all_tests();
BuilderTests<GrpcLikeMessageBuilder>::all_tests(); BuilderTests<GrpcLikeMessageBuilder>::all_tests();
@@ -140,7 +142,7 @@ void FlatBufferBuilderTest() {
REUSABLE_AFTER_RELEASE_RAW_AND_MOVE_ASSIGN REUSABLE_AFTER_RELEASE_RAW_AND_MOVE_ASSIGN
}; };
BuilderReuseTests<flatbuffers::FlatBufferBuilder>::run_tests(TestSelector(tests, tests+4)); BuilderReuseTests<FlatBufferBuilder, FlatBufferBuilder>::run_tests(TestSelector(tests, tests+4));
BuilderReuseTests<TestHeapBuilder>::run_tests(TestSelector(tests, tests+4)); BuilderReuseTests<TestHeapBuilder, TestHeapBuilder>::run_tests(TestSelector(tests, tests+4));
BuilderReuseTests<GrpcLikeMessageBuilder>::run_tests(TestSelector(tests, tests+4)); BuilderReuseTests<GrpcLikeMessageBuilder, GrpcLikeMessageBuilder>::run_tests(TestSelector(tests, tests+4));
} }

283
tests/test_builder.h
View File

@@ -2,6 +2,7 @@
#define TEST_BUILDER_H #define TEST_BUILDER_H
#include <set> #include <set>
#include <type_traits>
#include "monster_test_generated.h" #include "monster_test_generated.h"
#include "flatbuffers/flatbuffers.h" #include "flatbuffers/flatbuffers.h"
#include "test_assert.h" #include "test_assert.h"
@@ -13,6 +14,16 @@ class MessageBuilder;
} }
} }
template <class T, class U>
struct is_same {
static const bool value = false;
};
template <class T>
struct is_same<T, T> {
static const bool value = true;
};
extern const std::string m1_name; extern const std::string m1_name;
extern const Color m1_color; extern const Color m1_color;
extern const std::string m2_name; extern const std::string m2_name;
@@ -32,145 +43,157 @@ bool verify(const uint8_t *buf, size_t offset, const std::string &expected_name,
bool release_n_verify(flatbuffers::FlatBufferBuilder &fbb, const std::string &expected_name, Color color); bool release_n_verify(flatbuffers::FlatBufferBuilder &fbb, const std::string &expected_name, Color color);
bool release_n_verify(flatbuffers::grpc::MessageBuilder &mbb, const std::string &expected_name, Color color); bool release_n_verify(flatbuffers::grpc::MessageBuilder &mbb, const std::string &expected_name, Color color);
// clang-format off
#if !defined(FLATBUFFERS_CPP98_STL)
// clang-format on
template <class Builder> template <class Builder>
void builder_move_assign_after_releaseraw_test(Builder b1) {
auto root_offset1 = populate1(b1);
b1.Finish(root_offset1);
size_t size, offset;
b1.ReleaseRaw(size, offset);
Builder src;
auto root_offset2 = populate2(src);
src.Finish(root_offset2);
auto src_size = src.GetSize();
// Move into a released builder.
b1 = std::move(src);
TEST_EQ_FUNC(b1.GetSize(), src_size);
TEST_ASSERT_FUNC(release_n_verify(b1, m2_name, m2_color));
TEST_EQ_FUNC(src.GetSize(), 0);
}
// clang-format off
#endif // !defined(FLATBUFFERS_CPP98_STL)
// clang-format on
void builder_move_assign_after_releaseraw_test(flatbuffers::grpc::MessageBuilder b1);
template <class DestBuilder, class SrcBuilder = DestBuilder>
struct BuilderTests { struct BuilderTests {
// clang-format off // clang-format off
#if !defined(FLATBUFFERS_CPP98_STL) #if !defined(FLATBUFFERS_CPP98_STL)
// clang-format on // clang-format on
static void empty_builder_movector_test() { static void empty_builder_movector_test() {
Builder b1; SrcBuilder src;
size_t b1_size = b1.GetSize(); size_t src_size = src.GetSize();
Builder b2(std::move(b1)); DestBuilder dst(std::move(src));
size_t b2_size = b2.GetSize(); size_t dst_size = dst.GetSize();
TEST_EQ_FUNC(b1_size, 0); TEST_EQ_FUNC(src_size, 0);
TEST_EQ_FUNC(b1_size, b2_size); TEST_EQ_FUNC(src_size, dst_size);
} }
static void nonempty_builder_movector_test() { static void nonempty_builder_movector_test() {
Builder b1; SrcBuilder src;
populate1(b1); populate1(src);
size_t b1_size = b1.GetSize(); size_t src_size = src.GetSize();
Builder b2(std::move(b1)); DestBuilder dst(std::move(src));
TEST_EQ_FUNC(b1_size, b2.GetSize()); TEST_EQ_FUNC(src_size, dst.GetSize());
TEST_EQ_FUNC(b1.GetSize(), 0); TEST_EQ_FUNC(src.GetSize(), 0);
} }
static void builder_movector_before_finish_test() { static void builder_movector_before_finish_test() {
Builder b1; SrcBuilder src;
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(src);
Builder b2(std::move(b1)); DestBuilder dst(std::move(src));
b2.Finish(root_offset1); dst.Finish(root_offset1);
TEST_ASSERT_FUNC(release_n_verify(b2, m1_name, m1_color)); TEST_ASSERT_FUNC(release_n_verify(dst, m1_name, m1_color));
TEST_EQ_FUNC(b1.GetSize(), 0); TEST_EQ_FUNC(src.GetSize(), 0);
} }
static void builder_movector_after_finish_test() { static void builder_movector_after_finish_test() {
Builder b1; SrcBuilder src;
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(src);
b1.Finish(root_offset1); src.Finish(root_offset1);
auto b1_size = b1.GetSize(); auto src_size = src.GetSize();
Builder b2(std::move(b1)); DestBuilder dst(std::move(src));
TEST_EQ_FUNC(b2.GetSize(), b1_size); TEST_EQ_FUNC(dst.GetSize(), src_size);
TEST_ASSERT_FUNC(release_n_verify(b2, m1_name, m1_color)); TEST_ASSERT_FUNC(release_n_verify(dst, m1_name, m1_color));
TEST_EQ_FUNC(b1.GetSize(), 0); TEST_EQ_FUNC(src.GetSize(), 0);
} }
static void builder_move_assign_before_finish_test() { static void builder_move_assign_before_finish_test() {
Builder b1; SrcBuilder src;
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(src);
Builder b2; DestBuilder dst;
populate2(b2); populate2(dst);
b2 = std::move(b1); dst = std::move(src);
b2.Finish(root_offset1); dst.Finish(root_offset1);
TEST_ASSERT_FUNC(release_n_verify(b2, m1_name, m1_color)); TEST_ASSERT_FUNC(release_n_verify(dst, m1_name, m1_color));
TEST_EQ_FUNC(b1.GetSize(), 0); TEST_EQ_FUNC(src.GetSize(), 0);
} }
static void builder_move_assign_after_finish_test() { static void builder_move_assign_after_finish_test() {
Builder b1; SrcBuilder src;
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(src);
b1.Finish(root_offset1); src.Finish(root_offset1);
auto b1_size = b1.GetSize(); auto src_size = src.GetSize();
Builder b2; DestBuilder dst;
auto root_offset2 = populate2(b2); auto root_offset2 = populate2(dst);
b2.Finish(root_offset2); dst.Finish(root_offset2);
b2 = std::move(b1); dst = std::move(src);
TEST_EQ_FUNC(b2.GetSize(), b1_size); TEST_EQ_FUNC(dst.GetSize(), src_size);
TEST_ASSERT_FUNC(release_n_verify(b2, m1_name, m1_color)); TEST_ASSERT_FUNC(release_n_verify(dst, m1_name, m1_color));
TEST_EQ_FUNC(b1.GetSize(), 0); TEST_EQ_FUNC(src.GetSize(), 0);
} }
static void builder_move_assign_after_release_test() { static void builder_move_assign_after_release_test() {
Builder b1; DestBuilder dst;
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(dst);
b1.Finish(root_offset1); dst.Finish(root_offset1);
{ {
flatbuffers::DetachedBuffer b1_detached = b1.Release(); flatbuffers::DetachedBuffer dst_detached = dst.Release();
// detached buffer is deleted // detached buffer is deleted
} }
Builder b2; SrcBuilder src;
auto root_offset2 = populate2(b2); auto root_offset2 = populate2(src);
b2.Finish(root_offset2); src.Finish(root_offset2);
auto b2_size = b2.GetSize(); auto src_size = src.GetSize();
// Move into a released builder. // Move into a released builder.
b1 = std::move(b2); dst = std::move(src);
TEST_EQ_FUNC(b1.GetSize(), b2_size); TEST_EQ_FUNC(dst.GetSize(), src_size);
TEST_ASSERT_FUNC(release_n_verify(b1, m2_name, m2_color)); TEST_ASSERT_FUNC(release_n_verify(dst, m2_name, m2_color));
TEST_EQ_FUNC(b2.GetSize(), 0); TEST_EQ_FUNC(src.GetSize(), 0);
}
static void builder_move_assign_after_releaseraw_test() {
Builder b1;
auto root_offset1 = populate1(b1);
b1.Finish(root_offset1);
size_t size, offset;
uint8_t *buf = release_raw_base(b1, size, offset);
TEST_ASSERT_FUNC(verify(buf, offset, m1_name, m1_color));
free_raw(b1, buf);
Builder b2;
auto root_offset2 = populate2(b2);
b2.Finish(root_offset2);
auto b2_size = b2.GetSize();
// Move into a released builder.
b1 = std::move(b2);
TEST_EQ_FUNC(b1.GetSize(), b2_size);
TEST_ASSERT_FUNC(release_n_verify(b1, m2_name, m2_color));
TEST_EQ_FUNC(b2.GetSize(), 0);
} }
// clang-format off // clang-format off
#endif // !defined(FLATBUFFERS_CPP98_STL) #endif // !defined(FLATBUFFERS_CPP98_STL)
// clang-format on // clang-format on
static void builder_swap_before_finish_test() { static void builder_swap_before_finish_test(bool run = is_same<DestBuilder, SrcBuilder>::value) {
Builder b1; /// Swap is allowed only when lhs and rhs are the same concrete type.
auto root_offset1 = populate1(b1); if(run) {
auto size1 = b1.GetSize(); SrcBuilder src;
Builder b2; auto root_offset1 = populate1(src);
auto root_offset2 = populate2(b2); auto size1 = src.GetSize();
auto size2 = b2.GetSize(); DestBuilder dst;
b1.Swap(b2); auto root_offset2 = populate2(dst);
b1.Finish(root_offset2); auto size2 = dst.GetSize();
b2.Finish(root_offset1); src.Swap(dst);
TEST_EQ_FUNC(b1.GetSize() > size2, true); src.Finish(root_offset2);
TEST_EQ_FUNC(b2.GetSize() > size1, true); dst.Finish(root_offset1);
TEST_ASSERT_FUNC(release_n_verify(b1, m2_name, m2_color)); TEST_EQ_FUNC(src.GetSize() > size2, true);
TEST_ASSERT_FUNC(release_n_verify(b2, m1_name, m1_color)); TEST_EQ_FUNC(dst.GetSize() > size1, true);
TEST_ASSERT_FUNC(release_n_verify(src, m2_name, m2_color));
TEST_ASSERT_FUNC(release_n_verify(dst, m1_name, m1_color));
}
} }
static void builder_swap_after_finish_test() { static void builder_swap_after_finish_test(bool run = is_same<DestBuilder, SrcBuilder>::value) {
Builder b1; /// Swap is allowed only when lhs and rhs are the same concrete type.
auto root_offset1 = populate1(b1); if(run) {
b1.Finish(root_offset1); SrcBuilder src;
auto size1 = b1.GetSize(); auto root_offset1 = populate1(src);
Builder b2; src.Finish(root_offset1);
auto root_offset2 = populate2(b2); auto size1 = src.GetSize();
b2.Finish(root_offset2); DestBuilder dst;
auto size2 = b2.GetSize(); auto root_offset2 = populate2(dst);
b1.Swap(b2); dst.Finish(root_offset2);
TEST_EQ_FUNC(b1.GetSize(), size2); auto size2 = dst.GetSize();
TEST_EQ_FUNC(b2.GetSize(), size1); src.Swap(dst);
TEST_ASSERT_FUNC(release_n_verify(b1, m2_name, m2_color)); TEST_EQ_FUNC(src.GetSize(), size2);
TEST_ASSERT_FUNC(release_n_verify(b2, m1_name, m1_color)); TEST_EQ_FUNC(dst.GetSize(), size1);
TEST_ASSERT_FUNC(release_n_verify(src, m2_name, m2_color));
TEST_ASSERT_FUNC(release_n_verify(dst, m1_name, m1_color));
}
} }
static void all_tests() { static void all_tests() {
@@ -184,7 +207,7 @@ struct BuilderTests {
builder_move_assign_before_finish_test(); builder_move_assign_before_finish_test();
builder_move_assign_after_finish_test(); builder_move_assign_after_finish_test();
builder_move_assign_after_release_test(); builder_move_assign_after_release_test();
builder_move_assign_after_releaseraw_test(); builder_move_assign_after_releaseraw_test(DestBuilder());
// clang-format off // clang-format off
#endif // !defined(FLATBUFFERS_CPP98_STL) #endif // !defined(FLATBUFFERS_CPP98_STL)
// clang-format on // clang-format on
@@ -204,19 +227,19 @@ enum BuilderReuseTestSelector {
typedef std::set<BuilderReuseTestSelector> TestSelector; typedef std::set<BuilderReuseTestSelector> TestSelector;
template <class Builder> template <class DestBuilder, class SrcBuilder>
struct BuilderReuseTests { struct BuilderReuseTests {
static void builder_reusable_after_release_test(TestSelector selector) { static void builder_reusable_after_release_test(TestSelector selector) {
if (!selector.count(REUSABLE_AFTER_RELEASE)) { if (!selector.count(REUSABLE_AFTER_RELEASE)) {
return; return;
} }
Builder b1; DestBuilder fbb;
std::vector<flatbuffers::DetachedBuffer> buffers; std::vector<flatbuffers::DetachedBuffer> buffers;
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(fbb);
b1.Finish(root_offset1); fbb.Finish(root_offset1);
buffers.push_back(b1.Release()); buffers.push_back(fbb.Release());
TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color)); TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color));
} }
} }
@@ -226,14 +249,14 @@ struct BuilderReuseTests {
return; return;
} }
Builder b1; DestBuilder fbb;
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(fbb);
b1.Finish(root_offset1); fbb.Finish(root_offset1);
size_t size, offset; size_t size, offset;
uint8_t *buf = release_raw_base(b1, size, offset); uint8_t *buf = release_raw_base(fbb, size, offset);
TEST_ASSERT_FUNC(verify(buf, offset, m1_name, m1_color)); TEST_ASSERT_FUNC(verify(buf, offset, m1_name, m1_color));
free_raw(b1, buf); free_raw(fbb, buf);
} }
} }
@@ -245,16 +268,16 @@ struct BuilderReuseTests {
return; return;
} }
Builder b1; DestBuilder dst;
std::vector<flatbuffers::DetachedBuffer> buffers; std::vector<flatbuffers::DetachedBuffer> buffers;
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(dst);
b1.Finish(root_offset1); dst.Finish(root_offset1);
buffers.push_back(b1.Release()); buffers.push_back(dst.Release());
TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color)); TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color));
Builder b2; SrcBuilder src;
b1 = std::move(b2); dst = std::move(src);
TEST_EQ_FUNC(b2.GetSize(), 0); TEST_EQ_FUNC(src.GetSize(), 0);
} }
} }
@@ -263,17 +286,17 @@ struct BuilderReuseTests {
return; return;
} }
Builder b1; DestBuilder dst;
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
auto root_offset1 = populate1(b1); auto root_offset1 = populate1(dst);
b1.Finish(root_offset1); dst.Finish(root_offset1);
size_t size, offset; size_t size, offset;
uint8_t *buf = release_raw_base(b1, size, offset); uint8_t *buf = release_raw_base(dst, size, offset);
TEST_ASSERT_FUNC(verify(buf, offset, m1_name, m1_color)); TEST_ASSERT_FUNC(verify(buf, offset, m1_name, m1_color));
free_raw(b1, buf); free_raw(dst, buf);
Builder b2; SrcBuilder src;
b1 = std::move(b2); dst = std::move(src);
TEST_EQ_FUNC(b2.GetSize(), 0); TEST_EQ_FUNC(src.GetSize(), 0);
} }
} }
// clang-format off // clang-format off