feedc0de/boost_unordered
1
0
Fork 0
forked from boostorg/unordered
Code Pull Requests Activity

Merge latest unordered developments:

Browse Source 
Make simple_test test a little more.
Use doubles for calculating max load factor.
Some workarounds, mostly for Borland and running the tests.


[SVN r42666]
This commit is contained in:
Daniel James
2008-01-10 22:30:46 +00:00
parent 488bce194c
commit 9d7411840e
31 changed files with 458 additions and 508 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/objects/exception.hpp
+19 -128
View File
@@ -16,6 +16,7 @@
#include <iostream>
#include "../helpers/fwd.hpp"
#include "../helpers/allocator.hpp"
#include "memory.hpp"
#include <map>
#define RUN_EXCEPTION_TESTS(test_seq, param_seq) \
@@ -53,8 +54,6 @@
#define DISABLE_EXCEPTIONS \
::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(false)
#define HASH_CHECK(test) if(!(test)) BOOST_ERROR(BOOST_STRINGIZE(test))
namespace test {
static char const* scope = "";
bool exceptions_enabled = false;
@@ -151,8 +150,8 @@ namespace test {
test_runner(Test const& t) : test_(t) {}
void operator()() const {
DISABLE_EXCEPTIONS;
typename Test::data_type x(test_.init());
typename Test::strong_type strong;
BOOST_DEDUCED_TYPENAME Test::data_type x(test_.init());
BOOST_DEDUCED_TYPENAME Test::strong_type strong;
strong.store(x);
try {
ENABLE_EXCEPTIONS;
@@ -179,123 +178,15 @@ namespace exception
{
namespace detail
{
// This annoymous namespace won't cause ODR violations as I won't
// be linking multiple translation units together. I'll probably
// move this into a cpp file before a full release, but for now it's
// the most convenient way.
struct malloc_allocator_holder {
template <class T> struct apply {
typedef test::malloc_allocator<T> type;
};
};
namespace
{
struct memory_area {
void const* start;
void const* end;
memory_area(void const* s, void const* e)
: start(s), end(e)
{
BOOST_ASSERT(start != end);
}
};
struct memory_track {
explicit memory_track(int tag = -1) :
tag_(tag) {}
int tag_;
};
// This is a bit dodgy as it defines overlapping
// areas as 'equal', so this isn't a total ordering.
// But it is for non-overlapping memory regions - which
// is what'll be stored.
//
// All searches will be for areas entirely contained by
// a member of the set - so it should find the area that contains
// the region that is searched for.
struct memory_area_compare {
bool operator()(memory_area const& x, memory_area const& y) const {
return x.end <= y.start;
}
};
typedef std::map<memory_area, memory_track, memory_area_compare,
test::malloc_allocator<std::pair<memory_area const, memory_track> > >
allocated_memory_type;
allocated_memory_type allocated_memory;
unsigned int count_allocators = 0;
unsigned int count_allocations = 0;
unsigned int count_constructions = 0;
}
void allocator_ref()
{
if(count_allocators == 0) {
count_allocations = 0;
count_constructions = 0;
allocated_memory.clear();
}
++count_allocators;
}
void allocator_unref()
{
HASH_CHECK(count_allocators > 0);
if(count_allocators > 0) {
--count_allocators;
if(count_allocators == 0) {
bool no_allocations_left = (count_allocations == 0);
bool no_constructions_left = (count_constructions == 0);
bool allocated_memory_empty = allocated_memory.empty();
// Clearing the data before the checks terminate the tests.
count_allocations = 0;
count_constructions = 0;
allocated_memory.clear();
HASH_CHECK(no_allocations_left);
HASH_CHECK(no_constructions_left);
HASH_CHECK(allocated_memory_empty);
}
}
}
void track_allocate(void *ptr, std::size_t n, std::size_t size, int tag)
{
if(n == 0) {
BOOST_ERROR("Allocating 0 length array.");
}
else {
++count_allocations;
allocated_memory[memory_area(ptr, (char*) ptr + n * size)] =
memory_track(tag);
}
}
void track_deallocate(void* ptr, std::size_t n, std::size_t size, int tag)
{
allocated_memory_type::iterator pos
= allocated_memory.find(memory_area(ptr, (char*) ptr + n * size));
if(pos == allocated_memory.end()) {
BOOST_ERROR("Deallocating unknown pointer.");
} else {
HASH_CHECK(pos->first.start == ptr);
HASH_CHECK(pos->first.end == (char*) ptr + n * size);
HASH_CHECK(pos->second.tag_ == tag);
allocated_memory.erase(pos);
}
HASH_CHECK(count_allocations > 0);
if(count_allocations > 0) --count_allocations;
}
void track_construct(void* ptr, std::size_t /*size*/, int tag)
{
++count_constructions;
}
void track_destroy(void* ptr, std::size_t /*size*/, int tag)
{
HASH_CHECK(count_constructions > 0);
if(count_constructions > 0) --count_constructions;
test::detail::memory_tracker<malloc_allocator_holder> tracker;
}
}
@@ -519,7 +410,7 @@ namespace exception
SCOPE(allocator::allocator()) {
EPOINT("Mock allocator default constructor.");
}
detail::allocator_ref();
detail::tracker.allocator_ref();
}
template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_)
@@ -527,7 +418,7 @@ namespace exception
SCOPE(allocator::allocator()) {
EPOINT("Mock allocator template copy constructor.");
}
detail::allocator_ref();
detail::tracker.allocator_ref();
}
allocator(allocator const& x) : tag_(x.tag_)
@@ -535,11 +426,11 @@ namespace exception
SCOPE(allocator::allocator()) {
EPOINT("Mock allocator copy constructor.");
}
detail::allocator_ref();
detail::tracker.allocator_ref();
}
~allocator() {
detail::allocator_unref();
detail::tracker.allocator_unref();
}
allocator& operator=(allocator const& x) {
@@ -577,7 +468,7 @@ namespace exception
ptr = (T*) malloc(n * sizeof(T));
if(!ptr) throw std::bad_alloc();
}
detail::track_allocate((void*) ptr, n, sizeof(T), tag_);
detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
return pointer(ptr);
//return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
@@ -593,7 +484,7 @@ namespace exception
ptr = (T*) malloc(n * sizeof(T));
if(!ptr) throw std::bad_alloc();
}
detail::track_allocate((void*) ptr, n, sizeof(T), tag_);
detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
return pointer(ptr);
//return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
@@ -603,7 +494,7 @@ namespace exception
{
//::operator delete((void*) p);
if(p) {
detail::track_deallocate((void*) p, n, sizeof(T), tag_);
detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
using namespace std;
free(p);
}
@@ -614,11 +505,11 @@ namespace exception
EPOINT("Mock allocator construct function.");
new(p) T(t);
}
detail::track_construct((void*) p, sizeof(T), tag_);
detail::tracker.track_construct((void*) p, sizeof(T), tag_);
}
void destroy(pointer p) {
detail::track_destroy((void*) p, sizeof(T), tag_);
detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
p->~T();
}
test/objects/memory.hpp
+149
View File
@@ -0,0 +1,149 @@
// Copyright 2006-2007 Daniel James.
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#if !defined(BOOST_UNORDERED_TEST_MEMORY_HEADER)
#define BOOST_UNORDERED_TEST_MEMORY_HEADER
#define HASH_CHECK(test) if(!(test)) BOOST_ERROR(BOOST_STRINGIZE(test))
namespace test
{
namespace detail
{
// This annoymous namespace won't cause ODR violations as I won't
// be linking multiple translation units together. I'll probably
// move this into a cpp file before a full release, but for now it's
// the most convenient way.
struct memory_area {
void const* start;
void const* end;
memory_area(void const* s, void const* e)
: start(s), end(e)
{
BOOST_ASSERT(start != end);
}
};
struct memory_track {
explicit memory_track(int tag = -1) :
constructed_(0),
tag_(tag) {}
int constructed_;
int tag_;
};
// This is a bit dodgy as it defines overlapping
// areas as 'equal', so this isn't a total ordering.
// But it is for non-overlapping memory regions - which
// is what'll be stored.
//
// All searches will be for areas entirely contained by
// a member of the set - so it should find the area that contains
// the region that is searched for.
struct memory_area_compare {
bool operator()(memory_area const& x, memory_area const& y) const {
return x.end <= y.start;
}
};
struct default_allocator_holder { template <class T> struct apply {
typedef std::allocator<T> type; }; };
template <class AllocatorHolder = default_allocator_holder>
struct memory_tracker {
typedef std::map<memory_area, memory_track, memory_area_compare,
BOOST_DEDUCED_TYPENAME AllocatorHolder::
template apply<std::pair<memory_area const, memory_track> >::type
> allocated_memory_type;
allocated_memory_type allocated_memory;
unsigned int count_allocators;
unsigned int count_allocations;
unsigned int count_constructions;
memory_tracker() :
count_allocators(0), count_allocations(0),
count_constructions(0)
{}
void allocator_ref()
{
if(count_allocators == 0) {
count_allocations = 0;
count_constructions = 0;
allocated_memory.clear();
}
++count_allocators;
}
void allocator_unref()
{
HASH_CHECK(count_allocators > 0);
if(count_allocators > 0) {
--count_allocators;
if(count_allocators == 0) {
bool no_allocations_left = (count_allocations == 0);
bool no_constructions_left = (count_constructions == 0);
bool allocated_memory_empty = allocated_memory.empty();
// Clearing the data before the checks terminate the tests.
count_allocations = 0;
count_constructions = 0;
allocated_memory.clear();
HASH_CHECK(no_allocations_left);
HASH_CHECK(no_constructions_left);
HASH_CHECK(allocated_memory_empty);
}
}
}
void track_allocate(void *ptr, std::size_t n, std::size_t size, int tag)
{
if(n == 0) {
BOOST_ERROR("Allocating 0 length array.");
}
else {
++count_allocations;
allocated_memory[memory_area(ptr, (char*) ptr + n * size)] =
memory_track(tag);
}
}
void track_deallocate(void* ptr, std::size_t n, std::size_t size, int tag)
{
BOOST_DEDUCED_TYPENAME allocated_memory_type::iterator pos
= allocated_memory.find(memory_area(ptr, (char*) ptr + n * size));
if(pos == allocated_memory.end()) {
BOOST_ERROR("Deallocating unknown pointer.");
} else {
HASH_CHECK(pos->first.start == ptr);
HASH_CHECK(pos->first.end == (char*) ptr + n * size);
HASH_CHECK(pos->second.tag_ == tag);
allocated_memory.erase(pos);
}
HASH_CHECK(count_allocations > 0);
if(count_allocations > 0) --count_allocations;
}
void track_construct(void* ptr, std::size_t /*size*/, int tag)
{
++count_constructions;
}
void track_destroy(void* ptr, std::size_t /*size*/, int tag)
{
HASH_CHECK(count_constructions > 0);
if(count_constructions > 0) --count_constructions;
}
};
}
}
#endif
test/objects/test.hpp
+12 -144
View File
@@ -9,8 +9,9 @@
#include <boost/config.hpp>
#include <boost/limits.hpp>
#include <cstddef>
#include "../helpers/fwd.hpp"
#include <iostream>
#include "../helpers/fwd.hpp"
#include "memory.hpp"
#include <map>
namespace test
@@ -203,141 +204,8 @@ namespace test
namespace detail
{
// This annoymous namespace won't cause ODR violations as I won't
// be linking multiple translation units together. I'll probably
// move this into a cpp file before a full release, but for now it's
// the most convenient way.
namespace {
struct memory_area {
void const* start;
void const* end;
memory_area(void const* s, void const* e)
: start(s), end(e)
{
BOOST_ASSERT(start != end);
}
};
struct memory_track {
explicit memory_track(int tag = -1) :
constructed_(0),
tag_(tag) {}
int constructed_;
int tag_;
};
// This is a bit dodgy as it defines overlapping
// areas as 'equal', so this isn't a total ordering.
// But it is for non-overlapping memory regions - which
// is what'll be stored.
//
// All searches will be for areas entirely contained by
// a member of the set - so it should find the area that contains
// the region that is searched for.
struct memory_area_compare {
bool operator()(memory_area const& x, memory_area const& y) const {
return x.end <= y.start;
}
};
typedef std::map<memory_area, memory_track, memory_area_compare> allocated_memory_type;
allocated_memory_type allocated_memory;
unsigned int count_allocators = 0;
unsigned int count_allocations = 0;
unsigned int count_constructions = 0;
}
void allocator_ref()
{
if(count_allocators == 0) {
count_allocations = 0;
count_constructions = 0;
allocated_memory.clear();
}
++count_allocators;
}
void allocator_unref()
{
BOOST_TEST(count_allocators > 0);
if(count_allocators > 0) {
--count_allocators;
if(count_allocators == 0) {
bool no_allocations_left = (count_allocations == 0);
bool no_constructions_left = (count_constructions == 0);
bool allocated_memory_empty = allocated_memory.empty();
// Clearing the data before the checks terminate the tests.
count_allocations = 0;
count_constructions = 0;
allocated_memory.clear();
BOOST_TEST(no_allocations_left);
BOOST_TEST(no_constructions_left);
BOOST_TEST(allocated_memory_empty);
}
}
}
void track_allocate(void *ptr, std::size_t n, std::size_t size, int tag)
{
if(n == 0) {
BOOST_ERROR("Allocating 0 length array.");
}
else {
++count_allocations;
allocated_memory[memory_area(ptr, (char*) ptr + n * size)] =
memory_track(tag);
}
}
void track_deallocate(void* ptr, std::size_t n, std::size_t size, int tag)
{
allocated_memory_type::iterator pos
= allocated_memory.find(memory_area(ptr, (char*) ptr + n * size));
if(pos == allocated_memory.end()) {
BOOST_ERROR("Deallocating unknown pointer.");
} else {
BOOST_TEST(pos->first.start == ptr);
BOOST_TEST(pos->first.end == (char*) ptr + n * size);
BOOST_TEST(pos->second.tag_ == tag);
BOOST_TEST(pos->second.constructed_ == 0);
allocated_memory.erase(pos);
}
BOOST_TEST(count_allocations > 0);
if(count_allocations > 0) --count_allocations;
}
void track_construct(void* ptr, std::size_t size, int tag)
{
allocated_memory_type::iterator pos
= allocated_memory.find(memory_area(ptr, (char*) ptr + size));
if(pos == allocated_memory.end()) {
BOOST_ERROR("Constructing unknown pointer.");
}
else {
BOOST_TEST(pos->second.tag_ == tag);
++pos->second.constructed_;
}
++count_constructions;
}
void track_destroy(void* ptr, std::size_t size, int tag)
{
allocated_memory_type::iterator pos
= allocated_memory.find(memory_area(ptr, (char*) ptr + size));
if(pos == allocated_memory.end())
BOOST_ERROR("Destroying unknown pointer.");
else {
BOOST_TEST(pos->second.tag_ == tag);
BOOST_TEST(pos->second.constructed_ > 0);
if(pos->second.constructed_ > 0) --pos->second.constructed_;
}
BOOST_TEST(count_constructions > 0);
if(count_constructions > 0) --count_constructions;
test::detail::memory_tracker<test::detail::default_allocator_holder> tracker;
}
}
@@ -361,40 +229,40 @@ namespace test
template <class U> struct rebind { typedef allocator<U> other; };
explicit allocator(int t = 0) : tag_(t) { detail::allocator_ref(); }
template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_) { detail::allocator_ref(); }
allocator(allocator const& x) : tag_(x.tag_) { detail::allocator_ref(); }
~allocator() { detail::allocator_unref(); }
explicit allocator(int t = 0) : tag_(t) { detail::tracker.allocator_ref(); }
template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_) { detail::tracker.allocator_ref(); }
allocator(allocator const& x) : tag_(x.tag_) { detail::tracker.allocator_ref(); }
~allocator() { detail::tracker.allocator_unref(); }
pointer address(reference r) { return pointer(&r); }
const_pointer address(const_reference r) { return const_pointer(&r); }
pointer allocate(size_type n) {
pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
detail::track_allocate((void*) ptr, n, sizeof(T), tag_);
detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
return ptr;
}
pointer allocate(size_type n, const_pointer u)
{
pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
detail::track_allocate((void*) ptr, n, sizeof(T), tag_);
detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
return ptr;
}
void deallocate(pointer p, size_type n)
{
detail::track_deallocate((void*) p, n, sizeof(T), tag_);
detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
::operator delete((void*) p);
}
void construct(pointer p, T const& t) {
detail::track_construct((void*) p, sizeof(T), tag_);
detail::tracker.track_construct((void*) p, sizeof(T), tag_);
new(p) T(t);
}
void destroy(pointer p) {
detail::track_destroy((void*) p, sizeof(T), tag_);
detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
p->~T();
}