diff --git a/src/deps/miniasync/doc/data_mover_sync_get_vdm.3.md b/src/deps/miniasync/doc/data_mover_sync_get_vdm.3.md
index 8f87b006d43b5995d25bb15d704a031395b10a7b..e515f2cb3c5b197fd145ec4ec84bc4d2ae55824d 100644
--- a/src/deps/miniasync/doc/data_mover_sync_get_vdm.3.md
+++ b/src/deps/miniasync/doc/data_mover_sync_get_vdm.3.md
@@ -46,6 +46,7 @@ Synchronous data mover implementation supports following operations:
 
 * **vdm_memcpy**(3) - memory copy operation
 * **vdm_memmove**(3) - memory move operation
+* **vdm_memset**(3) - memory set operation
 
 # RETURN VALUE #
 
@@ -53,5 +54,5 @@ The **data_mover_sync_get_vdm**() function returns a pointer to *struct vdm* str
 
 # SEE ALSO #
 
-**vdm_memcpy**(3), **miniasync**(7),
+**vdm_memcpy**(3), **vdm_memmove**(3), **vdm_memset**(3), **miniasync**(7),
 **miniasync_vdm_synchronous**(7) and **<https://pmem.io>**
diff --git a/src/deps/miniasync/doc/data_mover_threads_get_vdm.3.md b/src/deps/miniasync/doc/data_mover_threads_get_vdm.3.md
index 0ed21762b69d5370fc1e440386dad1ee46917eb7..bd5e64b03c1f0a8ed3b996aa74ccad6e49c26332 100644
--- a/src/deps/miniasync/doc/data_mover_threads_get_vdm.3.md
+++ b/src/deps/miniasync/doc/data_mover_threads_get_vdm.3.md
@@ -45,6 +45,8 @@ from the thread data mover structure pointed by *dms*. Virtual data mover struct
 Thread data mover implementation supports following operations:
 
 * **vdm_memcpy**(3) - memory copy operation
+* **vdm_memmove**(3) - memory move operation
+* **vdm_memset**(3) - memory set operation
 
 # RETURN VALUE #
 
@@ -52,5 +54,5 @@ The **data_mover_threads_get_vdm**() function returns a pointer to *struct vdm*
 
 # SEE ALSO #
 
-**vdm_memcpy**(3), **miniasync**(7),
-**miniasync_vdm_threads**(7) and **<https://pmem.io>**
+**vdm_memcpy**(3), **vdm_memmove**(3), **vdm_memset**(3),
+**miniasync**(7), **miniasync_vdm_threads**(7) and **<https://pmem.io>**
diff --git a/src/deps/miniasync/doc/manuals.txt b/src/deps/miniasync/doc/manuals.txt
index 577e370016c22f1a07a0da946bf510e7ec2b9fde..8554e8b8a59f31b01eace5b26abf2d9b46ff9a8d 100644
--- a/src/deps/miniasync/doc/manuals.txt
+++ b/src/deps/miniasync/doc/manuals.txt
@@ -19,3 +19,4 @@ runtime_new.3
 runtime_wait.3
 vdm_memcpy.3
 vdm_memmove.3
