2003-01-14 05:56:56 +01:00
|
|
|
// -*- C++ -*-
|
2002-11-26 01:53:12 +01:00
|
|
|
// Testing allocator for the C++ library testsuite.
|
|
|
|
//
|
2004-10-15 01:03:26 +02:00
|
|
|
// Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
|
2002-11-26 01:53:12 +01:00
|
|
|
//
|
|
|
|
// This file is part of the GNU ISO C++ Library. This library is free
|
|
|
|
// software; you can redistribute it and/or modify it under the
|
|
|
|
// terms of the GNU General Public License as published by the
|
|
|
|
// Free Software Foundation; either version 2, or (at your option)
|
|
|
|
// any later version.
|
|
|
|
//
|
|
|
|
// This library is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU General Public License along
|
|
|
|
// with this library; see the file COPYING. If not, write to the Free
|
|
|
|
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
|
|
// USA.
|
|
|
|
//
|
|
|
|
// As a special exception, you may use this file as part of a free software
|
|
|
|
// library without restriction. Specifically, if other files instantiate
|
|
|
|
// templates or use macros or inline functions from this file, or you compile
|
|
|
|
// this file and link it with other files to produce an executable, this
|
|
|
|
// file does not by itself cause the resulting executable to be covered by
|
|
|
|
// the GNU General Public License. This exception does not however
|
|
|
|
// invalidate any other reasons why the executable file might be covered by
|
|
|
|
// the GNU General Public License.
|
|
|
|
|
|
|
|
// This file provides an test instrumentation allocator that can be
|
|
|
|
// used to verify allocation functionality of standard library
|
|
|
|
// containers. 2002.11.25 smw
|
|
|
|
|
2003-07-05 06:05:45 +02:00
|
|
|
#ifndef _GLIBCXX_TESTSUITE_ALLOCATOR_H
|
|
|
|
#define _GLIBCXX_TESTSUITE_ALLOCATOR_H
|
2002-11-26 01:53:12 +01:00
|
|
|
|
|
|
|
#include <cstddef>
|
|
|
|
#include <limits>
|
|
|
|
|
2004-09-02 00:17:00 +02:00
|
|
|
namespace
|
|
|
|
{
|
2004-10-29 23:03:07 +02:00
|
|
|
bool new_called = false;
|
|
|
|
bool delete_called = false;
|
2004-09-02 00:17:00 +02:00
|
|
|
};
|
|
|
|
|
2003-07-24 23:08:03 +02:00
|
|
|
namespace __gnu_test
|
2002-11-26 01:53:12 +01:00
|
|
|
{
|
2003-01-14 05:56:56 +01:00
|
|
|
class allocation_tracker
|
2002-11-26 01:53:12 +01:00
|
|
|
{
|
2003-01-14 05:56:56 +01:00
|
|
|
public:
|
|
|
|
typedef std::size_t size_type;
|
|
|
|
|
|
|
|
static void*
|
|
|
|
allocate(size_type blocksize)
|
|
|
|
{
|
|
|
|
allocationTotal_ += blocksize;
|
|
|
|
return ::operator new(blocksize);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
construct() { constructCount_++; }
|
2002-11-26 01:53:12 +01:00
|
|
|
|
2003-01-14 05:56:56 +01:00
|
|
|
static void
|
|
|
|
destroy() { destructCount_++; }
|
2002-11-26 01:53:12 +01:00
|
|
|
|
2003-01-14 05:56:56 +01:00
|
|
|
static void
|
|
|
|
deallocate(void* p, size_type blocksize)
|
|
|
|
{
|
|
|
|
::operator delete(p);
|
|
|
|
deallocationTotal_ += blocksize;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_type
|
|
|
|
allocationTotal() { return allocationTotal_; }
|
|
|
|
|
|
|
|
static size_type
|
|
|
|
deallocationTotal() { return deallocationTotal_; }
|
|
|
|
|
|
|
|
static int
|
|
|
|
constructCount() { return constructCount_; }
|
2002-11-26 01:53:12 +01:00
|
|
|
|
2003-01-14 05:56:56 +01:00
|
|
|
static int
|
|
|
|
destructCount() { return destructCount_; }
|
2002-11-26 01:53:12 +01:00
|
|
|
|
2003-01-14 05:56:56 +01:00
|
|
|
static void
|
|
|
|
resetCounts()
|
|
|
|
{
|
|
|
|
allocationTotal_ = 0;
|
|
|
|
deallocationTotal_ = 0;
|
|
|
|
constructCount_ = 0;
|
2002-11-26 01:53:12 +01:00
|
|
|
destructCount_ = 0;
|
2003-01-14 05:56:56 +01:00
|
|
|
}
|
2002-11-26 01:53:12 +01:00
|
|
|
|
|
|
|
private:
|
2003-01-14 05:56:56 +01:00
|
|
|
static size_type allocationTotal_;
|
|
|
|
static size_type deallocationTotal_;
|
|
|
|
static int constructCount_;
|
|
|
|
static int destructCount_;
|
|
|
|
};
|
|
|
|
|
|
|
|
// A simple basic allocator that just forwards to the
|
|
|
|
// allocation_tracker to fulfill memory requests. This class is
|
|
|
|
// templated on the target object type, but tracker isn't.
|
|
|
|
template<class T>
|
|
|
|
class tracker_alloc
|
2002-11-26 01:53:12 +01:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
typedef T value_type;
|
|
|
|
typedef T* pointer;
|
|
|
|
typedef const T* const_pointer;
|
|
|
|
typedef T& reference;
|
|
|
|
typedef const T& const_reference;
|
|
|
|
typedef std::size_t size_type;
|
|
|
|
typedef std::ptrdiff_t difference_type;
|
|
|
|
|
2003-01-14 05:56:56 +01:00
|
|
|
template<class U> struct rebind { typedef tracker_alloc<U> other; };
|
2002-11-26 01:53:12 +01:00
|
|
|
|
|
|
|
pointer
|
|
|
|
address(reference value) const
|
|
|
|
{ return &value; }
|
|
|
|
|
|
|
|
const_pointer
|
|
|
|
address(const_reference value) const
|
|
|
|
{ return &value; }
|
|
|
|
|
2003-01-14 05:56:56 +01:00
|
|
|
tracker_alloc() throw()
|
2002-11-26 01:53:12 +01:00
|
|
|
{ }
|
|
|
|
|
2003-01-14 05:56:56 +01:00
|
|
|
tracker_alloc(const tracker_alloc&) throw()
|
2002-11-26 01:53:12 +01:00
|
|
|
{ }
|
|
|
|
|
|
|
|
template<class U>
|
2003-01-14 05:56:56 +01:00
|
|
|
tracker_alloc(const tracker_alloc<U>&) throw()
|
2002-11-26 01:53:12 +01:00
|
|
|
{ }
|
|
|
|
|
2003-01-14 05:56:56 +01:00
|
|
|
~tracker_alloc() throw()
|
2002-11-26 01:53:12 +01:00
|
|
|
{ }
|
|
|
|
|
|
|
|
size_type
|
|
|
|
max_size() const throw()
|
|
|
|
{ return std::numeric_limits<std::size_t>::max() / sizeof(T); }
|
|
|
|
|
|
|
|
pointer
|
2003-01-14 05:56:56 +01:00
|
|
|
allocate(size_type n, const void* = 0)
|
2002-11-26 01:53:12 +01:00
|
|
|
{
|
2003-01-14 05:56:56 +01:00
|
|
|
return static_cast<pointer>(allocation_tracker::allocate(n * sizeof(T)));
|
2002-11-26 01:53:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
construct(pointer p, const T& value)
|
|
|
|
{
|
|
|
|
new (p) T(value);
|
2003-01-14 05:56:56 +01:00
|
|
|
allocation_tracker::construct();
|
2002-11-26 01:53:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
destroy(pointer p)
|
|
|
|
{
|
|
|
|
p->~T();
|
2003-01-14 05:56:56 +01:00
|
|
|
allocation_tracker::destroy();
|
2002-11-26 01:53:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
deallocate(pointer p, size_type num)
|
2003-01-14 05:56:56 +01:00
|
|
|
{ allocation_tracker::deallocate(p, num * sizeof(T)); }
|
2002-11-26 01:53:12 +01:00
|
|
|
};
|
|
|
|
|
2003-01-14 05:56:56 +01:00
|
|
|
template<class T1, class T2>
|
|
|
|
bool
|
|
|
|
operator==(const tracker_alloc<T1>&, const tracker_alloc<T2>&) throw()
|
|
|
|
{ return true; }
|
|
|
|
|
|
|
|
template<class T1, class T2>
|
|
|
|
bool
|
|
|
|
operator!=(const tracker_alloc<T1>&, const tracker_alloc<T2>&) throw()
|
|
|
|
{ return false; }
|
2004-07-28 18:37:20 +02:00
|
|
|
|
2004-09-02 00:17:00 +02:00
|
|
|
bool
|
|
|
|
check_construct_destroy(const char* tag, int expected_c, int expected_d);
|
2004-07-28 18:37:20 +02:00
|
|
|
|
2004-10-29 23:03:07 +02:00
|
|
|
template<typename Alloc, bool uses_global_new>
|
2004-10-15 01:03:26 +02:00
|
|
|
bool
|
|
|
|
check_new(Alloc a = Alloc())
|
|
|
|
{
|
|
|
|
bool test __attribute__((unused)) = true;
|
|
|
|
typename Alloc::pointer p = a.allocate(10);
|
2004-10-29 23:03:07 +02:00
|
|
|
test &= ( new_called == uses_global_new );
|
|
|
|
return test;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename Alloc, bool uses_global_delete>
|
|
|
|
bool
|
|
|
|
check_delete(Alloc a = Alloc())
|
|
|
|
{
|
|
|
|
bool test __attribute__((unused)) = true;
|
|
|
|
typename Alloc::pointer p = a.allocate(10);
|
2004-10-15 01:03:26 +02:00
|
|
|
a.deallocate(p, 10);
|
2004-10-29 23:03:07 +02:00
|
|
|
test &= ( delete_called == uses_global_delete );
|
2004-10-15 01:03:26 +02:00
|
|
|
return test;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename Alloc>
|
|
|
|
bool
|
|
|
|
check_deallocate_null()
|
|
|
|
{
|
|
|
|
// Let's not core here...
|
|
|
|
Alloc a;
|
2004-10-15 12:54:57 +02:00
|
|
|
a.deallocate(NULL, 1);
|
2004-10-15 01:03:26 +02:00
|
|
|
a.deallocate(NULL, 10);
|
|
|
|
}
|
2004-10-21 02:06:02 +02:00
|
|
|
|
|
|
|
template<typename Alloc>
|
|
|
|
bool
|
|
|
|
check_allocate_max_size()
|
|
|
|
{
|
|
|
|
Alloc a;
|
|
|
|
try
|
|
|
|
{
|
|
|
|
a.allocate(a.max_size() + 1);
|
|
|
|
}
|
|
|
|
catch(std::bad_alloc&)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
catch(...)
|
|
|
|
{
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
|
2003-07-24 23:08:03 +02:00
|
|
|
}; // namespace __gnu_test
|
2002-11-26 01:53:12 +01:00
|
|
|
|
2003-07-05 06:05:45 +02:00
|
|
|
#endif // _GLIBCXX_TESTSUITE_ALLOCATOR_H
|