diff --git a/logger/Makefile.am b/logger/Makefile.am
index e536adf2fba194f71cf60fe233072deb3944909f..cbeb4ca98041f1d4f29cbb0254db6709616c2bfe 100644
--- a/logger/Makefile.am
+++ b/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
diff --git a/logger/logger_dump.c b/logger/logger_dump.c
new file mode 100644
index 0000000000000000000000000000000000000000..2c21bd42c1d147209fb614286d4d07c7bcd5b8a8
--- /dev/null
+++ b/logger/logger_dump.c
@@ -0,0 +1,149 @@
+/*******************************************************************************
+ * 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
+
+}
diff --git a/logger/logger_dump.h b/logger/logger_dump.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab66c05daaa37a6b6effffa307ad98c5257ca44d
--- /dev/null
+++ b/logger/logger_dump.h
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * 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__
diff --git a/logger/logger_header.c b/logger/logger_header.c
index e322d1413592bf805ff075d24fe96acd514707e1..d78fbe08934efa0dc57651ffdb2f00b4e7e071be 100644
--- a/logger/logger_header.c
+++ b/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;
diff --git a/logger/logger_header.h b/logger/logger_header.h
index d26aaa617e8bd1b221e158a1558e369e7219cdd1..6e18c82e3654e9adc47ec8b7bc8532e5b342a022 100644
--- a/logger/logger_header.h
+++ b/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__
diff --git a/logger/logger_index.h b/logger/logger_index.h
new file mode 100644
index 0000000000000000000000000000000000000000..59b4b6457d4259858b9b6fe4c378776288ad7990
--- /dev/null
+++ b/logger/logger_index.h
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * 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__
diff --git a/logger/logger_io.c b/logger/logger_io.c
index 955ac5854cd5dd4a24888a413cc09bb4cac8fc18..9b82d273828b73eeed839e9a9b29511f158edecc 100644
--- a/logger/logger_io.c
+++ b/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);
}
diff --git a/logger/logger_io.h b/logger/logger_io.h
index f77725e7e040089a19196856e0b098c9828f3fee..e1f69c7f1ccc85791f093b710133a403c23ec5ba 100644
--- a/logger/logger_io.h
+++ b/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
diff --git a/logger/logger_particle.c b/logger/logger_particle.c
index de73d7a4c280f71a33e3988ea09b0e43a6e0f60a..fa2ed36e9a201d52a0c2eac80d5dcbea2e9c139f 100644
--- a/logger/logger_particle.c
+++ b/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 */
diff --git a/logger/logger_python_wrapper.c b/logger/logger_python_wrapper.c
index 1aed9689c92895b2c78a137d09e5cbcfded119f1..d390511755e743e88aa34d9a853eab129e89b082 100644
--- a/logger/logger_python_wrapper.c
+++ b/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(×, &h, map, fd);
-
- if (verbose > 0) {
- time_array_print(×);
- }
-
- /* get required time */
- double time = time_array_get_time(×, 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, ×);
+ 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("");
}
diff --git a/logger/logger_reader.c b/logger/logger_reader.c
index 58b7f0be6e68794a6f3b9a9763102f51eaa11271..1adb7540f8a2cf629302b5f560a4816d276dc86b 100644
--- a/logger/logger_reader.c
+++ b/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);
}
diff --git a/logger/logger_reader.h b/logger/logger_reader.h
index 7d902d6e2df431df445680f5521dd44e9a4ff5fe..5c6bac4f8b22aed49fff48eee3aa3cb8cdafa688 100644
--- a/logger/logger_reader.h
+++ b/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__
diff --git a/logger/logger_time.c b/logger/logger_time.c
index ac98a9413bd8b4df445ff5d1cb1960aa2d4f567c..71247341c0e9cdd1b2838be08ebaf1287073b61f 100644
--- a/logger/logger_time.c
+++ b/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(×tamp, &time, h, map, &tmp_offset);
+ time_read(×tamp, &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 */
diff --git a/logger/logger_time.h b/logger/logger_time.h
index 05940b6108fe73a5e5219a09a7d9fc8bdc18103e..004c3b4e3e9e83a1bfa8cf840951dc0e97686349 100644
--- a/logger/logger_time.h
+++ b/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);
diff --git a/logger/logger_tools.c b/logger/logger_tools.c
index aa9a7cdd4eb3e018144a30eb2dea3518965490e8..112a000d64fac5b8ff86f9a470dc4fc006f4b5c4 100644
--- a/logger/logger_tools.c
+++ b/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);
diff --git a/logger/logger_tools.h b/logger/logger_tools.h
index aecb788d658d1e7b7c2bbce31438ec40810bf18b..7bdaeb8f9323224e79f56b096ec665b6266dab08 100644
--- a/logger/logger_tools.h
+++ b/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);