diff --git a/include/haproxy/activity-t.h b/include/haproxy/activity-t.h
index ba9241d03..f7ea1f130 100644
--- a/include/haproxy/activity-t.h
+++ b/include/haproxy/activity-t.h
@@ -76,12 +76,12 @@ struct memprof_stats {
 	const void *caller;
 	enum memprof_method method;
 	/* 4-7 bytes hole here */
+	unsigned long long locked_calls;
 	unsigned long long alloc_calls;
 	unsigned long long free_calls;
 	unsigned long long alloc_tot;
 	unsigned long long free_tot;
 	void *info; // for pools, ptr to the pool
-	void *pad;  // pad to 64
 };
 #endif
 
diff --git a/src/activity.c b/src/activity.c
index ad4d60d8b..9f6bd6162 100644
--- a/src/activity.c
+++ b/src/activity.c
@@ -342,6 +342,8 @@ void *malloc(size_t size)
 	size = malloc_usable_size(ret) + sizeof(void *);
 
 	bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_MALLOC);
+	if (unlikely(th_ctx->lock_level & 0x7F))
+		_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_tot, size);
 	return ret;
@@ -367,6 +369,8 @@ void *calloc(size_t nmemb, size_t size)
 	size = malloc_usable_size(ret) + sizeof(void *);
 
 	bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_CALLOC);
+	if (unlikely(th_ctx->lock_level & 0x7F))
+		_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_tot, size);
 	return ret;
@@ -400,6 +404,8 @@ void *realloc(void *ptr, size_t size)
 		size += sizeof(void *);
 
 	bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_REALLOC);
+	if (unlikely(th_ctx->lock_level & 0x7F))
+		_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 	if (size > size_before) {
 		_HA_ATOMIC_ADD(&bin->alloc_calls, 1);
 		_HA_ATOMIC_ADD(&bin->alloc_tot, size - size_before);
@@ -431,6 +437,8 @@ char *strdup(const char *s)
 	size = malloc_usable_size(ret) + sizeof(void *);
 
 	bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_STRDUP);
+	if (unlikely(th_ctx->lock_level & 0x7F))
+		_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_tot, size);
 	return ret;
@@ -461,6 +469,8 @@ void free(void *ptr)
 	memprof_free_handler(ptr);
 
 	bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_FREE);
+	if (unlikely(th_ctx->lock_level & 0x7F))
+		_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 	_HA_ATOMIC_ADD(&bin->free_calls, 1);
 	_HA_ATOMIC_ADD(&bin->free_tot, size_before);
 }
@@ -481,6 +491,8 @@ char *strndup(const char *s, size_t size)
 
 	size = malloc_usable_size(ret) + sizeof(void *);
 	bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_STRNDUP);
+	if (unlikely(th_ctx->lock_level & 0x7F))
+		_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_tot, size);
 	return ret;
@@ -500,6 +512,8 @@ void *valloc(size_t size)
 
 	size = malloc_usable_size(ret) + sizeof(void *);
 	bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_VALLOC);
+	if (unlikely(th_ctx->lock_level & 0x7F))
+		_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_tot, size);
 	return ret;
@@ -519,6 +533,8 @@ void *pvalloc(size_t size)
 
 	size = malloc_usable_size(ret) + sizeof(void *);
 	bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_PVALLOC);
+	if (unlikely(th_ctx->lock_level & 0x7F))
+		_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_tot, size);
 	return ret;
@@ -538,6 +554,8 @@ void *memalign(size_t align, size_t size)
 
 	size = malloc_usable_size(ret) + sizeof(void *);
 	bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_MEMALIGN);
+	if (unlikely(th_ctx->lock_level & 0x7F))
+		_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_tot, size);
 	return ret;
@@ -557,6 +575,8 @@ void *aligned_alloc(size_t align, size_t size)
 
 	size = malloc_usable_size(ret) + sizeof(void *);
 	bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_ALIGNED_ALLOC);
+	if (unlikely(th_ctx->lock_level & 0x7F))
+		_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_tot, size);
 	return ret;
@@ -579,6 +599,8 @@ int posix_memalign(void **ptr, size_t align, size_t size)
 
 	size = malloc_usable_size(*ptr) + sizeof(void *);
 	bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_POSIX_MEMALIGN);
+	if (unlikely(th_ctx->lock_level & 0x7F))
+		_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_calls, 1);
 	_HA_ATOMIC_ADD(&bin->alloc_tot, size);
 	return ret;
@@ -715,6 +737,7 @@ static int cli_parse_set_profiling(char **args, char *payload, struct appctx *ap
 
 			/* also flush current profiling stats */
 			for (i = 0; i < sizeof(memprof_stats) / sizeof(memprof_stats[0]); i++) {
+				HA_ATOMIC_STORE(&memprof_stats[i].locked_calls, 0);
 				HA_ATOMIC_STORE(&memprof_stats[i].alloc_calls, 0);
 				HA_ATOMIC_STORE(&memprof_stats[i].free_calls, 0);
 				HA_ATOMIC_STORE(&memprof_stats[i].alloc_tot, 0);
@@ -1125,6 +1148,15 @@ static int cli_io_handler_show_profiling(struct appctx *appctx)
 			chunk_appendf(&trash," [pool=%s]", pool->name);
 		}
 
+		if (entry->locked_calls) {
+			unsigned long long tot_calls = entry->alloc_calls + entry->free_calls;
+
+			chunk_appendf(&trash," [locked=%llu (%d.%1d %%)]",
+				      entry->locked_calls,
+				      (int)(100ULL * entry->locked_calls / tot_calls),
+				      (int)((1000ULL * entry->locked_calls / tot_calls) % 10));
+		}
+
 		chunk_appendf(&trash, "\n");
 
 		if (applet_putchk(appctx, &trash) == -1)
diff --git a/src/pool.c b/src/pool.c
index d824b2b93..bcfb4fdc7 100644
--- a/src/pool.c
+++ b/src/pool.c
@@ -953,7 +953,7 @@ void pool_gc(struct pool_head *pool_ctx)
 	uint64_t mem_wait_start = 0;
 	int isolated = thread_isolated();
 
-	if (th_ctx->flags & TH_FL_TASK_PROFILING)
+	if (unlikely(th_ctx->flags & TH_FL_TASK_PROFILING))
 		mem_wait_start = now_mono_time();
 
 	if (!isolated)
@@ -1031,6 +1031,8 @@ void *__pool_alloc(struct pool_head *pool, unsigned int flags)
 			struct memprof_stats *bin;
 
 			bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_P_ALLOC);
+			if (unlikely(th_ctx->lock_level & 0x7F))
+				_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 			_HA_ATOMIC_ADD(&bin->alloc_calls, 1);
 			_HA_ATOMIC_ADD(&bin->alloc_tot, pool->size);
 			_HA_ATOMIC_STORE(&bin->info, pool);
@@ -1069,6 +1071,8 @@ void __pool_free(struct pool_head *pool, void *ptr)
 		struct memprof_stats *bin;
 
 		bin = memprof_get_bin(__builtin_return_address(0), MEMPROF_METH_P_FREE);
+		if (unlikely(th_ctx->lock_level & 0x7F))
+			_HA_ATOMIC_ADD(&bin->locked_calls, 1);
 		_HA_ATOMIC_ADD(&bin->free_calls, 1);
 		_HA_ATOMIC_ADD(&bin->free_tot, pool->size);
 		_HA_ATOMIC_STORE(&bin->info, pool);