SerializeBuffer.hh

Go to the documentation of this file.

#ifndef SERIALIZEBUFFER_HH
#define SERIALIZEBUFFER_HH
 
#include "MemBuffer.hh"
#include "inline.hh"
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <cassert>
#include <span>
#include <tuple>
 
namespace openmsx {
 
class OutputBuffer
{
public:
        OutputBuffer();
 
        void insert(const void* __restrict data, size_t len)
        {
#ifdef __GNUC__
                if (__builtin_constant_p(len)) {
                        if        (len == 1) {
                                insertN<1>(data); return;
                        } else if (len == 2) {
                                insertN<2>(data); return;
                        } else if (len == 4) {
                                insertN<4>(data); return;
                        } else if (len == 8) {
                                insertN<8>(data); return;
                        }
                }
#endif
                insertN(data, len);
        }
#ifdef __GNUC__
        template<size_t N> void insertN(const void* __restrict data);
#endif
        void insertN(const void* __restrict data, size_t len);
 
        template<typename TUPLE> ALWAYS_INLINE void insert_tuple_ptr(const TUPLE& tuple)
        {
                size_t len = 0;
                auto accum = [&](auto* p) { len += sizeof(*p); };
                std::apply([&](auto&&... args) { (accum(args), ...); }, tuple);
 
                uint8_t* newEnd = end + len;
                if (newEnd > finish) [[unlikely]] {
                        grow(len); // reallocates, thus newEnd is no longer valid.
                }
 
                uint8_t* dst = end;
                auto write = [&](auto* src) {
                        memcpy(dst, src, sizeof(*src));
                        dst += sizeof(*src);
                };
                std::apply([&](auto&&... args) { (write(args), ...); }, tuple);
                assert(dst == (end + len));
 
                end = dst;
        }
 
        template<typename T> ALWAYS_INLINE void insert_tuple_ptr(const std::tuple<T*>& tuple)
        {
                // single-element tuple -> use insert() because it's better tuned
                insert(std::get<0>(tuple), sizeof(T));
        }
 
        void insertAt(size_t pos, const void* __restrict data, size_t len)
        {
                assert(buf.data() + pos + len <= finish);
                memcpy(buf.data() + pos, data, len);
        }
 
        [[nodiscard]] std::span<uint8_t> allocate(size_t len)
        {
                auto* newEnd = end + len;
                // Make sure the next OutputBuffer will start with an initial size
                // that can hold this much space plus some slack.
                size_t newSize = newEnd - buf.data();
                lastSize = std::max(lastSize, newSize + 1000);
                if (newEnd <= finish) {
                        uint8_t* result = end;
                        end = newEnd;
                        return {result, len};
                } else {
                        return {allocateGrow(len), len};
                }
        }
 
        /*void deallocate(uint8_t* pos)
        {
                assert(buf.data() <= pos);
                assert(pos <= end);
                end = pos;
        }*/
 
        [[nodiscard]] size_t getPosition() const
        {
                return end - buf.data();
        }
 
        [[nodiscard]] MemBuffer<uint8_t> release(size_t& size);
 
private:
        void insertGrow(const void* __restrict data, size_t len);
        [[nodiscard]] uint8_t* allocateGrow(size_t len);
        void grow(size_t len);
 
        MemBuffer<uint8_t> buf; // begin of allocated memory
        uint8_t* end;           // points right after the last used byte
                                // so   end - buf == size
        uint8_t* finish;        // points right after the last allocated byte
                                // so   finish - buf == capacity
 
        static inline size_t lastSize = 50000; // initial estimate
};
 
 
class InputBuffer
{
public:
        InputBuffer(const uint8_t* data, size_t size);
 
        void read(void* __restrict result, size_t len) __restrict
        {
                memcpy(result, buf, len);
                buf += len;
                assert(buf <= finish);
        }
 
        void skip(size_t len)
        {
                buf += len;
                assert(buf <= finish);
        }
 
        [[nodiscard]] const uint8_t* getCurrentPos() const { return buf; }
 
private:
        const uint8_t* buf;
#ifndef NDEBUG
        const uint8_t* finish; // only used to check asserts
#endif
};
 
} // namespace openmsx
 
#endif