From cb6cd0e4159606619b1ce708c1b00f8d294cc4bb Mon Sep 17 00:00:00 2001 From: Harald Fernengel Date: Tue, 16 Jun 2009 15:40:54 +0200 Subject: add an out of memory checker --- .../exceptionsafety_objects.pro | 3 + tests/auto/exceptionsafety_objects/oomsimulator.h | 175 +++++++++++++++++++++ .../tst_exceptionsafety_objects.cpp | 149 ++++++++++++++++++ 3 files changed, 327 insertions(+) create mode 100644 tests/auto/exceptionsafety_objects/exceptionsafety_objects.pro create mode 100644 tests/auto/exceptionsafety_objects/oomsimulator.h create mode 100644 tests/auto/exceptionsafety_objects/tst_exceptionsafety_objects.cpp (limited to 'tests/auto/exceptionsafety_objects') diff --git a/tests/auto/exceptionsafety_objects/exceptionsafety_objects.pro b/tests/auto/exceptionsafety_objects/exceptionsafety_objects.pro new file mode 100644 index 0000000000..413e1e3852 --- /dev/null +++ b/tests/auto/exceptionsafety_objects/exceptionsafety_objects.pro @@ -0,0 +1,3 @@ +load(qttest_p4) +HEADERS += oomsimulator.h +SOURCES += tst_exceptionsafety_objects.cpp diff --git a/tests/auto/exceptionsafety_objects/oomsimulator.h b/tests/auto/exceptionsafety_objects/oomsimulator.h new file mode 100644 index 0000000000..1b092ea932 --- /dev/null +++ b/tests/auto/exceptionsafety_objects/oomsimulator.h @@ -0,0 +1,175 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include + +/* Use glibc's memory allocation hooks */ + +/* our hooks */ +static void *my_malloc_hook(size_t, const void *); +static void *my_realloc_hook(void *, size_t, const void *); +static void *my_memalign_hook(size_t, size_t, const void *); +static void my_free_hook(void *, const void *); + +/* original hooks. */ +static void *(*old_malloc_hook)(size_t, const void *); +static void *(*old_realloc_hook)(void *, size_t, const void *); +static void *(*old_memalign_hook)(size_t, size_t, const void *); +static void (*old_free_hook)(void *, const void *); + +/* initializer function */ +static void my_init_hook(); + +/* Override initialising hook from the C library. */ +void (*__malloc_initialize_hook) (void) = my_init_hook; + +static void disableHooks() +{ + __malloc_hook = old_malloc_hook; + __realloc_hook = old_realloc_hook; + __memalign_hook = old_memalign_hook; + __free_hook = old_free_hook; +} + +static void enableHooks() +{ + __malloc_hook = my_malloc_hook; + __realloc_hook = my_realloc_hook; + __memalign_hook = my_memalign_hook; + __free_hook = my_free_hook; +} + +void my_init_hook() +{ + old_malloc_hook = __malloc_hook; + old_realloc_hook = __realloc_hook; + old_memalign_hook = __memalign_hook; + old_free_hook = __free_hook; + enableHooks(); +} + +static bool mallocFailActive = false; +static int mallocFailIndex = 0; +static int mallocCount = 0; +static int freeCount = 0; + +struct AllocFailActivator +{ + inline AllocFailActivator() { mallocFailActive = true; } + inline ~AllocFailActivator() { mallocFailActive = false; } + + inline void deactivate() { mallocFailActive = false; } +}; + +void *my_malloc_hook(size_t size, const void *) +{ + if (mallocFailActive && --mallocFailIndex < 0) + return 0; // simulate OOM + + __malloc_hook = old_malloc_hook; + void *result = ::malloc (size); + __malloc_hook = my_malloc_hook; + + ++mallocCount; + return result; +} + +void *my_memalign_hook(size_t alignment, size_t size, const void *) +{ + if (mallocFailActive && --mallocFailIndex < 0) + return 0; // simulate OOM + + __memalign_hook = old_memalign_hook; + void *result = ::memalign(alignment, size); + __memalign_hook = my_memalign_hook; + + ++mallocCount; + return result; +} + +void *my_realloc_hook(void *ptr, size_t size, const void *) +{ + if (mallocFailActive && --mallocFailIndex < 0) + return 0; // simulate OOM + + __realloc_hook = old_realloc_hook; + __malloc_hook = old_malloc_hook; + void *result = ::realloc(ptr, size); + __malloc_hook = my_malloc_hook; + __realloc_hook = my_realloc_hook; + + if (!ptr) // realloc on a 0 pointer equals a new allocation + ++mallocCount; + return result; +} + +void my_free_hook(void *ptr, const void *) +{ + __free_hook = old_free_hook; + ::free(ptr); + __free_hook = my_free_hook; + + ++freeCount; +} + +static void *new_helper(std::size_t size) +{ + void *ptr = malloc(size); + if (!ptr) + throw std::bad_alloc(); + return ptr; +} + +// overload operator new +void* operator new(size_t size) throw (std::bad_alloc) { return new_helper(size); } +void* operator new[](size_t size) throw (std::bad_alloc) { return new_helper(size); } +void* operator new(size_t size, const std::nothrow_t&) throw() { return malloc(size); } +void* operator new[](std::size_t size, const std::nothrow_t&) throw() { return malloc(size); } + +// overload operator delete +void operator delete(void *ptr) throw() { if (ptr) free(ptr); } +void operator delete[](void *ptr) throw() { if (ptr) free(ptr); } +void operator delete(void *ptr, const std::nothrow_t&) throw() { if (ptr) free(ptr); } +void operator delete[](void *ptr, const std::nothrow_t&) throw() { if (ptr) free (ptr); } + +// ignore placement new and placement delete - those don't allocate. + + diff --git a/tests/auto/exceptionsafety_objects/tst_exceptionsafety_objects.cpp b/tests/auto/exceptionsafety_objects/tst_exceptionsafety_objects.cpp new file mode 100644 index 0000000000..31c8f0a9ce --- /dev/null +++ b/tests/auto/exceptionsafety_objects/tst_exceptionsafety_objects.cpp @@ -0,0 +1,149 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include +#include + +QT_USE_NAMESPACE + +// this test only works with GLIBC (let moc run regardless, because it doesn't know about __GLIBC__) +#if defined(QT_NO_EXCEPTIONS) || (!defined(__GLIBC__) && !defined(Q_MOC_RUN)) + QTEST_NOOP_MAIN +#else + +#include "oomsimulator.h" + +class tst_ExceptionSafetyObjects: public QObject +{ + Q_OBJECT + +public slots: + void initTestCase(); + +private slots: + void widgets_data(); + void widgets(); +}; + +void tst_ExceptionSafetyObjects::initTestCase() +{ +} + +// helper structs to create an arbitrary widget +struct AbstractWidgetCreator +{ + virtual QWidget *create(QWidget *parent) = 0; +}; + +Q_DECLARE_METATYPE(AbstractWidgetCreator *) + +template +struct WidgetCreator : public AbstractWidgetCreator +{ + QWidget *create(QWidget *parent) + { + return parent ? new T(parent) : new T; + } +}; + +void tst_ExceptionSafetyObjects::widgets_data() +{ + QTest::addColumn("widgetCreator"); + +#define NEWROW(T) QTest::newRow(#T) << static_cast(new WidgetCreator) + NEWROW(QWidget); + NEWROW(QPushButton); + NEWROW(QLabel); +} + +void tst_ExceptionSafetyObjects::widgets() +{ + QFETCH(AbstractWidgetCreator *, widgetCreator); + + mallocCount = freeCount = 0; + + int currentOOMIndex = 0; + + // activate mallocFail - WE'RE HOT! + AllocFailActivator allocFailActivator; + + do { + // start after first alloc (the first alloc is creation of the widget itself) + mallocFailIndex = ++currentOOMIndex; + + // first, create without a parent + try { + QScopedPointer ptr(widgetCreator->create(0)); + // QScopedPointer deletes the widget again here. + } catch (const std::bad_alloc &) { + // ignore all std::bad_alloc - note: valgrind should show no leaks + } + + // repeat the loop until we the malloc fail index indicates that + // there was no OOM simulation happening + } while (mallocFailIndex <= 0); + + // reset counting + currentOOMIndex = 0; + + do { + mallocFailIndex = ++currentOOMIndex; + + // create the widget with a parent + try { + QWidget parent; + widgetCreator->create(&parent); + // parent goes out of scope - widget should be deleted as well + } catch (const std::bad_alloc &) { + } + } while (mallocFailIndex <= 0); + +#ifdef VERBOSE + allocFailActivator.deactivate(); + + qDebug() << "mallocCount" << mallocCount << "freeCount" << freeCount << + "simulated alloc fails" << currentOOMIndex; +#endif +} + +QTEST_MAIN(tst_ExceptionSafetyObjects) +#include "tst_exceptionsafety_objects.moc" +#endif // QT_NO_EXCEPTIONS -- cgit v1.2.3