Move omc_assert functions to the threadData

Compiler/Template/CodegenCFunctions.tpl

@@ -4779,7 +4779,7 @@ template indexSubs(list<Dimension> dims, list<Subscript> subs, Context context,
 ::=
   if intNe(listLength(dims),listLength(subs)) then
     error(sourceInfo(),'indexSubs got different number of dimensions and subscripts')
-  else '[calc_base_index_dims_subs(<%listLength(dims)%><%
+  else '[calc_base_index_dims_subs(threadData, <%listLength(dims)%><%
     dims |> dim => ', <%dimension(dim)%>'%><%
     subs |> INDEX(__) => ', <%daeSubscriptExp(exp, context, &preExp, &varDecls, &auxFunction)%>'
     %>)]'

SimulationRuntime/c/gc/omc_gc.h

@@ -52,6 +52,7 @@ extern "C" {
 #if defined(_MSC_VER)
 #include "omc_inline.h"
 #endif
+typedef struct assertions_s assertions_t;
 
 typedef struct {
   void (*init)(void);
@@ -138,6 +139,7 @@ typedef struct threadData_s {
   void *plotClassPointer;
   PlotCallback plotCB;
   void *stackBottom; /* Actually offset 64 kB from bottom, just to never reach the bottom */
+  assertions_t *assert;
 } threadData_t;
 
 typedef threadData_t* OpenModelica_threadData_ThreadData;

SimulationRuntime/c/meta/meta_modelica.c

@@ -61,11 +61,11 @@ void* mmc_mk_rcon(double d)
     return MMC_TAGPTR(p);
 }
 
-void* mmc_mk_modelica_array(base_array_t arr)
+void* mmc_mk_modelica_array(threadData_t *threadData, base_array_t arr)
 {
   base_array_t *cpy = mmc_alloc_words(sizeof(arr)/sizeof(void*) + 1);
   memcpy(cpy, &arr, sizeof(base_array_t));
-  clone_base_array_spec(&arr, cpy);
+  clone_base_array_spec(threadData, &arr, cpy);
   /* Note: The data is hopefully not stack-allocated and can be passed this way */
   return cpy;
 }

SimulationRuntime/c/meta/meta_modelica_data.h

@@ -229,7 +229,7 @@ typedef int mmc_switch_type;
 #define mmc_mk_integer mmc_mk_icon
 #define mmc_mk_boolean mmc_mk_bcon
 #define mmc_mk_real mmc_mk_rcon
-void* mmc_mk_modelica_array(base_array_t);
+void* mmc_mk_modelica_array(threadData_t *threadData, base_array_t);
 
 void mmc_catch_dummy_fn();
 

SimulationRuntime/c/util/base_array.c

@@ -44,7 +44,7 @@
  ** sets all fields in a base_array, i.e. data, ndims and dim_size.
  **/
 
-void base_array_create(base_array_t *dest, void *data, int ndims, va_list ap)
+void base_array_create(threadData_t *threadData, base_array_t *dest, void *data, int ndims, va_list ap)
 {
     int i;
 
@@ -66,7 +66,7 @@ void base_array_create(base_array_t *dest, void *data, int ndims, va_list ap)
     */
 }
 
-int base_array_ok(const base_array_t *a)
+int base_array_ok(threadData_t *threadData, const base_array_t *a)
 {
     int i;
     if(a == NULL) {
@@ -94,7 +94,7 @@ int base_array_ok(const base_array_t *a)
  * Checks that all arrays have the same number of dimensions and same
  * dimension sizes.
  */
-void check_base_array_dim_sizes(const base_array_t *elts, int n)
+void check_base_array_dim_sizes(threadData_t *threadData, const base_array_t *elts, int n)
 {
     int i, curdim;
     int ndims = elts[0].ndims;
@@ -114,7 +114,7 @@ void check_base_array_dim_sizes(const base_array_t *elts, int n)
  * Checks that all arrays have the same number of dimensions and same
  * dimension sizes  for all sizes except for dimension k.
  */
-void check_base_array_dim_sizes_except(int k, const base_array_t *elts, int n)
+void check_base_array_dim_sizes_except(threadData_t *threadData, int k, const base_array_t *elts, int n)
 {
     int i, curdim, dimsize;
     int k_loc = k - 1;
@@ -136,7 +136,7 @@ void check_base_array_dim_sizes_except(int k, const base_array_t *elts, int n)
     }
 }
 
-int base_array_shape_eq(const base_array_t *a, const base_array_t *b)
+int base_array_shape_eq(threadData_t *threadData, const base_array_t *a, const base_array_t *b)
 {
     int i;
 
@@ -156,7 +156,7 @@ int base_array_shape_eq(const base_array_t *a, const base_array_t *b)
     return 1;
 }
 
-int base_array_one_element_ok(const base_array_t *a)
+int base_array_one_element_ok(threadData_t *threadData, const base_array_t *a)
 {
     int i;
 
@@ -168,7 +168,7 @@ int base_array_one_element_ok(const base_array_t *a)
     return 1;
 }
 
-int index_spec_fit_base_array(const index_spec_t *s, const base_array_t *a)
+int index_spec_fit_base_array(threadData_t *threadData, const index_spec_t *s, const base_array_t *a)
 {
     int i, j;
 
@@ -203,15 +203,15 @@ int index_spec_fit_base_array(const index_spec_t *s, const base_array_t *a)
     return 1;
 }
 
-void simple_alloc_1d_base_array(base_array_t *dest, int n, void *data)
+void simple_alloc_1d_base_array(threadData_t *threadData, base_array_t *dest, int n, void *data)
 {
     dest->ndims = 1;
     dest->dim_size = size_alloc(1);
     dest->dim_size[0] = n;
     dest->data = data;
 }
 
-void simple_alloc_2d_base_array(base_array_t *dest, int r, int c, void *data)
+void simple_alloc_2d_base_array(threadData_t *threadData, base_array_t *dest, int r, int c, void *data)
 {
     dest->ndims = 2;
     dest->dim_size = size_alloc(2);
@@ -220,7 +220,7 @@ void simple_alloc_2d_base_array(base_array_t *dest, int r, int c, void *data)
     dest->data = data;
 }
 
-size_t alloc_base_array(base_array_t *dest, int ndims, va_list ap)
+size_t alloc_base_array(threadData_t *threadData, base_array_t *dest, int ndims, va_list ap)
 {
     int i;
     size_t nr_of_elements = 1;
@@ -244,10 +244,10 @@ size_t alloc_base_array(base_array_t *dest, int ndims, va_list ap)
     return nr_of_elements;
 }
 
-void clone_base_array_spec(const base_array_t *source, base_array_t *dest)
+void clone_base_array_spec(threadData_t *threadData, const base_array_t *source, base_array_t *dest)
 {
     int i;
-    assert(base_array_ok(source));
+    assert(base_array_ok(threadData, source));
 
     dest->ndims = source->ndims;
     dest->dim_size = size_alloc(dest->ndims);
@@ -262,7 +262,7 @@ void clone_base_array_spec(const base_array_t *source, base_array_t *dest)
  a[1:3] := b;
 */
 
-size_t calc_base_index_spec(int ndims, const _index_t *idx_vec,
+size_t calc_base_index_spec(threadData_t *threadData, int ndims, const _index_t *idx_vec,
                             const base_array_t *arr, const index_spec_t *spec)
 {
     /* idx_vec is zero based */
@@ -271,9 +271,9 @@ size_t calc_base_index_spec(int ndims, const _index_t *idx_vec,
     int d2;
     size_t index = 0;
 
-    assert(base_array_ok(arr));
+    assert(base_array_ok(threadData, arr));
     assert(index_spec_ok(spec));
-    assert(index_spec_fit_base_array(spec, arr));
+    assert(index_spec_fit_base_array(threadData, spec, arr));
     assert((ndims == arr->ndims) && (ndims == spec->ndims));
 
     index = 0;
@@ -291,7 +291,7 @@ size_t calc_base_index_spec(int ndims, const _index_t *idx_vec,
 }
 
 /* Uses zero based indexing */
-size_t calc_base_index(int ndims, const _index_t *idx_vec, const base_array_t *arr)
+size_t calc_base_index(threadData_t *threadData, int ndims, const _index_t *idx_vec, const base_array_t *arr)
 {
     int i;
     size_t index = 0;
@@ -305,7 +305,7 @@ size_t calc_base_index(int ndims, const _index_t *idx_vec, const base_array_t *a
     return index;
 }
 
-size_t calc_base_index_dims_subs(int ndims,...)
+size_t calc_base_index_dims_subs(threadData_t *threadData, int ndims,...)
 {
 
     int i;
@@ -327,8 +327,7 @@ size_t calc_base_index_dims_subs(int ndims,...)
     index = 0;
     for(i = 0; i < ndims; ++i) {
         if (subs[i] < 0 || subs[i] >= dims[i]) {
-          FILE_INFO info = omc_dummyFileInfo;
-          omc_assert(NULL, info, "Dimension %d has bounds 1..%d, got array subscript %d", i+1, dims[i], subs[i]+1);
+          threadData->assert->error(threadData, NULL, "Dimension %d has bounds 1..%d, got array subscript %d", i+1, dims[i], subs[i]+1);
         }
         index = (index * dims[i]) + subs[i];
     }
@@ -338,7 +337,7 @@ size_t calc_base_index_dims_subs(int ndims,...)
 }
 
 /* 0-based index*/
-size_t calc_base_index_va(const base_array_t *source, int ndims, va_list ap)
+size_t calc_base_index_va(threadData_t *threadData, const base_array_t *source, int ndims, va_list ap)
 {
     int i;
     size_t index;
@@ -347,25 +346,24 @@ size_t calc_base_index_va(const base_array_t *source, int ndims, va_list ap)
     for(i = 0; i < ndims; ++i) {
         int sub_i = va_arg(ap, _index_t) - 1;
         if (sub_i < 0 || sub_i >= source->dim_size[i]) {
-          FILE_INFO info = omc_dummyFileInfo;
-          omc_assert(NULL, info, "Dimension %d has bounds 1..%d, got array subscript %d", i+1, source->dim_size[i], sub_i+1);
+          threadData->assert->error(threadData, NULL, "Dimension %d has bounds 1..%d, got array subscript %d", i+1, source->dim_size[i], sub_i+1);
         }
         index = (index * source->dim_size[i]) + sub_i;
     }
 
     return index;
 }
 
-int ndims_base_array(const base_array_t* a)
+int ndims_base_array(threadData_t *threadData, const base_array_t* a)
 {
-    assert(base_array_ok(a));
+    assert(base_array_ok(threadData, a));
     return a->ndims;
 }
 
-void clone_reverse_base_array_spec(const base_array_t* source, base_array_t* dest)
+void clone_reverse_base_array_spec(threadData_t *threadData, const base_array_t* source, base_array_t* dest)
 {
     int i;
-    assert(base_array_ok(source));
+    assert(base_array_ok(threadData, source));
 
     dest->ndims = source->ndims;
     dest->dim_size = size_alloc(dest->ndims);
@@ -376,16 +374,16 @@ void clone_reverse_base_array_spec(const base_array_t* source, base_array_t* des
     }
 }
 
-void index_alloc_base_array_size(const real_array_t * source,
+void index_alloc_base_array_size(threadData_t *threadData, const real_array_t * source,
                                  const index_spec_t* source_spec,
                                  base_array_t* dest)
 {
     int i;
     int j;
 
-    omc_assert_macro(base_array_ok(source));
+    omc_assert_macro(base_array_ok(threadData, source));
     omc_assert_macro(index_spec_ok(source_spec));
-    omc_assert_macro(index_spec_fit_base_array(source_spec, source));
+    omc_assert_macro(index_spec_fit_base_array(threadData, source_spec, source));
 
     for(i = 0, j = 0; i < source_spec->ndims; ++i) {
          if(source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
@@ -408,15 +406,15 @@ void index_alloc_base_array_size(const real_array_t * source,
     }
 }
 
-void indexed_assign_base_array_size_alloc(const base_array_t *source, base_array_t *dest, const index_spec_t *dest_spec, _index_t** _idx_vec1, _index_t** _idx_size)
+void indexed_assign_base_array_size_alloc(threadData_t *threadData, const base_array_t *source, base_array_t *dest, const index_spec_t *dest_spec, _index_t** _idx_vec1, _index_t** _idx_size)
 {
     _index_t* idx_vec1;
     _index_t* idx_size;
     int i, j;
-    omc_assert_macro(base_array_ok(source));
-    omc_assert_macro(base_array_ok(dest));
+    omc_assert_macro(base_array_ok(threadData, source));
+    omc_assert_macro(base_array_ok(threadData, dest));
     omc_assert_macro(index_spec_ok(dest_spec));
-    omc_assert_macro(index_spec_fit_base_array(dest_spec, dest));
+    omc_assert_macro(index_spec_fit_base_array(threadData, dest_spec, dest));
     for(i = 0,j = 0; i < dest_spec->ndims; ++i) {
         if(dest_spec->dim_size[i] != 0) {
             ++j;

SimulationRuntime/c/util/base_array.h

@@ -36,24 +36,24 @@
 #include <stdarg.h>
 #include "omc_msvc.h"
 
-static OMC_INLINE size_t getIndex_2D(_index_t *dim, int i, int j) {return i*dim[1]+j;}
-static OMC_INLINE size_t getIndex_3D(_index_t *dim, int i, int j, int k) {return i*dim[1]*dim[2]+j*dim[2]+k;}
-static OMC_INLINE size_t getIndex_4D(_index_t *dim, int i, int j, int k, int l) {return i*dim[1]*dim[2]*dim[3]+j*dim[2]*dim[3]+k*dim[3]+l;}
+static OMC_INLINE size_t getIndex_2D(threadData_t *threadData, _index_t *dim, int i, int j) {return i*dim[1]+j;}
+static OMC_INLINE size_t getIndex_3D(threadData_t *threadData, _index_t *dim, int i, int j, int k) {return i*dim[1]*dim[2]+j*dim[2]+k;}
+static OMC_INLINE size_t getIndex_4D(threadData_t *threadData, _index_t *dim, int i, int j, int k, int l) {return i*dim[1]*dim[2]*dim[3]+j*dim[2]*dim[3]+k*dim[3]+l;}
 
 /* Settings the fields of a base_array */
-void base_array_create(base_array_t *dest, void *data, int ndims, va_list ap);
+void base_array_create(threadData_t *threadData, base_array_t *dest, void *data, int ndims, va_list ap);
 
 /* Allocation of a vector */
-void simple_alloc_1d_base_array(base_array_t *dest, int n, void *data);
+void simple_alloc_1d_base_array(threadData_t *threadData, base_array_t *dest, int n, void *data);
 
 /* Allocation of a matrix */
-void simple_alloc_2d_base_array(base_array_t *dest, int r, int c, void *data);
+void simple_alloc_2d_base_array(threadData_t *threadData, base_array_t *dest, int r, int c, void *data);
 
 /* Allocate array */
-size_t alloc_base_array(base_array_t *dest, int ndims, va_list ap);
+size_t alloc_base_array(threadData_t *threadData, base_array_t *dest, int ndims, va_list ap);
 
 /* Number of elements in array. */
-static OMC_INLINE size_t base_array_nr_of_elements(const base_array_t a)
+static OMC_INLINE size_t base_array_nr_of_elements(threadData_t *threadData, const base_array_t a)
 {
   int i;
   size_t nr_of_elements = 1;
@@ -64,12 +64,12 @@ static OMC_INLINE size_t base_array_nr_of_elements(const base_array_t a)
 }
 
 /* Clones fields */
-void clone_base_array_spec(const base_array_t *source, base_array_t *dest);
+void clone_base_array_spec(threadData_t *threadData, const base_array_t *source, base_array_t *dest);
 
-void clone_reverse_base_array_spec(const base_array_t* source, base_array_t* dest);
+void clone_reverse_base_array_spec(threadData_t *threadData, const base_array_t* source, base_array_t* dest);
 
-int ndims_base_array(const base_array_t* a);
-static OMC_INLINE int size_of_dimension_base_array(const base_array_t a, int i)
+int ndims_base_array(threadData_t *threadData, const base_array_t* a);
+static OMC_INLINE int size_of_dimension_base_array(threadData_t *threadData, const base_array_t a, int i)
 {
   /* assert(base_array_ok(&a)); */
   if ((i > 0) && (i <= a.ndims)) {
@@ -89,24 +89,24 @@ static OMC_INLINE int size_of_dimension_base_array(const base_array_t a, int i)
 }
 
 /* Helper functions */
-int base_array_ok(const base_array_t *a);
-void check_base_array_dim_sizes(const base_array_t *elts, int n);
-void check_base_array_dim_sizes_except(int k, const base_array_t *elts, int n);
-int base_array_shape_eq(const base_array_t *a, const base_array_t *b);
-int base_array_one_element_ok(const base_array_t *a);
+int base_array_ok(threadData_t *threadData, const base_array_t *a);
+void check_base_array_dim_sizes(threadData_t *threadData, const base_array_t *elts, int n);
+void check_base_array_dim_sizes_except(threadData_t *threadData, int k, const base_array_t *elts, int n);
+int base_array_shape_eq(threadData_t *threadData, const base_array_t *a, const base_array_t *b);
+int base_array_one_element_ok(threadData_t *threadData, const base_array_t *a);
 
-size_t calc_base_index_spec(int ndims, const _index_t* idx_vec,
+size_t calc_base_index_spec(threadData_t *threadData, int ndims, const _index_t* idx_vec,
                             const base_array_t *arr, const index_spec_t *spec);
-size_t calc_base_index(int ndims, const _index_t *idx_vec, const base_array_t *arr);
-size_t calc_base_index_va(const base_array_t *source, int ndims, va_list ap);
+size_t calc_base_index(threadData_t *threadData, int ndims, const _index_t *idx_vec, const base_array_t *arr);
+size_t calc_base_index_va(threadData_t *threadData, const base_array_t *source, int ndims, va_list ap);
 
-size_t calc_base_index_dims_subs(int ndims,...);
+size_t calc_base_index_dims_subs(threadData_t *threadData, int ndims, ...);
 
-int index_spec_fit_base_array(const index_spec_t *s, const base_array_t *a);
+int index_spec_fit_base_array(threadData_t *threadData, const index_spec_t *s, const base_array_t *a);
 
 /* Helper function for index_alloc_TYPE_array; allocates the ndims and dim_size */
-void index_alloc_base_array_size(const base_array_t * source, const index_spec_t* source_spec, base_array_t* dest);
+void index_alloc_base_array_size(threadData_t *threadData, const base_array_t * source, const index_spec_t* source_spec, base_array_t* dest);
 /* Helper function for indexed_assign_TYPE_array; allocates the ndims and dim_size */
-void indexed_assign_base_array_size_alloc(const base_array_t *source, base_array_t *dest, const index_spec_t *dest_spec, _index_t** _idx_vec1, _index_t** _idx_size);
+void indexed_assign_base_array_size_alloc(threadData_t *threadData, const base_array_t *source, base_array_t *dest, const index_spec_t *dest_spec, _index_t** _idx_vec1, _index_t** _idx_size);
 
 #endif /* BASE_ARRAY_H_ */