nerdcruft/libcruft-util
1
0
Fork 0
Code Issues Releases Activity

alloc: all allocators should take a type for alloc/dealloc

Browse Source
This commit is contained in:
Danny Robson 2018-05-10 13:53:06 +10:00
parent 117a870b19
commit 38e1a19e37
21 changed files with 219 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -161,7 +161,7 @@ list (
alloc/raw/affix.hpp
alloc/raw/aligned/direct.hpp
alloc/raw/aligned/foreign.hpp
alloc/raw/dynamic.hpp
#alloc/raw/dynamic.hpp
alloc/raw/fallback.cpp
alloc/raw/fallback.hpp
alloc/raw/linear.cpp
@ -478,7 +478,7 @@ if (TESTS)
alloc/aligned/foreign
alloc/aligned/direct
alloc/arena
alloc/dynamic
#alloc/dynamic
alloc/linear
alloc/stack
alloc/forwarding

9
alloc/arena.hpp
View File

@ -19,6 +19,7 @@
#include "../memory/deleter.hpp"
#include "../cast.hpp"
#include "../view.hpp"
#include <memory>
#include <utility>
@ -38,14 +39,12 @@ namespace util::alloc {
U*
acquire (Args&&... args)
{
U *data = util::cast::alignment<U*> (
m_store.allocate (sizeof (U), alignof (U)).data ()
);
U *data = m_store.template allocate<U> (1).data ();
try {
new (data) U (std::forward<Args> (args)...);
} catch (...) {
m_store.deallocate (data, sizeof (U));
m_store.template deallocate<U> ({data,1});
throw;
}
@ -58,7 +57,7 @@ namespace util::alloc {
release (U *u)
{
u->~U ();
m_store.deallocate (reinterpret_cast<void*> (u), sizeof (U));
m_store.template deallocate<U> (util::view {u,1u});
}

8
alloc/forwarding.hpp
View File

@ -27,16 +27,16 @@ namespace util::alloc {
m_backing (backing)
{ ; }
template <typename ...Args>
template <typename T, typename ...Args>
auto allocate (Args &&...args)
{
return m_backing.allocate (std::forward<Args> (args)...);
return m_backing.template allocate<T> (std::forward<Args> (args)...);
}
template <typename ...Args>
template <typename T, typename ...Args>
auto deallocate (Args &&...args)
{
return m_backing.deallocate (std::forward<Args> (args)...);
return m_backing.template deallocate<T> (std::forward<Args> (args)...);
}
auto data (void) { return m_backing.data (); }

14
alloc/raw/affix.hpp
View File

@ -31,13 +31,15 @@ namespace util::alloc::raw {
/// useful for sentinels, reference counts, etc.
template <class ParentT, class PrefixT, class SuffixT>
class affix {
util::view<std::byte*> allocate (size_t bytes);
util::view<std::byte*> allocate (size_t bytes, size_t align);
void deallocate (util::view<std::byte*> ptr) { return deallocate (ptr.data (), ptr.size ()); }
void deallocate (util::view<std::byte*> ptr, size_t alignment) { return deallocate (ptr.data (), ptr.size (), alignment); }
void deallocate (void *ptr, size_t bytes);
void deallocate (void *ptr, size_t bytes, size_t align);
template <typename T>
util::view<T*> allocate (size_t bytes);
template <typename T>
util::view<T*> allocate (size_t bytes, size_t align);
template <typename T>
void deallocate (util::view<std::byte*>);
std::byte* begin (void);
const std::byte* begin (void) const;

10
alloc/raw/aligned/direct.hpp
View File

@ -37,17 +37,19 @@ namespace util::alloc::raw::aligned {
///////////////////////////////////////////////////////////////////////
template <typename T>
auto
allocate (std::size_t bytes)
allocate (std::size_t count)
{
return m_successor.allocate (bytes, m_alignment);
return m_successor.template allocate<T> (count, m_alignment);
}
//---------------------------------------------------------------------
template <typename T>
auto
deallocate (void *ptr, std::size_t bytes)
deallocate (util::view<T*> ptr)
{
return m_successor.deallocate (ptr, bytes);
return m_successor.template deallocate<T> (ptr);
}

28
alloc/raw/aligned/foreign.hpp
View File

@ -19,6 +19,7 @@
#include "direct.hpp"
#include "../../../cast.hpp"
#include "../../../pointer.hpp"
#include "../../../debug.hpp"
@ -66,20 +67,29 @@ namespace util::alloc::raw::aligned {
{ ; }
void*
allocate (std::size_t size)
template <typename T>
util::view<T*>
allocate (std::size_t count)
{
auto ptr= reinterpret_cast<std::byte*> (
m_successor.allocate (size).data ()
);
return ptr + m_offset;
auto root = m_successor.template allocate<T> (count);
auto base = root.template cast<char*> ().data ();
// we can't use alignment cast here because it will almost
// certainly fail the tests it performs.
return { util::cast::ffs<T*> (base + m_offset), count };
}
template <typename T>
auto
deallocate (void *ptr, std::size_t size)
deallocate (util::view<T*> ptr)
{
return m_successor.deallocate (
reinterpret_cast<std::byte*> (ptr) - m_offset, size
auto base = ptr.template cast<char*> ();
auto next = base - m_offset;
// we can't use alignment cast here because it will almost
// certainly fail the tests it performs.
return m_successor.template deallocate<T> (
util::view<T*> { util::cast::ffs<T*> (next), ptr.size () }
);
}

7
alloc/raw/dynamic.hpp
View File

@ -58,8 +58,11 @@ namespace util::alloc::raw {
// dynamically eliminate the function altogether given run-time
// dynamic dispatch needs the common calls exposed to the clients, and
// aligned allocate is stupid useful.
auto allocate (size_t bytes) { return m_child->allocate (bytes); }
auto allocate (size_t bytes, size_t alignment) { return m_child->allocate (bytes, alignment); }
template <typename T>
auto allocate (size_t bytes) { return m_child->allocate<T> (bytes); }
template <typename T>
auto allocate (size_t bytes, size_t alignment) { return m_child->allocate<T> (bytes, alignment); }
auto deallocate (void *ptr, size_t bytes)
{ return m_child->deallocate (ptr, bytes); }

15
alloc/raw/fallback.hpp
View File

@ -32,13 +32,16 @@ namespace util::alloc::raw {
m_children (_children...)
{ ; }
util::view<std::byte*> allocate (size_t bytes);
util::view<std::byte*> allocate (size_t bytes, size_t align);
template <typename T>
util::view<T*>
allocate (size_t bytes);
void deallocate (util::view<std::byte*> ptr) { return deallocate (ptr.data (), ptr.size ()); }
void deallocate (util::view<std::byte*> ptr, size_t alignment) { return deallocate (ptr.data (), ptr.size (), alignment); }
void deallocate (void *ptr, size_t bytes);
void deallocate (void *ptr, size_t bytes, size_t align);
template <typename T>
util::view<T*>
allocate (size_t bytes, size_t align);
template <typename T>
void deallocate (util::view<std::byte*> ptr);
private:
std::tuple<ChildT&...> m_children;

45
alloc/raw/linear.cpp
View File

@ -31,51 +31,6 @@ linear::linear (util::view<std::byte*> _data):
///////////////////////////////////////////////////////////////////////////////
util::view<std::byte*>
linear::allocate (size_t bytes)
{
if (m_cursor + bytes > m_end)
throw std::bad_alloc ();
auto ptr = m_cursor;
m_cursor += bytes;
return { ptr, bytes };
}
//-----------------------------------------------------------------------------
util::view<std::byte*>
linear::allocate (size_t bytes, size_t alignment)
{
auto ptr = align (m_cursor, alignment);
if (ptr + bytes > m_end)
throw std::bad_alloc ();
m_cursor = ptr + bytes;
return { ptr, bytes };
}
//-----------------------------------------------------------------------------
void
linear::deallocate (void *ptr, size_t bytes)
{
deallocate (ptr, bytes, alignof (std::max_align_t));
}
//-----------------------------------------------------------------------------
void
linear::deallocate (void *ptr, size_t bytes, size_t alignment)
{
(void)ptr;
(void)bytes;
(void)alignment;
}
//-----------------------------------------------------------------------------
std::byte*
linear::data (void)
{

40
alloc/raw/linear.hpp
View File

@ -18,6 +18,7 @@
#define CRUFT_UTIL_ALLOC_RAW_LINEAR_HPP
#include "../../view.hpp"
#include "../../pointer.hpp"
#include <cstddef>
#include <iterator>
@ -34,13 +35,40 @@ namespace util::alloc::raw {
linear (util::view<std::byte*> _data);
util::view<std::byte*> allocate (size_t bytes);
util::view<std::byte*> allocate (size_t bytes, size_t alignment);
template <typename T>
util::view<T*>
allocate (size_t count)
{
auto const bytes = count * sizeof (T);
if (m_cursor + bytes > m_end)
throw std::bad_alloc ();
void deallocate (util::view<std::byte*> ptr) { return deallocate (ptr.data (), ptr.size ()); }
void deallocate (util::view<std::byte*> ptr, size_t alignment) { return deallocate (ptr.data (), ptr.size (), alignment); }
void deallocate (void *ptr, size_t bytes);
void deallocate (void *ptr, size_t bytes, size_t alignment);
auto ptr = m_cursor;
m_cursor += bytes;
return { util::cast::alignment<T*> (ptr), count };
}
template <typename T>
util::view<T*>
allocate (size_t count, size_t alignment)
{
auto const bytes = count * sizeof (T);
auto ptr = util::align (m_cursor, alignment);
if (ptr + bytes > m_end)
throw std::bad_alloc ();
m_cursor = ptr + bytes;
return { util::cast::alignment<T*> (ptr), count };
}
template <typename T>
void deallocate (util::view<T*> ptr)
{
(void)ptr;
}
std::byte* data (void);
std::byte* begin (void);

42
alloc/raw/malloc.cpp
View File

@ -11,7 +11,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Copyright 2015 Danny Robson <danny@nerdcruft.net>
* Copyright 2018 Danny Robson <danny@nerdcruft.net>
*/
#include "malloc.hpp"
@ -20,43 +20,3 @@
#include <cstdlib>
using util::alloc::raw::malloc;
///////////////////////////////////////////////////////////////////////////////
util::view<std::byte*>
malloc::allocate (size_t bytes)
{
return allocate (bytes, alignof (std::max_align_t));
}
//-----------------------------------------------------------------------------
util::view<std::byte*>
malloc::allocate (size_t bytes, size_t align)
{
// C malloc guarantees maximal alignment
CHECK_LE (align, alignof (std::max_align_t));
(void)align;
return util::view<std::byte*> (reinterpret_cast<std::byte*> (::malloc (bytes)), bytes);
}
//-----------------------------------------------------------------------------
void
malloc::deallocate (void *ptr, size_t bytes)
{
return deallocate (ptr, bytes, alignof (std::max_align_t));
}
//-----------------------------------------------------------------------------
void
malloc::deallocate (void *ptr, size_t bytes, size_t align)
{
(void)bytes;
(void)align;
::free (ptr);
}

34
alloc/raw/malloc.hpp
View File

@ -11,7 +11,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Copyright 2015 Danny Robson <danny@nerdcruft.net>
* Copyright 2018 Danny Robson <danny@nerdcruft.net>
*/
#ifndef CRUFT_UTIL_ALLOC_RAW_MALLOC_HPP
@ -25,13 +25,33 @@
namespace util::alloc::raw {
class malloc {
public:
util::view<std::byte*> allocate (size_t bytes);
util::view<std::byte*> allocate (size_t bytes, size_t align);
template <typename T>
util::view<T*> allocate (size_t count)
{
return {
reinterpret_cast<T*> (malloc (sizeof (T) * count)),
count
};
}
void deallocate (util::view<std::byte*> ptr) { return deallocate (ptr.data (), ptr.size ()); }
void deallocate (util::view<std::byte*> ptr, size_t alignment) { return deallocate (ptr.data (), ptr.size (), alignment); }
void deallocate (void *ptr, size_t bytes);
void deallocate (void *ptr, size_t bytes, size_t align);
template <typename T>
util::view<T*>
allocate (size_t count, size_t align)
{
void* ptr;
posix_memalign (&ptr, align, sizeof (T) * count);
if (!ptr)
throw std::bad_alloc ();
return { reinterpret_cast<T*> (ptr), count };
}
template <typename T>
void
deallocate (util::view<std::byte*> ptr)
{
::free (ptr.data ());
}
};
}

42
alloc/raw/null.cpp
View File

@ -24,48 +24,6 @@
using util::alloc::raw::null;
///////////////////////////////////////////////////////////////////////////////
util::view<std::byte*>
null::allocate (size_t bytes)
{
return allocate (bytes, alignof (std::max_align_t));
}
//-----------------------------------------------------------------------------
util::view<std::byte*>
null::allocate (size_t bytes, size_t align)
{
(void)bytes;
(void)align;
throw std::bad_alloc ();
}
//-----------------------------------------------------------------------------
void
null::deallocate (void *ptr, size_t bytes)
{
return deallocate (ptr, bytes, alignof (std::max_align_t));
}
//-----------------------------------------------------------------------------
// calling deallocate with a non-null pointer is undefined, but we may as well
// let the application continuing running if we're not in a debug context.
void
null::deallocate (void *ptr, size_t bytes, size_t align)
{
(void)ptr;
(void)bytes;
(void)align;
// cast to void* to assist some of the printing machinery in the assertion
CHECK_EQ (ptr, static_cast<const void*> (nullptr));
}
///////////////////////////////////////////////////////////////////////////////
std::byte*
null::begin (void)

29
alloc/raw/null.hpp
View File

@ -32,13 +32,30 @@ namespace util::alloc::raw {
null (const null&) = delete;
null& operator= (const null&) = delete;
util::view<std::byte*> allocate (size_t bytes);
util::view<std::byte*> allocate (size_t bytes, size_t align);
template <typename T>
util::view<T*>
allocate (size_t count)
{
return allocate<T> (count, alignof (T));
}
void deallocate (util::view<std::byte*> ptr) { return deallocate (ptr.data (), ptr.size ()); }
void deallocate (util::view<std::byte*> ptr, size_t alignment) { return deallocate (ptr.data (), ptr.size (), alignment); }
void deallocate (void *ptr, size_t bytes);
void deallocate (void *ptr, size_t bytes, size_t align);
template <typename T>
util::view<T*>
allocate (size_t count, size_t align)
{
(void)count;
(void)align;
throw std::bad_alloc ();
}
template <typename T>
void
deallocate (util::view<T*> ptr)
{
(void)ptr;
CHECK_EQ (ptr.data (), static_cast<const void*> (nullptr));
}
util::view<std::byte*> data (void);
util::view<const std::byte*> data (void) const;

80
alloc/raw/stack.cpp
View File

@ -33,86 +33,6 @@ stack::stack (util::view<std::byte*> _data):
}
///////////////////////////////////////////////////////////////////////////////
union record {
using offset_t = uint32_t;
std::byte *as_bytes;
offset_t *as_offset;
};
//-----------------------------------------------------------------------------
constexpr auto MIN_ALIGNMENT = sizeof (record::offset_t);
///////////////////////////////////////////////////////////////////////////////
util::view<std::byte*>
stack::allocate (size_t bytes)
{
return allocate (bytes, alignof (std::max_align_t));
}
//-----------------------------------------------------------------------------
util::view<std::byte*>
stack::allocate (size_t bytes, size_t alignment)
{
// reserve space at the front of the allocation to record the total
// allocation size so we can account for alignment if required.
auto ptr = m_cursor + sizeof (record::offset_t);
// align the outgoing pointer if required
alignment = util::max (MIN_ALIGNMENT, alignment);
ptr = align (ptr, alignment);
// ensure we haven't overrun our allocated segment
if (ptr + bytes > m_end)
throw std::bad_alloc ();
// use a 'record' struct as a window into the reserved space at the front
// of the allocation and store the offset to the previous allocation head
// (from the record struct). allows us to account for alignment.
record record;
record.as_bytes = ptr - sizeof (record::offset_t);
*record.as_offset = util::cast::lossless <uint32_t> (ptr - m_cursor);
m_cursor = ptr + bytes;
return { ptr, bytes };
}
//-----------------------------------------------------------------------------
void
stack::deallocate (void *ptr, size_t bytes)
{
return deallocate (ptr, bytes, alignof (std::max_align_t));
}
//-----------------------------------------------------------------------------
void
stack::deallocate (void *_ptr, size_t bytes, size_t alignment)
{
(void)bytes;
// TODO: use alignment
(void)alignment;
//alignment = util::max (MIN_ALIGNMENT, alignment);
auto ptr = reinterpret_cast<std::byte*> (_ptr);
record record;
record.as_bytes = ptr - sizeof (record::offset_t);
//CHECK_LE (bytes, *record.as_offset);
CHECK_GE (m_cursor - *record.as_offset, m_begin);
m_cursor -= bytes;
m_cursor -= *record.as_offset;
}
//-----------------------------------------------------------------------------
std::byte*
stack::begin (void)

67
alloc/raw/stack.hpp
View File

@ -18,6 +18,7 @@
#define CRUFT_UTIL_ALLOC_RAW_STACK_HPP
#include "../../view.hpp"
#include "../../pointer.hpp"
#include <cstddef>
@ -34,13 +35,60 @@ namespace util::alloc::raw {
stack (util::view<std::byte*> _data);
util::view<std::byte*> allocate (size_t bytes, size_t alignment);
util::view<std::byte*> allocate (size_t bytes);
template <typename T>
util::view<T*>
allocate (size_t count, size_t alignment)
{
constexpr auto MIN_ALIGNMENT = sizeof (record::offset_t);
const auto bytes = count * sizeof (T);
// reserve space at the front of the allocation to record the total
// allocation size so we can account for alignment if required.
auto ptr = m_cursor + sizeof (record::offset_t);
// align the outgoing pointer if required
alignment = util::max (MIN_ALIGNMENT, alignment);
ptr = util::align (ptr, alignment);
// ensure we haven't overrun our allocated segment
if (ptr + bytes > m_end)
throw std::bad_alloc ();
// use a 'record' struct as a window into the reserved space at the front
// of the allocation and store the offset to the previous allocation head
// (from the record struct). allows us to account for alignment.
record r;
r.as_bytes = ptr - sizeof (record::offset_t);
*r.as_offset = util::cast::lossless <uint32_t> (ptr - m_cursor);
m_cursor = ptr + bytes;
return { util::cast::alignment<T*> (ptr), count };
}
template <typename T>
util::view<T*>
allocate (size_t count)
{
return allocate<T> (count, alignof (T));
}
template <typename T>
void deallocate (util::view<T*> _ptr)
{
auto ptr = reinterpret_cast<std::byte*> (_ptr.data ());
record r;
r.as_bytes = ptr - sizeof (record::offset_t);
//CHECK_LE (bytes, *record.as_offset);
CHECK_GE (m_cursor - *r.as_offset, m_begin);
m_cursor -= sizeof (T) * _ptr.size ();
m_cursor -= *r.as_offset;
}
void deallocate (util::view<std::byte*> ptr) { return deallocate (ptr.data (), ptr.size ()); }
void deallocate (util::view<std::byte*> ptr, size_t alignment) { return deallocate (ptr.data (), ptr.size (), alignment); }
void deallocate (void *ptr, size_t bytes);
void deallocate (void *ptr, size_t bytes, size_t alignment);
util::view<std::byte*> data (void);
util::view<const std::byte*> data (void) const;
@ -60,6 +108,13 @@ namespace util::alloc::raw {
size_t remain (void) const;
private:
union record {
using offset_t = uint32_t;
std::byte *as_bytes;
offset_t *as_offset;
};
std::byte *const m_begin;
std::byte *const m_end;
std::byte *m_cursor;

8
test/alloc/aligned/direct.cpp
View File

@ -29,10 +29,10 @@ main (int, char**)
// alignment to produce a likely system alignment. eg, 3 + 5 == 8 which is
// a power-of-2.
uintptr_t result[4] = {
reinterpret_cast<uintptr_t>(alloc.allocate (9).data ()), // just over a power of two
reinterpret_cast<uintptr_t>(alloc.allocate (1).data ()), // a single byte
reinterpret_cast<uintptr_t>(alloc.allocate (64).data ()), // a cache line
reinterpret_cast<uintptr_t>(alloc.allocate (250).data ()) // multiple cache lines, but not a power of two
reinterpret_cast<uintptr_t>(alloc.allocate<char> (9).data ()), // just over a power of two
reinterpret_cast<uintptr_t>(alloc.allocate<char> (1).data ()), // a single byte
reinterpret_cast<uintptr_t>(alloc.allocate<char> (64).data ()), // a cache line
reinterpret_cast<uintptr_t>(alloc.allocate<char> (250).data ()) // multiple lines, but not a power of two
};
tap.expect (

4
test/alloc/aligned/foreign.cpp
View File

@ -27,7 +27,7 @@ main ()
// ensure the first element allocated falls at the base address
tap.expect_eq (base, alloc.data (), "allocator base address is the supplied base address");
tap.expect_eq (base, alloc.allocate (8), "first allocation is the supplied base address");
tap.expect_eq (base, alloc.allocate<std::byte> (8).data (), "first allocation is the supplied base address");
// allocate a range of values and make sure they all satisfy our alignment.
// don't choose values which are likely to combine with the testing
@ -45,7 +45,7 @@ main ()
};
for (const auto &t: TESTS) {
auto ptr = reinterpret_cast<uintptr_t> (alloc.allocate (t.size));
auto ptr = reinterpret_cast<uintptr_t> (alloc.allocate<char> (t.size).data ());
auto offset = ptr - reinterpret_cast<uintptr_t> (base);
tap.expect_mod (offset, alignment, "%s", t.message);
}

2
test/alloc/forwarding.cpp
View File

@ -13,7 +13,7 @@ main ()
util::TAP::logger tap;
tap.expect_eq (linear.used (), 0u, "construction does not allocate");
forwarding.allocate (16u);
forwarding.allocate<uint8_t> (16u);
tap.expect_eq (linear.used (), 16u, "allocation size is exactly committed");
return tap.status ();

8
test/alloc/linear.cpp
View File

@ -18,12 +18,12 @@ main (void)
tap.expect_eq (store.capacity (), BUFFER_SIZE, "bytes capacity matches");
tap.expect_throw<std::bad_alloc> (
[&] (void) { store.allocate (BUFFER_SIZE + 1, 1); },
[&] (void) { store.allocate<char> (BUFFER_SIZE + 1, 1); },
"excessive allocation throws bad_alloc"
);
tap.expect_nothrow (
[&] (void) { store.allocate (BUFFER_SIZE); },
[&] (void) { store.allocate<char> (BUFFER_SIZE); },
"maximum allocation succeeds"
);
@ -31,14 +31,14 @@ main (void)
tap.expect_eq (store.remain (), 0u, "bytes remain matches");
tap.expect_throw<std::bad_alloc> (
[&] (void) { store.allocate (1, 1); },
[&] (void) { store.allocate<char> (1, 1); },
"minimum allocation fails after exhaustion"
);
store.reset ();
tap.expect_nothrow (
[&] (void) { store.allocate (1, 1); },
[&] (void) { store.allocate<char> (1, 1); },
"minimum allocation succeeds after reset"
);

10
test/alloc/stack.cpp
View File

@ -10,8 +10,8 @@ n_allocations (util::alloc::raw::stack &store,
size_t alignment = alignof (std::max_align_t))
{
for (unsigned i = 0; i < count; ++i) {
auto ptr = store.allocate (bytes, alignment);
store.deallocate (ptr, alignment);
auto ptr = store.allocate<uint8_t> (bytes, alignment);
store.deallocate (ptr);
}
}
@ -40,7 +40,7 @@ main (void)
// larger than total allocations should throw
tap.expect_throw<std::bad_alloc> (
[&store] (void) { store.allocate (BUFFER_AVAILABLE + 1, 1); },
[&store] (void) { store.allocate<uint8_t> (BUFFER_AVAILABLE + 1, 1); },
"excessive allocation throws bad_alloc"
);
@ -53,11 +53,11 @@ main (void)
// perform two near maximum allocations and check for exhaustion through
// bad_alloc
auto ptr = store.allocate (BUFFER_REQUEST);
auto ptr = store.allocate<uint8_t> (BUFFER_REQUEST);
(void)ptr;
tap.expect_throw<std::bad_alloc> (
[&store] (void) { store.allocate (BUFFER_REQUEST); },
[&store] (void) { store.allocate<uint8_t> (BUFFER_REQUEST); },
"bad_alloc thrown on exhaustion"
);