Changeset caa3fcca in OpenModelica

Timestamp:

2022-05-16T13:08:49+02:00 (2 years ago)

Author:

GitHub <noreply@…>

Branches:

maintenance/v1.20, maintenance/v1.21, maintenance/v1.22, maintenance/v1.23, master

Children:

2ad1387, 58677f97

Parents:

627bacf

git-author:

phannebohm <phannebohm@…> (05/16/22 13:08:49)

git-committer:

GitHub <noreply@…> (05/16/22 13:08:49)

Message:

[janitor] Cleanup events.c (#8956)

• [janitor] Cleanup events.c

• make tmpEventList truly static (no malloc)
• stop returning confusing double from bisection

• Fix array management

• Modularize findRoot

• suggested by bernhardbachmann

Files:

• OMCompiler/SimulationRuntime/c/simulation/solver/events.c (modified) (9 diffs)
• OMCompiler/SimulationRuntime/c/simulation/solver/events.h (modified) (1 diff)
• OMCompiler/SimulationRuntime/c/util/list.c (modified) (1 diff)
• OMCompiler/SimulationRuntime/c/util/list.h (modified) (1 diff)
• testsuite/simulation/modelica/algorithms_functions/ZeroCross.mos (modified) (1 diff)

OMCompiler/SimulationRuntime/c/simulation/solver/events.c

@@ -52 +52 @@
 
 int maxBisectionIterations = 0;
-double bisection(DATA* data, threadData_t *threadData, double*, double*, double*, double*, LIST*, LIST*);
+void bisection(DATA* data, threadData_t *threadData, double*, double*, double*, double*, LIST*, LIST*);
 int checkZeroCrossings(DATA *data, LIST *list, LIST*);
 void saveZeroCrossingsAfterEvent(DATA *data, threadData_t *threadData);
-
-int checkForStateEvent(DATA* data, LIST *eventList);
 
 /*! \fn checkForSampleEvent
@@ -151 +149 @@
   TRACE_PUSH
 
-  if (checkForStateEvent(data, eventLst))
-  {
-    if (useRootFinding)
-    {
-      *eventTime = findRoot(data, threadData, eventLst);
-    }
+  int found = checkForStateEvent(data, eventLst);
+  if(found && useRootFinding)
+  {
+    *eventTime = findRoot(data, threadData, eventLst, data->simulationInfo->timeValueOld, data->simulationInfo->realVarsOld, data->localData[0]->timeValue, data->localData[0]->realVars);
   }
 
@@ -289 +285 @@
  *  \param [ref] [threadData]
  *  \param [ref] [eventList]
- *  \return: first event of interval [oldTime, timeValue]
- *
- *  This function perform a root finding for interval = [oldTime, timeValue]
- */
-double findRoot(DATA* data, threadData_t *threadData, LIST *eventList)
-{
-  TRACE_PUSH
-
-  double eventTime;
-  long event_id;
+ *  \param [in]  [time_left]
+ *  \param [in]  [values_left]
+ *  \param [in]  [time_right]
+ *  \param [in]  [values_right]
+ *  \return: first event of interval [time_left, time_right]
+ */
+double findRoot(DATA* data, threadData_t* threadData, LIST* eventList, double time_left, double* values_left, double time_right, double* values_right)
+{
+  TRACE_PUSH
+
   LIST_NODE* it;
   fortran_integer i=0;
-  static LIST *tmpEventList = NULL;
-
-  double *states_right = (double*) malloc(data->modelData->nStates * sizeof(double));
-  double *states_left = (double*) malloc(data->modelData->nStates * sizeof(double));
-
-  double time_left = data->simulationInfo->timeValueOld;
-  double time_right = data->localData[0]->timeValue;
-
-  tmpEventList = allocList(sizeof(long));
-
-  assert(states_right);
-  assert(states_left);
+  static LIST tmpEventList = (LIST){NULL, NULL, sizeof(long), 0};
+
+  /* static work arrays */
+  static double *states_left = NULL;
+  static double *states_right = NULL;
+
+  /* allocate memory once at first call, never free */
+  if(!states_left)
+  {
+    states_left = (double*) malloc(data->modelData->nStates * sizeof(double));
+    assertStreamPrint(NULL, NULL != states_left, "out of memory");
+  }
+  if(!states_right)
+  {
+    states_right = (double*) malloc(data->modelData->nStates * sizeof(double));
+    assertStreamPrint(NULL, NULL != states_right, "out of memory");
+  }
+
+  /* write states to work arrays */
+  memcpy(states_left,  values_left,  data->modelData->nStates * sizeof(double));
+  memcpy(states_right, values_right, data->modelData->nStates * sizeof(double));
 
   for(it=listFirstNode(eventList); it; it=listNextNode(it))
@@ -319 +324 @@
   }
 
-  /* write states to work arrays */
-  memcpy(states_left,  data->simulationInfo->realVarsOld, data->modelData->nStates * sizeof(double));
-  memcpy(states_right, data->localData[0]->realVars    , data->modelData->nStates * sizeof(double));
-
   /* Search for event time and event_id with bisection method */
-  eventTime = bisection(data, threadData, &time_left, &time_right, states_left, states_right, tmpEventList, eventList);
-
-  if(listLen(tmpEventList) == 0)
+  bisection(data, threadData, &time_left, &time_right, states_left, states_right, &tmpEventList, eventList);
+
+  /* what happens here? */
+  if(listLen(&tmpEventList) == 0)
   {
     double value = fabs(data->simulationInfo->zeroCrossings[*((long*) listFirstData(eventList))]);
@@ -342 +344 @@
       if(value == fabs(data->simulationInfo->zeroCrossings[*((long*) listNodeData(it))]))
       {
-        listPushBack(tmpEventList, listNodeData(it));
+        listPushBack(&tmpEventList, listNodeData(it));
         infoStreamPrint(LOG_ZEROCROSSINGS, 0, "added tmp event : %ld", *((long*) listNodeData(it)));
       }
@@ -350 +352 @@
   listClear(eventList);
 
-  if(ACTIVE_STREAM(LOG_EVENTS))
-  {
-    if(listLen(tmpEventList) > 0)
-    {
-      debugStreamPrint(LOG_EVENTS, 0, "found events: ");
-    }
-    else
-    {
-      debugStreamPrint(LOG_EVENTS, 0, "found event: ");
-    }
-  }
-  while(listLen(tmpEventList) > 0)
-  {
-    event_id = *((long*)listFirstData(tmpEventList));
-    listPopFront(tmpEventList);
-
-    infoStreamPrint(LOG_ZEROCROSSINGS, 0, "Event id: %ld ", event_id);
-
+  debugStreamPrint(LOG_EVENTS, 0, (listLen(&tmpEventList) == 1) ? "found event: " : "found events: ");
+  while(listLen(&tmpEventList) > 0)
+  {
+    /* TODO do this directly w/o free-malloc */
+    long event_id = *((long*)listFirstData(&tmpEventList));
+    listPopFront(&tmpEventList);
     listPushFront(eventList, &event_id);
-  }
-
-  eventTime = time_right;
-  debugStreamPrint(LOG_EVENTS, 0, "time: %.10e", eventTime);
+
+    infoStreamPrint(LOG_ZEROCROSSINGS, 0, "Event id: %ld", event_id);
+  }
+
+  debugStreamPrint(LOG_EVENTS, 0, "time: %.10e", time_right);
 
   data->localData[0]->timeValue = time_left;
-  for(i=0; i < data->modelData->nStates; i++) {
-    data->localData[0]->realVars[i] = states_left[i];
-  }
+  memcpy(data->localData[0]->realVars, states_left, data->modelData->nStates * sizeof(double));
 
   /* determined continuous system */
@@ -384 +373 @@
   /*sim_result_emit(data);*/
 
-  data->localData[0]->timeValue = eventTime;
-  for(i=0; i < data->modelData->nStates; i++)
-  {
-    data->localData[0]->realVars[i] = states_right[i];
-  }
-
-  free(states_left);
-  free(states_right);
-
-  TRACE_POP
-  return eventTime;
+  data->localData[0]->timeValue = time_right;
+  memcpy(data->localData[0]->realVars, states_right, data->modelData->nStates * sizeof(double));
+
+  TRACE_POP
+  return time_right;
 }
 
@@ -406 +389 @@
  *  \param [ref] [eventListTmp]
  *  \param [in]  [eventList]
- *  \return Founded event time
  *
  *  Method to find root in interval [oldTime, timeValue]
  */
-double bisection(DATA* data, threadData_t *threadData, double* a, double* b, double* states_a, double* states_b, LIST *tmpEventList, LIST *eventList)
+void bisection(DATA* data, threadData_t *threadData, double* a, double* b, double* states_a, double* states_b, LIST *tmpEventList, LIST *eventList)
 {
   TRACE_PUSH
@@ -459 +441 @@
     }
   }
-  c = 0.5*(*a + *b);
-
-  TRACE_POP
-  return c;
+
+  TRACE_POP
 }
 

