Skip to content

ECC-2142: Use RAII LockGuard and thread-safe hashmap in BufrElementsTable #356

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 11 commits into
base: develop
Choose a base branch
from
+822 −1,476
Open

ECC-2142: Use RAII LockGuard and thread-safe hashmap in BufrElementsTable #356

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
772295c
Modernisation: Replace grie_trie with std::unordered_map
joobog Jul 25, 2025
7fcbeca
Modernisation: Replace char** lists with std::vector<std::string>
joobog Jul 25, 2025
7170970
Merge branch 'develop' into feature/modernisation_bufr_trie_v2
joobog Aug 4, 2025
d717476
Merge branch 'develop' into feature/modernisation_bufr_trie_v2
joobog Aug 7, 2025
cdcd082
Replace MUTEX macros with mutex wrappers
joobog Aug 25, 2025
b6a4d78
Merge branch 'develop' into feature/modernisation_thread_safety
joobog Aug 27, 2025
af1da93
Remove STL threads
joobog Aug 27, 2025
c23f95f
Workaround for __sigsetjmp() issue when using clang
joobog Sep 9, 2025
99bf0ed
Remove unused variables
joobog Sep 25, 2025
252dd41
Merge branch 'develop' into feature/modernisation_thread_safety
joobog Sep 29, 2025
787e323
Merge branch 'develop' into feature/modernisation_thread_safety
joobog Oct 15, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
224 changes: 51 additions & 173 deletions fortran/grib_fortran.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,7 @@

#include "grib_api_internal.h"
#include "grib_fortran_prototypes.h"
#include "sync/Mutex.h"

#if HAVE_SYS_TYPES_H
# include <sys/types.h>
Expand All @@ -33,53 +34,12 @@
*/
#define MIN_FILE_ID 50000

#if GRIB_PTHREADS
static pthread_once_t once = PTHREAD_ONCE_INIT;
static pthread_mutex_t handle_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t index_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t read_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t multi_handle_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t iterator_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t keys_iterator_mutex = PTHREAD_MUTEX_INITIALIZER;

static void init(void) {
pthread_mutexattr_t attr;

pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&handle_mutex,&attr);
pthread_mutex_init(&index_mutex,&attr);
pthread_mutex_init(&read_mutex,&attr);
pthread_mutex_init(&multi_handle_mutex,&attr);
pthread_mutex_init(&iterator_mutex,&attr);
pthread_mutex_init(&keys_iterator_mutex,&attr);
pthread_mutexattr_destroy(&attr);
}
#elif GRIB_OMP_THREADS
static int once = 0;
static omp_nest_lock_t handle_mutex;
static omp_nest_lock_t index_mutex;
static omp_nest_lock_t read_mutex;
static omp_nest_lock_t multi_handle_mutex;
static omp_nest_lock_t iterator_mutex;
static omp_nest_lock_t keys_iterator_mutex;

static void init()
{
GRIB_OMP_CRITICAL(lock_fortran)
{
if (once == 0) {
omp_init_nest_lock(&handle_mutex);
omp_init_nest_lock(&index_mutex);
omp_init_nest_lock(&read_mutex);
omp_init_nest_lock(&multi_handle_mutex);
omp_init_nest_lock(&iterator_mutex);
omp_init_nest_lock(&keys_iterator_mutex);
once = 1;
}
}
}
#endif
static eccodes::sync::Mutex handle_mutex;
static eccodes::sync::Mutex index_mutex;
static eccodes::sync::Mutex read_mutex;
static eccodes::sync::Mutex multi_handle_mutex;
static eccodes::sync::Mutex iterator_mutex;
static eccodes::sync::Mutex keys_iterator_mutex;

typedef enum FileMode {
FILE_MODE_READ,
Expand Down Expand Up @@ -447,29 +407,20 @@ static void _push_multi_handle(grib_multi_handle *h,int *gid)

static void push_handle(grib_handle *h,int *gid)
{
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&handle_mutex);
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{handle_mutex};
_push_handle(h,gid);
GRIB_MUTEX_UNLOCK(&handle_mutex);
return;
}

static void push_index(grib_index *h,int *gid)
{
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&index_mutex);
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{index_mutex};
_push_index(h,gid);
GRIB_MUTEX_UNLOCK(&index_mutex);
return;
}

static void push_multi_handle(grib_multi_handle *h,int *gid)
{
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&multi_handle_mutex);
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{multi_handle_mutex};
_push_multi_handle(h,gid);
GRIB_MUTEX_UNLOCK(&multi_handle_mutex);
return;
}

