diff --git a/src/deps/miniasync/ChangeLog b/src/deps/miniasync/ChangeLog
new file mode 100644
index 00000000000..8e1c8ad270b
--- /dev/null
+++ b/src/deps/miniasync/ChangeLog
@@ -0,0 +1,15 @@
+Wed Apr 22 2022 Weronika Lewandowska <weronika.lewandowska@intel.com>
+
+	* Version 0.1.0
+
+	This is the first official release of the miniasync library.
+ 
+	The library provides the API for asynchronous memory operations
+	through the use of features and runtime mechanisms and independence
+	in terms of hardware by implementing a virtual data mover.
+	
+	This release also contains:
+	- documentation on the implemented functionality
+	- basic examples
+	- working build system based on GHA
+	- functional test cases
diff --git a/src/deps/miniasync/doc/data_mover_dml_get_vdm.3.md b/src/deps/miniasync/doc/data_mover_dml_get_vdm.3.md
index b724a29cac7..ef5c1955afb 100644
--- a/src/deps/miniasync/doc/data_mover_dml_get_vdm.3.md
+++ b/src/deps/miniasync/doc/data_mover_dml_get_vdm.3.md
@@ -45,6 +45,8 @@ structure *struct vdm* is needed by every **miniasync**(7) data mover operation.
 **DML** 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_dml_get_vdm**() function returns a pointer to *struct vdm* stru
 
 # SEE ALSO #
 
-**vdm_memcpy**(3), **miniasync**(7),
-**miniasync_vdm_dml**(7) and **<https://pmem.io>**
+**vdm_memcpy**(3), **vdm_memmove**(3), **vdm_memset**(3),
+ **miniasync**(7), **miniasync_vdm_dml**(7) and **<https://pmem.io>**
diff --git a/src/deps/miniasync/doc/miniasync_vdm_dml.7.md b/src/deps/miniasync/doc/miniasync_vdm_dml.7.md
index 1337fb6af14..9e720c20961 100644
--- a/src/deps/miniasync/doc/miniasync_vdm_dml.7.md
+++ b/src/deps/miniasync/doc/miniasync_vdm_dml.7.md
@@ -60,6 +60,8 @@ To create a new **DML** data mover instance, use **data_mover_dml_new**(3) funct
 **DML** data mover supports following operations:
 
 * **vdm_memcpy**(3) - memory copy operation
+* **vdm_memmove**(3) - memory move operation
+* **vdm_memset**(3) - memory set operation
 
 **DML** data mover does not support notifier feature. For more information about
 notifiers, see **miniasync_future**(7).
