Parallel file reading OpenMP - c

Question

I would like to develop a simple program that can read different pieces of a file simultaneously.
I'm using C, OpenM and GCC.
I have a file with the following structure:
--------
| HEADER |
| ARRAY1 |
| TEXT |
| ARRAY2 |
--------
Keeping in mind that the HEADER and ARRAY1 sections are independent of each other, I would like to understand if I can use a multi-thread strategy to read these first pieces of the file at the same time.
I implemented a very easy test solution.
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
typedef unsigned char BYTE;
typedef struct FILEHEADER {
int x;
int y;
int elemNr;
} FileHeader;
static const char *filename = "test_data.bin";
void readFileHeader(FILE *fp, FileHeader *header, int nr)
{
fread(header, sizeof(int), nr, fp);
}
void readArray1(FILE *fp, int *array1, int n)
{
fseek(fp, sizeof(FileHeader), SEEK_SET);
fread(array1, sizeof(int), sizeof(int) * n, fp);
}
int main(int argc, char *argv[]) {
int thread_count = strtol(argv[1], NULL, 10);
omp_set_num_threads(thread_count);
const int n = 10;
// create the file and write the data inside
FILE *fp = fopen(filename, "wb");
FileHeader headerW = {.x = 5, .y = 9, .elemNr = 3};
BYTE *buffer = (BYTE*)&headerW;
fwrite(buffer, sizeof(BYTE), sizeof(int) * headerW.elemNr, fp);
int *array = calloc (n, sizeof(int));
for (int i = 0; i < n; i++)
array[i] = i;
buffer = (BYTE*)array;
fwrite(buffer, sizeof(BYTE), sizeof(int) * n, fp);
printf("write section\n");
printf("\nheader:\n\t");
printf("x: %d\n\ty: %d\n\telemNr: %d\n", headerW.x, headerW.y, headerW.elemNr);
printf("\narray:\n");
for (int i = 0; i < n; i++)
printf("\tarray[%d]: %d\n", i, array[i]);
printf("\n");
free(array);
fclose(fp);
// open the file and read the data inside
FILE *fp1 = fopen(filename, "rb");
FILE *fp2 = fopen(filename, "rb");
FileHeader headerR = {.x = 0, .y = 0, .elemNr = 0};
int *array1 = calloc (n, sizeof(int));
#pragma omp parallel sections
{
#pragma omp section
readFileHeader(fp1, &headerR, 3);
#pragma omp section
readArray1(fp2, array1, n);
}
printf("read section\n");
printf("\nheader:\n\t");
printf("x: %d\n\ty: %d\n\telemNr: %d\n", headerR.x, headerR.y, headerR.elemNr);
printf("\narray1:\n");
for (int i = 0; i < n; i++)
printf("\tarray1[%d]: %d\n", i, array1[i]);
// read the other parts of the file and do something
free(array1);
fclose(fp2);
fclose(fp1);
return 0;
}
This solution compiles and works.
However because of its simplicity, I'm not sure if it is really run in parallel.
Anyway, what I'm asking is if the idea behind is correct, in other words, can I safely read different parts of the same file, at the same time, by using a multi-thread strategy?
If the answer were to be no, there is another way to do that by using OpenMp?