Cleanup MatVer4

Belonging to [master]:
  - OpenModelica/OMCompiler#1956

Author: lochel

SimulationRuntime/c/simulation/results/MatVer4.cpp

@@ -31,6 +31,7 @@
 
 #include "MatVer4.h"
 
+#include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -51,35 +52,29 @@ const char isBigEndian()
   return (1 == test.i8[0]);
 }
 
-int writeMatVer4Matrix_4(FILE* file, const char* name, size_t rows, size_t cols, const void* matrixData, MatVer4Type_t type)
+size_t sizeofMatVer4Type(MatVer4Type_t type)
 {
-  struct MatVer4Header
-  {
-    unsigned int type;
-    unsigned int mrows;
-    unsigned int ncols;
-    unsigned int imagf;
-    unsigned int namelen;
-  } header;
-
-  size_t size;
   switch (type)
   {
   case MatVer4Type_DOUBLE:
-    size = sizeof(double);
-    break;
+    return sizeof(double);
   case MatVer4Type_SINGLE:
-    size = sizeof(float);
-    break;
+    return sizeof(float);
   case MatVer4Type_INT32:
-    size = sizeof(int32_t);
-    break;
+    return sizeof(int32_t);
   case MatVer4Type_CHAR:
-    size = sizeof(uint8_t);
-    break;
+    return sizeof(uint8_t);
   default:
-    return -1;
+    // Should never get here!
+    assert(0);
+    return 0;
   }
+}
+
+void writeMatrix_matVer4(FILE* file, const char* name, size_t rows, size_t cols, const void* matrixData, MatVer4Type_t type)
+{
+  MatVer4Header header;
+  size_t size = sizeofMatVer4Type(type);
 
   header.type = (isBigEndian() ? 1000 : 0) + type;
   header.mrows = (unsigned int) rows;
@@ -88,112 +83,40 @@ int writeMatVer4Matrix_4(FILE* file, const char* name, size_t rows, size_t cols,
   header.namelen = (unsigned int) strlen(name) + 1;
 
   fwrite(&header, sizeof(MatVer4Header), 1, file);
-  fwrite(name, sizeof(char), header.namelen, file);
-  fwrite(matrixData, size, rows * cols, file);
+  fwrite(name, sizeof(uint8_t), header.namelen, file);
 
-  return 0;
+  if (matrixData)
+    fwrite(matrixData, size, rows * cols, file);
 }
 
-int appendMatVer4Matrix_4(FILE* file, long position, const char* name, size_t rows, size_t cols, const void* matrixData, MatVer4Type_t type)
+void updateHeader_matVer4(FILE* file, long position, const char* name, size_t rows, size_t additional_cols, MatVer4Type_t type)
 {
-  struct MatVer4Header
-  {
-    unsigned int type;
-    unsigned int mrows;
-    unsigned int ncols;
-    unsigned int imagf;
-    unsigned int namelen;
-  } header;
-
-  size_t size;
-  switch (type)
-  {
-  case MatVer4Type_DOUBLE:
-    size = sizeof(double);
-    break;
-  case MatVer4Type_SINGLE:
-    size = sizeof(float);
-    break;
-  case MatVer4Type_INT32:
-    size = sizeof(int32_t);
-    break;
-  case MatVer4Type_CHAR:
-    size = sizeof(uint8_t);
-    break;
-  default:
-    return -1;
-  }
+  MatVer4Header header;
 
   long eof = ftell(file);
   fseek(file, position, SEEK_SET);
   fread(&header, sizeof(MatVer4Header), 1, file);
-  if (header.type != (isBigEndian() ? 1000 : 0) + type)
-    return -1;
-  if (header.mrows != rows)
-    return -1;
-  header.ncols += (unsigned int) cols;
-  if (header.imagf != 0)
-    return -1;
-  if (header.namelen != strlen(name) + 1)
-    return -1;
+
+  assert(header.type == (isBigEndian() ? 1000 : 0) + type);
+  assert(header.mrows == rows);
+  assert(header.imagf == 0);
+  assert(header.namelen == strlen(name) + 1);
+
+  header.ncols += (unsigned int) additional_cols;
 
   fseek(file, position, SEEK_SET);
   fwrite(&header, sizeof(MatVer4Header), 1, file);
   fseek(file, eof, SEEK_SET);
-  fwrite(matrixData, size, rows * cols, file);
-  return 0;
 }
 
-int writeMatVer4Header_4(FILE* file, long position, const char* name, size_t rows, size_t cols, MatVer4Type_t type)
+void appendMatrix_matVer4(FILE* file, long position, const char* name, size_t rows, size_t cols, const void* matrixData, MatVer4Type_t type)
 {
-  struct MatVer4Header
-  {
-    unsigned int type;
-    unsigned int mrows;
-    unsigned int ncols;
-    unsigned int imagf;
-    unsigned int namelen;
-  } header;
-
-  size_t size;
-  switch (type)
-  {
-  case MatVer4Type_DOUBLE:
-    size = sizeof(double);
-    break;
-  case MatVer4Type_SINGLE:
-    size = sizeof(float);
-    break;
-  case MatVer4Type_INT32:
-    size = sizeof(int32_t);
-    break;
-  case MatVer4Type_CHAR:
-    size = sizeof(uint8_t);
-    break;
-  default:
-    return -1;
-  }
-
-  long eof = ftell(file);
-  fseek(file, position, SEEK_SET);
-  fread(&header, sizeof(MatVer4Header), 1, file);
-  if (header.type != (isBigEndian() ? 1000 : 0) + type)
-    return -1;
-  if (header.mrows != rows)
-    return -1;
-  header.ncols = (unsigned int) cols;
-  if (header.imagf != 0)
-    return -1;
-  if (header.namelen != strlen(name) + 1)
-    return -1;
-
-  fseek(file, position, SEEK_SET);
-  fwrite(&header, sizeof(MatVer4Header), 1, file);
-  fseek(file, eof, SEEK_SET);
-  return 0;
+  size_t size = sizeofMatVer4Type(type);
+  updateHeader_matVer4(file, position, name, rows, cols, type);
+  fwrite(matrixData, size, rows * cols, file);
 }
 
-MatVer4Matrix* readMatVer4Matrix_4(FILE* file)
+MatVer4Matrix* readMatVer4Matrix(FILE* file)
 {
   MatVer4Matrix *matrix = (MatVer4Matrix*) malloc(sizeof(MatVer4Matrix));
   if (!matrix)
@@ -204,33 +127,15 @@ MatVer4Matrix* readMatVer4Matrix_4(FILE* file)
   // skip name
   fseek(file, matrix->header.namelen, SEEK_CUR);
 
-  size_t size;
-  switch (matrix->header.type % 100)
-  {
-  case MatVer4Type_DOUBLE:
-    size = sizeof(double);
-    break;
-  case MatVer4Type_SINGLE:
-    size = sizeof(float);
-    break;
-  case MatVer4Type_INT32:
-    size = sizeof(int32_t);
-    break;
-  case MatVer4Type_CHAR:
-    size = sizeof(uint8_t);
-    break;
-  default:
-    free(matrix);
-    return NULL;
-  }
-
+  MatVer4Type_t type = (MatVer4Type_t) (matrix->header.type % 100);
+  size_t size = sizeofMatVer4Type(type);
   matrix->data = malloc(matrix->header.mrows * matrix->header.ncols * size);
   fread(matrix->data, size, matrix->header.mrows*matrix->header.ncols, file);
 
   return matrix;
 }
 
-void freeMatVer4Matrix_4(MatVer4Matrix** matrix)
+void freeMatrix_matVer4(MatVer4Matrix** matrix)
 {
   if (*matrix)
   {
@@ -241,36 +146,18 @@ void freeMatVer4Matrix_4(MatVer4Matrix** matrix)
   }
 }
 
-int skipMatVer4Matrix_4(FILE* file)
+void skipMatrix_matVer4(FILE* file)
 {
   MatVer4Header header;
   fread(&header, sizeof(MatVer4Header), 1, file);
 
   // skip name
   fseek(file, header.namelen, SEEK_CUR);
 
-  size_t size;
-  switch (header.type % 100)
-  {
-  case MatVer4Type_DOUBLE:
-    size = sizeof(double);
-    break;
-  case MatVer4Type_SINGLE:
-    size = sizeof(float);
-    break;
-  case MatVer4Type_INT32:
-    size = sizeof(int32_t);
-    break;
-  case MatVer4Type_CHAR:
-    size = sizeof(uint8_t);
-    break;
-  default:
-    return -1;
-  }
-
   // skip data
+  MatVer4Type_t type = (MatVer4Type_t) (header.type % 100);
+  size_t size = sizeofMatVer4Type(type);
   fseek(file, header.mrows*header.ncols*size, SEEK_CUR);
-  return 0;
 }
 
 #ifdef __cplusplus

SimulationRuntime/c/simulation/results/MatVer4.h

@@ -62,14 +62,16 @@ typedef struct MatVer4Matrix
   void *data;
 } MatVer4Matrix;
 
