- Fixed compilation of util package

git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@10357 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

SimulationRuntime/c/openmodelica.h

@@ -125,13 +125,8 @@ 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;
+  _index_t buffer;
+  _index_t offset;
 };
 
 typedef struct state_s state;

SimulationRuntime/c/util/boolean_array.c

@@ -31,6 +31,7 @@
 
 
 #include "boolean_array.h"
+#include "memory_pool.h"
 
 #include <stdio.h>
 #include <stdlib.h>

SimulationRuntime/c/util/java_interface.h

@@ -32,7 +32,8 @@
 #ifndef JAVA_INTERFACE__H
 #define JAVA_INTERFACE__H
 
-#include "modelica.h"
+#include "openmodelica.h"
+#include "meta_modelica.h"
 #ifdef __cplusplus
 /*
  *  JNI C++ and C interfaces are different, but we use the same code for

SimulationRuntime/c/util/memory_pool.c

@@ -34,14 +34,12 @@
 #include <assert.h>
 #include <stdio.h>
 
+/* 16 MB of data ought to be enough */
+#define NR_ELEMENTS    4*1024*1024
+
 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;
+  int nbuffers;
   state current_state;
 };
 
@@ -51,13 +49,23 @@ one_state *current_states;
 
 void* push_memory_states(int maxThreads)
 {
+  int i;
   void *res = current_states;
-  current_states = calloc(maxThreads,sizeof(one_state));
+  current_states = malloc(maxThreads*sizeof(one_state));
+  assert(current_states);
+  for (i=0; i<maxThreads; i++) {
+    current_states[i].buffer = (int**) malloc(sizeof(int*));
+    current_states[i].buffer[0] = malloc(sizeof(int)*NR_ELEMENTS);
+    current_states[i].nbuffers = 1;
+    current_states[i].current_state.buffer = 0;
+    current_states[i].current_state.offset = 0;
+  }
   return res;
 }
 
 void pop_memory_states(void* new_states)
 {
+  free(current_states[0].buffer); /* TODO: Free all of them... */
   free(current_states);
   current_states = new_states;
 }
@@ -71,21 +79,15 @@ 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("  buffer: %d\n",(int)current_state.buffer);
+  printf("  offste: %d\n",(int)current_state.offset);
 }
 
 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("  buffer: %d\n",(int)s.buffer);
+  printf("  offste: %d\n",(int)s.offset);
 }
 
 void restore_memory_state(state restore_state)
@@ -95,113 +97,69 @@ 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.buffer = 0;
+  current_states[0].current_state.offset = 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.offset;
+  nelem = (n*sz)/sizeof(int) + ((n*sz)%sizeof(int) ? 1 : 0);
+  assert(nelem <= NR_ELEMENTS);
+  if (start + nelem > NR_ELEMENTS) {
+    if (current_states[ix].nbuffers == current_states[ix].current_state.buffer+1) {
+      /* We need to allocate another region */
+      current_states[ix].buffer=realloc(current_states[ix].buffer,sizeof(int*)*current_states[ix].nbuffers);
+      current_states[ix].buffer[current_states[ix].nbuffers]=malloc(sizeof(int)*NR_ELEMENTS);
+      assert(current_states[ix].buffer);
+    }
+    current_states[ix].current_state.buffer = current_states[ix].nbuffers++;
+    current_states[ix].current_state.offset = 0;
+    start = 0;
+    /* fprintf(stderr,"realloc %d %d %d\n", current_states[ix].nbuffers, current_states[ix].current_state.buffer, current_states[ix].current_state.offset); */
+  }
+  current_states[ix].current_state.offset += nelem;
+  /* fprintf(stderr,"return data buffer:%d offset:%d\n", current_states[ix].current_state.buffer, start); */
+  return current_states[ix].buffer[current_states[ix].current_state.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));
 }

SimulationRuntime/c/util/modelica.h

@@ -57,14 +57,6 @@ extern "C" {
 #define DLLDirection DLLExport
 #endif
 
-typedef void* modelica_complex; /* currently only External objects are represented using modelica_complex.*/
-typedef void* modelica_metatype; /* MetaModelica extension, added by sjoelund */
-/* MetaModelica extension.
-We actually store function-pointers in lists, etc...
-So it needs to be void*. If we use a platform with different sizes of function-
-pointers, some changes need to be done to code generation */
-typedef void* modelica_fnptr;
-
 #if defined(__MINGW32__) || defined(_MSC_VER)
  #define WIN32_LEAN_AND_MEAN
 #if !defined(NOMINMAX)

SimulationRuntime/c/util/string_array.c

@@ -31,6 +31,7 @@
 
 
 #include "string_array.h"
+#include "memory_pool.h"
 
 #include <stdio.h>
 #include <stdlib.h>