mirror of
https://github.com/Zygo/bees.git
synced 2025-05-17 21:35:45 +02:00
f0eb9b202f
After some benchmarking, it turns out that std::vector<uint8_t> is about 160 times slower than malloc(). malloc() is faster than "new uint8_t[]" too. Get rid of std:;vector<uint8_t> and replace it with a lightweight wrapper around malloc(), free(), and memcpy(). ByteVector has helpful methods for the common case of moving data to and from ioctl calls that use a fixed-length header placed contiguously with a variable-length input/output buffer. Data bytes are shared between copied ByteVector objects, allowing a large single buffer to be cheaply chopped up into smaller objects without memory copies. ByteVector implements the more useful parts of the std::vector API, so it can replace std::vector objects without needing an awkward adaptor class like Spanner. Signed-off-by: Zygo Blaxell <bees@furryterror.org>
72 lines
1.9 KiB
C++
72 lines
1.9 KiB
C++
#ifndef _CRUCIBLE_BYTEVECTOR_H_
|
|
#define _CRUCIBLE_BYTEVECTOR_H_
|
|
|
|
#include <memory>
|
|
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
|
|
namespace crucible {
|
|
using namespace std;
|
|
// new[] is a little slower than malloc
|
|
// shared_ptr is about 2x slower than unique_ptr
|
|
// vector<uint8_t> is ~160x slower
|
|
// so we won't bother with unique_ptr because we can't do shared copies with it
|
|
|
|
class ByteVector {
|
|
public:
|
|
using Pointer = shared_ptr<uint8_t>;
|
|
using value_type = Pointer::element_type;
|
|
using iterator = value_type*;
|
|
|
|
ByteVector() = default;
|
|
ByteVector(size_t size);
|
|
ByteVector(const ByteVector &that, size_t start, size_t length);
|
|
ByteVector(iterator begin, iterator end, size_t min_size = 0);
|
|
|
|
ByteVector at(size_t start, size_t length) const;
|
|
|
|
value_type& at(size_t) const;
|
|
iterator begin() const;
|
|
void clear();
|
|
value_type* data() const;
|
|
bool empty() const;
|
|
iterator end() const;
|
|
value_type& operator[](size_t) const;
|
|
size_t size() const;
|
|
bool operator==(const ByteVector &that) const;
|
|
|
|
// this version of erase only works at the beginning or end of the buffer, else throws exception
|
|
void erase(iterator first);
|
|
void erase(iterator first, iterator last);
|
|
|
|
// An important use case is ioctls that have a fixed-size header struct
|
|
// followed by a buffer for further arguments. These templates avoid
|
|
// doing reinterpret_casts every time.
|
|
template <class T> ByteVector(const T& object, size_t min_size);
|
|
template <class T> T* get() const;
|
|
private:
|
|
Pointer m_ptr;
|
|
size_t m_size = 0;
|
|
};
|
|
|
|
template <class T>
|
|
ByteVector::ByteVector(const T& object, size_t min_size)
|
|
{
|
|
const auto size = max(min_size, sizeof(T));
|
|
m_ptr = Pointer(static_cast<value_type*>(malloc(size)), free);
|
|
memcpy(m_ptr.get(), &object, sizeof(T));
|
|
m_size = size;
|
|
}
|
|
|
|
template <class T>
|
|
T*
|
|
ByteVector::get() const
|
|
{
|
|
return reinterpret_cast<T*>(data());
|
|
}
|
|
|
|
}
|
|
|
|
#endif // _CRUCIBLE_BYTEVECTOR_H_
|