static int _push_keys_iterator(grib_keys_iterator *i)
Expand Down Expand Up @@ -514,12 +465,8 @@ static int _push_keys_iterator(grib_keys_iterator *i)

static int push_keys_iterator(grib_keys_iterator *i)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
ret=_push_keys_iterator(i);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return ret;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{keys_iterator_mutex};
return _push_keys_iterator(i);
}

/* BUFR Keys iterator */
Expand Down Expand Up @@ -564,12 +511,8 @@ static int _push_bufr_keys_iterator(bufr_keys_iterator *i)
}
static int push_bufr_keys_iterator(bufr_keys_iterator *i)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
ret=_push_bufr_keys_iterator(i);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return ret;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{keys_iterator_mutex};
return _push_bufr_keys_iterator(i);
}


Expand Down Expand Up @@ -608,12 +551,8 @@ static grib_multi_handle* _get_multi_handle(int multi_handle_id)

static grib_handle* get_handle(int handle_id)
{
grib_handle* h=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&handle_mutex);
h=_get_handle(handle_id);
GRIB_MUTEX_UNLOCK(&handle_mutex);
return h;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{handle_mutex};
return _get_handle(handle_id);
}

extern "C" {
Expand All @@ -625,22 +564,15 @@ grib_handle* f_handle_id2c_handle(int handle_id){

static grib_index* get_index(int index_id)
{
grib_index* h=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&index_mutex);
h=_get_index(index_id);
GRIB_MUTEX_UNLOCK(&index_mutex);
return h;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{index_mutex};
return _get_index(index_id);
}

static grib_multi_handle* get_multi_handle(int multi_handle_id)
{
grib_multi_handle* h=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&multi_handle_mutex);
h=_get_multi_handle(multi_handle_id);
GRIB_MUTEX_UNLOCK(&multi_handle_mutex);
return h;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{multi_handle_mutex};
return _get_multi_handle(multi_handle_id);
}

static FILE* get_file(int file_id)
Expand Down Expand Up @@ -668,12 +600,8 @@ static grib_keys_iterator* _get_keys_iterator(int keys_iterator_id)
}
static grib_keys_iterator* get_keys_iterator(int keys_iterator_id)
{
grib_keys_iterator* i=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
i=_get_keys_iterator(keys_iterator_id);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return i;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{keys_iterator_mutex};
return _get_keys_iterator(keys_iterator_id);
}

/* BUFR */
Expand All @@ -689,12 +617,8 @@ static bufr_keys_iterator* _get_bufr_keys_iterator(int keys_iterator_id)
}
static bufr_keys_iterator* get_bufr_keys_iterator(int keys_iterator_id)
{
bufr_keys_iterator* i=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
i=_get_bufr_keys_iterator(keys_iterator_id);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return i;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{keys_iterator_mutex};
return _get_bufr_keys_iterator(keys_iterator_id);
}


Expand Down Expand Up @@ -774,33 +698,21 @@ static int _clear_multi_handle(int multi_handle_id)

static int clear_handle(int handle_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&handle_mutex);
ret=_clear_handle(handle_id);
GRIB_MUTEX_UNLOCK(&handle_mutex);
return ret;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{handle_mutex};
return _clear_handle(handle_id);
}

static int clear_index(int index_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&index_mutex);
ret=_clear_index(index_id);
GRIB_MUTEX_UNLOCK(&index_mutex);
return ret;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{index_mutex};
return _clear_index(index_id);
}

#if 0
static int clear_multi_handle(int multi_handle_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&multi_handle_mutex);
ret=_clear_multi_handle(multi_handle_id);
GRIB_MUTEX_UNLOCK(&multi_handle_mutex);
return ret;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{multi_handle_mutex};
return _clear_multi_handle(multi_handle_id);
}
#endif

Expand All @@ -819,12 +731,8 @@ static int _clear_keys_iterator(int keys_iterator_id)
}
static int clear_keys_iterator(int keys_iterator_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
ret=_clear_keys_iterator(keys_iterator_id);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return ret;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{keys_iterator_mutex};
return _clear_keys_iterator(keys_iterator_id);
}

/* BUFR */
Expand All @@ -843,12 +751,8 @@ static int _clear_bufr_keys_iterator(int keys_iterator_id)
}
static int clear_bufr_keys_iterator(int keys_iterator_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
ret=_clear_bufr_keys_iterator(keys_iterator_id);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return ret;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{keys_iterator_mutex};
return _clear_bufr_keys_iterator(keys_iterator_id);
}

