Skip to content

Commit

Permalink
- The memory pool now uses only one buffer for all data
Browse files Browse the repository at this point in the history 
git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@10349 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
  • Loading branch information
@sjoelund
sjoelund committed Nov 9, 2011
1 parent bad8ce5 commit eaca235
Show file tree
Hide file tree
Showing 2 changed files with 25 additions and 113 deletions.
118 changes: 24 additions & 94 deletions c_runtime/memory_pool.c
View file
Expand Up @@ -34,14 +34,10 @@
#include <assert.h>
#include <stdio.h>

#define NR_ELEMENTS 10000000

struct one_state_s {
m_real real_buffer[NR_REAL_ELEMENTS];
m_integer integer_buffer[NR_INTEGER_ELEMENTS];
m_string string_buffer[NR_STRING_ELEMENTS];
m_boolean boolean_buffer[NR_BOOLEAN_ELEMENTS];
m_integer size_buffer[NR_SIZE_ELEMENTS];
_index_t* index_buffer[NR_INDEX_ELEMENTS];
char char_buffer[NR_CHAR_ELEMENTS];
int buffer[NR_ELEMENTS];
state current_state;
};

Expand Down Expand Up @@ -71,21 +67,13 @@ void print_current_state()
{
state current_state = current_states[0].current_state;
printf("=== Current state ===\n");
printf("real index: %d\n",(int)current_state.real_buffer_ptr);
printf("integer index: %d\n",(int)current_state.integer_buffer_ptr);
printf("string index: %d\n",(int)current_state.string_buffer_ptr);
printf("boolean: %d\n",(int)current_state.boolean_buffer_ptr);
printf("char: %d\n",(int)current_state.char_buffer_ptr);
printf(" index: %d\n",(int)current_state);
}

void print_state(state s)
{
printf("=== State ===\n");
printf("real index: %d\n",(int)s.real_buffer_ptr);
printf("integer index: %d\n",(int)s.integer_buffer_ptr);
printf("string index: %d\n",(int)s.string_buffer_ptr);
printf("boolean: %d\n",(int)s.boolean_buffer_ptr);
printf("char: %d\n",(int)s.char_buffer_ptr);
printf(" index: %d\n",s);
}

void restore_memory_state(state restore_state)
Expand All @@ -95,113 +83,55 @@ void restore_memory_state(state restore_state)

void clear_current_state()
{
current_states[0].current_state.real_buffer_ptr = 0;
current_states[0].current_state.integer_buffer_ptr = 0;
current_states[0].current_state.string_buffer_ptr = 0;
current_states[0].current_state.boolean_buffer_ptr = 0;
current_states[0].current_state.char_buffer_ptr = 0;
current_states[0].current_state = 0;
}

/* allocates n reals in the real_buffer */
m_real* real_alloc(int ix, int n)
inline void* alloc_elements(int ix, int n, int sz)
{
_index_t start;

_index_t start,nelem;
assert(n>=0);
assert(current_states[ix].current_state.real_buffer_ptr + n < NR_REAL_ELEMENTS);
start = current_states[ix].current_state;
nelem = (n*sz)/sizeof(int) + ((n*sz)%sizeof(int) ? 1 : 0);
assert(start + nelem < NR_ELEMENTS);
current_states[ix].current_state += nelem;
return current_states[ix].buffer + start;
}

start = current_states[ix].current_state.real_buffer_ptr;
current_states[ix].current_state.real_buffer_ptr += n;
return current_states[ix].real_buffer+start;
/*return start;*/
/* allocates n reals in the real_buffer */
m_real* real_alloc(int ix, int n)
{
return alloc_elements(ix,n,sizeof(m_real));
}

/* allocates n integers in the integer_buffer */
m_integer* integer_alloc(int ix, int n)
{
_index_t start;

assert(n>=0);
assert(current_states[ix].current_state.integer_buffer_ptr +n < NR_INTEGER_ELEMENTS);

start = current_states[ix].current_state.integer_buffer_ptr;
current_states[ix].current_state.integer_buffer_ptr += n;

return current_states[ix].integer_buffer+start;
/* return start;*/

return alloc_elements(ix,n,sizeof(m_integer));
}

/* allocates n strings in the string_buffer */
m_string* string_alloc(int ix, int n)
{
_index_t start;

assert(n>=0);
assert(current_states[ix].current_state.string_buffer_ptr +n < NR_STRING_ELEMENTS);

start = current_states[ix].current_state.string_buffer_ptr;
current_states[ix].current_state.string_buffer_ptr += n;

return current_states[ix].string_buffer+start;
/*return start;*/

return alloc_elements(ix,n,sizeof(m_string));
}

/* allocates n booleans in the boolean_buffer */
m_boolean* boolean_alloc(int ix, int n)
{
_index_t start;

assert(n>=0);
assert(current_states[ix].current_state.boolean_buffer_ptr +n < NR_BOOLEAN_ELEMENTS);

start = current_states[ix].current_state.boolean_buffer_ptr;
current_states[ix].current_state.boolean_buffer_ptr += n;

return current_states[ix].boolean_buffer+start;
/* return start;*/

return alloc_elements(ix,n,sizeof(m_boolean));
}

_index_t* size_alloc(int ix, int n)
{
_index_t start;

assert(n>=0);
assert(n + current_states[ix].current_state.size_buffer_ptr < NR_SIZE_ELEMENTS);

start = current_states[ix].current_state.size_buffer_ptr;
current_states[ix].current_state.size_buffer_ptr += n;
return current_states[ix].size_buffer+start;

/* return start;*/
return alloc_elements(ix,n,sizeof(_index_t));
}

_index_t** index_alloc(int ix, int n)
{
_index_t start;

assert(n>=0);
assert(n + current_states[ix].current_state.index_buffer_ptr < NR_INDEX_ELEMENTS);

start = current_states[ix].current_state.index_buffer_ptr;
current_states[ix].current_state.index_buffer_ptr += n;
return current_states[ix].index_buffer+start;

/* return start;*/
return alloc_elements(ix,n,sizeof(_index_t*));
}

char* char_alloc(int ix, int n)
{
_index_t start;

assert(n>=0);
assert(n + current_states[ix].current_state.char_buffer_ptr < NR_CHAR_ELEMENTS);

start = current_states[ix].current_state.char_buffer_ptr;
current_states[ix].current_state.char_buffer_ptr += n;
return current_states[ix].char_buffer+start;

/* return start;*/
return alloc_elements(ix,n,sizeof(char));
}
20 changes: 1 addition & 19 deletions c_runtime/memory_pool.h
View file
Expand Up @@ -34,31 +34,13 @@

#include <stdlib.h>

#define NR_REAL_ELEMENTS 1000000
#define NR_INTEGER_ELEMENTS 1000000
#define NR_STRING_ELEMENTS 10000
#define NR_BOOLEAN_ELEMENTS 10000
#define NR_SIZE_ELEMENTS 1000000
#define NR_INDEX_ELEMENTS 1000000
#define NR_CHAR_ELEMENTS 10000

typedef double m_real;
typedef long m_integer;
typedef const char* m_string;
typedef signed char m_boolean;
typedef m_integer _index_t;

struct state_s {
_index_t real_buffer_ptr;
_index_t integer_buffer_ptr;
_index_t string_buffer_ptr;
_index_t boolean_buffer_ptr;
_index_t size_buffer_ptr;
_index_t index_buffer_ptr;
_index_t char_buffer_ptr;
};

typedef struct state_s state;
typedef _index_t state;

state get_memory_state();
void restore_memory_state(state restore_state);
Expand Down

0 comments on commit eaca235

Please sign in to comment.