mirror of
https://github.com/steveicarus/iverilog.git
synced 2026-08-29 01:03:29 +02:00
Cary R
7b1905b997
This patch adds code to free most of the memory when vvp finishes. It also adds valgrind hooks to manage the various memory pools. The functionality is enabled by passing --with-valgrind to configure. It requires that the valgrind/memcheck.h header from a recent version of valgrind be available. It check for the existence of this file, but not that it is new enough (version 3.1.3 is known to not work and version 3.4.0 is known to work). You can still use valgrind when this option is not given, but you will have memory that is not released and the memory pools show as a single block. With this vvp is 100% clean for many of the tests in the test suite. There are still a few things that need to be cleaned up, but it should be much easier to find any real leaks now. Enabling this causes a negligible increase in run time and memory. The memory could be a problem for very large simulations. The increase in run time is only noticeable on very short simulations where it should not matter.
120 lines
3.4 KiB
C++
120 lines
3.4 KiB
C++
/*
|
|
* Copyright (c) 2001-2009 Stephen Williams ([email protected])
|
|
*
|
|
* This source code is free software; you can redistribute it
|
|
* and/or modify it in source code form 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.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
|
|
*/
|
|
|
|
# include "codes.h"
|
|
# include "statistics.h"
|
|
# include "config.h"
|
|
#ifdef CHECK_WITH_VALGRIND
|
|
# include "vvp_cleanup.h"
|
|
#endif
|
|
# include <string.h>
|
|
# include <assert.h>
|
|
|
|
/*
|
|
* The code space is broken into chunks, to make for efficient
|
|
* allocation of large amounts. Each chunk is an array of vvp_code_s
|
|
* structures, with the last opcode loaded with an of_CHUNK_LINK
|
|
* instruction to branch to the next chunk. This handles the case
|
|
* where the program counter steps off the end of a chunk.
|
|
*/
|
|
const unsigned code_chunk_size = 1024;
|
|
|
|
static struct vvp_code_s *first_chunk = 0;
|
|
static struct vvp_code_s *current_chunk = 0;
|
|
static unsigned current_within_chunk = 0;
|
|
|
|
/*
|
|
* This initializes the code space. It sets up the first code chunk,
|
|
* and places at address 0 a ZOMBIE instruction.
|
|
*/
|
|
void codespace_init(void)
|
|
{
|
|
assert(current_chunk == 0);
|
|
first_chunk = new struct vvp_code_s [code_chunk_size];
|
|
current_chunk = first_chunk;
|
|
|
|
current_chunk[0].opcode = &of_ZOMBIE;
|
|
|
|
current_chunk[code_chunk_size-1].opcode = &of_CHUNK_LINK;
|
|
current_chunk[code_chunk_size-1].cptr = 0;
|
|
|
|
current_within_chunk = 1;
|
|
|
|
count_opcodes = 0;
|
|
size_opcodes += code_chunk_size * sizeof (struct vvp_code_s);
|
|
}
|
|
|
|
vvp_code_t codespace_next(void)
|
|
{
|
|
if (current_within_chunk == (code_chunk_size-1)) {
|
|
current_chunk[code_chunk_size-1].cptr
|
|
= new struct vvp_code_s [code_chunk_size];
|
|
current_chunk = current_chunk[code_chunk_size-1].cptr;
|
|
|
|
/* Put a link opcode on the end of the chunk. */
|
|
current_chunk[code_chunk_size-1].opcode = &of_CHUNK_LINK;
|
|
current_chunk[code_chunk_size-1].cptr = 0;
|
|
|
|
current_within_chunk = 0;
|
|
|
|
size_opcodes += code_chunk_size * sizeof (struct vvp_code_s);
|
|
}
|
|
|
|
vvp_code_t res = current_chunk + current_within_chunk;
|
|
return res;
|
|
}
|
|
|
|
vvp_code_t codespace_allocate(void)
|
|
{
|
|
vvp_code_t res = codespace_next();
|
|
current_within_chunk += 1;
|
|
count_opcodes += 1;
|
|
|
|
memset(res, 0, sizeof(*res));
|
|
|
|
return res;
|
|
}
|
|
|
|
vvp_code_t codespace_null(void)
|
|
{
|
|
return first_chunk + 0;
|
|
}
|
|
|
|
#ifdef CHECK_WITH_VALGRIND
|
|
void codespace_delete(void)
|
|
{
|
|
vvp_code_t cur = first_chunk;
|
|
|
|
do {
|
|
vvp_code_t next = cur[code_chunk_size-1].cptr;
|
|
for (unsigned idx = 0 ; idx < code_chunk_size; idx += 1) {
|
|
count_opcodes -= 1;
|
|
if ((cur+idx)->opcode == &of_VPI_CALL) {
|
|
vpi_call_delete((cur+idx)->handle);
|
|
}
|
|
if (count_opcodes == 0) break;
|
|
}
|
|
/* Don't count the &of_CHUNK_LINK opcode. */
|
|
if (count_opcodes != 0) count_opcodes += 1;
|
|
delete [] cur;
|
|
cur = next;
|
|
} while (cur != 0);
|
|
}
|
|
#endif
|