Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
SWIFT
SWIFTsim
Commits
256a6a78
Commit
256a6a78
authored
Nov 09, 2018
by
Loic Hausammann
Browse files
Remove logger_parameters and update the header
parent
7fcb2228
Changes
2
Hide whitespace changes
Inline
Side-by-side
src/logger.c
View file @
256a6a78
...
...
@@ -40,28 +40,25 @@
#include
"part.h"
#include
"units.h"
/*
header constants
/*
* Thoses are definitions from the format and therefore should not be changed!
* Size in bytes
*/
/*
size of
a mask */
/*
number of bytes for
a mask */
#define logger_mask_size 1
/*
size of
an offset */
/*
number bytes for
an offset */
#define logger_offset_size 7
/*
size of
the version information */
/*
number of bytes for
the version information */
#define logger_version_size 20
/*
size of the size information
*/
#define logger_
header_num
be
r
_size 2
/*
number of bytes for the labels in the header
*/
#define logger_
la
be
l
_size 2
0
char
logger_version
[
logger_version_size
]
=
"0.1"
;
/* number of bytes for the number in the header */
#define logger_number_size 4
const
unsigned
int
logger_datatype_size
[
logger_data_count
]
=
{
sizeof
(
int
),
sizeof
(
float
),
sizeof
(
double
),
sizeof
(
char
),
sizeof
(
long
long
),
1
,
};
char
logger_version
[
logger_version_size
]
=
"0.1"
;
/**
* @brief Write the header of a chunk (offset + mask).
...
...
@@ -104,39 +101,8 @@ void logger_write_data(struct dump *d, size_t *offset, size_t size,
/* write data to the buffer */
memcpy
(
buff
,
p
,
size
);
}
/**
* @brief Write a parameter to the file
*
* TODO Make it thread safe or remove it.
*
* write data in the following order: name, data type, data.
* It should be used only for the file header.
*
* @param d #dump file
* @param params #logger_parameters file format informations
* @param offset (return) offset of the next chunk
* @param p pointer to the data
* @param name Label of the parameter (should be smaller than log->name)
* @param data_type #logger_datatype to write
*/
void
logger_write_general_data
(
struct
dump
*
d
,
const
struct
logger_parameters
*
params
,
size_t
*
offset
,
const
void
*
p
,
char
*
name
,
size_t
data_type
)
{
/* write name */
logger_write_data
(
d
,
offset
,
params
->
label_size
,
name
);
/* write data type */
logger_write_data
(
d
,
offset
,
params
->
data_type_size
,
&
data_type
);
/* write value */
if
(
data_type
>=
logger_data_count
)
error
(
"Not implemented"
);
size_t
size
=
logger_datatype_size
[
data_type
];
logger_write_data
(
d
,
offset
,
size
,
p
);
/* Update offset to end of chunk */
*
offset
+=
size
;
}
...
...
@@ -414,10 +380,8 @@ void logger_log_timestamp(struct logger *log, integertime_t timestamp,
void
logger_ensure_size
(
struct
logger
*
log
,
size_t
total_nr_parts
,
size_t
total_nr_gparts
,
size_t
total_nr_sparts
)
{
struct
logger_parameters
*
log_params
=
log
->
params
;
/* count part memory */
size_t
limit
=
log
_params
->
total
_size
;
size_t
limit
=
log
->
max_chunk
_size
;
limit
*=
total_nr_parts
;
...
...
@@ -431,6 +395,142 @@ void logger_ensure_size(struct logger *log, size_t total_nr_parts,
dump_ensure
(
log
->
dump
,
limit
,
log
->
buffer_scale
*
limit
);
}
/**
* @brief Generate a list of the mask size.
*
* This function requires a call to free on the pointer.
*
* @param log The #logger.
*/
int
*
logger_get_list_mask_size
(
const
struct
logger
*
log
)
{
int
*
output
=
malloc
(
sizeof
(
int
)
*
log
->
number_masks
);
if
(
output
==
NULL
)
error
(
"Unable to allocate memory"
);
/* Position */
output
[
0
]
=
3
*
sizeof
(
double
);
/* Velocity */
output
[
1
]
=
3
*
sizeof
(
float
);
/* Acceleration */
output
[
2
]
=
3
*
sizeof
(
float
);
/* Internal Energy */
output
[
3
]
=
sizeof
(
float
);
/* Smoothing Length */
output
[
4
]
=
sizeof
(
float
);
/* Density */
output
[
5
]
=
sizeof
(
float
);
/* Constants */
output
[
6
]
=
sizeof
(
float
)
+
sizeof
(
long
long
);
/* Time stamp */
output
[
7
]
=
sizeof
(
integertime_t
)
+
sizeof
(
double
);
return
output
;
}
/**
* @brief Generate a list of the mask names.
*
* This function requires a call to free on the pointer.
*
* @param log The #logger.
*/
char
*
logger_get_list_mask_name
(
const
struct
logger
*
log
)
{
size_t
block_size
=
logger_label_size
*
log
->
number_masks
;
char
*
output
=
malloc
(
block_size
);
if
(
output
==
NULL
)
error
(
"Unable to allocate memory"
);
char
*
cur_name
=
output
;
/* set the mask names */
char
tmp
[
logger_label_size
];
strcpy
(
tmp
,
"position"
);
memcpy
(
cur_name
,
&
tmp
,
logger_label_size
);
cur_name
+=
logger_label_size
;
strcpy
(
tmp
,
"velocity"
);
memcpy
(
cur_name
,
&
tmp
,
logger_label_size
);
cur_name
+=
logger_label_size
;
strcpy
(
tmp
,
"acceleration"
);
memcpy
(
cur_name
,
&
tmp
,
logger_label_size
);
cur_name
+=
logger_label_size
;
strcpy
(
tmp
,
"entropy"
);
memcpy
(
cur_name
,
&
tmp
,
logger_label_size
);
cur_name
+=
logger_label_size
;
strcpy
(
tmp
,
"cutoff radius"
);
memcpy
(
cur_name
,
&
tmp
,
logger_label_size
);
cur_name
+=
logger_label_size
;
strcpy
(
tmp
,
"density"
);
memcpy
(
cur_name
,
&
tmp
,
logger_label_size
);
cur_name
+=
logger_label_size
;
strcpy
(
tmp
,
"consts"
);
memcpy
(
cur_name
,
&
tmp
,
logger_label_size
);
cur_name
+=
logger_label_size
;
strcpy
(
tmp
,
"timestamp"
);
memcpy
(
cur_name
,
&
tmp
,
logger_label_size
);
cur_name
+=
logger_label_size
;
return
output
;
}
/**
* @brief Generate a list of the masks.
*
* This function requires a call to free on the pointer.
*
* @param log The #logger.
*/
int
*
logger_get_list_mask
(
const
struct
logger
*
log
)
{
int
*
output
=
malloc
(
sizeof
(
int
)
*
log
->
number_masks
);
if
(
output
==
NULL
)
error
(
"Unable to allocate memory"
);
/* Position */
output
[
0
]
=
logger_mask_x
;
/* Velocity */
output
[
1
]
=
logger_mask_v
;
/* Acceleration */
output
[
2
]
=
logger_mask_a
;
/* Internal Energy */
output
[
3
]
=
logger_mask_u
;
/* Smoothing Length */
output
[
4
]
=
logger_mask_h
;
/* Density */
output
[
5
]
=
logger_mask_rho
;
/* Constants */
output
[
6
]
=
logger_mask_consts
;
/* Time stamp */
output
[
7
]
=
logger_mask_timestamp
;
return
output
;
}
/**
* @brief Compute the maximal size of a chunk.
*
* @param log The #logger.
*/
int
logger_compute_max_chunk_size
(
const
struct
logger
*
log
)
{
int
*
output
=
logger_get_list_mask_size
(
log
);
int
max_size
=
logger_offset_size
+
logger_mask_size
;
/* Loop over all fields except timestamp */
for
(
int
i
=
0
;
i
<
log
->
number_masks
-
1
;
i
++
)
{
max_size
+=
output
[
i
];
}
free
(
output
);
return
max_size
;
}
/**
* @brief intialize the logger structure
*
...
...
@@ -455,11 +555,10 @@ void logger_init(struct logger *log, struct swift_params *params) {
strcpy
(
logger_name_file
,
log
->
base_name
);
strcat
(
logger_name_file
,
".dump"
);
/* init parameters */
log
->
params
=
(
struct
logger_parameters
*
)
malloc
(
sizeof
(
struct
logger_parameters
));
logger_parameters_init
(
log
->
params
);
/* Define some constants */
log
->
number_masks
=
8
;
log
->
max_chunk_size
=
logger_compute_max_chunk_size
(
log
);
/* init dump */
log
->
dump
=
malloc
(
sizeof
(
struct
dump
));
struct
dump
*
dump_file
=
log
->
dump
;
...
...
@@ -474,8 +573,8 @@ void logger_init(struct logger *log, struct swift_params *params) {
*/
void
logger_clean
(
struct
logger
*
log
)
{
dump_close
(
log
->
dump
);
logger_parameters_clean
(
log
->
params
);
free
(
log
->
params
)
;
free
(
log
->
dump
);
log
->
dump
=
NULL
;
}
/**
...
...
@@ -488,7 +587,6 @@ void logger_clean(struct logger *log) {
void
logger_write_file_header
(
struct
logger
*
log
,
const
struct
engine
*
e
)
{
/* get required variables */
const
struct
logger_parameters
log_params
=
*
log
->
params
;
struct
dump
*
dump
=
log
->
dump
;
size_t
file_offset
=
dump
->
file_offset
;
...
...
@@ -501,167 +599,47 @@ void logger_write_file_header(struct logger *log, const struct engine *e) {
/* Write version information */
logger_write_data
(
dump
,
&
file_offset
,
logger_version_size
,
&
logger_version
);
/* write number of bytes used for the offsets */
logger_write_data
(
dump
,
&
file_offset
,
logger_header_number_size
,
&
log_params
.
offset_size
);
/* write offset direction */
int
reversed
=
0
;
logger_write_data
(
dump
,
&
file_offset
,
logger_
datatype_size
[
logger_data_bool
]
,
const
int
reversed
=
0
;
logger_write_data
(
dump
,
&
file_offset
,
logger_
number_size
,
&
reversed
);
/* placeholder to write the offset of the first log here */
char
*
skip_header
=
dump_get
(
dump
,
log
_params
.
offset_size
,
&
file_offset
);
char
*
skip_header
=
dump_get
(
dump
,
log
ger_
offset_size
,
&
file_offset
);
/* write number of bytes used for names */
logger_write_data
(
dump
,
&
file_offset
,
logger_header_number_size
,
&
log_params
.
label_size
);
/* write number of bytes used for numbers */
logger_write_data
(
dump
,
&
file_offset
,
logger_header_number_size
,
&
log_params
.
number_size
);
/* write number of bytes used for masks */
logger_write_data
(
dump
,
&
file_offset
,
logger_header_number_size
,
&
log_params
.
mask_size
);
const
int
label_size
=
logger_label_size
;
logger_write_data
(
dump
,
&
file_offset
,
logger_number_size
,
&
label_size
);
/* write number of masks */
logger_write_data
(
dump
,
&
file_offset
,
log_params
.
number_size
,
&
log_params
.
number_mask
);
logger_write_data
(
dump
,
&
file_offset
,
logger_number_size
,
&
log
->
number_masks
);
/* Get masks informations */
int
*
mask_sizes
=
logger_get_list_mask_size
(
log
);
int
*
masks
=
logger_get_list_mask
(
log
);
char
*
mask_names
=
logger_get_list_mask_name
(
log
);
/* write masks */
// loop over all mask type
for
(
size_
t
i
=
0
;
i
<
log
_params
.
number_mask
;
i
++
)
{
for
(
in
t
i
=
0
;
i
<
log
->
number_mask
s
;
i
++
)
{
// mask name
size_t
j
=
i
*
log_params
.
label_size
;
logger_write_data
(
dump
,
&
file_offset
,
log_params
.
label_size
,
&
log_params
.
masks_name
[
j
]);
// mask
logger_write_data
(
dump
,
&
file_offset
,
log_params
.
mask_size
,
&
log_params
.
masks
[
i
]);
size_t
j
=
i
*
logger_label_size
;
logger_write_data
(
dump
,
&
file_offset
,
logger_label_size
,
&
mask_names
[
j
]);
// mask size
logger_write_data
(
dump
,
&
file_offset
,
log
_params
.
number_size
,
&
log_params
.
masks_data
_size
[
i
]);
logger_write_data
(
dump
,
&
file_offset
,
log
ger_
number_size
,
&
mask
_size
s
[
i
]);
}
/* write mask data */
// TODO
/* loop over each mask and each data in this mask */
/* write number of bytes for each field */
/* write data type (float, double, ...) */
/* write data name (mass, id, ...) */
/* Write data */
char
*
name
=
malloc
(
sizeof
(
char
)
*
log_params
.
label_size
);
strcpy
(
name
,
"time_base"
);
logger_write_general_data
(
dump
,
&
log_params
,
&
file_offset
,
&
e
->
time_base
,
name
,
logger_data_double
);
/* cleanup memory */
free
(
mask_sizes
);
free
(
masks
);
free
(
mask_names
);
/* last step: write first offset */
memcpy
(
skip_header
,
&
file_offset
,
log_params
.
offset_size
);
/* free memory */
free
(
name
);
}
/**
* @brief initialize the #logger_parameters with the format informations
*
* @param log_params #logger_parameters to initialize
*/
void
logger_parameters_init
(
struct
logger_parameters
*
log_params
)
{
/* set parameters */
log_params
->
label_size
=
20
;
log_params
->
offset_size
=
7
;
log_params
->
mask_size
=
1
;
log_params
->
number_size
=
1
;
log_params
->
data_type_size
=
1
;
log_params
->
number_mask
=
8
;
/* set masks array */
log_params
->
masks
=
malloc
(
sizeof
(
size_t
)
*
log_params
->
number_mask
);
log_params
->
masks
[
0
]
=
logger_mask_x
;
log_params
->
masks
[
1
]
=
logger_mask_v
;
log_params
->
masks
[
2
]
=
logger_mask_a
;
log_params
->
masks
[
3
]
=
logger_mask_u
;
log_params
->
masks
[
4
]
=
logger_mask_h
;
log_params
->
masks
[
5
]
=
logger_mask_rho
;
log_params
->
masks
[
6
]
=
logger_mask_consts
;
log_params
->
masks
[
7
]
=
logger_mask_timestamp
;
/* set the mask names */
size_t
block_size
=
log_params
->
label_size
*
log_params
->
number_mask
;
log_params
->
masks_name
=
malloc
(
block_size
);
char
*
cur_name
=
log_params
->
masks_name
;
char
tmp
[
log_params
->
label_size
];
strcpy
(
tmp
,
"position"
);
memcpy
(
cur_name
,
&
tmp
,
log_params
->
label_size
);
cur_name
+=
log_params
->
label_size
;
strcpy
(
tmp
,
"velocity"
);
memcpy
(
cur_name
,
&
tmp
,
log_params
->
label_size
);
cur_name
+=
log_params
->
label_size
;
strcpy
(
tmp
,
"acceleration"
);
memcpy
(
cur_name
,
&
tmp
,
log_params
->
label_size
);
cur_name
+=
log_params
->
label_size
;
strcpy
(
tmp
,
"entropy"
);
memcpy
(
cur_name
,
&
tmp
,
log_params
->
label_size
);
cur_name
+=
log_params
->
label_size
;
strcpy
(
tmp
,
"cutoff radius"
);
memcpy
(
cur_name
,
&
tmp
,
log_params
->
label_size
);
cur_name
+=
log_params
->
label_size
;
strcpy
(
tmp
,
"density"
);
memcpy
(
cur_name
,
&
tmp
,
log_params
->
label_size
);
cur_name
+=
log_params
->
label_size
;
strcpy
(
tmp
,
"consts"
);
memcpy
(
cur_name
,
&
tmp
,
log_params
->
label_size
);
cur_name
+=
log_params
->
label_size
;
strcpy
(
tmp
,
"timestamp"
);
memcpy
(
cur_name
,
&
tmp
,
log_params
->
label_size
);
cur_name
+=
log_params
->
label_size
;
/* set the data size */
log_params
->
masks_data_size
=
malloc
(
sizeof
(
size_t
)
*
log_params
->
number_mask
);
log_params
->
masks_data_size
[
0
]
=
3
*
sizeof
(
double
);
log_params
->
masks_data_size
[
1
]
=
3
*
sizeof
(
float
);
log_params
->
masks_data_size
[
2
]
=
3
*
sizeof
(
float
);
log_params
->
masks_data_size
[
3
]
=
sizeof
(
float
);
log_params
->
masks_data_size
[
4
]
=
sizeof
(
float
);
log_params
->
masks_data_size
[
5
]
=
sizeof
(
float
);
log_params
->
masks_data_size
[
6
]
=
sizeof
(
float
)
+
sizeof
(
long
long
);
log_params
->
masks_data_size
[
7
]
=
sizeof
(
integertime_t
)
+
sizeof
(
double
);
/* Compute the size of a chunk if all the mask are activated */
log_params
->
total_size
=
logger_offset_size
+
logger_mask_size
;
for
(
size_t
i
=
0
;
i
<
log_params
->
number_mask
;
i
++
)
{
if
(
log_params
->
masks
[
i
]
!=
logger_mask_timestamp
)
log_params
->
total_size
+=
log_params
->
masks_data_size
[
i
];
}
// todo masks_type
}
/**
* @brief Clean the #logger_parameters
*
* @param log_params The #logger_parameters
*/
void
logger_parameters_clean
(
struct
logger_parameters
*
log_params
)
{
free
(
log_params
->
masks
);
free
(
log_params
->
masks_name
);
free
(
log_params
->
masks_data_size
);
memcpy
(
skip_header
,
&
file_offset
,
logger_offset_size
);
}
/**
...
...
src/logger.h
View file @
256a6a78
...
...
@@ -81,45 +81,12 @@ enum logger_masks {
logger_mask_h
=
(
1
<<
4
),
logger_mask_rho
=
(
1
<<
5
),
logger_mask_consts
=
(
1
<<
6
),
logger_mask_timestamp
=
(
1
<<
7
),
logger_mask_timestamp
=
(
1
<<
7
),
/* Need to be the last */
};
/* Size of the strings. */
#define logger_string_length 200
/* parameters of the logger */
struct
logger_parameters
{
/* size of a label in bytes */
size_t
label_size
;
/* size of an offset in bytes */
size_t
offset_size
;
/* size of a mask in bytes */
size_t
mask_size
;
/* size of a number in bytes */
size_t
number_size
;
/* size of a data type in bytes */
size_t
data_type_size
;
/* number of different mask */
size_t
number_mask
;
/* value of each masks */
size_t
*
masks
;
/* data size of each mask */
size_t
*
masks_data_size
;
/* label of each mask */
char
*
masks_name
;
/* Size of a chunk if every mask are activated */
size_t
total_size
;
};
/* structure containing global data */
struct
logger
{
/* Number of particle steps between dumping a chunk of data */
...
...
@@ -137,8 +104,11 @@ struct logger {
/* scaling factor when buffer is too small */
float
buffer_scale
;
/* logger parameters */
struct
logger_parameters
*
params
;
/* Size of a chunk if every mask are activated */
int
max_chunk_size
;
/* Number of masks used in the logger */
int
number_masks
;
}
SWIFT_STRUCT_ALIGN
;
...
...
@@ -151,18 +121,6 @@ struct logger_part_data {
size_t
last_offset
;
};
enum
logger_datatype
{
logger_data_int
,
logger_data_float
,
logger_data_double
,
logger_data_char
,
logger_data_longlong
,
logger_data_bool
,
logger_data_count
/* should be last */
};
extern
const
unsigned
int
logger_datatype_size
[];
/* Function prototypes. */
int
logger_compute_chunk_size
(
unsigned
int
mask
);
void
logger_log_all
(
struct
logger
*
log
,
const
struct
engine
*
e
);
...
...
@@ -183,9 +141,6 @@ int logger_read_gpart(struct gpart *p, size_t *offset, const char *buff);
int
logger_read_timestamp
(
unsigned
long
long
int
*
t
,
double
*
time
,
size_t
*
offset
,
const
char
*
buff
);
void
logger_parameters_init
(
struct
logger_parameters
*
log_params
);
void
logger_parameters_clean
(
struct
logger_parameters
*
log_params
);
/**
* @brief Initialize the logger data for a particle.
*
...
...
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment