# Global parameters
[global]
group = pmemobj
file = ./testfile.locks
ops-per-thread = 1000000:*10:10000000

# Single mutex benchmarks
[single_pmem_locks]
bench = obj_locks

[single_pmem_locks_uninitialized]
bench = obj_locks
run_id = true
run_id_init_val = 4

[single_system_mutex]
bench = obj_locks
use_system_threads = true

# Multiple mutex benchmarks - 1by1
[multiple_pmem_locks_locked_once_1by1]
bench = obj_locks
ops-per-thread = 1
numlocks = 1000000:*10:10000000

[multiple_pmem_locks_uninitialized_locked_once_1by1]
bench = obj_locks
ops-per-thread = 1
numlocks = 1000000:*10:10000000
run_id_init_val = 4

[multiple_system_mutex_locked_once_1by1]
bench = obj_locks
ops-per-thread = 1
use_system_threads = true
numlocks = 1000000:*10:10000000

[multiple_pmem_locks_1by1]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100

[multiple_pmem_locks_uninitialized_1by1]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
run_id = true
run_id_init_val = 4

[multiple_system_mutex_1by1]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
use_system_threads = true

# Multiple mutex benchmarks - all-lock
[multiple_pmem_locks_locked_once_alllock]
bench = obj_locks
ops-per-thread = 1
numlocks = 1000000:*10:10000000
mode = all-lock

[multiple_pmem_locks_uninitialized_locked_once_alllock]
bench = obj_locks
ops-per-thread = 1
numlocks = 1000000:*10:10000000
mode = all-lock
run_id = true
run_id_init_val = 4

[multiple_system_mutex_locked_once_alllock]
bench = obj_locks
ops-per-thread = 1
numlocks = 1000000:*10:10000000
use_system_threads = true
mode = all-lock

[multiple_pmem_locks_alllock]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
mode = all-lock

[multiple_pmem_locks_uninitialized_alllock]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
run_id = true
run_id_init_val = 4
mode = all-lock

[multiple_system_mutex_alllock]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
use_system_threads = true
mode = all-lock

#rwlock benchmarks
[single_pmem_wrlock]
bench = obj_locks
bench_type = rwlock

[single_pmem_rdlock]
bench = obj_locks
bench_type = rwlock
rdlock = true

[single_system_wrlock]
bench = obj_locks
bench_type = rwlock
use_system_threads = true

[single_system_rdlock]
bench = obj_locks
bench_type = rwlock
rdlock = true
use_system_threads = true

[multiple_pmem_wrlock_locked_once_1by1]
bench = obj_locks
ops-per-thread = 1
numlocks = 1000000:*10:10000000
bench_type = rwlock

[multiple_pmem_wrlock_uninitialized_locked_once_1by1]
bench = obj_locks
ops-per-thread = 1
numlocks = 1000000:*10:10000000
run_id_init_val = 4
bench_type = rwlock

[multiple_system_wrlock_locked_once_1by1]
bench = obj_locks
ops-per-thread = 1
use_system_threads = true
numlocks = 1000000:*10:10000000
bench_type = rwlock

[multiple_pmem_wrlock_1by1]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
bench_type = rwlock

[multiple_pmem_wrlock_uninitialized_1by1]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
run_id = true
run_id_init_val = 4
bench_type = rwlock

[multiple_system_wrlock_1by1]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
use_system_threads = true
bench_type = rwlock

[multiple_pmem_wrlock_locked_once_alllock]
bench = obj_locks
ops-per-thread = 1
numlocks = 1000000:*10:10000000
bench_type = rwlock
mode = all-lock

[multiple_pmem_wrlock_uninitialized_locked_once_alllock]
bench = obj_locks
ops-per-thread = 1
numlocks = 1000000:*10:10000000
run_id_init_val = 4
bench_type = rwlock
mode = all-lock

[multiple_system_wrlock_locked_once_alllock]
bench = obj_locks
ops-per-thread = 1
use_system_threads = true
numlocks = 1000000:*10:10000000
bench_type = rwlock
mode = all-lock

[multiple_pmem_wrlock_alllock]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
bench_type = rwlock
mode = all-lock

[multiple_pmem_wrlock_uninitialized_alllock]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
run_id = true
run_id_init_val = 4
bench_type = rwlock
mode = all-lock

[multiple_system_wrlock_alllock]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
use_system_threads = true
bench_type = rwlock
mode = all-lock

# volatile mutex - only for testing
# it is an alternate implementation of PMEMmutex, which keeps
# the system mutex in RAM
[single_volatile_mutex]
bench = obj_locks
bench_type = volatile-mutex

[multiple_volatile_mutex_locked_once_1by1]
bench = obj_locks
ops-per-thread = 1
numlocks = 1000000:*10:10000000
bench_type = volatile-mutex

[multiple_volatile_mutex_1by1]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
bench_type = volatile-mutex

[multiple_volatile_mutex_locked_once_alllock]
bench = obj_locks
ops-per-thread = 1
numlocks = 1000000:*10:10000000
mode = all-lock
bench_type = volatile-mutex

[multiple_volatile_mutex_alllock]
bench = obj_locks
numlocks = 10000:*10:100000
ops-per-thread = 10000:/10:100
mode = all-lock
bench_type = volatile-mutex