/*****************************************************************************/
Expand Down Expand Up @@ -1003,10 +907,10 @@ void grib_f_write_on_fail(int* gid)
grib_handle* h=NULL;
pid_t pid=getpid();

GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&handle_mutex)
file_count++;
GRIB_MUTEX_UNLOCK(&handle_mutex)
{
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{handle_mutex};
file_count++;
}

snprintf(filename, sizeof(filename), "%ld_%d_error.grib",(long)pid,file_count);

Expand Down Expand Up @@ -1073,12 +977,8 @@ static int _push_iterator(grib_iterator *i)
}
static int push_iterator(grib_iterator *i)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&iterator_mutex);
ret=_push_iterator(i);
GRIB_MUTEX_UNLOCK(&iterator_mutex);
return ret;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{iterator_mutex};
return _push_iterator(i);
}
static grib_iterator* _get_iterator(int iterator_id)
{
Expand All @@ -1092,12 +992,8 @@ static grib_iterator* _get_iterator(int iterator_id)
}
static grib_iterator* get_iterator(int iterator_id)
{
grib_iterator* i=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&iterator_mutex);
i=_get_iterator(iterator_id);
GRIB_MUTEX_UNLOCK(&iterator_mutex);
return i;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{iterator_mutex};
return _get_iterator(iterator_id);
}
static int _clear_iterator(int iterator_id)
{
Expand All @@ -1114,12 +1010,8 @@ static int _clear_iterator(int iterator_id)
}
static int clear_iterator(int iterator_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&iterator_mutex);
ret=_clear_iterator(iterator_id);
GRIB_MUTEX_UNLOCK(&iterator_mutex);
return ret;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{iterator_mutex};
return _clear_iterator(iterator_id);
}
static int _grib_f_iterator_new_(int* gid,int* iterid,int* mode) {
int err=0;
Expand All @@ -1139,12 +1031,8 @@ static int _grib_f_iterator_new_(int* gid,int* iterid,int* mode) {
return err;
}
int grib_f_iterator_new_(int* gid,int* iterid,int* mode) {
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&iterator_mutex)
ret=_grib_f_iterator_new_(gid,iterid,mode);
GRIB_MUTEX_UNLOCK(&iterator_mutex)
return ret;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock(iterator_mutex);
return _grib_f_iterator_new_(gid,iterid,mode);
}
/*****************************************************************************/
int grib_f_iterator_next_(int* iterid,double* lat,double* lon,double* value) {
Expand Down Expand Up @@ -1179,12 +1067,8 @@ static int _grib_f_keys_iterator_new_(int* gid,int* iterid,char* name_space,int
}
int grib_f_keys_iterator_new_(int* gid,int* iterid,char* name_space,int len)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&keys_iterator_mutex)
ret=_grib_f_keys_iterator_new_(gid,iterid,name_space,len);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
return ret;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock(keys_iterator_mutex);
return _grib_f_keys_iterator_new_(gid,iterid,name_space,len);
}

/*****************************************************************************/
Expand Down Expand Up @@ -1313,12 +1197,8 @@ static int _codes_f_bufr_keys_iterator_new_(int* gid,int* iterid)
}
int codes_f_bufr_keys_iterator_new_(int* gid,int* iterid)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&keys_iterator_mutex)
ret=_codes_f_bufr_keys_iterator_new_(gid,iterid);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
return ret;
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock(keys_iterator_mutex);
return _codes_f_bufr_keys_iterator_new_(gid,iterid);
}
/*****************************************************************************/
int codes_f_bufr_keys_iterator_next_(int* iterid)
Expand Down Expand Up @@ -1569,11 +1449,9 @@ int any_f_new_from_scanned_file_(int* fid, int* msgid, int* gid)
msg = (l_message_info*)grib_oarray_get(info_messages, n);

if (msg && f) {
GRIB_MUTEX_INIT_ONCE(&once, &init);
GRIB_MUTEX_LOCK(&read_mutex);
eccodes::sync::LockGuard<eccodes::sync::Mutex> lock{read_mutex};
fseeko(f, msg->offset, SEEK_SET);
h = any_new_from_file (c, f, &err);
GRIB_MUTEX_UNLOCK(&read_mutex);
}
if (err) return err;

Expand Down
Loading
Loading