allocator.cpp

Go to the documentation of this file.

 
// expand _TEST_EXPORT macros
#define _RWSTD_TEST_SRC
 
#include <rw_allocator.h>
#include <rw_new.h>         // for operator_new()
#include <rw_driver.h>         // for rw_assert()
#include <rw_exception.h>   // for rw_throw()
 
#include <new>              // for bad_alloc, placement new
#include <stdarg.h>         // for va_arg(), va_list
#include <string.h>         // for memset()
 
 
static const char* const
_rw_func_names[] = {
    "UserAlloc ()",
    "UserAlloc (const UserAlloc&)",
    "UserAlloc (const UserAlloc<U>&)",
    "~UserAlloc ()",
    "operator= (const UserAlloc&)",
    "operator=<U>(const UserAlloc<U>&)",
    "allocate (size_type, void*)",
    "deallocate (pointer, size_type)",
    "construct (pointer, const_reference)",
    "destroy (pointer)",
    "address (reference) const",
    "max_size () const"
};
 
static int _rw_id_gen;   // generates unique ids
 
 
 
SharedAlloc::
SharedAlloc (size_t nbytes /* = MAX_SIZE */, size_t nblocks /* = MAX_SIZE */)
    : max_bytes_ (nbytes), max_blocks_ (nblocks),
      n_bytes_ (0), n_blocks_ (0), n_refs_ (0), id_ (0)
{
    memset (n_calls_, 0, sizeof n_calls_);
    memset (n_throws_, 0, sizeof n_throws_);
    memset (throw_at_calls_, 0, sizeof throw_at_calls_);
}
 
 
/* virtual */ SharedAlloc::
~SharedAlloc ()
{
    static size_t deadbeef = 0;
    if (0 == deadbeef) {
        deadbeef = size_t (0xdeadbeefU);
        if (deadbeef < deadbeef << 1) {
            // assume 64-bit size_t
            deadbeef <<= 31;
            deadbeef <<=  1;
            deadbeef  |= size_t (0xdeadbeefU);
        }
    }
 
    // invalidate
    size_t n = sizeof n_calls_ / sizeof *n_calls_;
    for (size_t i = 0; i != n; ++i)
        n_calls_ [i] = deadbeef;
 
    n = sizeof n_throws_ / sizeof *n_throws_;
    for (size_t i = 0; i != n; ++i)
        n_throws_ [i] = deadbeef;
 
    n = sizeof throw_at_calls_ / sizeof *throw_at_calls_;
    for (size_t i = 0; i != n; ++i)
        throw_at_calls_ [i] = deadbeef;
}
 
 
/* virtual */ void* SharedAlloc::
allocate (size_t nelems, size_t size, const void* /* = 0 */)
{
    funcall (m_allocate);
 
    const size_t nbytes = nelems * size;
 
    if (max_blocks_ < n_blocks_ + nelems)
        rw_throw (ex_bad_alloc, __FILE__, __LINE__, 0,
                  "allocate (%zu):  reached block limit of %zu",
                  nbytes, max_blocks_);
 
    if (max_bytes_ < n_bytes_ + nbytes)
        rw_throw (ex_bad_alloc, __FILE__, __LINE__, 0,
                  "allocate (%zu):  reached size limit of %zu",
                  nbytes, max_bytes_);
 
    return operator_new (nbytes, false);
}
 
 
/* virtual */ void SharedAlloc::
deallocate (void *ptr, size_t /* nelems */, size_t /* size */)
{
    funcall (m_deallocate);
 
    return operator_delete (ptr, false);
}
 
 
/* virtual */ size_t SharedAlloc::
max_size (size_t size /* = 1 */)
{
    funcall (m_max_size);
 
    return max_blocks_ / size;
}
 
 
/* virtual */ void SharedAlloc::
funcall (MemFun mf, const SharedAlloc *other /* = 0 */)
{
    // increment the number of calls regardless of success
    ++n_calls_ [mf];
 
    if (m_ctor == mf) {
        // ordinary (not a copy or converting) ctor
        if (id_ <= 0) {
            RW_ASSERT (0 == n_refs_);
            id_ = ++_rw_id_gen;
        }
 
        // increment the number of references to this allocator
        ++n_refs_;
    }
    else if (m_cpy_ctor == mf || m_cvt_ctor == mf) {
        // copy or converting ctor
        RW_ASSERT (0 < id_);
        RW_ASSERT (0 < n_refs_);
 
        // increment the number of references to this allocator
        ++n_refs_;
    }
    else if (m_cpy_assign == mf || m_cvt_assign == mf) {
        // assignment operator
        RW_ASSERT (0 <= id_ && id_ <= _rw_id_gen);
        RW_ASSERT (0 < n_refs_);
 
        RW_ASSERT (0 != other);
 
        if (this != other) {
            // decrement the number of references and invalidate
            // id if no object refers to *this
            if (0 == --n_refs_)
                id_ = -1;
 
            SharedAlloc* const po = _RWSTD_CONST_CAST (SharedAlloc*, other);
 
            if (other->id_ <= 0)
                po->id_ = ++_rw_id_gen;
 
            ++po->n_refs_;
        }
    }
    else if (m_dtor == mf) {
        // dtor
        RW_ASSERT (0 <= id_ && id_ <= _rw_id_gen);
        RW_ASSERT (0 < n_refs_);
 
        // decrement the number of references and invalidate
        // id if no object refers to *this
        if (0 == --n_refs_)
            id_ = -1;
    }
 
    // check the number of calls and throw an exception
    // if the specified limit has been reached
    if (n_calls_ [mf] == throw_at_calls_ [mf]) {
        // increment the exception counter for this function
        ++n_throws_ [mf];
 
        rw_throw (ex_bad_alloc, __FILE__, __LINE__, 0,
                  "UserAlloc::%s: reached call limit of %zu",
                  _rw_func_names [mf], throw_at_calls_);
 
        RW_ASSERT (!"logic error: should not reach");
    }
}
 
 
/* static */ SharedAlloc* SharedAlloc::
instance (SharedAlloc *pinst /* = 0 */)
{
    // get or a set a pointer to the global allocator object
    static SharedAlloc* pglobal = 0;
 
    if (0 == pglobal) {
        // construct the global allocator object in the static buffer
        static size_t instbuf [sizeof (SharedAlloc) / sizeof (size_t) + 1];
        static SharedAlloc* const pbuf = new (instbuf) SharedAlloc ();
 
        pglobal = pbuf;
    }
 
    if (pinst) {
        // set the global allocator object and return a pointer
        // to the previous one
        SharedAlloc* const tmp = pglobal;
        pglobal = pinst;
        pinst   = tmp;
    }
    else
        pinst = pglobal;
 
    RW_ASSERT (0 != pinst);
 
    return pinst;
}
 
 
void SharedAlloc::
reset_call_counters ()
{
    memset (n_calls_, 0, sizeof n_calls_);
}
 
 
/* static */ const char* SharedAlloc::
func_name (MemFun mf)
{
    return _rw_func_names [mf];
}
 
 
static void
_rw_check_leaks (int line, size_t expect_blocks, size_t expect_bytes)
{
    if (0 < line) {
        // determine and report memory leaks since last checkpoint
 
        /* const */ size_t nbytes;
        const       size_t nblocks = rwt_check_leaks (&nbytes, 0);
 
        if (_RWSTD_SIZE_MAX == expect_blocks)
            expect_blocks = nblocks;
 
        if (_RWSTD_SIZE_MAX == expect_bytes)
            expect_bytes = nbytes;
 
        rw_assert (nblocks == expect_blocks && nbytes == expect_bytes,
                   0, line,
                   "line %d. %{$FUNCALL} operator new allocated "
                   "%zu bytes in %zu blocks, expected %zu bytes "
                   "in %zu blocks",
                   __LINE__, nbytes, nblocks,
                   expect_bytes, expect_blocks);
    }
    else {
        // establish a checkpoint for memory leaks
        rwt_check_leaks (0, 0);
    }
}
 
 
_TEST_EXPORT void
rw_check_leaks (const SharedAlloc *palloc        /* =  0 */,
                int                line          /* =  0 */, 
                size_t             expect_blocks /* =  0 */,
                size_t             expect_bytes  /* = -1 */)
{
    _rw_check_leaks (line, expect_blocks, expect_bytes);
 
    if (0 == palloc)
        return;
 
    static size_t nbytes;
    static size_t nblocks;
 
    if (0 < line) {
        // determine and report memory leaks since last checkpoint
        const size_t leaked_bytes  = palloc->n_bytes_ - nbytes;
        const size_t leaked_blocks = palloc->n_blocks_ - nblocks;
 
        if (_RWSTD_SIZE_MAX == expect_blocks)   // don't care
            expect_blocks = leaked_blocks;
 
        if (_RWSTD_SIZE_MAX == expect_bytes)   // don't care
            expect_bytes = nbytes;
 
        rw_assert (   leaked_blocks == expect_blocks
                   && leaked_bytes == expect_bytes, 0, line,
                   "line %d. %{$FUNCALL} UserAlloc allocated "
                   "%zu bytes in %zu blocks, expected %zu bytes "
                   "in %zu blocks",
                   __LINE__, leaked_bytes, leaked_blocks,
                   expect_bytes, expect_blocks);
    }
    else {
        // establish a checkpoint for memory leaks
        nbytes  = palloc->n_bytes_;
        nblocks = palloc->n_blocks_;
    }
}