20.temp.buffer.cpp

Go to the documentation of this file.

 
#include <memory>      // for get_temporary_buffer()
 
#include <cerrno>      // for errno
#include <cstddef>     // for ptrdiff_t, size_t
#include <cstdio>      // for sprintf()
#include <cstring>     // for memset()
 
#ifdef _MSC_VER
#  include <climits>     // for INT_MAX
#  include <crtdbg.h>    // for _CrtSetReportMode()
#endif
 
#include <rw_new.h>
#include <rw_printf.h>
#include <rw_driver.h>
 
#ifndef _RWSTD_NO_SETRLIMIT
  // #undef works around SunPro bug #568
# undef _TIME_T
# include <sys/resource.h>   // for setrlimit()
# include <unistd.h>         // for sbrk()
#endif   // _RWSTD_NO_SETRLIMIT
 
#ifdef _AIX
 
// declare the loader symbol _edata defined by the AIX loader:
// The first address following the initialized data region.
extern "C" {
extern void* _edata;
}   // extern "C"
 
#endif   // _AIX
 
 
int compare (const void *beg, const void *end, int val)
{
    typedef unsigned char UChar;
 
    const UChar ucval = UChar (val);
 
    for (const UChar *pc = (const UChar*)beg; pc != end; ++pc) {
        if (*pc != ucval)
            return *pc - ucval;
    }
 
    return 0;
}
 
 
template <class T>
void test_success (T*, const char *tname)
{
    RW_ASSERT (0 != tname);
 
    rw_info (0, 0, __LINE__, "std::get_temporary_buffer<%s>(ptrdiff_t)",
             tname);
 
    // verify that passing 0 as the argument either returns pair (0, 0)
    // or pair (p, N) with p being a unique pointer in consecutive calls
    // and N >= 0
 
    static const unsigned pa_size = 32;
 
#ifndef __HP_aCC
 
    std::pair<T*, std::ptrdiff_t> pa [pa_size];
 
#else   // if defined (__HP_aCC)
 
    // working around an HP aCC bug (PR #27302)
    std::pair<T*, std::ptrdiff_t>* const pa =
        new std::pair<T*, std::ptrdiff_t>[pa_size];
 
#endif   // __HP_aCC
 
    // establish a checkpoint for memory leaks
    rwt_check_leaks (0, 0);
 
    pa [0] = std::get_temporary_buffer<T>(0);
 
    if (pa [0].first) {
 
        std::memset (pa [0].first, ~0U, pa [0].second * sizeof (T));
 
        pa [1] = std::get_temporary_buffer<T>(0);
 
        if (pa [1].first)
            std::memset (pa [1].first, ~1U, pa [1].second * sizeof (T));
 
        rw_assert (pa [0].first != pa [1].first, 0, __LINE__,
                   "get_temporary_buffer<%s>(0).first not unique: "
                   "got %#p and %#p", tname, pa [0].first, pa [1].first);
    }
    else {
        rw_assert (0 == pa [0].second, 0, __LINE__,
                   "get_temporary_buffer<%s>(0) == { 0, 0 }, got "
                   "{ %#p, %td }", tname, pa [0].first, pa [0].second);
    }
 
    pa [2] = std::get_temporary_buffer<T>(2);
 
    rw_assert (0 != pa [2].first, 0, __LINE__,
               "get_temporary_buffer<%s>(2).first != 0, got 0", tname);
 
    if (0 == pa [2].first)
        return;
 
    std::memset (pa [2].first, ~2U, pa [2].second * sizeof (T));
 
    rw_assert (2 <= pa [2].second, 0, __LINE__,
               "get_temporary_buffer<%s>(2).second >= 2, got %td",
               tname, pa [2].second);
    
    pa [3] = std::get_temporary_buffer<T>(3);
    
 
    rw_assert (0 != pa [3].first, 0, __LINE__,
               "get_temporary_buffer<%s>(3).first != 0, got 0", tname);
 
    if (!pa [3].first)
        return;
 
    rw_assert (3 <= pa [3].second, 0, __LINE__,
               "get_temporary_buffer<%s>(3).second >= 3, got %td",
               tname, pa [3].second);
 
    // verify correct alignment (if the storage isn't properly aligned,
    // expect SIGBUS on RISC machines, or SIGSEGV on HP-UX/PA-RISC)
    pa [3].first [0] = T ();
    pa [3].first [1] = T ();
    pa [3].first [2] = T ();
 
    std::memset (pa [3].first, ~3U, pa [3].second * sizeof (T));
 
    // get the remaining temporary buffers and verify that they
    // are each distinct from one another
    for (unsigned i = 4; i != pa_size; ++i) {
 
        const std::ptrdiff_t size =
            std::ptrdiff_t (i % 2 ? i : _RWSTD_TMPBUF_SIZE + i);
 
        pa [i] = std::get_temporary_buffer<T>(size);
 
        if (pa [i].first)
            std::memset (pa [i].first, ~i, pa [i].second * sizeof (T));
    }
 
    // verify the uniqueness of all ranges
    for (unsigned i = 0; i < pa_size; ++i) {
        for (unsigned j = 0; j < pa_size; ++j) {
            const bool fail =
                   i != j && pa [i].first
                && pa [i].first >= pa [j].first
                && pa [i].first <  pa [j].first + pa [j].second;
 
            rw_assert (!fail, 0, __LINE__,
                       "pair { %#p, %td } returned from call %u overlaps "
                       "pair { %#p, %td } returned from call %u",
                       pa [i].first, pa [i].second, i,
                       pa [j].first, pa [j].second, j);
 
            if (fail) {
                // break out of both loops
                i = j = unsigned (-1);
            }
        }
    }
 
    rw_info (0, 0, __LINE__,
             "std::return_temporary_buffer<%s>(%1$s*)", tname);
 
    // call return_temporary_buffer() on each returned pointer
    // and verify that the contents of the buffers pointed to
    // by all remaining unallocated pointers are unchanged
    for (unsigned i = 0; i < pa_size; ++i) {
 
        std::return_temporary_buffer (pa [i].first);
 
        for (unsigned j = i + 1; j < pa_size; ++j) {
 
            const bool success =
                0 == compare (pa [j].first, pa [j].first + pa [j].second, ~j);
 
            rw_assert (success, 0, __LINE__,
                       "return_temporary_buffer<%s>(%#p) corrupted "
                       "a buffer designated by { %#p %td }",
                       tname, pa [i].first, pa [j].first, pa [j].second);
 
            if (!success) {
                // break out of both loops
                i = j = unsigned (-1);
            }
        }
    }
 
    std::size_t nbytes;
    const std::size_t nblocks = rwt_check_leaks (&nbytes, 0);
 
    // verify the absence of memory leaks
    rw_assert (!nblocks && !nbytes, 0, __LINE__,
               "temporary buffer leaked %d bytes in %d blocks",
               nbytes, nblocks);
 
#ifdef __HP_aCC
 
    delete[] pa;
 
#endif   // __HP_aCC
 
}
 
 
template <class T>
void test_failure (T*, const char *tname)
{
    if (0 == tname) {
        static char buf [40];
        rw_sprintf (buf, "char[%zu]", sizeof (T));
        tname = buf;
    }
        
    rw_info (0, 0, __LINE__,
             "std::get_temporary_buffer<%s>(ptrdiff_t) on arithmetic overflow",
             tname);
 
    std::ptrdiff_t nelems = -1;
 
    std::pair<T*, std::ptrdiff_t> pa;
 
    pa = std::get_temporary_buffer<T>(nelems);
 
    rw_assert (0 == pa.first && 0 == pa.second, 0, __LINE__,
               "std::get_temporary_buffer<%s>(%td) == { 0, 0 }, "
               "got { %#p, %td }",
               tname, nelems, pa.first, pa.second);
 
    for (std::size_t i = 2; i && i < sizeof (T); i <<= 1) {
        // exercise arithmetic overflow (not to be confused
        // with the out-of-memory tests below)
 
        // attempts to allocate space for an array of elements
        // with a total size that exceeds SIZE_MAX must fail
        nelems = (_RWSTD_PTRDIFF_MAX / i) + 1;
 
        pa = std::get_temporary_buffer<T>(nelems);
 
        rw_assert (0 == pa.first && 0 == pa.second, 0, __LINE__,
                   "get_temporary_buffer<%s>(%ld) == { 0, 0 }, "
                   "got { %#p, %td }",
                   tname, nelems, pa.first, pa.second);
    }
 
#ifndef _RWSTD_NO_SETRLIMIT
 
    // exercise get_temporary_buffer in the presence of allocation
    // failure (caused by setting the soft data limit to the current
    // value)
 
    // retrieve the current soft (rlim_cur) and hard (rlim_max) limits
    struct rlimit rlim_old;
    if (getrlimit (RLIMIT_DATA, &rlim_old)) {
        rw_warn (0, 0, __LINE__,
                 "getrlimit(RLIMIT_DATA, { .rlim_max=%zu, .rlim_cur=%zu}) "
                 "failed: %{#m}: %m", rlim_old.rlim_max, rlim_old.rlim_cur);
        return;
    }
 
    // set the soft limit to 0, leaving the hard limit unchanged
    struct rlimit rlim_new = rlim_old;
 
#ifdef _AIX
    {
        // AIX setrlimit() fails to lower the limit for resource
        // whose current usage is already higher than the new limit.
        // Instead of setting the limit to 0, compute the current
        // usage and use it to set the soft limit
        const char* const brk_min = (char*)_edata;
        const char* const brk_cur = (char*)sbrk (0);
 
        rlim_new.rlim_cur = brk_cur - brk_min;
    }
#else   // if !defined (_AIX)
    rlim_new.rlim_cur = 0;
#endif   // _AIX
 
    errno = 0;
 
    // IEEE Std 1003.1, 2004 Edition (SUSv3):
    // RLIMIT_DATA
    // ...is the maximum size of a process' data segment, in bytes.
    // If this limit is exceeded, the malloc() function shall fail
    // with errno set to [ENOMEM].
    if (setrlimit (RLIMIT_DATA, &rlim_new)) {
        rw_warn (0, 0, __LINE__,
                 "setrlimit(RLIMIT_DATA, { .rlim_max=%zu, .rlim_cur=%zu}) "
                 "failed to lower the soft limit: %{#m}: %m",
                 rlim_new.rlim_max, rlim_new.rlim_cur);
        return;
    }
 
    std::size_t nbytes = rlim_old.rlim_max;
 
#if 0 < _RWSTD_TMPBUF_SIZE
 
    // make sure the size is larger than the size of the temp buff
    if (nbytes <= _RWSTD_TMPBUF_SIZE)
        nbytes = _RWSTD_TMPBUF_SIZE + 1;
 
#else   // if _RWSTD_TMPBUF_SIZE <= 0
 
    nbytes = 65536;
 
#endif   // _RWSTD_TMPBUF_SIZE
 
    if (nbytes < _RWSTD_SIZE_MAX)
        ++nbytes;
 
    if (nbytes <= std::size_t (_RWSTD_PTRDIFF_MAX))
        nelems = std::ptrdiff_t (nbytes);
    else
        nelems = _RWSTD_PTRDIFF_MAX;
 
    nelems /= sizeof (T);
 
    // retrieve the current limit just to show it in the info message
    // ignore any errors
    getrlimit (RLIMIT_DATA, &rlim_new);
 
    rw_info (0, 0, __LINE__,
             "std::get_temporary_buffer<%s>(%td) in low memory conditions "
             ": { .rlim_max = %zu, .rlim_cur = %zu }",
             tname, nelems, rlim_new.rlim_max, rlim_new.rlim_cur);
 
    // expect the function to fail
    pa = std::get_temporary_buffer<T>(nelems);
 
    // reset the soft limit to the original value (do it before any
    // test output in case memory needs to be allocated during the
    // output)
    if (setrlimit (RLIMIT_DATA, &rlim_old)) {
        rw_warn (0, 0, __LINE__,
                 "setrlimit(RLIMIT_DATA, { .rlim_max=%zu, .rlim_cur=%zu }) "
                 "failed to restore the soft limit: %{#m}: %m",
                 rlim_old.rlim_max, rlim_old.rlim_cur);
    }
 
    rw_assert (0 == pa.first && 0 == pa.second, 0, __LINE__,
               "get_temporary_buffer<%s>(%td) == { 0, 0 } "
               "in low memory conditions, got { %#p, %td }",
               tname, nbytes, pa.first, pa.second);
 
#endif   // _RWSTD_NO_SETRLIMIT
 
}
 
 
typedef void (*FunctionPointer)();
 
