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
|
/* Ergo, version 3.5, a program for linear scaling electronic structure
* calculations.
* Copyright (C) 2016 Elias Rudberg, Emanuel H. Rubensson, Pawel Salek,
* and Anastasia Kruchinina.
*
* 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 3 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.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Primary academic reference:
* KohnâSham Density Functional Theory Electronic Structure Calculations
* with Linearly Scaling Computational Time and Memory Usage,
* Elias Rudberg, Emanuel H. Rubensson, and Pawel Salek,
* J. Chem. Theory Comput. 7, 340 (2011),
* <http://dx.doi.org/10.1021/ct100611z>
*
* For further information about Ergo, see <http://www.ergoscf.org>.
*/
#ifndef MAT_ALLOCATORMANAGER_HEADER
#define MAT_ALLOCATORMANAGER_HEADER
#include <stdexcept>
#include <list>
#include <string>
#include <sstream>
#include <iomanip> /* For setprecision */
#include <iostream>
#include <cstdlib>
#include "Allocator.h"
namespace mat {
template<class Treal>
class AllocatorManager
{
public:
void init(size_t noOfRealsPerBuffer_,
size_t noOfBuffers_) {
if(noOfRealsPerBuffer != 0) {
// This means that the AllocatorManager has already been initialized.
// We allow this if the parameters are the same.
if(noOfRealsPerBuffer_ != noOfRealsPerBuffer || noOfBuffers_ != noOfBuffers)
throw std::runtime_error("Error in AllocatorManager: "
"attempt to re-initialize with different parameters.");
}
if(noOfRealsPerBuffer_ <= 0 || noOfBuffers_ <= 0)
throw std::runtime_error("Error in AllocatorManager: bad input to init().");
noOfRealsPerBuffer = noOfRealsPerBuffer_;
noOfBuffers = noOfBuffers_;
}
static AllocatorManager & instance();
Treal* alloc(size_t n) {
if(n != noOfRealsPerBuffer)
return new Treal[n];
pthread_mutex_lock(&mutex);
// Go through list to see if there is any free space.
typename std::list< Allocator<Treal>* >::iterator it = list.begin();
while(it != list.end()) {
if(!(*it)->isFull()) {
// OK, found allocator that is not full. Use it.
Treal* ptr = (*it)->alloc();
pthread_mutex_unlock(&mutex);
return ptr;
}
it++;
}
// We did not find any non-full existing allocator. Need to add a new one.
/* ELIAS NOTE 2016-06-30: Important to catch exceptions here so
that we unlock the mutex in case allocation fails, otherwise
program may hang later when trying to lock the mutex e.g. to
delete something after catching the exception elsewhere in the
code. This happened with some test runs on Triolith and it was
very annoying, took a long time to figure out why the runs
hanged. */
Allocator<Treal>* newAllocator;
try {
newAllocator = new Allocator<Treal>(noOfRealsPerBuffer,
noOfBuffers);
}
catch (const std::bad_alloc & e) {
size_t noOfBytesPerAllocator = noOfBuffers * noOfRealsPerBuffer * sizeof(Treal);
size_t totNoOfBytesAllocated = list.size() * noOfBytesPerAllocator;
std::cerr << "Error in AllocatorManager::alloc(): std::bad_alloc exception caught. Usage before error: list.size() = " << list.size()
<< " --> " << (double)totNoOfBytesAllocated/1000000000 << " GB used. peakListSize = " << peakListSize << std::endl;
pthread_mutex_unlock(&mutex);
throw e;
}
catch(...) {
std::cerr << "Error in AllocatorManager::alloc(): exception caught (but not std::bad_alloc!?!)." << std::endl;
pthread_mutex_unlock(&mutex);
throw std::runtime_error("Error in AllocatorManager::alloc(): exception caught (but not std::bad_alloc!?!).");
}
list.push_back(newAllocator);
if(list.size() > peakListSize)
peakListSize = list.size();
Treal* ptr = newAllocator->alloc();
pthread_mutex_unlock(&mutex);
return ptr;
}
void free(Treal* ptr) {
pthread_mutex_lock(&mutex);
// Go through list to see if this ptr belongs to any allocator.
typename std::list< Allocator<Treal>* >::iterator it = list.begin();
while(it != list.end()) {
if((*it)->ownsPtr(ptr)) {
(*it)->free(ptr);
// Now check if allocator is empty; in that case we want to remove it.
if((*it)->isEmpty()) {
delete *it;
list.erase(it);
}
pthread_mutex_unlock(&mutex);
return;
}
it++;
}
delete [] ptr;
pthread_mutex_unlock(&mutex);
}
std::string getStatistics() {
size_t noOfBytesPerAllocator = noOfBuffers * noOfRealsPerBuffer * sizeof(Treal);
size_t totNoOfBytesAllocated = list.size() * noOfBytesPerAllocator;
size_t peakNoOfBytesAllocated = peakListSize * noOfBytesPerAllocator;
size_t totNoOfBytesUsed = 0;
// Go through list to compute totNoOfBytesUsed
typename std::list< Allocator<Treal>* >::iterator it = list.begin();
while(it != list.end()) {
totNoOfBytesUsed += (size_t)((*it)->getNoOfOccupiedSlots()) * noOfRealsPerBuffer * sizeof(Treal);
it++;
}
std::stringstream ss;
ss << "AllocatorManager statistics: ";
ss << std::setprecision(3)
<< " noOfRealsPerBuffer: " << noOfRealsPerBuffer
<< " noOfBuffers: " << noOfBuffers
<< " list.size(): " << list.size()
<< ". "
<< "Allocated: " << (double)totNoOfBytesAllocated / 1e9 << " GB, "
<< "Used: " << (double)totNoOfBytesUsed / 1e9 << " GB, "
<< "Peak alloc: " << (double)peakNoOfBytesAllocated/ 1e9 << " GB.";
return ss.str();
}
private:
AllocatorManager() : noOfRealsPerBuffer(0), noOfBuffers(0), peakListSize(0) {
pthread_mutex_init(&mutex, NULL);
}
~AllocatorManager() {
if(!list.empty()) {
std::cerr << "Error in AllocatorManager destructor: not empty." << std::endl;
abort();
}
// Go through list to free any allocators that are left.
typename std::list< Allocator<Treal>* >::iterator it = list.begin();
while(it != list.end()) {
delete *it;
it++;
}
}
std::list< Allocator<Treal>* > list;
size_t noOfRealsPerBuffer;
size_t noOfBuffers;
pthread_mutex_t mutex;
size_t peakListSize;
}; // end class AllocatorManager
} /* end namespace mat */
#endif
|