@@ -78,6 +80,6 @@ struct vdm_memcpy_future memcpy_fut = vdm_memcpy(dml_mover, dest, src,
 # SEE ALSO #
 
 **data_mover_dml_new**(3), **data_mover_dml_get_vdm**(3),
-**vdm_memcpy**(3), **miniasync**(7), **miniasync_future**(7),
-**miniasync_vdm**(7), **<https://github.com/intel/DML>**
-and **<https://pmem.io>**
+**vdm_memcpy**(3), **vdm_memmove**(3), **vdm_memset**(3),
+**miniasync**(7), **miniasync_future**(7), **miniasync_vdm**(7),
+**<https://github.com/intel/DML>** and **<https://pmem.io>**
diff --git a/src/deps/miniasync/extras/dml/CMakeLists.txt b/src/deps/miniasync/extras/dml/CMakeLists.txt
index 739fefc3918..99c09753a6a 100644
--- a/src/deps/miniasync/extras/dml/CMakeLists.txt
+++ b/src/deps/miniasync/extras/dml/CMakeLists.txt
@@ -20,18 +20,11 @@ add_check_whitespace(miniasync-vdm-dml
 	${CMAKE_CURRENT_SOURCE_DIR}/utils/*.[ch])
 
 set(DML_SOURCES
-    data_mover_dml.c
+	data_mover_dml.c
 )
 
-set(DML_CORE_DEPS
-	${CORE_SOURCE_DIR}/cpu.c
-	${CORE_SOURCE_DIR}/os_posix.c
-	${CORE_SOURCE_DIR}/os_thread_posix.c
-	${CORE_SOURCE_DIR}/out.c
-	${CORE_SOURCE_DIR}/util.c
-	${CORE_SOURCE_DIR}/util_posix.c)
-
-add_library(miniasync-vdm-dml SHARED ${DML_SOURCES} ${DML_CORE_DEPS})
+add_library(miniasync-vdm-dml SHARED ${DML_SOURCES})
+target_link_libraries(miniasync-vdm-dml PRIVATE dml dl)
 
 target_include_directories(miniasync-vdm-dml PRIVATE .
 	${MINIASYNC_DML_INCLUDE_DIR}
@@ -59,4 +52,4 @@ set(CHECK_MOVDIR64B_SOURCES
 
 add_link_executable(check_movdir64b
 	"${CHECK_MOVDIR64B_SOURCES}"
-	"")
+	"dml")
diff --git a/src/deps/miniasync/extras/dml/data_mover_dml.c b/src/deps/miniasync/extras/dml/data_mover_dml.c
index 67384af3404..e76f459f53f 100644
--- a/src/deps/miniasync/extras/dml/data_mover_dml.c
+++ b/src/deps/miniasync/extras/dml/data_mover_dml.c
@@ -8,7 +8,6 @@
 
 #include "core/membuf.h"
 #include "core/out.h"
-#include "core/util.h"
 #include "libminiasync-vdm-dml.h"
 
 #define SUPPORTED_FLAGS VDM_F_MEM_DURABLE | VDM_F_NO_CACHE_HINT
@@ -72,19 +71,69 @@ data_mover_dml_memcpy_job_init(dml_job_t *dml_job,
 }
 
 /*
- * data_mover_dml_memcpy_job_delete -- delete job struct
+ * data_mover_dml_memmove_job_init -- initializes new memmove dml job
+ */
+static dml_job_t *
+data_mover_dml_memmove_job_init(dml_job_t *dml_job,
+	void *dest, void *src, size_t n, uint64_t flags)
+{
+	uint64_t dml_flags = 0;
+	data_mover_dml_translate_flags(flags, &dml_flags);
+
+	dml_job->operation = DML_OP_MEM_MOVE;
+	dml_job->source_first_ptr = (uint8_t *)src;
+	dml_job->destination_first_ptr = (uint8_t *)dest;
+	dml_job->source_length = n;
+	dml_job->destination_length = n;
+	dml_job->flags = dml_flags;
+
+	return dml_job;
+}
+
+/*
+ * data_mover_dml_memset_job_init -- initializes new memset dml job
+ */
+static dml_job_t *
+data_mover_dml_memset_job_init(dml_job_t *dml_job,
+	void *ptr, int value, size_t n, uint64_t flags)
+{
+	uint64_t dml_flags = 0;
+	data_mover_dml_translate_flags(flags, &dml_flags);
+
+	dml_job->operation = DML_OP_FILL;
+	dml_job->destination_first_ptr = (uint8_t *)ptr;
+	dml_job->destination_length = n;
+	dml_job->flags = dml_flags;
+
+	/*
+	 * Original 'memset' implementation converts the provided 'value' into
+	 * a 'unsigned char' type.
+	 */
+	unsigned char c = (unsigned char)value;
+
+	/* Populate the pattern */
+	for (size_t i = 0; i < 8 && i < n; i++) {
+		dml_job->pattern[i] = (uint8_t)c;
+	}
+
+	return dml_job;
+}
+
+/*
+ * data_mover_dml_job_delete -- delete job struct
  */
 static void
-data_mover_dml_memcpy_job_delete(dml_job_t **dml_job)
+data_mover_dml_job_delete(dml_job_t **dml_job)
 {
 	dml_finalize_job(*dml_job);
 }
 
 /*
- * data_mover_dml_memcpy_job_submit -- submit memcpy job (nonblocking)
+ * data_mover_dml_memory_op_job_submit -- submit job for memory operations,
+ * which include memcpy and memmove (nonblocking)
  */
 static void *
-data_mover_dml_memcpy_job_submit(dml_job_t *dml_job)
+data_mover_dml_memory_op_job_submit(dml_job_t *dml_job)
 {
 	dml_status_t status;
 	status = dml_submit_job(dml_job);
@@ -105,28 +154,30 @@ data_mover_dml_operation_new(struct vdm *vdm,
 	dml_job_t *dml_job;
 
 	switch (type) {
-		case VDM_OPERATION_MEMCPY: {
-			status = dml_get_job_size(vdm_dml->path, &job_size);
-			if (status != DML_STATUS_OK)
-				return NULL;
-
-			dml_job = membuf_alloc(vdm_dml->membuf, job_size);
-			if (dml_job == NULL)
-				return NULL;
-
-			dml_status_t status =
-				dml_init_job(vdm_dml->path, dml_job);
-			if (status != DML_STATUS_OK) {
-				membuf_free(dml_job);
-				return NULL;
-			}
-
-			return dml_job;
-		}
+		case VDM_OPERATION_MEMCPY:
+		case VDM_OPERATION_MEMMOVE:
+		case VDM_OPERATION_MEMSET:
+			break;
 		default:
-		ASSERT(0); /* unreachable */
+			ASSERT(0); /* unreachable */
+	}
+
+	status = dml_get_job_size(vdm_dml->path, &job_size);
+	if (status != DML_STATUS_OK)
+		return NULL;
+
+	dml_job = membuf_alloc(vdm_dml->membuf, job_size);
+	if (dml_job == NULL)
+		return NULL;
+
+	dml_status_t job_status =
+		dml_init_job(vdm_dml->path, dml_job);
+	if (job_status != DML_STATUS_OK) {
+		membuf_free(dml_job);
+		return NULL;
 	}
-	return NULL;
+
+	return dml_job;
 }
 
 /*
@@ -154,15 +205,25 @@ data_mover_dml_operation_delete(void *data,
 
 	switch (job->operation) {
 		case DML_OP_MEM_MOVE:
-			output->type = VDM_OPERATION_MEMCPY;
-			output->output.memcpy.dest =
-				job->destination_first_ptr;
+			if (job->flags & DML_FLAG_COPY_ONLY) {
+				output->type = VDM_OPERATION_MEMCPY;
+				output->output.memcpy.dest =
+					job->destination_first_ptr;
+			} else {
+				output->type = VDM_OPERATION_MEMMOVE;
+				output->output.memmove.dest =
+					job->destination_first_ptr;
+			}
+			break;
+		case DML_OP_FILL:
+			output->type = VDM_OPERATION_MEMSET;
+			output->output.memset.str = job->destination_first_ptr;
 			break;
 		default:
 			ASSERT(0);
 	}
 
-	data_mover_dml_memcpy_job_delete(&job);
+	data_mover_dml_job_delete(&job);
 
 	membuf_free(data);
 }
@@ -202,13 +263,35 @@ data_mover_dml_operation_start(void *data,
 	}
 
 	dml_job_t *job = (dml_job_t *)data;
-	data_mover_dml_memcpy_job_init(job,
-		operation->data.memcpy.dest,
-		operation->data.memcpy.src,
-		operation->data.memcpy.n,
-		operation->data.memcpy.flags);
 
-	data_mover_dml_memcpy_job_submit(job);
+	switch (operation->type) {
+		case VDM_OPERATION_MEMCPY:
+				data_mover_dml_memcpy_job_init(job,
+					operation->data.memcpy.dest,
+					operation->data.memcpy.src,
+					operation->data.memcpy.n,
+					operation->data.memcpy.flags);
+				data_mover_dml_memory_op_job_submit(job);
+				break;
+		case VDM_OPERATION_MEMMOVE:
+				data_mover_dml_memmove_job_init(job,
+					operation->data.memmove.dest,
+					operation->data.memmove.src,
+					operation->data.memmove.n,
+					operation->data.memmove.flags);
+				data_mover_dml_memory_op_job_submit(job);
+			break;
+		case VDM_OPERATION_MEMSET:
+				data_mover_dml_memset_job_init(job,
+					operation->data.memset.str,
+					operation->data.memset.c,
+					operation->data.memset.n,
+					operation->data.memset.flags);
+				data_mover_dml_memory_op_job_submit(job);
+			break;
+		default:
+			ASSERT(0);
+	}
 
 	return 0;
 }
diff --git a/src/deps/miniasync/src/CMakeLists.txt b/src/deps/miniasync/src/CMakeLists.txt
index 2d1304726be..392823749bc 100644
--- a/src/deps/miniasync/src/CMakeLists.txt
+++ b/src/deps/miniasync/src/CMakeLists.txt
@@ -59,6 +59,7 @@ if(WIN32)
 endif()
 
 set_target_properties(miniasync PROPERTIES
+	SOVERSION 0.1.0-rc1
 	PUBLIC_HEADER ${MINIASYNC_INCLUDE_DIR}/libminiasync.h
 )
 
diff --git a/src/deps/miniasync/src/core/cpu.c b/src/deps/miniasync/src/core/cpu.c
index 7d65ef0b9c3..e47c502037a 100644
--- a/src/deps/miniasync/src/core/cpu.c
+++ b/src/deps/miniasync/src/core/cpu.c
@@ -17,6 +17,9 @@
 
 #include "cpu.h"
 
+#if defined(__x86_64__) || defined(__amd64__) || defined(_M_X64) || \
+	defined(_M_AMD64)
+
 #define EAX_IDX 0
 #define EBX_IDX 1
 #define ECX_IDX 2
@@ -43,10 +46,6 @@ cpuid(unsigned func, unsigned subfunc, unsigned cpuinfo[4])
 	__cpuidex((int *)cpuinfo, (int)func, (int)subfunc);
 }
 
-#else
-
-#error unsupported compiler
-
 #endif
 
 #ifndef bit_MOVDIR64B
@@ -78,3 +77,12 @@ is_cpu_movdir64b_present(void)
 {
 	return is_cpu_feature_present(0x7, ECX_IDX, bit_MOVDIR64B);
 }
+
+#else
+
+/*
+ * Nothing to be done here yet. There is no support for 64B atomic copy on
+ * the other architectures yet.
+ */
+
+#endif
diff --git a/src/deps/miniasync/src/core/cpu.h b/src/deps/miniasync/src/core/cpu.h
index 837d9a75c1d..fc14dc35021 100644
--- a/src/deps/miniasync/src/core/cpu.h
+++ b/src/deps/miniasync/src/core/cpu.h
@@ -8,6 +8,11 @@
  * cpu.h -- definitions for "cpu" module
  */
 
+#if defined(__x86_64__) || defined(__amd64__) || defined(_M_X64) || \
+	defined(_M_AMD64)
+
 int is_cpu_movdir64b_present(void);
 
 #endif
+
+#endif
diff --git a/src/deps/miniasync/src/core/util.h b/src/deps/miniasync/src/core/util.h
index 112db635493..acd45aac773 100644
--- a/src/deps/miniasync/src/core/util.h
+++ b/src/deps/miniasync/src/core/util.h
@@ -577,6 +577,23 @@ static
 #define SUPPRESS_ARG_8(X, ...) SUPPRESS_ARG_1(X); SUPPRESS_ARG_7(__VA_ARGS__)
 #define SUPPRESS_ARG_9(X, ...) SUPPRESS_ARG_1(X); SUPPRESS_ARG_8(__VA_ARGS__)
 
+#if defined(__x86_64__) || defined(__amd64__) || defined(_M_X64) || \
+	defined(_M_AMD64)
+
+#include <emmintrin.h>
+#define WAIT() _mm_pause()
+
+#else
+
+/*
+ * Notice there are better implementations for wait-like functions on other
+ * architectures (e.g. powerpc64le), but the current code is generic enough
+ * and doesn't break the build.
+ */
+#define WAIT() do {} while (0)
+
+#endif
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/deps/miniasync/src/include/libminiasync/future.h b/src/deps/miniasync/src/include/libminiasync/future.h
index a7ba6a82be4..d20f582041e 100644
--- a/src/deps/miniasync/src/include/libminiasync/future.h
+++ b/src/deps/miniasync/src/include/libminiasync/future.h
@@ -63,8 +63,17 @@
 
 #include <stddef.h>
 #include <stdint.h>
+
+#if defined(__x86_64__) || defined(__amd64__) || defined(_M_X64) || \
+	defined(_M_AMD64)
 #include <emmintrin.h>
 
+#define __FUTURE_WAIT() _mm_pause()
+#else
+#include <sched.h>
+#define __FUTURE_WAIT() sched_yield()
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -261,7 +270,7 @@ future_poll(struct future *fut, struct future_notifier *notifier)
 
 #define FUTURE_BUSY_POLL(_futurep)\
 while (future_poll(FUTURE_AS_RUNNABLE((_futurep)), NULL) !=\
-	FUTURE_STATE_COMPLETE) { _mm_pause(); }
+	FUTURE_STATE_COMPLETE) { __FUTURE_WAIT(); }
 
 static inline enum future_state
 async_chain_impl(struct future_context *ctx, struct future_notifier *notifier)
diff --git a/src/deps/miniasync/src/runtime.c b/src/deps/miniasync/src/runtime.c
index f88fc2174a9..beb648aedcd 100644
--- a/src/deps/miniasync/src/runtime.c
+++ b/src/deps/miniasync/src/runtime.c
@@ -1,10 +1,12 @@
 // SPDX-License-Identifier: BSD-3-Clause
 /* Copyright 2021-2022, Intel Corporation */
 
+#include <stdlib.h>
+
 #include "libminiasync/runtime.h"
 #include "core/os_thread.h"
 #include "core/os.h"
-#include <emmintrin.h>
+#include "core/util.h"
 
 struct runtime_waker_data {
 	os_cond_t *cond;
@@ -105,7 +107,7 @@ runtime_wait_multiple(struct runtime *runtime, struct future *futs[],
 			if (ndone == nfuts)
 				return;
 
-			_mm_pause();
+			WAIT();
 		}
 		runtime_sleep(runtime);
 	}
diff --git a/src/deps/miniasync/tests/CMakeLists.txt b/src/deps/miniasync/tests/CMakeLists.txt
index 93e0d096f13..2263cfcf155 100644
--- a/src/deps/miniasync/tests/CMakeLists.txt
+++ b/src/deps/miniasync/tests/CMakeLists.txt
@@ -12,10 +12,12 @@ set(LIBS_BASIC
 
 set(LIBS_DML
 	miniasync-vdm-dml
-	dl
-	dml
 	${LIBS_BASIC})
 
+set(SOURCES_UTIL_DML
+	${CORE_SOURCE_DIR}/cpu.c
+	${MINIASYNC_DML_SOURCE_DIR}/utils/util_dml.c)
+
 set(SOURCES_DUMMY_TEST
 	dummy/dummy.c)
 
@@ -28,9 +30,17 @@ set(SOURCES_FUTURE_TEST
 set(SOURCES_MEMCPY_PTHREADS_TEST
 	memcpy_threads/memcpy_threads.c)
 
-set(SOURCES_DATA_MOVER_DML_TEST
-	data_mover_dml/data_mover_dml.c
-	${MINIASYNC_DML_SOURCE_DIR}/utils/util_dml.c)
+set(SOURCES_DATA_MOVER_DML_TEST_MEMCPY
+	data_mover_dml_memcpy/data_mover_dml_memcpy.c
+	${SOURCES_UTIL_DML})
+
+set(SOURCES_DATA_MOVER_DML_TEST_MEMMOVE
+	data_mover_dml_memmove/data_mover_dml_memmove.c
+	${SOURCES_UTIL_DML})
+
+set(SOURCES_DATA_MOVER_DML_TEST_MEMSET
+	data_mover_dml_memset/data_mover_dml_memset.c
+	${SOURCES_UTIL_DML})
 
 set(SOURCES_MEMBUF_TEST
 	membuf/membuf_simple.c)
@@ -46,7 +56,7 @@ set(SOURCES_MEMSET_SYNC_TEST
 
 set(SOURCES_VDM_OPERATION_FUTURE_POLL
 	vdm_operation_future_poll/vdm_operation_future_poll.c
-	${MINIASYNC_DML_SOURCE_DIR}/utils/util_dml.c)
+	${SOURCES_UTIL_DML})
 
 set(SOURCES_MEMMOVE_THREADS_TEST
 	memmove_threads/memmove_threads.c)
@@ -138,14 +148,24 @@ endif()
 
 # add miniasync-vdm-dml test only if the sources in extras/dml were compiled
 if (COMPILE_DML)
-	add_link_executable(data_mover_dml
-			"${SOURCES_DATA_MOVER_DML_TEST}"
+	add_link_executable(data_mover_dml_memcpy
+			"${SOURCES_DATA_MOVER_DML_TEST_MEMCPY}"
+			"${LIBS_DML}")
+
+	add_link_executable(data_mover_dml_memmove
+			"${SOURCES_DATA_MOVER_DML_TEST_MEMMOVE}"
+			"${LIBS_DML}")
+
+	add_link_executable(data_mover_dml_memset
+			"${SOURCES_DATA_MOVER_DML_TEST_MEMSET}"
 			"${LIBS_DML}")
 
 	add_link_executable(vdm_operation_future_poll
 			"${SOURCES_VDM_OPERATION_FUTURE_POLL}"
 			"${LIBS_DML}")
 
-	test("data_mover_dml" "data_mover_dml" test_data_mover_dml none)
+	test("data_mover_dml_memcpy" "data_mover_dml_memcpy" test_data_mover_dml_memcpy none)
+	test("data_mover_dml_memmove" "data_mover_dml_memmove" test_data_mover_dml_memmove none)
+	test("data_mover_dml_memset" "data_mover_dml_memset" test_data_mover_dml_memset none)
 	test("vdm_operation_future_poll" "vdm_operation_future_poll" test_vdm_operation_future_poll none)
 endif()
diff --git a/src/deps/miniasync/tests/cmake/ctest_helpers.cmake b/src/deps/miniasync/tests/cmake/ctest_helpers.cmake
index 24876c46afc..79b2228fc90 100644
--- a/src/deps/miniasync/tests/cmake/ctest_helpers.cmake
+++ b/src/deps/miniasync/tests/cmake/ctest_helpers.cmake
@@ -23,6 +23,13 @@ function(add_link_executable name sources libs)
 	target_include_directories(${name}
 		PRIVATE ${CORE_SOURCE_DIR})
 
+if(WIN32)
+	target_include_directories(${name}
+		PRIVATE ${MINIASYNC_INCLUDE_DIR_WIN}/sys)
+	target_include_directories(${name}
+		PRIVATE ${MINIASYNC_INCLUDE_DIR_WIN})
+endif()
+
 	target_link_libraries(${name} PRIVATE ${libs})
 endfunction()
 
diff --git a/src/deps/miniasync/tests/data_mover_dml/test_data_mover_dml.cmake b/src/deps/miniasync/tests/data_mover_dml/test_data_mover_dml.cmake
deleted file mode 100644
index fbeee1d5fa1..00000000000
--- a/src/deps/miniasync/tests/data_mover_dml/test_data_mover_dml.cmake
+++ /dev/null
@@ -1,18 +0,0 @@
-# SPDX-License-Identifier: BSD-3-Clause
-# Copyright 2021-2022, Intel Corporation
-
-# an example for the data_mover_dml test case
-
-include(${SRC_DIR}/cmake/test_helpers.cmake)
-
-setup()
-
-# check for MOVDIR64B instruction
-check_movdir64b()
-
-# execute DML tests only if MOVDIR64B instruction is available
-if (MOVDIR64B EQUAL 1)
-	execute(0 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/data_mover_dml)
-endif()
-
-cleanup()
diff --git a/src/deps/miniasync/tests/data_mover_dml/data_mover_dml.c b/src/deps/miniasync/tests/data_mover_dml_memcpy/data_mover_dml_memcpy.c
similarity index 87%
rename from src/deps/miniasync/tests/data_mover_dml/data_mover_dml.c
rename to src/deps/miniasync/tests/data_mover_dml_memcpy/data_mover_dml_memcpy.c
index 3d66ec05106..67b706dc24e 100644
--- a/src/deps/miniasync/tests/data_mover_dml/data_mover_dml.c
+++ b/src/deps/miniasync/tests/data_mover_dml_memcpy/data_mover_dml_memcpy.c
@@ -64,7 +64,13 @@ int test_supported_flags() {
 		data_mover_dml_new(DATA_MOVER_DML_SOFTWARE);
 	struct vdm *dml_mover = data_mover_dml_get_vdm(dmd);
 	int ret = test_flag(dml_mover, VDM_F_MEM_DURABLE, 1);
-	ret += test_flag(dml_mover, VDM_F_NO_CACHE_HINT, 1);
+
+	/*
+	 * The code below is temporarily commented because VDM_F_NO_CACHE_HINT
+	 * flag turned out to be not implemented in the hardware.
+	 *
+	 * ret += test_flag(dml_mover, VDM_F_NO_CACHE_HINT, 1);
+	 */
 
 	data_mover_dml_delete(dmd);
 	return ret;
@@ -85,6 +91,8 @@ main(void)
 		ret = test_dml_hw_path_flag_memcpy();
 		if (ret)
 			return ret;
+	} else {
+		UT_LOG_SKIP("test_dml_hw_path_flag_memmove");
 	}
 
 	ret = test_supported_flags();
diff --git a/src/deps/miniasync/tests/data_mover_dml_memcpy/test_data_mover_dml_memcpy.cmake b/src/deps/miniasync/tests/data_mover_dml_memcpy/test_data_mover_dml_memcpy.cmake
new file mode 100644
index 00000000000..8a060124846
--- /dev/null
+++ b/src/deps/miniasync/tests/data_mover_dml_memcpy/test_data_mover_dml_memcpy.cmake
@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright 2021-2022, Intel Corporation
+
+# an example for the data_mover_dml test case
+
+include(${SRC_DIR}/cmake/test_helpers.cmake)
+
+setup()
+
+# check for MOVDIR64B instruction
+check_movdir64b()
+
+# inform that some test cases involving 'mvodir64b' instruction will be skipped
+if (MOVDIR64B EQUAL 0)
+	message(STATUS "movdir64b instruction not available, some test cases will be skipped!")
+endif()
+
+execute(0 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/data_mover_dml_memcpy)
+
+execute_assert_pass(${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/data_mover_dml_memcpy)
+
+cleanup()
diff --git a/src/deps/miniasync/tests/data_mover_dml_memmove/data_mover_dml_memmove.c b/src/deps/miniasync/tests/data_mover_dml_memmove/data_mover_dml_memmove.c
new file mode 100644
index 00000000000..99166bab552
--- /dev/null
+++ b/src/deps/miniasync/tests/data_mover_dml_memmove/data_mover_dml_memmove.c
@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2022, Intel Corporation */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libminiasync.h>
+#include <libminiasync-vdm-dml.h>
+#include "util_dml.h"
+#include "test_helpers.h"
+
+static int
+dml_memmove(enum data_mover_dml_type type, uint64_t flags, size_t size)
+{
+	/* assert that size is a multiply of 4 */
+	if (size % 4 != 0) {
+		fprintf(stderr,
+				"size parameter is not a multiply of 4");
+		return 1;
+	}
+
+	char *buffer = malloc(size);
+	if (buffer == NULL) {
+		fprintf(stderr,
+				"memory for the buffer could not be allocated");
+		return 1;
+	}
+
+	/* fill up the buffer with 'As', 'Bs' and 'Cs' */
+	memset(buffer, 'A', size / 4);
+	memset(buffer + size / 4, 'B', size / 4);
+	memset(buffer + 2 * size / 4, 'C', size / 4);
+
+	struct runtime *r = runtime_new();
+
+	struct data_mover_dml *dmd = data_mover_dml_new(type);
+	struct vdm *dml_mover_async = data_mover_dml_get_vdm(dmd);
+
+	/*
+	 * Copy 'As' and 'Bs' from the beginning of the buffer
+	 * to the address where 'Bs' start.
+	 */
+	struct vdm_operation_future test_memmove_fut =
+		vdm_memmove(dml_mover_async, buffer + size / 4,
+					buffer, 2 * size / 4, 0);
+
+	runtime_wait(r, FUTURE_AS_RUNNABLE(&test_memmove_fut));
+
+	for (size_t i = 0; i < 2 * size / 4; i++) {
+		UT_ASSERTeq(buffer[i], 'A');
+	}
+
+	for (size_t i = 2 * size / 4; i < 3 * size / 4; i++) {
+		UT_ASSERTeq(buffer[i], 'B');
+	}
+
+	data_mover_dml_delete(dmd);
+
+	runtime_delete(r);
+	free(buffer);
+
+	return 0;
+}
+
+static int
+test_dml_basic_memmove()
+{
+	return
+		dml_memmove(DATA_MOVER_DML_SOFTWARE, 0, 4) ||
+		dml_memmove(DATA_MOVER_DML_SOFTWARE, 0, 12) ||
+		dml_memmove(DATA_MOVER_DML_SOFTWARE, 0, 1024);
+}
+
+static int
+test_dml_durable_flag_memmove()
+{
+	return
+		dml_memmove(DATA_MOVER_DML_SOFTWARE,
+					VDM_F_MEM_DURABLE, 4) ||
+		dml_memmove(DATA_MOVER_DML_SOFTWARE,
+					VDM_F_MEM_DURABLE, 12) ||
+		dml_memmove(DATA_MOVER_DML_SOFTWARE,
+					VDM_F_MEM_DURABLE, 1024);
+}
+
+static int
+test_dml_hw_path_flag_memmove()
+{
+	return
+		dml_memmove(DATA_MOVER_DML_HARDWARE, 0, 4) ||
+		dml_memmove(DATA_MOVER_DML_HARDWARE, 0, 12) ||
+		dml_memmove(DATA_MOVER_DML_HARDWARE, 0, 1024);
+}
+
+int
+main(void)
+{
+	int ret = test_dml_basic_memmove();
+	if (ret)
+		return ret;
+
+	ret = test_dml_durable_flag_memmove();
+	if (ret)
+		return ret;
+
+	if (util_dml_check_hw_available() == 0) {
+		ret = test_dml_hw_path_flag_memmove();
+		if (ret)
+			return ret;
+	} else {
+		UT_LOG_SKIP("test_dml_hw_path_flag_memmove");
+	}
+
+	return 0;
+}
diff --git a/src/deps/miniasync/tests/data_mover_dml_memmove/test_data_mover_dml_memmove.cmake b/src/deps/miniasync/tests/data_mover_dml_memmove/test_data_mover_dml_memmove.cmake
new file mode 100644
index 00000000000..fdd40f4c230
--- /dev/null
+++ b/src/deps/miniasync/tests/data_mover_dml_memmove/test_data_mover_dml_memmove.cmake
@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright 2022, Intel Corporation
+
+# an example for the data_mover_dml test case
+
+include(${SRC_DIR}/cmake/test_helpers.cmake)
+
+setup()
+
+# check for MOVDIR64B instruction
+check_movdir64b()
+
+# inform that some test cases involving 'mvodir64b' instruction will be skipped
+if (MOVDIR64B EQUAL 0)
+	message(STATUS "movdir64b instruction not available, some test cases will be skipped!")
+endif()
+
+execute(0 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/data_mover_dml_memmove)
+
+execute_assert_pass(${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/data_mover_dml_memmove)
+
+cleanup()
diff --git a/src/deps/miniasync/tests/data_mover_dml_memset/data_mover_dml_memset.c b/src/deps/miniasync/tests/data_mover_dml_memset/data_mover_dml_memset.c
new file mode 100644
index 00000000000..c6c7b47c918
--- /dev/null
+++ b/src/deps/miniasync/tests/data_mover_dml_memset/data_mover_dml_memset.c
@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2022, Intel Corporation */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libminiasync.h>
+#include <libminiasync-vdm-dml.h>
+#include "test_helpers.h"
+#include "util_dml.h"
+
+static int
+dml_memset(enum data_mover_dml_type type, uint64_t flags, size_t size)
+{
+	/* Size should be dividable by 2 */
+	char *buf = malloc(size);
+
+	struct runtime *r = runtime_new();
+
+	struct data_mover_dml *dmd = data_mover_dml_new(type);
+	struct vdm *dml_mover_async = data_mover_dml_get_vdm(dmd);
+
+	/* First set the whole buffer with 'x' values */
+	struct vdm_operation_future set_x_fut =
+			vdm_memset(dml_mover_async, buf, 'x', size, flags);
+
+	runtime_wait(r, FUTURE_AS_RUNNABLE(&set_x_fut));
+
+	for (size_t i = 0; i < size; i++) {
+		UT_ASSERTeq(buf[i], 'x');
+	}
+
+	/* Then, set the buffer with 'y', and 'z' values in a 1:1 ratio */
+	struct vdm_operation_future set_y_fut =
+			vdm_memset(dml_mover_async, buf, 'y', size / 2, flags);
+	struct vdm_operation_future set_z_fut =
+			vdm_memset(dml_mover_async, buf + size / 2, 'z',
+					size / 2, flags);
+
+	struct future *futs[] = {
+		FUTURE_AS_RUNNABLE(&set_y_fut),
+		FUTURE_AS_RUNNABLE(&set_z_fut)
+	};
+	runtime_wait_multiple(r, futs, 2);
+
+	for (size_t i = 0; i < size / 2; i++) {
+		UT_ASSERTeq(buf[i], 'y');
+		UT_ASSERTeq(buf[i + size / 2], 'z');
+	}
+
+	data_mover_dml_delete(dmd);
+
+	runtime_delete(r);
+	free(buf);
+
+	return 0;
+}
+
+static int
+test_dml_basic_memset()
+{
+	return
+		dml_memset(DATA_MOVER_DML_SOFTWARE, 0, 8) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, 0, 16) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, 0, 32) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, 0, 64) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, 0, 128) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, 0, 256) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, 0, 512) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, 0, 1024);
+}
+
+static int
+test_dml_durable_flag_memset()
+{
+	return
+		dml_memset(DATA_MOVER_DML_SOFTWARE, VDM_F_MEM_DURABLE, 8) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, VDM_F_MEM_DURABLE, 16) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, VDM_F_MEM_DURABLE, 32) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, VDM_F_MEM_DURABLE, 64) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, VDM_F_MEM_DURABLE, 128) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, VDM_F_MEM_DURABLE, 256) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, VDM_F_MEM_DURABLE, 512) ||
+		dml_memset(DATA_MOVER_DML_SOFTWARE, VDM_F_MEM_DURABLE, 1024);
+}
+
+static int
+test_dml_hw_path_flag_memset()
+{
+	return
+		dml_memset(DATA_MOVER_DML_HARDWARE, 0, 8) ||
+		dml_memset(DATA_MOVER_DML_HARDWARE, 0, 16) ||
+		dml_memset(DATA_MOVER_DML_HARDWARE, 0, 32) ||
+		dml_memset(DATA_MOVER_DML_HARDWARE, 0, 64) ||
+		dml_memset(DATA_MOVER_DML_HARDWARE, 0, 128) ||
+		dml_memset(DATA_MOVER_DML_HARDWARE, 0, 256) ||
+		dml_memset(DATA_MOVER_DML_HARDWARE, 0, 512) ||
+		dml_memset(DATA_MOVER_DML_HARDWARE, 0, 1024);
+}
+
+int
+main(void)
+{
+	int ret = test_dml_basic_memset();
+	if (ret)
+		return ret;
+
+	ret = test_dml_durable_flag_memset();
+	if (ret)
+		return ret;
+
+	if (util_dml_check_hw_available() == 0) {
+		ret = test_dml_hw_path_flag_memset();
+		if (ret)
+			return ret;
+	} else {
+		UT_LOG_SKIP("test_dml_hw_path_flag_memset");
+	}
+
+	return 0;
+}
diff --git a/src/deps/miniasync/tests/data_mover_dml_memset/test_data_mover_dml_memset.cmake b/src/deps/miniasync/tests/data_mover_dml_memset/test_data_mover_dml_memset.cmake
new file mode 100644
index 00000000000..dfcc3bac0c9
--- /dev/null
+++ b/src/deps/miniasync/tests/data_mover_dml_memset/test_data_mover_dml_memset.cmake
@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright 2022, Intel Corporation
+
+# an example for the data_mover_dml test case
+
+include(${SRC_DIR}/cmake/test_helpers.cmake)
+
+setup()
+
+# check for MOVDIR64B instruction
+check_movdir64b()
+
+# inform that some test cases involving 'mvodir64b' instruction will be skipped
+if (MOVDIR64B EQUAL 0)
+	message(STATUS "movdir64b instruction not available, some test cases will be skipped!")
+endif()
+
+execute(0 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/data_mover_dml_memset)
+
+execute_assert_pass(${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/data_mover_dml_memset)
+
+cleanup()
diff --git a/src/deps/miniasync/tests/future/test_future.c b/src/deps/miniasync/tests/future/test_future.c
index 6efe045fc6b..ae44d6fe014 100644
--- a/src/deps/miniasync/tests/future/test_future.c
+++ b/src/deps/miniasync/tests/future/test_future.c
@@ -3,6 +3,7 @@
 
 #include "libminiasync/future.h"
 #include "test_helpers.h"
+#include "core/util.h"
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -290,7 +291,7 @@ test_lazy_init()
 {
 	struct multiply_up_down_fut fut = async_multiply_up_down(5, 5);
 	while (future_poll(FUTURE_AS_RUNNABLE(&fut), FAKE_NOTIFIER) !=
-		FUTURE_STATE_COMPLETE) { _mm_pause(); }
+		FUTURE_STATE_COMPLETE) { WAIT(); }
 	struct multiply_up_down_output *mud_output = FUTURE_OUTPUT(&fut);
 	UT_ASSERTeq(mud_output->result_sum, 2);
 	struct multiply_up_down_data *mud_data = FUTURE_DATA(&fut);
diff --git a/src/deps/miniasync/tests/memmove_sync/memmove_sync.c b/src/deps/miniasync/tests/memmove_sync/memmove_sync.c
index 6e059752be2..1662bcf5cc5 100644
--- a/src/deps/miniasync/tests/memmove_sync/memmove_sync.c
+++ b/src/deps/miniasync/tests/memmove_sync/memmove_sync.c
@@ -165,6 +165,11 @@ test_memmove_overlapping(size_t size)
  */
 int test_supported_flags() {
 	struct data_mover_sync *dms = data_mover_sync_new();
+	if (dms == NULL) {
+		fprintf(stderr,
+				"error while creating synchronous data mover");
+		return 1;
+	}
 	struct vdm *sync_mover = data_mover_sync_get_vdm(dms);
 	int ret = test_flag(sync_mover, VDM_F_MEM_DURABLE, 0);
 	ret += test_flag(sync_mover, VDM_F_NO_CACHE_HINT, 0);
diff --git a/src/deps/miniasync/tests/memmove_threads/memmove_threads.c b/src/deps/miniasync/tests/memmove_threads/memmove_threads.c
index 86720dc7483..09f78c2e933 100644
--- a/src/deps/miniasync/tests/memmove_threads/memmove_threads.c
+++ b/src/deps/miniasync/tests/memmove_threads/memmove_threads.c
@@ -146,6 +146,11 @@ test_thread_memmove_multiple(size_t str_len)
  */
 int test_supported_flags() {
 	struct data_mover_threads *dmt = data_mover_threads_default();
+	if (dmt == NULL) {
+		fprintf(stderr,
+				"error while creating threads data mover");
+		return 1;
+	}
 	struct vdm *thread_mover = data_mover_threads_get_vdm(dmt);
 	int ret = test_flag(thread_mover, VDM_F_MEM_DURABLE, 0);
 	data_mover_threads_delete(dmt);
diff --git a/src/deps/miniasync/tests/test_helpers.h b/src/deps/miniasync/tests/test_helpers.h
index 8d5464e9f2b..1abca4f3732 100644
--- a/src/deps/miniasync/tests/test_helpers.h
+++ b/src/deps/miniasync/tests/test_helpers.h
@@ -46,6 +46,11 @@
 		(unsigned long long)(min), (unsigned long long)(max));\
 } while (/*CONSTCOND*/0)
 
+#define UT_LOG_SKIP(testcase) do {\
+	fprintf(stdout, "SKIP: " testcase " test case");\
+	fprintf(stdout, "\n");\
+} while (/*CONSTCOND*/0)
+
 static inline int
 test_flag(struct vdm *vdm, unsigned flag, int expected_value)
 {
diff --git a/src/deps/miniasync/tests/vdm/test_vdm.c b/src/deps/miniasync/tests/vdm/test_vdm.c
index d1e9ebd57c8..48b0f278fae 100644
--- a/src/deps/miniasync/tests/vdm/test_vdm.c
+++ b/src/deps/miniasync/tests/vdm/test_vdm.c
@@ -36,7 +36,7 @@ async_alloc(size_t size)
 	fut.data.n = size;
 	FUTURE_INIT(&fut, alloc_impl);
 	return fut;
-};
+}
 
 struct strdup_data {
 	FUTURE_CHAIN_ENTRY(struct alloc_fut, alloc);
diff --git a/src/deps/miniasync/tests/vdm_operation_future_poll/test_vdm_operation_future_poll.cmake b/src/deps/miniasync/tests/vdm_operation_future_poll/test_vdm_operation_future_poll.cmake
index 6278e7d6716..c909a5a0665 100644
--- a/src/deps/miniasync/tests/vdm_operation_future_poll/test_vdm_operation_future_poll.cmake
+++ b/src/deps/miniasync/tests/vdm_operation_future_poll/test_vdm_operation_future_poll.cmake
@@ -5,12 +5,8 @@ include(${SRC_DIR}/cmake/test_helpers.cmake)
 
 setup()
 
-# check for MOVDIR64B instruction
-check_movdir64b()
+execute(0 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/vdm_operation_future_poll)
 
-# execute DML tests only if MOVDIR64B instruction is available
-if (MOVDIR64B EQUAL 1)
-    execute(0 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/vdm_operation_future_poll)
-endif()
+execute_assert_pass(${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${BUILD}/vdm_operation_future_poll)
 
 cleanup()