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
|
/*
Copyright (C) 2008-2015 Jaroslav Hajek
This file is part of Octave.
Octave 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.
Octave 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 Octave; see the file COPYING. If not, see
<http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <iostream>
#include "lo-error.h"
#include "oct-locbuf.h"
// FIXME: Maybe we should querying for available physical memory?
#ifndef OCTAVE_LOCBUF_CHUNKSIZE_MB
#define OCTAVE_LOCBUF_CHUNKSIZE_MB 32
#endif
// Each chunk will be at least this big.
const size_t octave_chunk_buffer::chunk_size =
static_cast<size_t> (OCTAVE_LOCBUF_CHUNKSIZE_MB) << 20;
char *octave_chunk_buffer::top = 0;
char *octave_chunk_buffer::chunk = 0;
size_t octave_chunk_buffer::left = 0;
size_t octave_chunk_buffer::active = 0;
octave_chunk_buffer::octave_chunk_buffer (size_t size) : cnk (0), dat (0)
{
// Alignment mask. The size of double or long int, whichever is
// greater. All data will be aligned to this size. If it's not
// enough for a type, that type should not be declared as POD.
static const size_t align_mask = (sizeof (long) < sizeof (double)
? sizeof (double)
: sizeof (long)) - 1;
active++;
if (! size)
return;
// Align size. Note that size_t is unsigned, so size-1 must correctly
// wrap around.
size = ((size - 1) | align_mask) + 1;
if (size > left)
{
// Big buffers (> 1/8 chunk) will be allocated as stand-alone and
// won't disrupt the chain.
if (size > chunk_size >> 3)
{
// Use new [] to get std::bad_alloc if out of memory.
dat = new char [size];
return;
}
dat = new char [chunk_size];
chunk = top = dat;
left = chunk_size;
}
// Now allocate memory from the chunk and update state.
cnk = chunk;
dat = top;
left -= size;
top += size;
}
octave_chunk_buffer::~octave_chunk_buffer (void)
{
active--;
if (cnk == chunk)
{
// Our chunk is still the active one. Just restore the state.
left += top - dat;
top = dat;
}
else
{
if (cnk)
{
// Responsible for deletion.
delete [] chunk;
chunk = cnk;
top = dat;
// FIXME: the following calcuation of remaining data will
// only work if each chunk has the same chunk_size.
left = chunk_size - (dat - cnk);
}
else
{
// We were a stand-alone buffer.
delete [] dat;
}
}
}
// Clear the final chunk of allocated memory.
void
octave_chunk_buffer::clear (void)
{
if (active == 0)
{
delete [] chunk;
chunk = 0;
top = 0;
left = 0;
}
else
{
// FIXME: Doesn't this situation represent a programming error of
// some kind? If so, maybe this should be a fatal error?
(*current_liboctave_warning_with_id_handler)
("Octave:local-buffer-inconsistency",
"octave_chunk_buffer::clear: %d active allocations remain!",
active);
}
}
|
