X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=mymemory.h;h=6fb2992bd4e4e93abce31d6002957830575c7081;hp=0788e69f39c7beceef47a9944fb4ebee059346c7;hb=7742256df627848c1c375f979f5369a45c92057b;hpb=99928ab8d61239d499f5bf45ae9a2b41595350f8 diff --git a/mymemory.h b/mymemory.h index 0788e69f..6fb2992b 100644 --- a/mymemory.h +++ b/mymemory.h @@ -4,8 +4,8 @@ #ifndef _MY_MEMORY_H #define _MY_MEMORY_H -#include #include +#include #include "config.h" @@ -23,6 +23,9 @@ } \ void operator delete[](void *p, size_t size) { \ model_free(p); \ + } \ + void * operator new(size_t size, void *p) { /* placement new */ \ + return p; \ } /** SNAPSHOTALLOC declares the allocators for a class to allocate @@ -39,16 +42,27 @@ } \ void operator delete[](void *p, size_t size) { \ snapshot_free(p); \ + } \ + void * operator new(size_t size, void *p) { /* placement new */ \ + return p; \ } void *model_malloc(size_t size); void *model_calloc(size_t count, size_t size); void model_free(void *ptr); +void * model_realloc(void *ptr, size_t size); void * snapshot_malloc(size_t size); void * snapshot_calloc(size_t count, size_t size); +void * snapshot_realloc(void *ptr, size_t size); void snapshot_free(void *ptr); +typedef void * mspace; +extern mspace sStaticSpace; + +void * Thread_malloc(size_t size); +void Thread_free(void *ptr); + /** @brief Provides a non-snapshotting allocator for use in STL classes. * * The code was adapted from a code example from the book The C++ @@ -61,15 +75,15 @@ void snapshot_free(void *ptr); */ template class ModelAlloc { - public: +public: // type definitions - typedef T value_type; + typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef T& reference; typedef const T& const_reference; - typedef size_t size_type; - typedef size_t difference_type; + typedef size_t size_type; + typedef size_t difference_type; // rebind allocator to type U template @@ -130,14 +144,106 @@ class ModelAlloc { /** Return that all specializations of this allocator are interchangeable. */ template bool operator ==(const ModelAlloc&, - const ModelAlloc&) throw() { + const ModelAlloc&) throw() { return true; } /** Return that all specializations of this allocator are interchangeable. */ template bool operator!= (const ModelAlloc&, - const ModelAlloc&) throw() { + const ModelAlloc&) throw() { + return false; +} + +/** @brief Provides a snapshotting allocator for use in STL classes. + * + * The code was adapted from a code example from the book The C++ + * Standard Library - A Tutorial and Reference by Nicolai M. Josuttis, + * Addison-Wesley, 1999 © Copyright Nicolai M. Josuttis 1999 + * Permission to copy, use, modify, sell and distribute this software + * is granted provided this copyright notice appears in all copies. + * This software is provided "as is" without express or implied + * warranty, and with no claim as to its suitability for any purpose. + */ +template +class SnapshotAlloc { +public: + // type definitions + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef size_t size_type; + typedef size_t difference_type; + + // rebind allocator to type U + template + struct rebind { + typedef SnapshotAlloc other; + }; + + // return address of values + pointer address(reference value) const { + return &value; + } + const_pointer address(const_reference value) const { + return &value; + } + + /* constructors and destructor + * - nothing to do because the allocator has no state + */ + SnapshotAlloc() throw() { + } + SnapshotAlloc(const SnapshotAlloc&) throw() { + } + template + SnapshotAlloc(const SnapshotAlloc&) throw() { + } + ~SnapshotAlloc() throw() { + } + + // return maximum number of elements that can be allocated + size_type max_size() const throw() { + return std::numeric_limits::max() / sizeof(T); + } + + // allocate but don't initialize num elements of type T + pointer allocate(size_type num, const void * = 0) { + pointer p = (pointer)snapshot_malloc(num * sizeof(T)); + return p; + } + + // initialize elements of allocated storage p with value value + void construct(pointer p, const T& value) { + // initialize memory with placement new + new((void*)p)T(value); + } + + // destroy elements of initialized storage p + void destroy(pointer p) { + // destroy objects by calling their destructor + p->~T(); + } + + // deallocate storage p of deleted elements + void deallocate(pointer p, size_type num) { + snapshot_free((void*)p); + } +}; + +/** Return that all specializations of this allocator are interchangeable. */ +template +bool operator ==(const SnapshotAlloc&, + const SnapshotAlloc&) throw() { + return true; +} + +/** Return that all specializations of this allocator are interchangeable. */ +template +bool operator!= (const SnapshotAlloc&, + const SnapshotAlloc&) throw() { return false; } @@ -145,19 +251,17 @@ bool operator!= (const ModelAlloc&, extern "C" { #endif typedef void * mspace; -extern void* mspace_malloc(mspace msp, size_t bytes); +extern void * mspace_malloc(mspace msp, size_t bytes); extern void mspace_free(mspace msp, void* mem); -extern void* mspace_realloc(mspace msp, void* mem, size_t newsize); -extern void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size); +extern void * mspace_realloc(mspace msp, void* mem, size_t newsize); +extern void * mspace_calloc(mspace msp, size_t n_elements, size_t elem_size); extern mspace create_mspace_with_base(void* base, size_t capacity, int locked); extern mspace create_mspace(size_t capacity, int locked); -#if USE_MPROTECT_SNAPSHOT -extern mspace user_snapshot_space; -#endif +extern mspace model_snapshot_space; #ifdef __cplusplus -}; /* end of extern "C" */ +}; /* end of extern "C" */ #endif -#endif /* _MY_MEMORY_H */ +#endif /* _MY_MEMORY_H */