Mercurial > octave-nkf
view liboctave/util/oct-locbuf.cc @ 19895:19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Try to wrap long lines to < 80 characters.
Use GNU style and don't indent first brace of function definition.
"case" statement is aligned flush left with brace of switch stmt.
Remove trailing '\' line continuation from the end of #define macros.
Use 2 spaces for indent.
* files-dock-widget.cc, history-dock-widget.cc, main-window.cc, octave-cmd.cc,
octave-dock-widget.cc, octave-gui.cc, resource-manager.cc, settings-dialog.cc,
shortcut-manager.cc, welcome-wizard.cc, workspace-view.cc, cellfun.cc, data.cc,
debug.cc, debug.h, dirfns.cc, error.h, file-io.cc, gl-render.cc, gl-render.h,
gl2ps-renderer.h, graphics.cc, graphics.in.h, help.cc, input.cc, load-path.cc,
load-path.h, lookup.cc, lu.cc, oct-stream.cc, octave-default-image.h,
ordschur.cc, pr-output.cc, qz.cc, strfns.cc, symtab.cc, symtab.h, sysdep.cc,
variables.cc, zfstream.h, __fltk_uigetfile__.cc, __init_fltk__.cc,
__magick_read__.cc, __osmesa_print__.cc, audiodevinfo.cc, ov-classdef.cc,
ov-classdef.h, ov-fcn.h, ov-float.cc, ov-flt-complex.cc, ov-java.cc,
ov-range.cc, ov-re-mat.cc, ov-usr-fcn.h, ov.cc, op-int.h, options-usage.h,
pt-eval.cc, Array-C.cc, Array-fC.cc, Array.cc, Array.h, PermMatrix.cc,
Sparse.cc, chMatrix.h, dSparse.cc, dim-vector.h, bsxfun-decl.h, bsxfun-defs.cc,
oct-norm.cc, Sparse-op-defs.h, oct-inttypes.cc, oct-inttypes.h, main.in.cc,
mkoctfile.in.cc: Cleanup C++ code to follow Octave coding conventions.
author | Rik <rik@octave.org> |
---|---|
date | Wed, 25 Feb 2015 11:55:49 -0800 |
parents | 4197fc428c7d |
children |
line wrap: on
line source
/* 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); } }