OMCompiler/SimulationRuntime/c/simulation/solver/events.h

@@ -50 +50 @@
 void handleEvents(DATA* data, threadData_t *threadData, LIST* eventLst, double *eventTime, SOLVER_INFO* solverInfo);
 
-double findRoot(DATA *data, threadData_t *threadData, LIST *eventList);
+double findRoot(DATA* data, threadData_t* threadData, LIST* eventList, double time_left, double* states_left, double time_right, double* states_right);
 
 #ifdef __cplusplus

OMCompiler/SimulationRuntime/c/util/list.c

@@ -41 +41 @@
 #include <string.h>
 
-struct LIST_NODE
-{
-  void *data;
-  LIST_NODE *next;
-};
-
-struct LIST
-{
-  LIST_NODE *first;
-  LIST_NODE *last;
-  unsigned int itemSize;
-  unsigned int length;
-};
 
 LIST *allocList(unsigned int itemSize)

OMCompiler/SimulationRuntime/c/util/list.h

@@ -43 +43 @@
 
   /* type-free list */
-  struct LIST_NODE;
-  typedef struct LIST_NODE LIST_NODE;
+  typedef struct LIST_NODE
+  {
+    void *data;
+    struct LIST_NODE *next;
+  } LIST_NODE;
 
-  struct LIST;
-  typedef struct LIST LIST;
+  typedef struct LIST
+  {
+    LIST_NODE *first;
+    LIST_NODE *last;
+    unsigned int itemSize;
+    unsigned int length;
+  } LIST;
 
   LIST *allocList(unsigned int itemSize);

testsuite/simulation/modelica/algorithms_functions/ZeroCross.mos

@@ -4 +4 @@
 // teardown_command: rm -rf ZeroCrossAlg* output.log *.conv.cpp
 // cflags: -d=-newInst
-// 
+//
 //  Simulate model containing ZeroCrossing in for loop algorithm
 //