Add a few structures

logger/Makefile.am

@@ -42,10 +42,12 @@ lib_LTLIBRARIES = liblogger.la
 # endif
 
 # List required headers
-include_HEADERS = logger_header.h logger_io.h logger_particle.h logger_time.h logger_tools.h logger_reader.h
+include_HEADERS = logger_header.h logger_io.h logger_particle.h logger_time.h logger_tools.h logger_reader.h \
+	logger_index.h logger_dump.h
 
 # Common source files
-AM_SOURCES = logger_header.c logger_io.c logger_particle.c logger_time.c logger_tools.c logger_reader.c
+AM_SOURCES = logger_header.c logger_io.c logger_particle.c logger_time.c logger_tools.c logger_reader.c \
+	logger_dump.c
 if HAVEPYTHON
 AM_SOURCES += logger_python_wrapper.c
 endif

logger/logger_dump.c

+/*******************************************************************************
+ * This file is part of SWIFT.
+ * Copyright (c) 2019 Loic Hausammann (loic.hausammann@epfl.ch)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ******************************************************************************/
+#include "logger_dump.h"
+#include "logger_reader.h"
+#include "logger_io.h"
+
+/**
+ * @brief Initialize the #logger_dump.
+ *
+ * If required this function will also reverse the offsets.
+ * @param dump The #logger_dump.
+ * @param filename the dump's filename.
+ * @param reader The #logger_reader.
+ */
+void logger_dump_init(
+    struct logger_dump *dump, char *filename,
+    struct logger_reader *reader) {
+
+  /* Set the pointer to the reader. */
+  dump->reader = reader;
+
+  /* Open file, map it and get its size. */
+  if (reader->verbose > 1)
+    message("Mapping the dump file.");
+  dump->dump.map = io_mmap_file(filename, &dump->dump.file_size);
+
+  /* Read header. */
+  if (reader->verbose > 1)
+    message("Reading the header.");
+  header_read(&dump->header, dump);
+
+  /* Print the header. */
+  if (reader->verbose > 0) {
+    header_print(&dump->header);
+  }
+
+  /* Check if the offset are corrupted */
+  if (header_are_offset_corrupted(&dump->header)) {
+    error("The offsets have been corrupted");
+  }
+
+  /* Reverse offset direction */
+  if (reader->verbose > 1)
+    message("Checking if offsets need to be reversed.");
+  if (header_are_offset_backward(&dump->header)) {
+    logger_dump_reverse_offset(dump);
+  }
+
+  /* Initialize the time array */
+  if (reader->verbose > 1)
+    message("Reading the time stamps.");
+  time_array_init(&dump->times, dump);
+
+  if (reader->verbose > 0) {
+    time_array_print(&dump->times);
+  }
+
+}
+
+/**
+ * @brief Free the allocated memory and unmap the file.
+ *
+ * @param dump The #logger_dump.
+ */
+void logger_dump_free(struct logger_dump *dump) {
+  io_munmap_file(dump->dump.map, dump->dump.file_size);
+
+}
+
+
+/**
+ * @brief Reverse offset in dump file
+ *
+ * @param dump The #logger_dump
+ */
+void logger_dump_reverse_offset(struct logger_dump *dump) {
+
+  struct header *header = &dump->header;
+  const struct logger_reader *reader = dump->reader;
+
+  if (!header_are_offset_backward(header)) {
+    error("The offset are already reversed.");
+  }
+
+
+#ifdef SWIFT_DEBUG_CHECKS
+  /* check offset */
+  if (reader->verbose > 0) {
+    message("Check offsets...\n");
+  }
+  size_t offset_debug = header->offset_first;
+  while (offset_debug < dump->dump.file_size) {
+    tools_check_offset(header, dump->dump.map, &offset_debug);
+  }
+  if (reader->verbose > 0) {
+    message("Check done\n");
+  }
+#endif
+
+  /* reverse header offset */
+  header_change_offset_direction(header, logger_offset_corrupted);
+  
+  size_t offset = header->offset_first;
+
+  /* reverse chunks */
+  if (reader->verbose > 0) {
+    message("Reversing offsets...\n");
+  }
+  while (offset < dump->dump.file_size) {
+    tools_reverse_offset(header, dump->dump.map, &offset);
+  }
+  if (reader->verbose > 0) {
+    message("Reversing done\n");
+  }
+
+  /* reverse header offset */
+  header_change_offset_direction(header, logger_offset_forward);
+
+#ifdef SWIFT_DEBUG_CHECKS
+  /* check offset */
+  if (reader->verbose > 0) {
+    message("Check offsets...\n");
+  }
+  offset_debug = header->offset_first;
+  while (offset_debug < dump->dump.file_size) {
+    tools_check_offset(header, dump->dump.map, &offset_debug);
+  }
+  if (reader->verbose > 0) {
+    message("Check done\n");
+  }
+#endif
+
+}

