Some more inlining for arrays

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

Compiler/runtime/Dynload.cpp

@@ -593,25 +593,25 @@ void *type_desc_to_value(type_description *desc)
   };
   case TYPE_DESC_REAL_ARRAY: {
     void *ptr = (modelica_real *) desc->data.real_array.data
-      + real_array_nr_of_elements(&(desc->data.real_array)) - 1;
+      + base_array_nr_of_elements(desc->data.real_array) - 1;
     return generate_array(TYPE_DESC_REAL, 1, desc->data.real_array.ndims,
                           desc->data.real_array.dim_size, &ptr);
   };
   case TYPE_DESC_INT_ARRAY: {
     void *ptr = (modelica_integer *) desc->data.int_array.data
-      + integer_array_nr_of_elements(&(desc->data.int_array)) - 1;
+      + base_array_nr_of_elements(desc->data.int_array) - 1;
     return generate_array(TYPE_DESC_INT, 1, desc->data.int_array.ndims,
                           desc->data.int_array.dim_size, &ptr);
   };
   case TYPE_DESC_BOOL_ARRAY: {
     void *ptr = (modelica_boolean *) desc->data.bool_array.data
-      + boolean_array_nr_of_elements(&(desc->data.bool_array)) - 1;
+      + base_array_nr_of_elements(desc->data.bool_array) - 1;
     return generate_array(TYPE_DESC_BOOL, 1, desc->data.bool_array.ndims,
                           desc->data.bool_array.dim_size, &ptr);
   };
   case TYPE_DESC_STRING_ARRAY: {
     void *ptr = (modelica_string_t *) desc->data.string_array.data
-      + string_array_nr_of_elements(&(desc->data.string_array)) - 1;
+      + base_array_nr_of_elements(desc->data.string_array) - 1;
     return generate_array(TYPE_DESC_STRING, 1, desc->data.string_array.ndims,
                           desc->data.string_array.dim_size, &ptr);
   };

SimulationRuntime/c/optimization/initialOptimizer/allocate_optimizer_vars.c

@@ -234,7 +234,7 @@ static int freeIpoptData(IPOPT_DATA_ *iData)
   free(sopt->Hg);
 
   for(i = 0; i < dim->nx; i++)
-    iData->scaling.scaldt[i];
+    free(iData->scaling.scaldt[i]);
   free(iData->scaling.scaldt);
 
   for(i = 0; i < dim->nJ; i++){

SimulationRuntime/c/util/base_array.c

@@ -204,17 +204,6 @@ int index_spec_fit_base_array(const index_spec_t *s, const base_array_t *a)
     return 1;
 }
 