struct MyStruct { };
typedef void (MyStruct::*MemberPointer)();
 
template <std::size_t N>
struct BigStruct { char dummy [N]; };
 
 
template <class T>
void test_get_temporary_buffer (T *dummy, const char *tname)
{
    RW_ASSERT (0 != tname);
 
    test_success (dummy, tname);
    test_failure (dummy, tname);
}
 
 
static int
run_test (int, char**)
{
    test_get_temporary_buffer ((char*)0, "char");
 
    test_get_temporary_buffer ((int*)0, "int");
 
#ifdef _RWSTD_LONG_LONG
 
    test_get_temporary_buffer ((_RWSTD_LONG_LONG*)0, "long long");
 
#else   // if !defined (_RWSTD_LONG_LONG)
 
    test_get_temporary_buffer ((long*)0, "long");
 
#endif   // _RWSTD_LONG_LONG
 
#ifndef _RWSTD_NO_LONG_DOUBLE
 
    test_get_temporary_buffer ((long double*)0, "long double");
 
#else   // if defined (_RWSTD_NO_LONG_DOUBLE)
 
    test_get_temporary_buffer ((double*)0, "double");
 
#endif   // _RWSTD_NO_LONG_DOUBLE
 
    // exercise ordinary pointers
    test_get_temporary_buffer ((void**)0, "void*");
 
    // exercise function pointers
    test_get_temporary_buffer ((FunctionPointer*)0, "void (*)()");
 
    // exercise pointers to members
    test_get_temporary_buffer ((MemberPointer*)0, "void (struct::*)()");
 
#if    (!defined (__IBMCPP__) || __IBMCPP__ > 700) \
    && !defined (__HP_aCC)
 
#  ifndef _MSC_VER
    const std::size_t MAX_SIZE = _RWSTD_PTRDIFF_MAX;
#  else
    // the MSVC and ICC/Windows has maximum size of
    // the array equal to 0x7fffffff bytes
    const std::size_t MAX_SIZE = INT_MAX;
#  endif
 
    // avoid instantiating test on very large structs
    // to prevent failures (at compile or run-time) due
    // to compiler bugs
    test_failure ((BigStruct<MAX_SIZE / 2>*)0, 0);
    test_failure ((BigStruct<MAX_SIZE - 1>*)0, 0);
    test_failure ((BigStruct<MAX_SIZE>*)0, 0);
 
#else
 
    // work around VAC++ 7.0 (and prior) bug #549
    // work around HP aCC 3,5,6 bug #565
    rw_warn (0, 0, __LINE__, "get_temp_buffer<large-struct>() "
             "not tested due to a compiler bug");
 
#endif   // VAC++ > 7.0
 
    return 0;
}
 
 
int main (int argc, char *argv[])
{
#ifdef _MSC_VER
    // disable "Invalid allocation size: 4294967292 bytes"
    // message box from malloc()
    _CrtSetReportMode (_CRT_ERROR, _CRTDBG_MODE_DEBUG);
#endif
 
    return rw_test (argc, argv, __FILE__,
                    "lib.temporary.buffer",
                    0 /* no comment */,
                    run_test,
                    "",
                    (void*)0 /* sentinel */);
}