+vdm_memset.3
diff --git a/src/deps/miniasync/doc/miniasync_vdm.7.md b/src/deps/miniasync/doc/miniasync_vdm.7.md
index 64b19c28dfa5e2debcd20581429286b39e3bb4df..06053701fc92d7633a47748039861cd5f0634c75 100644
--- a/src/deps/miniasync/doc/miniasync_vdm.7.md
+++ b/src/deps/miniasync/doc/miniasync_vdm.7.md
@@ -47,6 +47,7 @@ struct vdm {
 enum vdm_operation_type {
 	VDM_OPERATION_MEMCPY,
 	VDM_OPERATION_MEMMOVE,
+	VDM_OPERATION_MEMSET,
 };
 
 enum vdm_operation_result {
@@ -93,6 +94,7 @@ Currently, virtual data mover API supports following operation types:
 
 * **VDM_OPERATION_MEMCPY** - a memory copy operation
 * **VDM_OPERATION_MEMMOVE** - a memory move operation
+* **VDM_OPERATION_MEMSET** - a memory set operation
 
 For more information about concrete data mover implementations, see **miniasync_vdm_threads**(7),
 **miniasync_vdm_synchronous**(7) and **miniasync_vdm_dml**(7).
@@ -120,7 +122,7 @@ The *result* field can be set to one of the following values:
 
 # SEE ALSO #
 
-**vdm_memcpy**(3),
+**vdm_memcpy**(3), **vdm_memmove**(3), **vdm_memset**(3),
 **miniasync**(7), **miniasync_future**(7),
 **miniasync_vdm_dml**(7), **miniasync_vdm_synchronous**(7),
 **miniasync_vdm_threads**(7) and **<https://pmem.io>**
diff --git a/src/deps/miniasync/doc/miniasync_vdm_synchronous.7.md b/src/deps/miniasync/doc/miniasync_vdm_synchronous.7.md
index f590f4f3a170ecc670d07e88dd95857b19c4fc8d..698dd0a3e88243a9a741daae2e8bbb4ad46447c8 100644
--- a/src/deps/miniasync/doc/miniasync_vdm_synchronous.7.md
+++ b/src/deps/miniasync/doc/miniasync_vdm_synchronous.7.md
@@ -45,6 +45,7 @@ Synchronous data mover supports following operations:
 
 * **vdm_memcpy**(3) - memory copy operation
 * **vdm_memmove**(3) - memory move operation
+* **vdm_memset**(3) - memory set operation
 
 Synchronous data mover does not support notifier feature. For more information about
 notifiers, see **miniasync_future**(7).
@@ -65,5 +66,5 @@ struct vdm_memcpy_future memcpy_fut =
 # SEE ALSO #
 
  **data_mover_sync_new**(3), **data_mover_sync_get_vdm**(3),
- **vdm_memcpy**(3), **miniasync**(7), **miniasync_future**(7),
- **miniasync_vdm**(7) and **<https://pmem.io>**
+ **vdm_memcpy**(3), **vdm_memmove**(3), **vdm_memset**(3), **miniasync**(7),
+ **miniasync_future**(7), **miniasync_vdm**(7) and **<https://pmem.io>**
diff --git a/src/deps/miniasync/doc/miniasync_vdm_threads.7.md b/src/deps/miniasync/doc/miniasync_vdm_threads.7.md
index ce07fa4d543d9351b3c461ae32ec94e9a8c59582..ba6102692cfdcdecbdd012b68d15bc161287cc67 100644
--- a/src/deps/miniasync/doc/miniasync_vdm_threads.7.md
+++ b/src/deps/miniasync/doc/miniasync_vdm_threads.7.md
@@ -52,6 +52,8 @@ To create a new thread data mover instance, use **data_mover_threads_new**(3) or
 Thread data mover supports following operations:
 
 * **vdm_memcpy**(3) - memory copy operation
+* **vdm_memmove**(3) - memory move operation
+* **vdm_memset**(3) - memory set operation
 
 Thread data mover supports following notifer types:
 
@@ -76,6 +78,6 @@ struct vdm_memcpy_future memcpy_fut =
 # SEE ALSO #
 
 **data_mover_threads_default**(3), **data_mover_threads_get_vdm**(3),
-**data_mover_threads_new**(3), **vdm_memcpy**(3),
-**miniasync**(7), **miniasync_future**(7),
+**data_mover_threads_new**(3), **vdm_memcpy**(3), **vdm_memmove**(3),
+**vdm_memset**(3), **miniasync**(7), **miniasync_future**(7),
 **miniasync_vdm**(7) and **<https://pmem.io>**
diff --git a/src/deps/miniasync/doc/vdm_memcpy.3.md b/src/deps/miniasync/doc/vdm_memcpy.3.md
index 680d0e009b0088b38beb5e0532ccf64a6dd80132..96581f98449f28ab9393ca7f3679528ef4e45766 100644
--- a/src/deps/miniasync/doc/vdm_memcpy.3.md
+++ b/src/deps/miniasync/doc/vdm_memcpy.3.md
@@ -27,16 +27,10 @@ secondary_title: miniasync
 ```c
 #include <libminiasync.h>
 
-struct vdm {
-	vdm_operation_new op_new;
-	vdm_operation_delete op_delete;
-	vdm_operation_start op_start;
-	vdm_operation_check op_check;
-};
-
 enum vdm_operation_type {
 	VDM_OPERATION_MEMCPY,
 	VDM_OPERATION_MEMMOVE,
+	VDM_OPERATION_MEMSET,
 };
 
 struct vdm_operation_output_memcpy {
@@ -70,5 +64,5 @@ The **vdm_memcpy**() function returns an initialized *struct vdm_operation_futur
 
 # SEE ALSO #
 
-**vdm_memmove**(3), **miniasync**(7), **miniasync_vdm**(7),
+**vdm_memmove**(3), **vdm_memset**(3), **miniasync**(7), **miniasync_vdm**(7),
 **miniasync_vdm_dml**(7) and **<https://pmem.io>**
diff --git a/src/deps/miniasync/doc/vdm_memmove.3.md b/src/deps/miniasync/doc/vdm_memmove.3.md
index a645676f55c45b3535d738126bd81e8249e18544..3990be5458d4bbe5c2d61d69614ab63e02727679 100644
--- a/src/deps/miniasync/doc/vdm_memmove.3.md
+++ b/src/deps/miniasync/doc/vdm_memmove.3.md
@@ -27,35 +27,16 @@ secondary_title: miniasync
 ```c
 #include <libminiasync.h>
 
-struct vdm {
-	vdm_operation_new op_new;
-	vdm_operation_delete op_delete;
-	vdm_operation_start op_start;
-	vdm_operation_check op_check;
-};
-
 enum vdm_operation_type {
 	VDM_OPERATION_MEMCPY,
 	VDM_OPERATION_MEMMOVE,
+	VDM_OPERATION_MEMSET,
 };
 
 struct vdm_operation_output_memmove {
 	void *dest;
 };
 
-struct vdm_operation_data {
-	void *op;
-	struct vdm *vdm;
-};
-
-struct vdm_operation_output {
-	enum vdm_operation_type type;
-	union {
-		struct vdm_operation_output_memcpy memcpy;
-		struct vdm_operation_output_memmove memmove;
-	} output;
-};
-
 FUTURE(vdm_operation_future,
 	struct vdm_operation_data, struct vdm_operation_output);
 
@@ -81,5 +62,5 @@ The **vdm_memmove**() function returns an initialized *struct vdm_operation_futu
 
 # SEE ALSO #
 
-**vdm_memcpy**(3), **miniasync**(7), **miniasync_vdm**(7),
+**vdm_memcpy**(3), **vdm_memset**(3), **miniasync**(7), **miniasync_vdm**(7),
 **miniasync_vdm_dml**(7) and **<https://pmem.io>**
diff --git a/src/deps/miniasync/doc/vdm_memset.3.md b/src/deps/miniasync/doc/vdm_memset.3.md
new file mode 100644
index 0000000000000000000000000000000000000000..fd13e6997b3eacb799fdaafa5d94ac3524504120
--- /dev/null
+++ b/src/deps/miniasync/doc/vdm_memset.3.md
@@ -0,0 +1,66 @@
+---
+layout: manual
+Content-Style: 'text/css'
+title: _MP(VDM_MEMSET, 3)
+collection: miniasync
+header: VDM_MEMSET
+secondary_title: miniasync
+...
+
+[comment]: <> (SPDX-License-Identifier: BSD-3-Clause)
+[comment]: <> (Copyright 2022, Intel Corporation)
+
+[comment]: <> (vdm_memset.3 -- man page for miniasync vdm_memset operation)
+
+[NAME](#name)<br />
+[SYNOPSIS](#synopsis)<br />
+[DESCRIPTION](#description)<br />
+[RETURN VALUE](#return-value)<br />
+[SEE ALSO](#see-also)<br />
+
+# NAME #
+
+**vdm_memset**() - create a new memset virtual data mover operation structure
+
+# SYNOPSIS #
+
+```c
+#include <libminiasync.h>
+
+enum vdm_operation_type {
+	VDM_OPERATION_MEMCPY,
+	VDM_OPERATION_MEMMOVE,
+	VDM_OPERATION_MEMSET,
+};
+
+struct vdm_operation_output_memset {
+	void *str;
+};
+
+FUTURE(vdm_operation_future,
+	struct vdm_operation_data, struct vdm_operation_output);
+
+struct vdm_operation_future vdm_memset(struct vdm *vdm, void *str, int c,
+	size_t n, uint64_t flags);
+```
+
+For general description of virtual data mover API, see **miniasync_vdm**(7).
+
+# DESCRIPTION #
+
+**vdm_memset**() initializes and returns a new memset future based on the virtual data mover
+implementation instance *vdm*. The parameters: *str*, *c*, *n* are standard memset parameters.
+The *flags* represents data mover specific flags. TODO: provide an example of the flags usage after
+implementing memset future for dml.
+
+Memset future obtained using **vdm_memset**() will attempt to copy the character *c* to the
+first, *n* bytes of the memory area *str* when its polled.
+
+## RETURN VALUE ##
+
+The **vdm_memset**() function returns an initialized *struct vdm_operation_future* memset future.
+
+# SEE ALSO #
+
+**vdm_memcpy**(3), **vdm_memmove**(3), **miniasync**(7), **miniasync_vdm**(7),
+**miniasync_vdm_dml**(7) and **<https://pmem.io>**
diff --git a/src/deps/miniasync/src/data_mover_sync.c b/src/deps/miniasync/src/data_mover_sync.c
index 0a14dd0035cb87e087afb6ee359168eca16110c3..3c558002f184eaf55eeea2cc6cb5db218c833124 100644
--- a/src/deps/miniasync/src/data_mover_sync.c
+++ b/src/deps/miniasync/src/data_mover_sync.c
@@ -78,6 +78,11 @@ sync_operation_delete(void *data, const struct vdm_operation *operation,
 			output->output.memmove.dest =
 				operation->data.memcpy.dest;
 			break;
+		case VDM_OPERATION_MEMSET:
+			output->type = VDM_OPERATION_MEMSET;
+			output->output.memset.str =
+				operation->data.memset.str;
+			break;
 		default:
 			ASSERT(0);
 	}
@@ -109,6 +114,11 @@ sync_operation_start(void *data, const struct vdm_operation *operation,
 				operation->data.memcpy.src,
 				operation->data.memcpy.n);
 			break;
+		case VDM_OPERATION_MEMSET:
+			memset(operation->data.memset.str,
+				operation->data.memset.c,
+				operation->data.memset.n);
+			break;
 		default:
 			ASSERT(0);
 	}
diff --git a/src/deps/miniasync/src/data_mover_threads.c b/src/deps/miniasync/src/data_mover_threads.c
index 04631070aa7a59d04bd055b7e26ec70f82666697..302b0a6c7a1b157e0ecc1ede1d20eda3feddbf8b 100644
--- a/src/deps/miniasync/src/data_mover_threads.c
+++ b/src/deps/miniasync/src/data_mover_threads.c
@@ -20,6 +20,8 @@
 
 struct data_mover_threads_op_fns {
 	memcpy_fn op_memcpy;
+	memmove_fn op_memmove;
+	memset_fn op_memset;
 };
 
 struct data_mover_threads {
@@ -49,15 +51,41 @@ void *std_memcpy(void *dst, const void *src, size_t n, unsigned flags) {
 	return memcpy(dst, src, n);
 }
 
-static struct data_mover_threads_op_fns op_fns_default = {
-	.op_memcpy = std_memcpy
-};
-
 void data_mover_threads_set_memcpy_fn(struct data_mover_threads *dmt,
 				memcpy_fn op_memcpy) {
 	dmt->op_fns.op_memcpy = op_memcpy;
 }
 
+/*
+ * Standard implementation of memmove used if none was specified by the user.
+ */
+void *std_memmove(void *dst, const void *src, size_t n, unsigned flags) {
+	return memmove(dst, src, n);
+}
+
+void data_mover_threads_set_memmove_fn(struct data_mover_threads *dmt,
+				memmove_fn op_memmove) {
+	dmt->op_fns.op_memmove = op_memmove;
+}
+
+/*
+ * Standard implementation of memset used if none was specified by the user.
+ */
+void *std_memset(void *str, int c, size_t n, unsigned flags) {
+	return memset(str, c, n);
+}
+
+void data_mover_threads_set_memset_fn(struct data_mover_threads *dmt,
+				memset_fn op_memset) {
+	dmt->op_fns.op_memset = op_memset;
+}
+
+static struct data_mover_threads_op_fns op_fns_default = {
+	.op_memcpy = std_memcpy,
+	.op_memmove = std_memmove,
+	.op_memset = std_memset,
+};
+
 /*
  * data_mover_threads_do_operation -- implementation of the various
  * operations supported by this data mover
@@ -74,6 +102,20 @@ data_mover_threads_do_operation(struct data_mover_threads_data *data,
 			op_memcpy(mdata->dest,
 				mdata->src, mdata->n, (unsigned)mdata->flags);
 		} break;
+		case VDM_OPERATION_MEMMOVE: {
+			struct vdm_operation_data_memmove *mdata
+				= &data->op.data.memmove;
+			memmove_fn op_memmove = dmt->op_fns.op_memmove;
+			op_memmove(mdata->dest,
+				mdata->src, mdata->n, (unsigned)mdata->flags);
+		} break;
+		case VDM_OPERATION_MEMSET: {
+			struct vdm_operation_data_memset *mdata
+				= &data->op.data.memset;
+			memset_fn op_memset = dmt->op_fns.op_memset;
+			op_memset(mdata->str,
+				mdata->c, mdata->n, (unsigned)mdata->flags);
+		} break;
 		default:
 			ASSERT(0); /* unreachable */
 			break;
@@ -176,6 +218,16 @@ data_mover_threads_operation_delete(void *data,
 			output->output.memcpy.dest =
 				operation->data.memcpy.dest;
 			break;
+		case VDM_OPERATION_MEMMOVE:
+			output->type = VDM_OPERATION_MEMMOVE;
+			output->output.memmove.dest =
+				operation->data.memmove.dest;
+			break;
+		case VDM_OPERATION_MEMSET:
+			output->type = VDM_OPERATION_MEMSET;
+			output->output.memset.str =
+				operation->data.memset.str;
+			break;
 		default:
 			ASSERT(0);
 	}
diff --git a/src/deps/miniasync/src/include/libminiasync/data_mover_threads.h b/src/deps/miniasync/src/include/libminiasync/data_mover_threads.h
index d86d89a8d1975aa3c7e92d21c28761dfcc0c2994..2edd9cd3d216fb324354414fff9b114432e685d1 100644
--- a/src/deps/miniasync/src/include/libminiasync/data_mover_threads.h
+++ b/src/deps/miniasync/src/include/libminiasync/data_mover_threads.h
@@ -12,6 +12,10 @@ extern "C" {
 
 typedef void *(*memcpy_fn)(void *dst, const void *src,
 				size_t n, unsigned flags);
+typedef void *(*memmove_fn)(void *dst, const void *src,
+				size_t n, unsigned flags);
+typedef void *(*memset_fn)(void *str, int c, size_t n,
+				unsigned flags);
 
 struct data_mover_threads;
 struct data_mover_threads *data_mover_threads_new(size_t nthreads,
@@ -21,6 +25,10 @@ struct vdm *data_mover_threads_get_vdm(struct data_mover_threads *dmt);
 void data_mover_threads_delete(struct data_mover_threads *dmt);
 void data_mover_threads_set_memcpy_fn(struct data_mover_threads *dmt,
 	memcpy_fn op_memcpy);
+void data_mover_threads_set_memmove_fn(struct data_mover_threads *dmt,
+	memmove_fn op_memmove);
+void data_mover_threads_set_memset_fn(struct data_mover_threads *dmt,
+	memset_fn op_memset);
 
 #ifdef __cplusplus
 }
diff --git a/src/deps/miniasync/src/include/libminiasync/vdm.h b/src/deps/miniasync/src/include/libminiasync/vdm.h
index c4d65a376bc0b583d7f9342f1ad55b6375c43fb7..cbfea82a123d9bbe2247cd2281bd8e0361310a39 100644
--- a/src/deps/miniasync/src/include/libminiasync/vdm.h
+++ b/src/deps/miniasync/src/include/libminiasync/vdm.h
@@ -33,6 +33,7 @@ struct vdm;
 enum vdm_operation_type {
 	VDM_OPERATION_MEMCPY,
 	VDM_OPERATION_MEMMOVE,
+	VDM_OPERATION_MEMSET,
 };
 
 enum vdm_operation_result {
@@ -55,6 +56,13 @@ struct vdm_operation_data_memmove {
 	uint64_t flags;
 };
 
+struct vdm_operation_data_memset {
+	void *str;
+	int c;
+	size_t n;
+	uint64_t flags;
+};
+
 /* sized so that sizeof(vdm_operation_data) is 64 */
 #define VDM_OPERATION_DATA_MAX_SIZE (40)
 
@@ -62,6 +70,7 @@ struct vdm_operation {
 	union {
 		struct vdm_operation_data_memcpy memcpy;
 		struct vdm_operation_data_memmove memmove;
+		struct vdm_operation_data_memset memset;
 		uint8_t data[VDM_OPERATION_DATA_MAX_SIZE];
 	} data;
 	enum vdm_operation_type type;
@@ -82,12 +91,17 @@ struct vdm_operation_output_memmove {
 	void *dest;
 };
 
+struct vdm_operation_output_memset {
+	void *str;
+};
+
 struct vdm_operation_output {
 	enum vdm_operation_type type;
 	enum vdm_operation_result result;
 	union {
 		struct vdm_operation_output_memcpy memcpy;
 		struct vdm_operation_output_memmove memmove;
+		struct vdm_operation_output_memset memset;
 	} output;
 };
 
@@ -203,6 +217,28 @@ vdm_memmove(struct vdm *vdm, void *dest, void *src, size_t n, uint64_t flags)
 	future.output.type = VDM_OPERATION_MEMMOVE;
 	future.output.result = VDM_SUCCESS;
 	future.output.output.memmove.dest = NULL;
+
+	vdm_generic_operation(vdm, &future);
+	return future;
+}
+
+/*
+ * vdm_memset -- instantiates a new memset vdm operation and returns a new
+ * future to represent that operation
+ */
+static inline struct vdm_operation_future
+vdm_memset(struct vdm *vdm, void *str, int c, size_t n, uint64_t flags)
+{
+	struct vdm_operation_future future;
+	future.data.operation.type = VDM_OPERATION_MEMSET;
+	future.data.operation.data.memset.str = str;
+	future.data.operation.data.memset.flags = flags;
+	future.data.operation.data.memset.n = n;
+	future.data.operation.data.memset.c = c;
+	future.output.type = VDM_OPERATION_MEMSET;
+	future.output.result = VDM_SUCCESS;
+	future.output.output.memset.str = NULL;
+
 	vdm_generic_operation(vdm, &future);
 	return future;
 }
diff --git a/src/deps/miniasync/tests/CMakeLists.txt b/src/deps/miniasync/tests/CMakeLists.txt
index 360363d8001a73a93c678752caaa69fffd824e17..d1300ba51e1aaecacf9c5e5bb7e35b0cfee6d291 100644
--- a/src/deps/miniasync/tests/CMakeLists.txt
+++ b/src/deps/miniasync/tests/CMakeLists.txt
@@ -41,10 +41,19 @@ set(SOURCES_MEMMOVE_SYNC_TEST
 set(SOURCES_VDM_TEST
 	vdm/test_vdm.c)
 
+set(SOURCES_MEMSET_SYNC_TEST
+	memset_sync/memset_sync.c)
+
 set(SOURCES_VDM_OPERATION_FUTURE_POLL
 	vdm_operation_future_poll/vdm_operation_future_poll.c
 	${MINIASYNC_DML_SOURCE_DIR}/utils/util_dml.c)
 
+set(SOURCES_MEMMOVE_THREADS_TEST
+	memmove_threads/memmove_threads.c)
+
+set(SOURCES_MEMSET_THREADS_TEST
+	memset_threads/memset_threads.c)
+
 add_custom_target(tests)
 
 add_flag(-Wall)
@@ -91,6 +100,18 @@ add_link_executable(vdm
 		"${SOURCES_VDM_TEST}"
 		"${LIBS_BASIC}")
 
+add_link_executable(memset_sync
+		"${SOURCES_MEMSET_SYNC_TEST}"
+		"${LIBS_BASIC}")
+
+add_link_executable(memmove_threads
+		"${SOURCES_MEMMOVE_THREADS_TEST}"
+		"${LIBS_BASIC}")
+
+add_link_executable(memset_threads
+		"${SOURCES_MEMSET_THREADS_TEST}"
+		"${LIBS_BASIC}")
+
 # add test using test function defined in the ctest_helpers.cmake file
 test("dummy" "dummy" test_dummy none)
 test("dummy_drd" "dummy" test_dummy drd)
@@ -103,6 +124,9 @@ test("memcpy_threads" "memcpy_threads" test_memcpy_threads none)
 test("membuf" "membuf" test_membuf none)
 test("memmove_sync" "memmove_sync" test_memmove_sync none)
 test("vdm" "vdm" test_vdm none)
+test("memset_sync" "memset_sync" test_memset_sync none)
+test("memmove_threads" "memmove_threads" test_memmove_threads none)
+test("memset_threads" "memset_threads" test_memset_threads none)
 
 # add tests running examples only if they are built
 if(BUILD_EXAMPLES)
diff --git a/src/deps/miniasync/tests/memmove_threads/memmove_threads.c b/src/deps/miniasync/tests/memmove_threads/memmove_threads.c
new file mode 100644
index 0000000000000000000000000000000000000000..33574ea7450b655febcf7712d4a186bd2d392ebe
--- /dev/null
+++ b/src/deps/miniasync/tests/memmove_threads/memmove_threads.c
@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2022, Intel Corporation */
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "libminiasync.h"
+#include "core/os.h"
+#include "test_helpers.h"
+
+int
+test_thread_memmove_single(size_t str_len)
+{
+	int ret = 0;
+	unsigned seed = (unsigned)time(NULL);
+	fprintf(stdout, "seed: %u\n", seed);
+	struct runtime *r = runtime_new();
+	struct data_mover_threads *dmt = data_mover_threads_default();
+
+	if (dmt == NULL) {
+		runtime_delete(r);
+		return 1;
+	}
+
+	struct vdm *vdm = data_mover_threads_get_vdm(dmt);
+
+	char *buf_a = malloc(str_len);
+	char *buf_b = malloc(str_len);
+
+	if (!buf_a || !buf_b)
+		UT_FATAL("buffers out of memory");
+
+	for (size_t i = 0; i < str_len; i++) {
+		buf_a[i] = (char)os_rand_r(&seed) % 256;
+		buf_b[i] = (char)os_rand_r(&seed) % 256;
+	}
+
+	if (strcmp(buf_a, buf_b) == 0) {
+		UT_FATAL("buffers contain the same value before memmove");
+	}
+
+	struct vdm_operation_future test_memmove_fut =
+		vdm_memmove(vdm, buf_a, buf_b, str_len, 0);
+
+	struct future *future_memmove = FUTURE_AS_RUNNABLE(&test_memmove_fut);
+
+	runtime_wait(r, future_memmove);
+
+	for (size_t i = 0; i < str_len; i++) {
+		UT_ASSERTeq(buf_a[i], buf_b[i]);
+	}
+
+	free(buf_a);
+	free(buf_b);
+
+	runtime_delete(r);
+	data_mover_threads_delete(dmt);
+
+	return ret;
+}
+
+int
+test_thread_memmove_multiple(size_t str_len)
+{
+	int ret = 0;
+	unsigned seed = (unsigned)time(NULL);
+	fprintf(stdout, "seed: %u\n", seed);
+	struct runtime *r = runtime_new();
+	struct data_mover_threads *dmt = data_mover_threads_default();
+
+	if (dmt == NULL) {
+		fprintf(stderr,
+				"error while creating synchronous data mover");
+		runtime_delete(r);
+		return 1;
+	}
+
+	struct vdm *vdm = data_mover_threads_get_vdm(dmt);
+
+	char *buf_a = malloc(str_len);
+	char *buf_b = malloc(str_len);
+	char *buf_c = malloc(str_len);
+	char *buf_d = malloc(str_len);
+
+	if (!buf_a || !buf_b || !buf_c || !buf_d)
+		UT_FATAL("buffers out of memory");
+
+	for (size_t i = 0; i < str_len; i++) {
+		buf_a[i] = (char)os_rand_r(&seed) % 256;
+		buf_b[i] = (char)os_rand_r(&seed) % 256;
+		buf_c[i] = (char)os_rand_r(&seed) % 256;
+		buf_d[i] = (char)os_rand_r(&seed) % 256;
+	}
+
+	struct future **futures = malloc(sizeof(struct future *) * 4);
+	if (futures == NULL)
+		UT_FATAL("futures out of memory");
+
+	struct vdm_operation_future memmove_fut_b_to_a =
+		vdm_memmove(vdm, buf_a, buf_b, str_len / 2, 0);
+
+	struct vdm_operation_future memmove_fut_c_to_a =
+		vdm_memmove(vdm, buf_a + str_len / 2, buf_c,
+			str_len / 2, 0);
+
+	struct vdm_operation_future memmove_fut_b_to_d =
+		vdm_memmove(vdm, buf_d, buf_b, str_len / 2, 0);
+
+	struct vdm_operation_future memmove_fut_c_to_d =
+		vdm_memmove(vdm, buf_d + str_len / 2, buf_c,
+			str_len / 2, 0);
+
+	futures[0] = FUTURE_AS_RUNNABLE(&memmove_fut_b_to_a);
+	futures[1] = FUTURE_AS_RUNNABLE(&memmove_fut_c_to_a);
+	futures[2] = FUTURE_AS_RUNNABLE(&memmove_fut_b_to_d);
+	futures[3] = FUTURE_AS_RUNNABLE(&memmove_fut_c_to_d);
+
+	runtime_wait_multiple(r, futures, 4);
+
+	for (size_t i = 0; i < str_len / 2; i++) {
+		UT_ASSERTeq(buf_a[i], buf_b[i]);
+		UT_ASSERTeq(buf_d[i], buf_b[i]);
+	}
+
+	size_t j = 0;
+	for (size_t i = str_len / 2; i < str_len; i++) {
+		UT_ASSERTeq(buf_a[i], buf_c[j]);
+		UT_ASSERTeq(buf_d[i], buf_c[j]);
+		j++;
+	}
+
+	free(buf_a);
+	free(buf_b);
+	free(buf_c);
+	free(buf_d);
+	free(futures);
+
+	runtime_delete(r);
+	data_mover_threads_delete(dmt);
+
+	return ret;
+}
+
+int
+main(void)
+{
+	return
+		test_thread_memmove_single(10000000) ||
+		test_thread_memmove_single(30000000) ||
+		test_thread_memmove_single(50000000) ||
+		test_thread_memmove_multiple(10000000) ||
+		test_thread_memmove_multiple(30000000) ||
+		test_thread_memmove_multiple(50000000);
+}
diff --git a/src/deps/miniasync/tests/memmove_threads/test_memmove_threads.cmake b/src/deps/miniasync/tests/memmove_threads/test_memmove_threads.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d46074429518ad8bf16802cc24f75869a6017cdb
--- /dev/null
+++ b/src/deps/miniasync/tests/memmove_threads/test_memmove_threads.cmake
@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright 2022, Intel Corporation
+
+include(${SRC_DIR}/cmake/test_helpers.cmake)
+
+setup()
+
+execute(0 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/memmove_threads)
+execute_assert_pass(${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/memmove_threads)
+
+cleanup()
diff --git a/src/deps/miniasync/tests/memset_sync/memset_sync.c b/src/deps/miniasync/tests/memset_sync/memset_sync.c
new file mode 100644
index 0000000000000000000000000000000000000000..23f8c74d90231e299593364d83f20983c4f90523
--- /dev/null
+++ b/src/deps/miniasync/tests/memset_sync/memset_sync.c
@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2022, Intel Corporation */
+
+#include <stdlib.h>
+#include <string.h>
+#include "libminiasync.h"
+#include "test_helpers.h"
+
+int
+test_memset(char c)
+{
+	int ret = 0;
+
+	size_t buffer_size = strlen("teststring");
+
+	char *buffer = malloc(buffer_size + 1);
+	if (buffer == NULL) {
+		fprintf(stderr,
+				"memory for the first buffer could not be allocated");
+		return 1;
+	}
+
+	char *test_buffer = malloc(buffer_size + 1);
+	if (test_buffer == NULL) {
+		fprintf(stderr,
+				"memory for the second buffer could not be allocated");
+		goto cleanup_1;
+	}
+
+	memcpy(buffer, "teststring", buffer_size + 1);
+	memcpy(test_buffer, buffer, buffer_size + 1);
+
+	struct data_mover_sync *dms = data_mover_sync_new();
+	if (dms == NULL) {
+		ret = 1;
+		fprintf(stderr,
+				"error while creating synchronous data mover");
+		goto cleanup_2;
+	}
+
+	struct vdm *sync_mover = data_mover_sync_get_vdm(dms);
+	if (sync_mover == NULL) {
+		ret = 1;
+		fprintf(stderr,
+				"error while extracting synchronous vdm");
+		goto cleanup_3;
+	}
+
+	struct vdm_operation_future test_memset_fut =
+		vdm_memset(sync_mover, buffer, c, buffer_size / 2, 0);
+
+	FUTURE_BUSY_POLL(&test_memset_fut);
+
+	for (size_t i = 0; i < buffer_size / 2; i++) {
+		UT_ASSERTeq(buffer[i], c);
+	}
+
+	for (size_t i = buffer_size / 2; i < buffer_size + 1; i++) {
+		UT_ASSERTeq(buffer[i], test_buffer[i]);
+	}
+
+	cleanup_3:
+	data_mover_sync_delete(dms);
+
+	cleanup_2:
+	free(test_buffer);
+
+	cleanup_1:
+	free(buffer);
+
+	return ret;
+}
+
+int
+main(void)
+{
+	return
+		test_memset('!') ||
+		test_memset('a') ||
+		test_memset('X') ||
+		test_memset((char)0xA5) ||
+		test_memset((char)0x5A);
+}
diff --git a/src/deps/miniasync/tests/memset_sync/test_memset_sync.cmake b/src/deps/miniasync/tests/memset_sync/test_memset_sync.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..3e19bee069d4c3336afef4c80b4bac25d1f670bb
--- /dev/null
+++ b/src/deps/miniasync/tests/memset_sync/test_memset_sync.cmake
@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright 2022, Intel Corporation
+
+include(${SRC_DIR}/cmake/test_helpers.cmake)
+
+setup()
+
+execute(0 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/memset_sync)
+execute_assert_pass(${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/memset_sync)
+
+cleanup()
diff --git a/src/deps/miniasync/tests/memset_threads/memset_threads.c b/src/deps/miniasync/tests/memset_threads/memset_threads.c
new file mode 100644
index 0000000000000000000000000000000000000000..aff895e9cee3f7d6542f497f285849a95f56db74
--- /dev/null
+++ b/src/deps/miniasync/tests/memset_threads/memset_threads.c
@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2022, Intel Corporation */
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "libminiasync.h"
+#include "core/os.h"
+#include "test_helpers.h"
+
+int
+test_thread_memset_single(size_t str_len)
+{
+	int ret = 0;
+	unsigned seed = (unsigned)time(NULL);
+	fprintf(stdout, "seed: %u\n", seed);
+	struct runtime *r = runtime_new();
+	struct data_mover_threads *dmt = data_mover_threads_default();
+
+	if (dmt == NULL) {
+		runtime_delete(r);
+		return 1;
+	}
+
+	struct vdm *vdm = data_mover_threads_get_vdm(dmt);
+
+	char *buf_a = malloc(str_len);
+
+	if (buf_a == NULL)
+		UT_FATAL("buffer out of memory");
+
+	char symbol = (char)os_rand_r(&seed) % 256;
+
+	struct vdm_operation_future test_memset_fut =
+		vdm_memset(vdm, buf_a, symbol, str_len, 0);
+
+	struct future *future_memset = FUTURE_AS_RUNNABLE(&test_memset_fut);
+
+	runtime_wait(r, future_memset);
+
+	for (size_t i = 0; i < str_len; i++) {
+		UT_ASSERTeq(buf_a[i], symbol);
+	}
+
+	free(buf_a);
+
+	runtime_delete(r);
+	data_mover_threads_delete(dmt);
+
+	return ret;
+}
+
+int
+test_thread_memset_multiple(size_t str_len)
+{
+	int ret = 0;
+	unsigned seed = (unsigned)time(NULL);
+	fprintf(stdout, "seed: %u\n", seed);
+	struct runtime *r = runtime_new();
+	struct data_mover_threads *dmt = data_mover_threads_default();
+
+	if (dmt == NULL) {
+		fprintf(stderr,
+				"error while creating synchronous data mover");
+		runtime_delete(r);
+		return 1;
+	}
+
+	struct vdm *vdm = data_mover_threads_get_vdm(dmt);
+
+	char *buf_a = malloc(str_len);
+	char *buf_b = malloc(str_len);
+
+	if (!buf_a || !buf_b)
+		UT_FATAL("buffers out of memory");
+
+	char symbol_first = (char)os_rand_r(&seed) % 256;
+	char symbol_second = (char)os_rand_r(&seed) % 256;
+
+	struct future **futures = malloc(sizeof(struct future *) * 4);
+	if (futures == NULL)
+		UT_FATAL("futures out of memory");
+
+	struct vdm_operation_future memmove_fut_symbol_f_to_a =
+		vdm_memset(vdm, buf_a, symbol_first, str_len / 2, 0);
+
+	struct vdm_operation_future memmove_fut_symbol_s_to_a =
+		vdm_memset(vdm, buf_a + str_len / 2, symbol_second,
+			str_len / 2, 0);
+
+	struct vdm_operation_future memmove_fut_symbol_s_to_b =
+		vdm_memset(vdm, buf_b, symbol_second, str_len / 2, 0);
+
+	struct vdm_operation_future memmove_fut_symbol_f_to_b =
+		vdm_memset(vdm, buf_b + str_len / 2, symbol_first,
+			str_len / 2, 0);
+
+	futures[0] = FUTURE_AS_RUNNABLE(&memmove_fut_symbol_f_to_a);
+	futures[1] = FUTURE_AS_RUNNABLE(&memmove_fut_symbol_s_to_a);
+	futures[2] = FUTURE_AS_RUNNABLE(&memmove_fut_symbol_s_to_b);
+	futures[3] = FUTURE_AS_RUNNABLE(&memmove_fut_symbol_f_to_b);
+
+	runtime_wait_multiple(r, futures, 4);
+
+	for (size_t i = 0; i < str_len / 2; i++) {
+		UT_ASSERTeq(buf_a[i], symbol_first);
+		UT_ASSERTeq(buf_b[i], symbol_second);
+	}
+
+	for (size_t i = str_len / 2; i < str_len; i++) {
+		UT_ASSERTeq(buf_a[i], symbol_second);
+		UT_ASSERTeq(buf_b[i], symbol_first);
+	}
+
+	free(buf_a);
+	free(buf_b);
+	free(futures);
+
+	runtime_delete(r);
+	data_mover_threads_delete(dmt);
+
+	return ret;
+}
+
+int
+main(void)
+{
+	return
+		test_thread_memset_single(100000000) ||
+		test_thread_memset_single(300000000) ||
+		test_thread_memset_single(500000000) ||
+		test_thread_memset_multiple(100000000) ||
+		test_thread_memset_multiple(300000000) ||
+		test_thread_memset_multiple(500000000);
+}
diff --git a/src/deps/miniasync/tests/memset_threads/test_memset_threads.cmake b/src/deps/miniasync/tests/memset_threads/test_memset_threads.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..791f75021160f54bc1ace24b473038b837b52b01
--- /dev/null
+++ b/src/deps/miniasync/tests/memset_threads/test_memset_threads.cmake
@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright 2022, Intel Corporation
+
+include(${SRC_DIR}/cmake/test_helpers.cmake)
+
+setup()
+
+execute(0 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/memset_threads)
+execute_assert_pass(${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/memset_threads)
+
+cleanup()