-size_t base_array_nr_of_elements(const base_array_t *a)
-{
-  int i;
-  size_t nr_of_elements = 1;
-  for(i = 0; i < a->ndims; ++i)
-  {
-     nr_of_elements *= a->dim_size[i];
-  }
-  return nr_of_elements;
-}
-
 void simple_alloc_1d_base_array(base_array_t *dest, int n, void *data)
 {
     dest->ndims = 1;

SimulationRuntime/c/util/base_array.h

@@ -37,6 +37,10 @@
 #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;}
+
 /* Settings the fields of a base_array */
 void base_array_create(base_array_t *dest, void *data, int ndims, va_list ap);
 
@@ -50,7 +54,15 @@ void simple_alloc_2d_base_array(base_array_t *dest, int r, int c, void *data);
 size_t alloc_base_array(base_array_t *dest, int ndims, va_list ap);
 
 /* Number of elements in array. */
-size_t base_array_nr_of_elements(const base_array_t *a);
+static OMC_INLINE size_t base_array_nr_of_elements(const base_array_t a)
+{
+  int i;
+  size_t nr_of_elements = 1;
+  for(i = 0; i < a.ndims; ++i) {
+     nr_of_elements *= a.dim_size[i];
+  }
+  return nr_of_elements;
+}
 
 /* Clones fields */
 void clone_base_array_spec(const base_array_t *source, base_array_t *dest);

SimulationRuntime/c/util/boolean_array.c

@@ -84,7 +84,7 @@ void alloc_boolean_array(boolean_array_t *dest, int ndims, ...)
 
 void alloc_boolean_array_data(boolean_array_t* a)
 {
-    a->data = boolean_alloc(base_array_nr_of_elements(a));
+    a->data = boolean_alloc(base_array_nr_of_elements(*a));
 }
 
 void copy_boolean_array_data(const boolean_array_t source, boolean_array_t *dest)
@@ -95,7 +95,7 @@ void copy_boolean_array_data(const boolean_array_t source, boolean_array_t *dest
     assert(base_array_ok(dest));
     assert(base_array_shape_eq(&source, dest));
 
-    nr_of_elements = base_array_nr_of_elements(&source);
+    nr_of_elements = base_array_nr_of_elements(source);
 
     for(i = 0; i < nr_of_elements; ++i) {
         boolean_set(dest, i, boolean_get(source, i));
@@ -116,7 +116,7 @@ void and_boolean_array(const boolean_array_t *source1, const boolean_array_t *so
     alloc_boolean_array_data(dest);
 
 
-    nr_of_elements = base_array_nr_of_elements(source1);
+    nr_of_elements = base_array_nr_of_elements(*source1);
 
     for(i = 0; i < nr_of_elements; ++i) {
         boolean_set(dest, i, boolean_get(*source1, i) && boolean_get(*source2, i));
@@ -137,7 +137,7 @@ void or_boolean_array(const boolean_array_t *source1, const boolean_array_t *sou
     alloc_boolean_array_data(dest);
 
 
-    nr_of_elements = base_array_nr_of_elements(source1);
+    nr_of_elements = base_array_nr_of_elements(*source1);
 
     for(i = 0; i < nr_of_elements; ++i) {
         boolean_set(dest, i, boolean_get(*source1, i) || boolean_get(*source2, i));
@@ -154,7 +154,7 @@ void not_boolean_array(const boolean_array_t *source, boolean_array_t *dest)
     alloc_boolean_array_data(dest);
 
 
-    nr_of_elements = base_array_nr_of_elements(source);
+    nr_of_elements = base_array_nr_of_elements(*source);
 
     for(i = 0; i < nr_of_elements; ++i) {
         boolean_set(dest, i, !boolean_get(*source, i));
@@ -167,7 +167,7 @@ void copy_boolean_array_data_mem(const boolean_array_t source, modelica_boolean
 
     assert(base_array_ok(&source));
 
-    nr_of_elements = base_array_nr_of_elements(&source);
+    nr_of_elements = base_array_nr_of_elements(source);
 
     for(i = 0; i < nr_of_elements; ++i) {
         dest[i] = boolean_get(source, i);
@@ -242,7 +242,7 @@ void print_boolean_array(const boolean_array_t *source)
         }
     } else if(source->ndims > 1) {
         size_t k, n;
-        n = base_array_nr_of_elements(source) /
+        n = base_array_nr_of_elements(*source) /
             (source->dim_size[0] * source->dim_size[1]);
         for(k = 0; k < n; ++k) {
             for(i = 0; i < source->dim_size[1]; ++i) {
@@ -492,7 +492,7 @@ void simple_index_boolean_array1(const boolean_array_t* source, int i1,
                                  boolean_array_t* dest)
 {
     size_t i;
-    size_t nr_of_elements = base_array_nr_of_elements(dest);
+    size_t nr_of_elements = base_array_nr_of_elements(*dest);
     size_t off = nr_of_elements * i1;
 
     assert(dest->ndims == (source->ndims - 1));
@@ -507,7 +507,7 @@ void simple_index_boolean_array2(const boolean_array_t* source,
                                  boolean_array_t* dest)
 {
     size_t i;
-    size_t nr_of_elements = base_array_nr_of_elements(dest);
+    size_t nr_of_elements = base_array_nr_of_elements(*dest);
     size_t off = nr_of_elements * ((source->dim_size[1] * i1) + i2);
 
     for(i = 0 ; i < nr_of_elements ; i++) {
@@ -533,7 +533,7 @@ void array_boolean_array(boolean_array_t* dest,int n,boolean_array_t* first,...)
     check_base_array_dim_sizes((const base_array_t **)elts,n);
 
     for(i = 0, c = 0; i < n; ++i) {
-        int m = base_array_nr_of_elements(elts[i]);
+        int m = base_array_nr_of_elements(*elts[i]);
         for(j = 0; j < m; ++j) {
             boolean_set(dest, c, boolean_get(*elts[i], j));
             c++;
@@ -575,7 +575,7 @@ void array_alloc_boolean_array(boolean_array_t* dest, int n,
     }
 
     for(i = 0, c = 0; i < n; ++i) {
-        int m = base_array_nr_of_elements(elts[i]);
+        int m = base_array_nr_of_elements(*elts[i]);
         for(j = 0; j < m; ++j) {
             boolean_set(dest, c, boolean_get(*elts[i], j));
             c++;
@@ -863,7 +863,7 @@ void vector_boolean_array(const boolean_array_t* a, boolean_array_t* dest)
 
     /* Assert that a has at most one dimension with dim_size>1*/
 
-    nr_of_elements = base_array_nr_of_elements(a);
+    nr_of_elements = base_array_nr_of_elements(*a);
     for(i = 0; i < nr_of_elements; ++i) {
         boolean_set(dest, i, boolean_get(*a, i));
     }
@@ -953,7 +953,7 @@ void fill_boolean_array(boolean_array_t* dest,modelica_boolean s)
     size_t nr_of_elements;
     size_t i;
 
-    nr_of_elements = base_array_nr_of_elements(dest);
+    nr_of_elements = base_array_nr_of_elements(*dest);
     for(i = 0; i < nr_of_elements; ++i) {
         boolean_set(dest, i, s);
     }

SimulationRuntime/c/util/boolean_array.h

@@ -45,23 +45,17 @@ static OMC_INLINE modelica_boolean boolean_get(const boolean_array_t a, size_t i
 
 static OMC_INLINE modelica_boolean boolean_get_2D(const boolean_array_t a, size_t i, size_t j)
 {
-    modelica_boolean value = boolean_get(a, (i * a.dim_size[1]) + j);
-    return value;
+    return boolean_get(a, getIndex_2D(a.dim_size,i,j));
 }
 
 static OMC_INLINE modelica_boolean boolean_get_3D(const boolean_array_t a, size_t i, size_t j, size_t k)
 {
-    modelica_boolean value = boolean_get(a, (i * a.dim_size[1] * a.dim_size[2])
-                                          + (j * a.dim_size[2]) + k);
-    return value;
+    return boolean_get(a, getIndex_3D(a.dim_size,i,j,k));
 }
 
 static OMC_INLINE modelica_boolean boolean_get_4D(const boolean_array_t a, size_t i, size_t j, size_t k, size_t l)
 {
-    modelica_boolean value = boolean_get(a, (i * a.dim_size[1] * a.dim_size[2] * a.dim_size[3])
-                                          + (j * a.dim_size[2] * a.dim_size[3])
-                                          + (k * a.dim_size[3]) + l);
-    return value;
+    return boolean_get(a, getIndex_4D(a.dim_size,i,j,k,l));
 }
 
 /* Setting the fields of a boolean_array */
@@ -192,9 +186,6 @@ extern void transpose_boolean_array(const boolean_array_t* a, boolean_array_t* d
 
 extern void fill_boolean_array(boolean_array_t* dest,modelica_boolean s);
 
-static inline size_t boolean_array_nr_of_elements(const boolean_array_t*a)
-{ return base_array_nr_of_elements(a); }
-
 static inline void clone_reverse_boolean_array_spec(const boolean_array_t*source,
                                                     boolean_array_t *dest)
 { clone_reverse_base_array_spec(source, dest); }

SimulationRuntime/c/util/generic_array.c

@@ -41,10 +41,6 @@
 #include <math.h>
 
 
-static inline size_t generic_array_nr_of_elements(const base_array_t *a)
-{ return base_array_nr_of_elements(a); }
-
-
 void* generic_ptrget(const base_array_t *a, size_t sze, size_t i) {
   return (a->data) + (i*sze);
 }
@@ -72,7 +68,7 @@ void* generic_array_element_addr(const base_array_t* source, size_t sze, int ndi
 
 void alloc_generic_array_data(base_array_t* a, size_t sze)
 {
-    a->data = generic_alloc(base_array_nr_of_elements(a),sze);
+    a->data = generic_alloc(base_array_nr_of_elements(*a),sze);
 }
 
 // void copy_generic_array_data(const base_array_t * source, base_array_t* dest)