/usr/include/ace/Malloc_Base.h is in libace-dev 6.3.3+dfsg-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 | // -*- C++ -*-
//=============================================================================
/**
* @file Malloc_Base.h
*
* @author Doug Schmidt and Irfan Pyarali
*/
//=============================================================================
#ifndef ACE_MALLOC_BASE_H
#define ACE_MALLOC_BASE_H
#include /**/ "ace/pre.h"
#include /**/ "ace/ACE_export.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "ace/os_include/sys/os_types.h"
#include "ace/os_include/sys/os_mman.h"
#include "ace/os_include/sys/os_types.h"
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
// The definition of this class is located in Malloc.cpp.
/**
* @class ACE_Allocator
*
* @brief Interface for a dynamic memory allocator that uses inheritance
* and dynamic binding to provide extensible mechanisms for
* allocating and deallocating memory.
*/
class ACE_Export ACE_Allocator
{
public:
/// Unsigned integer type used for specifying memory block lengths.
typedef size_t size_type;
// = Memory Management
/// Get pointer to a default ACE_Allocator.
static ACE_Allocator *instance (void);
/// Set pointer to a process-wide ACE_Allocator and return existing
/// pointer.
static ACE_Allocator *instance (ACE_Allocator *);
/// Delete the dynamically allocated Singleton
static void close_singleton (void);
/// "No-op" constructor (needed to make certain compilers happy).
ACE_Allocator (void);
/// Virtual destructor
virtual ~ACE_Allocator (void);
/// Allocate @a nbytes, but don't give them any initial value.
virtual void *malloc (size_type nbytes) = 0;
/// Allocate @a nbytes, giving them @a initial_value.
virtual void *calloc (size_type nbytes, char initial_value = '\0') = 0;
/// Allocate <n_elem> each of size @a elem_size, giving them
/// @a initial_value.
virtual void *calloc (size_type n_elem,
size_type elem_size,
char initial_value = '\0') = 0;
/// Free @a ptr (must have been allocated by ACE_Allocator::malloc()).
virtual void free (void *ptr) = 0;
/// Remove any resources associated with this memory manager.
virtual int remove (void) = 0;
// = Map manager like functions
/**
* Associate @a name with @a pointer. If @a duplicates == 0 then do
* not allow duplicate @a name/@a pointer associations, else if
* @a duplicates != 0 then allow duplicate @a name/@a pointer
* associations. Returns 0 if successfully binds (1) a previously
* unbound @a name or (2) @a duplicates != 0, returns 1 if trying to
* bind a previously bound @a name and @a duplicates == 0, else
* returns -1 if a resource failure occurs.
*/
virtual int bind (const char *name, void *pointer, int duplicates = 0) = 0;
/**
* Associate @a name with @a pointer. Does not allow duplicate
* @a name/@a pointer associations. Returns 0 if successfully binds
* (1) a previously unbound @a name, 1 if trying to bind a previously
* bound @a name, or returns -1 if a resource failure occurs. When
* this call returns @a pointer's value will always reference the
* void * that @a name is associated with. Thus, if the caller needs
* to use @a pointer (e.g., to free it) a copy must be maintained by
* the caller.
*/
virtual int trybind (const char *name, void *&pointer) = 0;
/// Locate @a name and pass out parameter via pointer. If found,
/// return 0, returns -1 if failure occurs.
virtual int find (const char *name, void *&pointer) = 0;
/// Returns 0 if the name is in the mapping. -1, otherwise.
virtual int find (const char *name) = 0;
/// Unbind (remove) the name from the map. Don't return the pointer
/// to the caller
virtual int unbind (const char *name) = 0;
/// Break any association of name. Returns the value of pointer in
/// case the caller needs to deallocate memory.
virtual int unbind (const char *name, void *&pointer) = 0;
// = Protection and "sync" (i.e., flushing memory to persistent
// backing store).
/**
* Sync @a len bytes of the memory region to the backing store
* starting at @c this->base_addr_. If @a len == -1 then sync the
* whole region.
*/
virtual int sync (ssize_t len = -1, int flags = MS_SYNC) = 0;
/// Sync @a len bytes of the memory region to the backing store
/// starting at @a addr.
virtual int sync (void *addr, size_type len, int flags = MS_SYNC) = 0;
/**
* Change the protection of the pages of the mapped region to @a prot
* starting at <this->base_addr_> up to @a len bytes. If @a len == -1
* then change protection of all pages in the mapped region.
*/
virtual int protect (ssize_t len = -1, int prot = PROT_RDWR) = 0;
/// Change the protection of the pages of the mapped region to @a prot
/// starting at @a addr up to @a len bytes.
virtual int protect (void *addr, size_type len, int prot = PROT_RDWR) = 0;
#if defined (ACE_HAS_MALLOC_STATS)
/// Dump statistics of how malloc is behaving.
virtual void print_stats (void) const = 0;
#endif /* ACE_HAS_MALLOC_STATS */
/// Dump the state of the object.
virtual void dump (void) const = 0;
private:
// DO NOT ADD ANY STATE (DATA MEMBERS) TO THIS CLASS!!!! See the
// <ACE_Allocator::instance> implementation for explanation.
/// Pointer to a process-wide ACE_Allocator instance.
static ACE_Allocator *allocator_;
/// Must delete the <allocator_> if non-0.
static int delete_allocator_;
};
ACE_END_VERSIONED_NAMESPACE_DECL
#include /**/ "ace/post.h"
#endif /* ACE_MALLOC_BASE_H */
|