logger/logger_dump.h

+/*******************************************************************************
+ * This file is part of SWIFT.
+ * Copyright (c) 2019 Loic Hausammann (loic.hausammann@epfl.ch)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ******************************************************************************/
+/**
+ * @brief This file contains the high level function for the dump.
+ */
+#ifndef __LOGGER_LOGGER_DUMP_H__
+#define __LOGGER_LOGGER_DUMP_H__
+
+#include "logger_header.h"
+#include "logger_time.h"
+
+struct logger_reader;
+
+/**
+ * @brief This structure deals with the dump file.
+ */
+struct logger_dump {
+
+  /* Information contained in the header. */
+  struct header header;
+
+  /* The reader that is using this dump. */
+  struct logger_reader *reader;
+
+  /* Information about the time chunks */
+  struct time_array times;
+
+  /* Dump's filename */
+  char *filename;
+
+  /* The dump's variables. */
+  struct {
+    /* Mapped data */
+    void *map;
+
+    /* File size */
+    size_t file_size;
+
+  } dump;
+
+};
+
+
+void logger_dump_init(struct logger_dump *dump, char *filename, struct logger_reader *reader);
+void logger_dump_reverse_offset(struct logger_dump *dump);
+void logger_dump_free(struct logger_dump *dump);
+
+#endif // __LOGGER_LOGGER_DUMP_H__

logger/logger_header.c

@@ -20,11 +20,19 @@
 
 #include "logger_io.h"
 #include "logger_tools.h"
+#include "logger_dump.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+/* Task type names. */
+const char *logger_offset_name[logger_offset_count] = {
+  "Forward", "Backward", "Corrupted",
+};
+
+
+
 /**
  * @brief Print the properties of the header to stdout.
  *
@@ -32,23 +40,18 @@
  */
 void header_print(const struct header *h) {
 #ifdef SWIFT_DEBUG_CHECKS
-  message("Debug checks enabled\n");
+  message("Debug checks enabled");
 #endif
-  message("Version:          %s\n", h->version);
-  message("First Offset:     %lu\n", h->offset_first);
-  char direction[20];
-  if (h->forward_offset)
-    strcpy(direction, "Forward");
-  else
-    strcpy(direction, "Backward");
-  message("Offset direction: %s\n", direction);
-  message("Number masks:     %lu\n", h->number_mask);
+  message("Version:          %s", h->version);
+  message("First Offset:     %lu", h->offset_first);
+  message("Offset direction: %s", logger_offset_name[h->offset_direction]);
+  message("Number masks:     %lu", h->number_mask);
 
   for (size_t i = 0; i < h->number_mask; i++) {
-    message("\tMask:  %s\n", h->masks[i].name);
-    message("\tValue: %u\n", h->masks[i].mask);
-    message("\tSize:  %i\n", h->masks[i].size);
-    message("\n");
+    message("\tMask:  %s", h->masks[i].name);
+    message("\tValue: %u", h->masks[i].mask);
+    message("\tSize:  %i", h->masks[i].size);
+    message("");
   }
 };
 
