mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-11-05 15:21:43 +00:00
145 lines
3.1 KiB
C++
145 lines
3.1 KiB
C++
#pragma once
|
|
|
|
#include <boost/noncopyable.hpp>
|
|
|
|
#include <DB/Common/ProfileEvents.h>
|
|
#include <DB/Common/Allocator.h>
|
|
|
|
#include <DB/Common/Exception.h>
|
|
#include <DB/Core/Defines.h>
|
|
|
|
|
|
namespace ProfileEvents
|
|
{
|
|
extern const Event IOBufferAllocs;
|
|
extern const Event IOBufferAllocBytes;
|
|
}
|
|
|
|
|
|
namespace DB
|
|
{
|
|
|
|
|
|
/** Replacement for std::vector<char> to use in buffers.
|
|
* Differs in that is doesn't do unneeded memset. (And also tries to do as little as possible.)
|
|
* Also allows to allocate aligned piece of memory (to use with O_DIRECT, for example).
|
|
*/
|
|
struct Memory : boost::noncopyable, Allocator<false>
|
|
{
|
|
size_t m_capacity = 0;
|
|
size_t m_size = 0;
|
|
char * m_data = nullptr;
|
|
size_t alignment = 0;
|
|
|
|
Memory() {}
|
|
|
|
/// If alignment != 0, then allocate memory aligned to specified value.
|
|
Memory(size_t size_, size_t alignment_ = 0) : m_capacity(size_), m_size(m_capacity), alignment(alignment_)
|
|
{
|
|
alloc();
|
|
}
|
|
|
|
~Memory()
|
|
{
|
|
dealloc();
|
|
}
|
|
|
|
Memory(Memory && rhs)
|
|
{
|
|
*this = std::move(rhs);
|
|
}
|
|
|
|
Memory & operator=(Memory && rhs)
|
|
{
|
|
std::swap(m_capacity, rhs.m_capacity);
|
|
std::swap(m_size, rhs.m_size);
|
|
std::swap(m_data, rhs.m_data);
|
|
std::swap(alignment, rhs.alignment);
|
|
|
|
return *this;
|
|
}
|
|
|
|
size_t size() const { return m_size; }
|
|
const char & operator[](size_t i) const { return m_data[i]; }
|
|
char & operator[](size_t i) { return m_data[i]; }
|
|
const char * data() const { return m_data; }
|
|
char * data() { return m_data; }
|
|
|
|
void resize(size_t new_size)
|
|
{
|
|
if (0 == m_capacity)
|
|
{
|
|
m_size = m_capacity = new_size;
|
|
alloc();
|
|
}
|
|
else if (new_size < m_capacity)
|
|
{
|
|
m_size = new_size;
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
new_size = align(new_size, alignment);
|
|
m_data = static_cast<char *>(Allocator::realloc(m_data, m_capacity, new_size, alignment));
|
|
m_capacity = new_size;
|
|
m_size = m_capacity;
|
|
}
|
|
}
|
|
|
|
static size_t align(const size_t value, const size_t alignment)
|
|
{
|
|
if (!alignment)
|
|
return value;
|
|
|
|
return (value + alignment - 1) / alignment * alignment;
|
|
}
|
|
|
|
private:
|
|
void alloc()
|
|
{
|
|
if (!m_capacity)
|
|
{
|
|
m_data = nullptr;
|
|
return;
|
|
}
|
|
|
|
ProfileEvents::increment(ProfileEvents::IOBufferAllocs);
|
|
ProfileEvents::increment(ProfileEvents::IOBufferAllocBytes, m_capacity);
|
|
|
|
size_t new_capacity = align(m_capacity, alignment);
|
|
m_data = static_cast<char *>(Allocator::alloc(new_capacity, alignment));
|
|
m_capacity = new_capacity;
|
|
m_size = m_capacity;
|
|
}
|
|
|
|
void dealloc()
|
|
{
|
|
if (!m_data)
|
|
return;
|
|
|
|
Allocator::free(m_data, m_capacity);
|
|
m_data = nullptr; /// To avoid double free if next alloc will throw an exception.
|
|
}
|
|
};
|
|
|
|
|
|
/** Buffer that could own its working memory.
|
|
* Template parameter: ReadBuffer or WriteBuffer
|
|
*/
|
|
template <typename Base>
|
|
class BufferWithOwnMemory : public Base
|
|
{
|
|
protected:
|
|
Memory memory;
|
|
public:
|
|
/// If non-nullptr 'existing_memory' is passed, then buffer will not create its own memory and will use existing_memory without ownership.
|
|
BufferWithOwnMemory(size_t size = DBMS_DEFAULT_BUFFER_SIZE, char * existing_memory = nullptr, size_t alignment = 0)
|
|
: Base(nullptr, 0), memory(existing_memory ? 0 : size, alignment)
|
|
{
|
|
Base::set(existing_memory ? existing_memory : memory.data(), size);
|
|
}
|
|
};
|
|
|
|
|
|
}
|