Add read report

src/colloids.c

@@ -175,8 +175,6 @@ __host__ int colloids_info_recreate(int newcell[3], colloids_info_t ** pinfo) {
  *
  *  colloids_memcpy
  *
- *  FIXME: flag is unused
- *
  *****************************************************************************/
 
 __host__ int colloids_memcpy(colloids_info_t * info, int flag) {
@@ -193,11 +191,16 @@ __host__ int colloids_memcpy(colloids_info_t * info, int flag) {
     assert((info->target == info));
   }
   else {
-    colloid_t * tmp;
-    tdpAssert(tdpMemcpy(&tmp, &info->target->map_new, sizeof(colloid_t **),
-			tdpMemcpyDeviceToHost));
-    tdpAssert(tdpMemcpy(tmp, info->map_new, info->nsites*sizeof(colloid_t *),
-			tdpMemcpyHostToDevice));
+    if (flag == tdpMemcpyHostToDevice) {
+      colloid_t * tmp;
+      tdpAssert(tdpMemcpy(&tmp, &info->target->map_new, sizeof(colloid_t **),
+			  tdpMemcpyDeviceToHost));
+      tdpAssert(tdpMemcpy(tmp, info->map_new, info->nsites*sizeof(colloid_t *),
+			  tdpMemcpyHostToDevice));
+    }
+    else {
+      pe_exit(info->pe, "Bad flag in colloids_memcpy()\n");
+    }
   }
 
   return 0;

src/field.c

@@ -1672,7 +1672,7 @@ int field_io_write(field_t * field, int timestep, io_event_t * event) {
     }
 
     io->impl->free(&io);
-    io_event_report(event, meta, field->name);
+    io_event_report_write(event, meta, field->name);
   }
 
   return ifail;
@@ -1682,8 +1682,6 @@ int field_io_write(field_t * field, int timestep, io_event_t * event) {
  *
  *  field_io_read
  *
- *  FIXME io_event is unused
- *
  *****************************************************************************/
 
 int field_io_read(field_t * field, int timestep, io_event_t * event) {
@@ -1699,17 +1697,24 @@ int field_io_read(field_t * field, int timestep, io_event_t * event) {
   assert(ifail == 0);
 
   if (ifail == 0) {
+    io_event_record(event, IO_EVENT_READ);
     io->impl->read(io, filename);
+    io_event_record(event, IO_EVENT_DISAGGR);
     field_io_aggr_unpack(field, io->aggr);
     io->impl->free(&io);
+
+    if (meta->options.report) {
+      pe_info(field->pe, "MPIIO read from %s\n", filename);
+      io_event_report_read(event, meta, field->name);
+    }
   }
 
   return ifail;
 }
 
 /*****************************************************************************
  *
- * field_graph_halo_send_create
+ *  field_graph_halo_send_create
  *
  *****************************************************************************/
 

src/io_event.c

@@ -47,12 +47,45 @@ int io_event_record(io_event_t * event, io_event_record_t iorec) {
  *****************************************************************************/
 
 int io_event_report(io_event_t * event, const io_metadata_t * metadata,
-		    const char * name) {
+		    const char * name, io_event_record_t iorec) {
 
   assert(event);
   assert(metadata);
   assert(name);
 
+  switch (iorec) {
+  case IO_EVENT_READ:
+    io_event_report_read(event, metadata, name);
+    break;
+  case IO_EVENT_WRITE:
+    io_event_report_write(event, metadata, name);
+    break;
+  default:
+    /* Internal error. */
+    pe_exit(metadata->cs->pe, "Bad io event in report\n");
+  }
+
+  return 0;
+}
+
+/*****************************************************************************
+ *
+ *  io_event_report_read
+ *
+ *  Report for an i/o event in parallel.
+ *  The aggregation report might want the local data size (currently total).
+ *  The file write is the total data size of the file.
+ *
+ *  Some refinement might be wanted for multiple files.
+ *
+ *****************************************************************************/
+
+int io_event_report_read(io_event_t * event, const io_metadata_t * metadata,
+			 const char * name) {
+
+  assert(event);
+  assert(metadata);
+  assert(name);
 
   /* End of event (for reporting purposes) */
   event->time[IO_EVENT_REPORT] = MPI_Wtime();
@@ -64,10 +97,79 @@ int io_event_report(io_event_t * event, const io_metadata_t * metadata,
     const char * units = NULL;
     double dunit6 = 1.0e+06; /* Units of data size are MB */
     double dunit9 = 1.0e+09; /* Units of data size are GB */
+
     /* Times (we assume these have been collected correctly! */
+    /* Read, then disaggregate, then report */
+
+    double tr = event->time[IO_EVENT_DISAGGR] - event->time[IO_EVENT_READ];
+    double ta = event->time[IO_EVENT_REPORT] - event->time[IO_EVENT_DISAGGR];
+
+    /* Record size and total file size. */
+
+    double dr = metadata->element.datasize*metadata->element.count;
+    double ds = metadata->subfile.sizes[X]*metadata->subfile.sizes[Y]*
+                metadata->subfile.sizes[Z];
+    double db = dr*ds;
+
+    if (db > dunit9) {
+      /* Use GB */
+      units = "GB";
+      db = db/dunit9;
+    }
+    else {
+      /* Use MB */
+      units = "MB";
+      db = db/dunit6;
+    }
+    pe_info(pe, "- %10s read          %7.3f %2s in %7.3f seconds\n",
+	    name, db, units, tr);
+    pe_info(pe, "- %10s disaggregated %7.3f %2s in %7.3f seconds\n",
+	    name, db, units, ta);
+    pe_info(pe, "- %10s rate          %7.3f GB per second\n",
+	    name, dr*ds/dunit9/tr);
+  }
+
+  return 0;
+}
+
+/*****************************************************************************
+ *
+ *  io_event_report_write
+ *
+ *  The aggregation report might want the local data size (currently total).
+ *  The file write is the total data size of the file.
+ *
+ *  Some refinement might be wanted for multiple files.
+ *
+ *****************************************************************************/
+
+int io_event_report_write(io_event_t * event, const io_metadata_t * metadata,
+			  const char * name) {
+
+  assert(event);
+  assert(metadata);
+  assert(name);
+
+
+  /* End of event (for reporting purposes) */
+  event->time[IO_EVENT_REPORT] = MPI_Wtime();
+
+  if (metadata->options.report) {
+
+    pe_t * pe = metadata->cs->pe;
+
+    const char * units = NULL;
+    double dunit6 = 1.0e+06; /* Units of data size are MB */
+    double dunit9 = 1.0e+09; /* Units of data size are GB */
+
+    /* Times (we assume these have been collected correctly! */
+    /* Write: aggr is first, write is second, report last */
+
     double ta = event->time[IO_EVENT_WRITE]  - event->time[IO_EVENT_AGGR];
     double tw = event->time[IO_EVENT_REPORT] - event->time[IO_EVENT_WRITE];
+
     /* Record size and total file size. */
+
     double dr = metadata->element.datasize*metadata->element.count;
     double ds = metadata->subfile.sizes[X]*metadata->subfile.sizes[Y]*
                 metadata->subfile.sizes[Z];

src/io_event.h

@@ -9,7 +9,7 @@
  *  Edinburgh Soft Matter and Statistical Physics Group and
  *  Edinburgh Parallel Computing Centre
  *
- *  (c) 2022 The University of Edinburgh
+ *  (c) 2022-2024 The University of Edinburgh
  *
  *  Kevin Stratford ([email protected])
  *
@@ -22,6 +22,8 @@
 
 enum io_event_record_enum {
   IO_EVENT_AGGR = 0,
+  IO_EVENT_DISAGGR,
+  IO_EVENT_READ,
   IO_EVENT_WRITE,
   IO_EVENT_REPORT,
   IO_EVENT_MAX
@@ -38,6 +40,10 @@ struct io_event_s {
 
 int io_event_record(io_event_t * event, io_event_record_t iorec);
 int io_event_report(io_event_t * event, const io_metadata_t * metadata,
-		    const char * name);
+		    const char * name, io_event_record_t iorec);
+int io_event_report_read(io_event_t * event, const io_metadata_t * metadata,
+			 const char * name);
+int io_event_report_write(io_event_t * event, const io_metadata_t * metadata,
+			  const char * name);
 
 #endif

src/lb_data.c

@@ -1417,7 +1417,7 @@ int lb_io_write(lb_t * lb, int timestep, io_event_t * event) {
       }
 
       io->impl->free(&io);
-      io_event_report(event, meta, "dist");
+      io_event_report_write(event, meta, "dist");
     }
   }
 

src/noise.c

@@ -648,7 +648,7 @@ int noise_io_write(noise_t * ns, int timestep, io_event_t * event) {
       if (meta->options.report) {
 	pe_info(ns->pe, "Wrote noise state to file: %s\n", filename);
       }
-      io_event_report(event, meta, ns->options.filestub);
+      io_event_report_write(event, meta, ns->options.filestub);
     }
   }