-int writeMatVer4Matrix_4(FILE* file, const char* name, size_t rows, size_t cols, const void* matrixData, MatVer4Type_t type);
-int appendMatVer4Matrix_4(FILE* file, long position, const char* name, size_t rows, size_t cols, const void* matrixData, MatVer4Type_t type);
-int writeMatVer4Header_4(FILE* file, long position, const char* name, size_t rows, size_t cols, MatVer4Type_t type);
+size_t sizeofMatVer4Type(MatVer4Type_t type);
 
-MatVer4Matrix* readMatVer4Matrix_4(FILE* file);
-void freeMatVer4Matrix_4(MatVer4Matrix** matrix);
+void writeMatrix_matVer4(FILE* file, const char* name, size_t rows, size_t cols, const void* matrixData, MatVer4Type_t type);
+void updateHeader_matVer4(FILE* file, long position, const char* name, size_t rows, size_t additional_cols, MatVer4Type_t type);
+void appendMatrix_matVer4(FILE* file, long position, const char* name, size_t rows, size_t cols, const void* matrixData, MatVer4Type_t type);
 
-int skipMatVer4Matrix_4(FILE* file);
+MatVer4Matrix* readMatrix_matVer4(FILE* file);
+void freeMatrix_matVer4(MatVer4Matrix** matrix);
+
+void skipMatrix_matVer4(FILE* file);
 
 #ifdef __cplusplus
 }