@@ -80,14 +83,14 @@ int header_get_field_index(const struct header *h, const char *field) {
  * @brief Inverse the offset direction
  *
  * @param h #header file structure
- * @param map file mapping
+ * @param new_value The new value to write
  *
  */
-void header_change_offset_direction(struct header *h, void *map) {
-  h->forward_offset = !h->forward_offset;
+void header_change_offset_direction(struct header *h, int new_value) {
+  h->offset_direction = new_value;
   size_t offset = LOGGER_VERSION_SIZE;
 
-  io_write_data(map, LOGGER_NUMBER_SIZE, &h->forward_offset, &offset);
+  io_write_data(h->dump->dump.map, LOGGER_NUMBER_SIZE, &new_value, &offset);
 }
 
 /**
@@ -96,18 +99,23 @@ void header_change_offset_direction(struct header *h, void *map) {
  * @param h out: header
  * @param map file mapping
  */
-void header_read(struct header *h, void *map) {
+void header_read(struct header *h, struct logger_dump *dump) {
   size_t offset = 0;
+  void *map = dump->dump.map;
+
+  /* Set pointer to dump */
+  h->dump = dump;
 
   /* read version */
   io_read_data(map, LOGGER_VERSION_SIZE, &h->version, &offset);
 
   /* read offset direction */
-  h->forward_offset = 0;
-  io_read_data(map, LOGGER_NUMBER_SIZE, &h->forward_offset, &offset);
+  h->offset_direction = -1;
+  io_read_data(map, LOGGER_NUMBER_SIZE, &h->offset_direction, &offset);
 
-  if (h->forward_offset != 0 && h->forward_offset != 1)
-    error("Non boolean value for the offset direction (%i)", h->forward_offset);
+  if (!header_are_offset_forward(h) && !header_are_offset_backward(h) &&
+      !header_are_offset_corrupted(h))
+    error("Wrong offset value in the header (%i)", h->offset_direction);
 
   /* read offset to first data */
   h->offset_first = 0;

logger/logger_header.h

@@ -29,6 +29,22 @@
 #define LOGGER_OFFSET_SIZE 7
 #define LOGGER_MASK_SIZE 1
 
+enum logger_offset_direction {
+  logger_offset_backward = 0,
+  logger_offset_forward,
+  logger_offset_corrupted,
+  /* Number of offset type */
+  logger_offset_count,
+};
+
+/**
+ * @brief Names of the offset directions.
+ */
+extern const char *logger_offset_name[];
+
+
+struct logger_dump;
+
 /**
  * @brief This structure contains everything from the file header.
  *
@@ -41,30 +57,61 @@
  * The only function that modify the file is @header_change_offset_direction.
  */
 struct header {
-  /* Logger version */
+  /* Logger version. */
   char version[STRING_SIZE];
 
-  /* offset of the first header */
+  /* Offset of the first header. */
   size_t offset_first;
 
-  /* Number of bytes for names */
+  /* Number of bytes for names. */
   size_t name_length;
 
-  /* number of masks */
+  /* Number of masks. */
   size_t number_mask;
 
-  /* list of masks */
+  /* List of masks. */
   struct mask_data *masks;
 
-  /* offset direction */
-  int forward_offset;
+  /* Direction of the offset in the chunks. */
+  int offset_direction;
+
+  /* The corresponding dump */
+  struct logger_dump *dump;
 };
 
 void header_print(const struct header *h);
 void header_free(struct header *h);
 int header_get_field_index(const struct header *h, const char *field);
-void header_read(struct header *h, void *map);
+void header_read(struct header *h, struct logger_dump *dump);
 size_t header_get_mask_size(const struct header *h, const size_t mask);
-void header_change_offset_direction(struct header *h, void *map);
+void header_change_offset_direction(struct header *h, int new_value);
+
+
+/**
+ * @brief Check if the offset are forward.
+ * @param h The #header.
+ */
+__attribute__((always_inline)) INLINE static int header_are_offset_forward(
+    const struct header *h) {
+  return h->offset_direction == logger_offset_forward;
+}
+
+/**
+ * @brief Check if the offset are backward.
+ * @param h The #header.
+ */
+__attribute__((always_inline)) INLINE static int header_are_offset_backward(
+    const struct header *h) {
+  return h->offset_direction == logger_offset_backward;
+}
+
+/**
+ * @brief Check if the offset are corrupted.
+ * @param h The #header.
+ */
+__attribute__((always_inline)) INLINE static int header_are_offset_corrupted(
+    const struct header *h) {
+  return h->offset_direction == logger_offset_corrupted;
+}
 
 #endif  // __LOGGER_LOGGER_HEADER_H__

logger/logger_index.h

+/*******************************************************************************
+ * This file is part of SWIFT.
+ * Copyright (c) 2019 Loic Hausammann (loic.hausammann@epfl.ch)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ******************************************************************************/
+
+/**
+ * @brief This file deals with the index files.
+ */
+#ifndef __LOGGER_LOGGER_INDEX_H__
+#define __LOGGER_LOGGER_INDEX_H__
+
+/**
+ * @brief This structure will contain the data related to
+ *   the index file.
+ */
+struct logger_index {};
+
+#endif // __LOGGER_LOGGER_INDEX_H__

logger/logger_io.c

@@ -40,46 +40,46 @@ void io_get_file_size(int fd, size_t *size) {
 }
 
 /**
- * @brief Open a file and map it
+ * @brief Map a file.
  *
- * @param filename file to read
- * @param fd out: file id
- * @param map out: file mapping
+ * @io_munmap_file should be called to unmap the file.
+ *
+ * @param filename file to read.
+ * @param file_size (out) size of the file.
  *
  */
-void io_open_file(char *filename, int *fd, void **map) {
+void *io_mmap_file(char *filename, size_t *file_size) {
   /* open file */
-  *fd = open(filename, O_RDWR);
-  if (*fd == -1)
+  int fd = open(filename, O_RDWR);
+  if (fd == -1)
     error("Unable to open file %s (%s)", filename, strerror(errno));
 
   /* get file size */
-  size_t size = 0;
-  io_get_file_size(*fd, &size);
+  *file_size = 0;
+  io_get_file_size(fd, file_size);
 
   /* map memory */
-  *map = mmap(NULL, size, PROT_WRITE | PROT_READ, MAP_SHARED, *fd, 0);
+  void *map = mmap(NULL, *file_size, PROT_WRITE | PROT_READ, MAP_SHARED, fd, 0);
   if (map == MAP_FAILED)
-    error("Failed to allocate map of size %zi bytes. (%s)", size,
+    error("Failed to allocate map of size %zi bytes. (%s)", *file_size,
           strerror(errno));
+
+  close(fd);
+
+  return map;
 }
 
 /**
- * @brief Close a file and unmap it
+ * @brief Unmap a file
  *
- * @param fd file id
  * @param map file mapping
+ * @param file_size The file size.
  *
  */
-void io_close_file(int *fd, void **map) {
-  /* get file size */
-  size_t size = 0;
-  io_get_file_size(*fd, &size);
-
+void io_munmap_file(void *map, size_t file_size) {
   /* unmap */
-  if (munmap(*map, size) != 0) {
+  if (munmap(map, file_size) != 0) {
     error("Unable to unmap the file (%s)", strerror(errno));
   }
 
-  close(*fd);
 }

logger/logger_io.h

@@ -29,8 +29,8 @@
 #include <stdlib.h>
 
 void io_get_file_size(int fd, size_t *size);
-void io_open_file(char *filename, int *fd, void **map);
-void io_close_file(int *fd, void **map);
+void *io_mmap_file(char *filename, size_t *file_size);
+void io_munmap_file(void *map, size_t file_size);
 
 /**
  * @brief read a mask with its offset

logger/logger_particle.c

@@ -152,7 +152,9 @@ void logger_particle_read(struct logger_particle *part, const struct header *h,
   /* read next particle */
   struct logger_particle part_next;
 
-  if (!h->forward_offset) error("TODO");
+  if (!header_are_offset_forward(h)) {
+    error("Cannot read a particle with non forward offsets.");
+  }
 
   if (h_offset == 0) return;
   /* get absolute offset of next particle */

logger/logger_python_wrapper.c

@@ -41,8 +41,6 @@
 static PyObject *loadFromIndex(__attribute__((unused)) PyObject *self,
                                PyObject *args) {
 
-  struct header h;
-
   /* input */
   PyArrayObject *offset = NULL;
   char *filename = NULL;
@@ -76,87 +74,64 @@ static PyObject *loadFromIndex(__attribute__((unused)) PyObject *self,
     error("Offset does not contain unsigned int");
   }
 
-  /* open file */
-  int fd;
-  void *map;
-  io_open_file(filename, &fd, &map);
-
-  /* read header */
-  header_read(&h, map);
-
-  /* reverse offset if needed */
-  if (!h.forward_offset) {
-    io_close_file(&fd, &map);
-
-    reverse_offset(filename, verbose);
-
-    io_open_file(filename, &fd, &map);
-
-    /* Reset header */
-    header_free(&h);
-
-    header_read(&h, map);
-  }
-
-  /* read timestamps */
-  struct time_array times;
-
-  time_array_init(&times, &h, map, fd);
-
-  if (verbose > 0) {
-    time_array_print(&times);
-  }
-
-  /* get required time */
-  double time = time_array_get_time(&times, time_offset);
+  /* initialize the reader */
+  verbose = 2;
+  struct logger_reader reader;
+  logger_reader_init(&reader, filename, verbose);
+  struct header *h = &reader.dump.header;
 
   /* init array */
   npy_intp dim[2];
   dim[0] = PyArray_DIMS(offset)[0];
   dim[1] = DIM;
 
+  /* Get required time. */
+  double time = time_array_get_time(&reader.dump.times, time_offset);
+
   /* init output */
-  if (header_get_field_index(&h, "positions") != -1) {
+  if (header_get_field_index(h, "positions") != -1) {
     pos = (PyArrayObject *)PyArray_SimpleNew(2, dim, NPY_DOUBLE);
   }
 
-  if (header_get_field_index(&h, "velocities") != -1) {
+  if (header_get_field_index(h, "velocities") != -1) {
     vel = (PyArrayObject *)PyArray_SimpleNew(2, dim, NPY_FLOAT);
   }
 
-  if (header_get_field_index(&h, "accelerations") != -1) {
+  if (header_get_field_index(h, "accelerations") != -1) {
     acc = (PyArrayObject *)PyArray_SimpleNew(2, dim, NPY_FLOAT);
   }
 
-  if (header_get_field_index(&h, "entropy") != -1) {
+  if (header_get_field_index(h, "entropy") != -1) {
     entropy =
         (PyArrayObject *)PyArray_SimpleNew(1, PyArray_DIMS(offset), NPY_FLOAT);
   }
 
-  if (header_get_field_index(&h, "smoothing length") != -1) {
+  if (header_get_field_index(h, "smoothing length") != -1) {
     h_sph =
         (PyArrayObject *)PyArray_SimpleNew(1, PyArray_DIMS(offset), NPY_FLOAT);
   }
 
-  if (header_get_field_index(&h, "density") != -1) {
+  if (header_get_field_index(h, "density") != -1) {
     rho =
         (PyArrayObject *)PyArray_SimpleNew(1, PyArray_DIMS(offset), NPY_FLOAT);
   }
 
-  if (header_get_field_index(&h, "consts") != -1) {
+  if (header_get_field_index(h, "consts") != -1) {
     mass =
         (PyArrayObject *)PyArray_SimpleNew(1, PyArray_DIMS(offset), NPY_FLOAT);
     id = (PyArrayObject *)PyArray_SimpleNew(1, PyArray_DIMS(offset), NPY_ULONG);
   }
 
+  if (verbose > 1)
+    message("Reading particles.");
   /* loop over all particles */
   for (npy_intp i = 0; i < PyArray_DIMS(offset)[0]; i++) {
     struct logger_particle part;
 
     size_t *offset_particle = (size_t *)PyArray_GETPTR1(offset, i);
 
-    logger_particle_read(&part, &h, map, offset_particle, time,
-                         logger_reader_lin, &times);
+    logger_particle_read(&part, &reader.dump.header, reader.dump.dump.map, offset_particle, time,
+                         logger_reader_lin, &reader.dump.times);
 
     double *dtmp;
     float *ftmp;
@@ -206,7 +181,8 @@ static PyObject *loadFromIndex(__attribute__((unused)) PyObject *self,
     }
   }
 
-  header_free(&h);
+  /* Free the memory */
+  logger_reader_free(&reader);
 
   /* construct return */
   PyObject *dict = PyDict_New();
@@ -248,8 +224,6 @@ static PyObject *loadFromIndex(__attribute__((unused)) PyObject *self,
     PyDict_SetItem(dict, key, PyArray_Return(id));
   }
 
-  io_close_file(&fd, &map);
-
   return dict;
 }
 
@@ -270,7 +244,12 @@ static PyObject *pyReverseOffset(__attribute__((unused)) PyObject *self,
 
   if (!PyArg_ParseTuple(args, "s|i", &filename, &verbose)) return NULL;
 
-  reverse_offset(filename, verbose);
+  /* initialize the reader (and reverse the offset if necessary) */
+  struct logger_reader reader;
+  logger_reader_init(&reader, filename, verbose);
+
+  /* Free the reader */
+  logger_reader_free(&reader);
 
   return Py_BuildValue("");
 }

logger/logger_reader.c

@@ -16,87 +16,35 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  ******************************************************************************/
-#include "logger_header.h"
-#include "logger_io.h"
+
+#include "logger_reader.h"
 
 /**
- * @brief Reverse offset in dump file
+ * @brief Initialize the reader.
  *
- * @param filename string filename of the dump file
- * @param verbose Verbose level
+ * @param reader The #logger_reader.
+ * @param filename The dump filename.
+ * @param verbose The verbose level.
  */
-void reverse_offset(char *filename, int verbose) {
-  struct header h;
-
-  /* open file */
-  int fd;
-  void *map;
-  io_open_file(filename, &fd, &map);
-
-  /* read header */
-  header_read(&h, map);
-
-  if (verbose > 0) {
-    header_print(&h);
-  }
-
-  /* check offset direction */
-  if (h.forward_offset) {
-    error("Offset are already reversed");
-  }
-
-  /* compute file size */
-  size_t sz;
-  io_get_file_size(fd, &sz);
-
-  size_t offset;
-
-#ifdef SWIFT_DEBUG_CHECKS
-  /* check offset */
-  if (verbose > 0) {
-    message("Check offsets...\n");
-  }
-  offset = h.offset_first;
-  while (offset < sz) {
-    tools_check_offset(&h, map, &offset);
-  }
-  if (verbose > 0) {
-    message("Check done\n");
-  }
-#endif
+void logger_reader_init(struct logger_reader *reader, char *filename, int verbose) {
+  if (verbose > 1)
+    message("Initializing the reader");
+  /* Initialize the reader variables */
+  reader->verbose = verbose;
 
-  /* reverse header offset */
-  header_change_offset_direction(&h, map);
+  /* Initialize the dump */
+  logger_dump_init(&reader->dump, filename, reader);
 
-  offset = h.offset_first;
-
-  /* reverse chunks */
-  if (verbose > 0) {
-    message("Reversing offsets...\n");
-  }
-  while (offset < sz) {
-    tools_reverse_offset(&h, map, &offset);
-  }
-  if (verbose > 0) {
-    message("Reversing done\n");
-  }
-
-#ifdef SWIFT_DEBUG_CHECKS
-  /* check offset */
-  if (verbose > 0) {
-    message("Check offsets...\n");
-  }
-  offset = h.offset_first;
-  while (offset < sz) {
-    tools_check_offset(&h, map, &offset);
-  }
-  if (verbose > 0) {
-    message("Check done\n");
-  }
-#endif
-
-  /* free internal variables */
-  header_free(&h);
+  if (verbose > 1)
+    message("Initialization done.");
+}
 
-  io_close_file(&fd, &map);
+/**
+ * @brief Free the reader.
+ *
+ * @param reader The #logger_reader.
+ */
+void logger_reader_free(struct logger_reader *reader) {
+  /* Free the dump */
+  logger_dump_free(&reader->dump);
 }

logger/logger_reader.h

@@ -22,6 +22,28 @@
 #ifndef __LOGGER_LOGGER_READER_H__
 #define __LOGGER_LOGGER_READER_H__
 
-void reverse_offset(char *filename, int verbose);
+#include "logger_dump.h"
+#include "logger_index.h"
+
+/**
+ * @brief Main structure of the logger.
+ *
+ * This structure contains all the variables required for the logger.
+ * It should be the only structure that the user see.
+ */
+struct logger_reader {
+
+  /* Information contained in the index file */
+  struct logger_index index;
+  
+  /* Informations contained in the file header */
+  struct logger_dump dump;
+
+  /* Level of verbosity */
+  int verbose;
+};
+
+void logger_reader_init(struct logger_reader *reader, char *filename, int verbose);
+void logger_reader_free(struct logger_reader *reader);
 
 #endif  // __LOGGER_LOGGER_READER_H__

logger/logger_time.c

@@ -18,6 +18,8 @@
  ******************************************************************************/
 #include "logger_time.h"
 #include "logger_io.h"
+#include "logger_dump.h"
+#include "logger_reader.h"
 
 /**
  * @brief read a time stamp
@@ -79,41 +81,37 @@ void time_first_timestamp(const struct header *h, void *map, size_t *offset) {
 }
 
 /**
- * @brief Initialize a time array
+ * @brief Initialize a time array.
  *
- * @param t #time_array to initialize
- * @param h #header file structure
- * @param map file mapping
- * @param fd file id
+ * @param t #time_array to initialize.
+ * @param dump The #logger_dump.
  */
-void time_array_init(struct time_array *t, const struct header *h, void *map,
-                     int fd) {
+void time_array_init(struct time_array *t, struct logger_dump *dump) {
 
   t->next = NULL;
   t->prev = NULL;
 
   /* get first time stamp */
   size_t offset = 0;
-  time_first_timestamp(h, map, &offset);
+  time_first_timestamp(&dump->header, dump->dump.map, &offset);
 
   integertime_t timestamp = 0;
   double time = 0;
 
   /* get file size */
-  size_t file_size;
-  io_get_file_size(fd, &file_size);
+  size_t file_size = dump->dump.file_size;
 
   while (offset < file_size) {
-
     /* read time */
     t->offset = offset;
     size_t tmp_offset = offset;
-    time_read(&timestamp, &time, h, map, &tmp_offset);
+    time_read(&timestamp, &time, &dump->header, dump->dump.map, &tmp_offset);
     t->timestamp = timestamp;
     t->time = time;
 
     /* get next chunk */
-    int test = tools_get_next_chunk(h, map, &offset, fd);
+    int test = tools_get_next_chunk(&dump->header, dump->dump.map, &offset,
+				    dump->dump.file_size);
     if (test == -1) break;
 
     /* allocate next time_array */

logger/logger_time.h

@@ -61,8 +61,7 @@ struct time_array {
 
 void time_read(integertime_t *timestamp, double *time, const struct header *h,
                void *map, size_t *offset);
-void time_array_init(struct time_array *t, const struct header *h, void *map,
-                     int fd);
+void time_array_init(struct time_array *t, struct logger_dump *dump);
 integertime_t time_array_get_integertime(struct time_array *t,
                                          const size_t offset);
 double time_array_get_time(struct time_array *t, const size_t offset);

logger/logger_tools.c

@@ -30,16 +30,18 @@
  * @param h #header structure of the file
  * @param map file mapping
  * @param offset In: initial offset, Out: offset of the next chunk
- * @param fd file id
+ * @param file_size The file size.
  *
  * @return -1 if no next chunk, otherwise 0
  */
 int tools_get_next_chunk(const struct header *h, void *map, size_t *offset,
-                         int fd) {
-  if (h->forward_offset)
+                         size_t file_size) {
+  if (header_are_offset_forward(h))
     return _tools_get_next_chunk_forward(h, map, offset);
+  if (header_are_offset_backward(h))
+    return _tools_get_next_chunk_backward(h, map, offset, file_size);
   else
-    return _tools_get_next_chunk_backward(h, map, offset, fd);
+    error("Offsets are corrupted");
 }
 
 /**
@@ -72,21 +74,18 @@ int _tools_get_next_chunk_forward(const struct header *h, void *map,
  * @param h #header structure of the file
  * @param map file mapping
  * @param offset In: initial offset, Out: offset of the next chunk
- * @param fd file id
+ * @param file_size The file size.
  *
  * @return error code, -1 if no next chunk
  */
 int _tools_get_next_chunk_backward(const struct header *h, void *map,
-                                   size_t *offset, int fd) {
+                                   size_t *offset, size_t file_size) {
 #ifndef SWIFT_DEBUG_CHECKS
   error("Should not be used, method too slow");
 #endif
   size_t current_offset = *offset;
   size_t chunk_header = LOGGER_MASK_SIZE + LOGGER_OFFSET_SIZE;
 
-  size_t file_size = 0;
-  io_get_file_size(fd, &file_size);
-
   while (current_offset < file_size) {
     size_t mask = 0;
     size_t prev_offset;
@@ -177,14 +176,17 @@ void tools_check_offset(const struct header *h, void *map, size_t *offset) {
   io_read_mask(h, map, offset, &mask, &pointed_offset);
 
   /* get absolute offset */
-  if (h->forward_offset)
+  if (header_are_offset_forward(h))
     pointed_offset += tmp;
-  else {
+  if (header_are_offset_backward(h)) {
     if (tmp < pointed_offset)
       error("Offset too large (%lu) at %lu with mask %lu", pointed_offset, tmp,
             mask);
     pointed_offset = tmp - pointed_offset;
   }
+  else {
+    error("Offset are corrupted");
+  }
 
   /* set offset after current chunk */
   *offset += header_get_mask_size(h, mask);

logger/logger_tools.h

@@ -57,9 +57,9 @@ struct header;
   })
 
 int tools_get_next_chunk(const struct header *h, void *map, size_t *offset,
-                         int fd);
+                         size_t file_size);
 int _tools_get_next_chunk_backward(const struct header *h, void *map,
-                                   size_t *offset, int fd);
+                                   size_t *offset, size_t file_size);
 int _tools_get_next_chunk_forward(const struct header *h, void *map,
                                   size_t *offset);
 void tools_reverse_offset(const struct header *h, void *map, size_t *offset);