/usr/lib/grass74/include/grass/iostream/mm.h is in grass-dev 7.4.0-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 167 168 169 170 171 172 173 174 175 176 177 | /****************************************************************************
*
* MODULE: iostream
*
* COPYRIGHT (C) 2007 Laura Toma
*
*
* Iostream is a library that implements streams, external memory
* sorting on streams, and an external memory priority queue on
* streams. These are the fundamental components used in external
* memory algorithms.
* Credits: The library was developed by Laura Toma. The kernel of
* class STREAM is based on the similar class existent in the GPL TPIE
* project developed at Duke University. The sorting and priority
* queue have been developed by Laura Toma based on communications
* with Rajiv Wickremesinghe. The library was developed as part of
* porting Terraflow to GRASS in 2001. PEARL upgrades in 2003 by
* Rajiv Wickremesinghe as part of the Terracost project.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details. *
* **************************************************************************/
#ifndef _MM_H
#define _MM_H
#include <sys/types.h>
// GCC with C++98 and -fexceptions requires exception
// specifiers, however with C++11 and newer, using them causes an error.
#if __cplusplus < 201103L
#define GRASS_MM_USE_EXCEPTION_SPECIFIER
#endif /* __cplusplus < 201103L */
#define MM_REGISTER_VERSION 2
// The default amount of memory we will allow to be allocated (40MB).
#define MM_DEFAULT_MM_SIZE (40<<20)
// MM accounting modes
typedef enum {
MM_IGNORE_MEMORY_EXCEEDED=0,
MM_ABORT_ON_MEMORY_EXCEEDED,
MM_WARN_ON_MEMORY_EXCEEDED
} MM_mode;
// MM Error codes
enum MM_err {
MM_ERROR_NO_ERROR = 0,
MM_ERROR_INSUFFICIENT_SPACE,
MM_ERROR_UNDERFLOW,
MM_ERROR_EXCESSIVE_ALLOCATION
};
// types of memory usage queries we can make on streams
enum MM_stream_usage {
// Overhead of the object without the buffer
MM_STREAM_USAGE_OVERHEAD = 1,
// amount used by a buffer
MM_STREAM_USAGE_BUFFER,
// Amount currently in use.
MM_STREAM_USAGE_CURRENT,
// Maximum amount possibly in use.
MM_STREAM_USAGE_MAXIMUM
};
// Declarations of a very simple memory manager desgined to work with
// BTEs that rely on the underlying OS to manage physical memory.
class MM_register {
private:
// The number of instances of this class and descendents that exist.
static int instances;
// The amount of space remaining to be allocated.
size_t remaining;
// The user-specified limit on memory.
size_t user_limit;
// the amount that has been allocated.
size_t used;
// flag indicates how we are keeping track of memory
static MM_mode register_new;
//protected:
// // private methods, only called by operators new and delete.
public: // Need to be accessible from pqueue constructor
MM_err register_allocation (size_t sz);
MM_err register_deallocation(size_t sz);
public:
MM_register();
~MM_register(void);
MM_err set_memory_limit(size_t sz);
void enforce_memory_limit ();
void ignore_memory_limit ();
void warn_memory_limit ();
MM_mode get_limit_mode();
void print_limit_mode();
size_t memory_available ();
size_t memory_used ();
size_t memory_limit ();
int space_overhead ();
void print();
// make these members of MM_register
#ifdef GRASS_MM_USE_EXCEPTION_SPECIFIER
void * operator new(size_t) throw (std::bad_alloc);
void * operator new[] (size_t) throw (std::bad_alloc);
void operator delete(void *) throw();
void operator delete[](void *) throw();
#else
void * operator new(size_t);
void * operator new[] (size_t);
void operator delete(void *) noexcept;
void operator delete[](void *) noexcept;
#endif /* GRASS_MM_USE_EXCEPTION_SPECIFIER */
friend class mm_register_init;
};
// A class to make sure that MM_manager gets set up properly (only one
// instance) .
class mm_register_init {
private:
// The number of mm_register_init objects that exist.
static unsigned int count;
public:
mm_register_init(void);
~mm_register_init(void);
};
static mm_register_init source_file_mm_register_init;
// Here is the single memory management object (defined in mm.C).
extern MM_register MM_manager;
#endif // _MM_H
|