SimulationRuntime/c/simulation/results/simulation_result_mat4.cpp

@@ -55,6 +55,7 @@ typedef struct mat_data {
   size_t nSignals;
   size_t nEmits;
   void* data_2;
+  MatVer4Type_t type;
 } mat_data;
 
 static const char timeName[] = "time";
@@ -74,6 +75,8 @@ void mat4_init4(simulation_result *self, DATA *data, threadData_t *threadData)
 
   rt_tick(SIM_TIMER_OUTPUT);
 
+  matData->type = omc_flag[FLAG_SINGLE_PRECISION] ? MatVer4Type_SINGLE : MatVer4Type_DOUBLE;
+
   matData->pFile = fopen(self->filename, "wb+");
   if (!matData->pFile)
   {
@@ -86,7 +89,7 @@ void mat4_init4(simulation_result *self, DATA *data, threadData_t *threadData)
   // Class Type: Character Array
   //  Data Type: 8-bit, unsigned integer
   const char Aclass[] = "A1\0bt.\0ir1\0na\0\0Tj\0\0re\0\0ac\0\0nt\0\0so\0\0\0r\0\0\0y\0\0\0";
-  writeMatVer4Matrix_4(matData->pFile, "Aclass", 4, 11, Aclass, MatVer4Type_CHAR);
+  writeMatrix_matVer4(matData->pFile, "Aclass", 4, 11, Aclass, MatVer4Type_CHAR);
 
   /* Find the longest var name and description. */
   size_t maxLengthName = strlen(timeName) + 1;
@@ -309,7 +312,7 @@ void mat4_init4(simulation_result *self, DATA *data, threadData_t *threadData)
   // Dimensions: maxLength x nVars
   // Class Type: Character Array
   //  Data Type: 8-bit, unsigned integer
-  writeMatVer4Matrix_4(matData->pFile, "name", maxLengthName, matData->nSignals, name, MatVer4Type_CHAR);
+  writeMatrix_matVer4(matData->pFile, "name", maxLengthName, matData->nSignals, name, MatVer4Type_CHAR);
   free(name);
   name = NULL;
 
@@ -318,7 +321,7 @@ void mat4_init4(simulation_result *self, DATA *data, threadData_t *threadData)
   // Dimensions: maxLength x nVars
   // Class Type: Character Array
   //  Data Type: 8-bit, unsigned integer
-  writeMatVer4Matrix_4(matData->pFile, "description", maxLengthDesc, matData->nSignals, description, MatVer4Type_CHAR);
+  writeMatrix_matVer4(matData->pFile, "description", maxLengthDesc, matData->nSignals, description, MatVer4Type_CHAR);
   free(description);
   description = NULL;
   rt_accumulate(SIM_TIMER_OUTPUT);
@@ -565,11 +568,11 @@ void mat4_writeParameterData4(simulation_result *self, DATA *data, threadData_t
   // Dimensions: 4 x nVars
   // Class Type: 32-bit, signed integer array
   //  Data Type: 32-bit, signed integer
-  writeMatVer4Matrix_4(matData->pFile, "dataInfo", 4, matData->nSignals, dataInfo, MatVer4Type_INT32);
+  writeMatrix_matVer4(matData->pFile, "dataInfo", 4, matData->nSignals, dataInfo, MatVer4Type_INT32);
   free(dataInfo);
   dataInfo = NULL;
 
-  size_t size = omc_flag[FLAG_SINGLE_PRECISION] ? sizeof(float) : sizeof(double);
+  size_t size = sizeofMatVer4Type(matData->type);
   cur = 0;
   void* data_1 = malloc(size * matData->nData1 * 2);
 
@@ -624,7 +627,7 @@ void mat4_writeParameterData4(simulation_result *self, DATA *data, threadData_t
   // Dimensions: nParams x 2
   // Class Type: Double Precision Array
   //  Data Type: IEEE 754 double-precision
-  writeMatVer4Matrix_4(matData->pFile, "data_1", matData->nData1, 2, data_1, omc_flag[FLAG_SINGLE_PRECISION] ? MatVer4Type_SINGLE : MatVer4Type_DOUBLE);
+  writeMatrix_matVer4(matData->pFile, "data_1", matData->nData1, 2, data_1, matData->type);
   if (data_1)
   {
     free(data_1);
@@ -638,7 +641,7 @@ void mat4_writeParameterData4(simulation_result *self, DATA *data, threadData_t
   //  Data Type: IEEE 754 double-precision
   matData->data2HdrPos = ftell(matData->pFile);
   matData->data_2 = malloc(size * matData->nData2);
-  writeMatVer4Matrix_4(matData->pFile, "data_2", matData->nData2, 0, NULL, omc_flag[FLAG_SINGLE_PRECISION] ? MatVer4Type_SINGLE : MatVer4Type_DOUBLE);
+  writeMatrix_matVer4(matData->pFile, "data_2", matData->nData2, 0, NULL, matData->type);
   rt_accumulate(SIM_TIMER_OUTPUT);
 }
 
@@ -688,8 +691,8 @@ void mat4_emit4(simulation_result *self, DATA *data, threadData_t *threadData)
         if (mData->booleanAlias[i].negate)
           WRITE_REAL_VALUE(matData->data_2, cur++, (1-data->localData[0]->booleanVars[mData->booleanAlias[i].nameID]));
 
-  //appendMatVer4Matrix_4(matData->pFile, matData->data2HdrPos, "data_2", matData->nData2, 1, matData->data_2, omc_flag[FLAG_SINGLE_PRECISION] ? MatVer4Type_SINGLE : MatVer4Type_DOUBLE);
-  fwrite(matData->data_2, omc_flag[FLAG_SINGLE_PRECISION] ? sizeof(float) : sizeof(double), matData->nData2, matData->pFile);
+  //appendMatVer4Matrix_4(matData->pFile, matData->data2HdrPos, "data_2", matData->nData2, 1, matData->data_2, matData->type);
+  fwrite(matData->data_2, sizeofMatVer4Type(matData->type), matData->nData2, matData->pFile);
   matData->nEmits++;
 
   rt_accumulate(SIM_TIMER_OUTPUT);
@@ -706,7 +709,7 @@ void mat4_free4(simulation_result *self, DATA *data, threadData_t *threadData)
     return;
   }
 
-  writeMatVer4Header_4(matData->pFile, matData->data2HdrPos, "data_2", matData->nData2, matData->nEmits, omc_flag[FLAG_SINGLE_PRECISION] ? MatVer4Type_SINGLE : MatVer4Type_DOUBLE);
+  updateHeader_matVer4(matData->pFile, matData->data2HdrPos, "data_2", matData->nData2, matData->nEmits, matData->type);
 
   if (matData->data_2) {
     free(matData->data_2);