aws-crt 0.1.9 → 0.2.0

data/aws-crt-ffi/crt/aws-c-common/source/system_info.c

@@ -0,0 +1,80 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/common/private/system_info_priv.h>
+
+#include <aws/common/logging.h>
+
+void s_destroy_env(void *arg) {
+    struct aws_system_environment *env = arg;
+
+    if (env) {
+        aws_system_environment_destroy_platform_impl(env);
+        aws_mem_release(env->allocator, env);
+    }
+}
+
+struct aws_system_environment *aws_system_environment_load(struct aws_allocator *allocator) {
+    struct aws_system_environment *env = aws_mem_calloc(allocator, 1, sizeof(struct aws_system_environment));
+    env->allocator = allocator;
+    aws_ref_count_init(&env->ref_count, env, s_destroy_env);
+
+    if (aws_system_environment_load_platform_impl(env)) {
+        AWS_LOGF_ERROR(
+            AWS_LS_COMMON_GENERAL,
+            "id=%p: failed to load system environment with error %s.",
+            (void *)env,
+            aws_error_debug_str(aws_last_error()));
+        goto error;
+    }
+
+    AWS_LOGF_TRACE(
+        AWS_LS_COMMON_GENERAL,
+        "id=%p: virtualization vendor detected as \"" PRInSTR "\"",
+        (void *)env,
+        AWS_BYTE_CURSOR_PRI(aws_system_environment_get_virtualization_vendor(env)));
+    AWS_LOGF_TRACE(
+        AWS_LS_COMMON_GENERAL,
+        "id=%p: virtualization product name detected as \"" PRInSTR " \"",
+        (void *)env,
+        AWS_BYTE_CURSOR_PRI(aws_system_environment_get_virtualization_vendor(env)));
+
+    env->os = aws_get_platform_build_os();
+    env->cpu_count = aws_system_info_processor_count();
+    env->cpu_group_count = aws_get_cpu_group_count();
+
+    return env;
+error:
+    s_destroy_env(env);
+    return NULL;
+}
+
+struct aws_system_environment *aws_system_environment_acquire(struct aws_system_environment *env) {
+    aws_ref_count_acquire(&env->ref_count);
+    return env;
+}
+
+void aws_system_environment_release(struct aws_system_environment *env) {
+    aws_ref_count_release(&env->ref_count);
+}
+
+struct aws_byte_cursor aws_system_environment_get_virtualization_vendor(const struct aws_system_environment *env) {
+    struct aws_byte_cursor vendor_string = aws_byte_cursor_from_buf(&env->virtualization_vendor);
+    return aws_byte_cursor_trim_pred(&vendor_string, aws_char_is_space);
+}
+
+struct aws_byte_cursor aws_system_environment_get_virtualization_product_name(
+    const struct aws_system_environment *env) {
+    struct aws_byte_cursor product_name_str = aws_byte_cursor_from_buf(&env->product_name);
+    return aws_byte_cursor_trim_pred(&product_name_str, aws_char_is_space);
+}
+
+size_t aws_system_environment_get_processor_count(struct aws_system_environment *env) {
+    return env->cpu_count;
+}
+
+AWS_COMMON_API
+size_t aws_system_environment_get_cpu_group_count(const struct aws_system_environment *env) {
+    return env->cpu_group_count;
+}

data/aws-crt-ffi/crt/aws-c-common/source/task_scheduler.c

@@ -135,7 +135,7 @@ void aws_task_scheduler_schedule_now(struct aws_task_scheduler *scheduler, struc
         (void *)task,
         task->type_tag);
 
-    task->priority_queue_node.current_index = SIZE_MAX;
+    aws_priority_queue_node_init(&task->priority_queue_node);
     aws_linked_list_node_reset(&task->node);
     task->timestamp = 0;
 
@@ -161,7 +161,7 @@ void aws_task_scheduler_schedule_future(
 
     task->timestamp = time_to_run;
 
-    task->priority_queue_node.current_index = SIZE_MAX;
+    aws_priority_queue_node_init(&task->priority_queue_node);
     aws_linked_list_node_reset(&task->node);
     int err = aws_priority_queue_push_ref(&scheduler->timed_queue, &task, &task->priority_queue_node);
     if (AWS_UNLIKELY(err)) {

data/aws-crt-ffi/crt/aws-c-common/source/windows/cross_process_lock.c

@@ -0,0 +1,93 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <windows.h>
+
+#include <aws/common/byte_buf.h>
+#include <aws/common/cross_process_lock.h>
+#include <aws/common/error.h>
+#include <aws/common/logging.h>
+#include <inttypes.h>
+
+struct aws_cross_process_lock {
+    struct aws_allocator *allocator;
+    HANDLE mutex;
+};
+
+struct aws_cross_process_lock *aws_cross_process_lock_try_acquire(
+    struct aws_allocator *allocator,
+    struct aws_byte_cursor instance_nonce) {
+
+    /* validate we don't have a directory slash. */
+    struct aws_byte_cursor to_find = aws_byte_cursor_from_c_str("\\");
+    struct aws_byte_cursor found;
+    AWS_ZERO_STRUCT(found);
+    if (aws_byte_cursor_find_exact(&instance_nonce, &to_find, &found) != AWS_OP_ERR &&
+        aws_last_error() != AWS_ERROR_STRING_MATCH_NOT_FOUND) {
+        AWS_LOGF_ERROR(
+            AWS_LS_COMMON_GENERAL,
+            "static: Lock " PRInSTR " creation has illegal character \\",
+            AWS_BYTE_CURSOR_PRI(instance_nonce));
+        aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+        return NULL;
+    }
+
+    struct aws_cross_process_lock *instance_lock = NULL;
+
+    /* "Local\" prefix, per the docs, specifies user session scope (rather than "Global\" to the system). */
+    struct aws_byte_cursor path_prefix = aws_byte_cursor_from_c_str("Local\\aws_crt_cross_process_lock/");
+    struct aws_byte_buf nonce_buf;
+    aws_byte_buf_init_copy_from_cursor(&nonce_buf, allocator, path_prefix);
+    aws_byte_buf_append_dynamic(&nonce_buf, &instance_nonce);
+    aws_byte_buf_append_null_terminator(&nonce_buf);
+
+    HANDLE mutex = CreateMutexA(NULL, FALSE, (LPCSTR)nonce_buf.buffer);
+
+    if (!mutex) {
+        AWS_LOGF_WARN(
+            AWS_LS_COMMON_GENERAL,
+            "static: Lock %s creation failed with error %" PRIx32,
+            (const char *)nonce_buf.buffer,
+            GetLastError());
+        aws_translate_and_raise_io_error_or(GetLastError(), AWS_ERROR_MUTEX_FAILED);
+        goto cleanup;
+    }
+
+    /* from the docs:
+     * If the mutex is a named mutex and the object existed before this function call, the return value is a handle
+     * to the existing object, and the GetLastError function returns ERROR_ALREADY_EXISTS. */
+    if (GetLastError() == ERROR_ALREADY_EXISTS) {
+        AWS_LOGF_TRACE(
+            AWS_LS_COMMON_GENERAL,
+            "static: Lock %s is already acquired by another instance",
+            (const char *)nonce_buf.buffer);
+        CloseHandle(mutex);
+        aws_raise_error(AWS_ERROR_MUTEX_CALLER_NOT_OWNER);
+        goto cleanup;
+    }
+
+    instance_lock = aws_mem_calloc(allocator, 1, sizeof(struct aws_cross_process_lock));
+    instance_lock->mutex = mutex;
+    instance_lock->allocator = allocator;
+
+    AWS_LOGF_TRACE(
+        AWS_LS_COMMON_GENERAL,
+        "static: Lock %s acquired by this instance with HANDLE %p",
+        (const char *)nonce_buf.buffer,
+        (void *)mutex);
+
+cleanup:
+
+    /* we could do this once above but then we'd lose logging for the buffer. */
+    aws_byte_buf_clean_up(&nonce_buf);
+    return instance_lock;
+}
+
+void aws_cross_process_lock_release(struct aws_cross_process_lock *instance_lock) {
+    if (instance_lock) {
+        CloseHandle(instance_lock->mutex);
+        AWS_LOGF_TRACE(AWS_LS_COMMON_GENERAL, "static: Lock released for handle %p", (void *)instance_lock->mutex);
+        aws_mem_release(instance_lock->allocator, instance_lock);
+    }
+}

data/aws-crt-ffi/crt/aws-c-common/source/windows/system_resource_utils.c

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/common/system_resource_util.h>
+
+#include <windows.h>
+
+#include <psapi.h>
+
+int aws_init_memory_usage_for_current_process(struct aws_memory_usage_stats *memory_usage) {
+    AWS_PRECONDITION(memory_usage);
+
+    AWS_ZERO_STRUCT(*memory_usage);
+    HANDLE hProcess = GetCurrentProcess();
+
+    PROCESS_MEMORY_COUNTERS pmc;
+
+    BOOL ret = GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc));
+    CloseHandle(hProcess);
+
+    if (!ret) {
+        return aws_raise_error(AWS_ERROR_SYS_CALL_FAILURE);
+    }
+
+    memory_usage->maxrss = pmc.PeakWorkingSetSize;
+    memory_usage->page_faults = pmc.PageFaultCount;
+
+    return AWS_OP_SUCCESS;
+}

data/aws-crt-ffi/crt/aws-c-common/tests/CMakeLists.txt

@@ -94,6 +94,7 @@ add_test_case(priority_queue_remove_root_test)
 add_test_case(priority_queue_remove_leaf_test)
 add_test_case(priority_queue_remove_interior_sift_up_test)
 add_test_case(priority_queue_remove_interior_sift_down_test)
+add_test_case(priority_queue_clear_backpointers_test)
 
 add_test_case(linked_list_push_back_pop_front)
 add_test_case(linked_list_push_front_pop_back)
@@ -304,6 +305,7 @@ add_test_case(test_cpu_count_at_least_works_superficially)
 add_test_case(test_stack_trace_decoding)
 add_test_case(test_platform_build_os)
 add_test_case(test_sanity_check_numa_discovery)
+add_test_case(test_sanity_check_environment_loader)
 
 add_test_case(test_realloc_fallback)
 add_test_case(test_realloc_passthrough)
@@ -317,6 +319,10 @@ add_test_case(sba_threaded_allocs_and_frees)
 add_test_case(sba_threaded_reallocs)
 add_test_case(sba_churn)
 add_test_case(sba_metrics)
+add_test_case(default_threaded_reallocs)
+add_test_case(default_threaded_allocs_and_frees)
+add_test_case(aligned_threaded_reallocs)
+add_test_case(aligned_threaded_allocs_and_frees)
 
 add_test_case(test_memtrace_none)
 add_test_case(test_memtrace_count)
@@ -399,6 +405,8 @@ add_test_case(ring_buffer_acquire_up_to_multi_threaded_test)
 add_test_case(string_to_log_level_success_test)
 add_test_case(string_to_log_level_failure_test)
 
+add_test_case(test_memory_usage_maxrss)
+
 if(NOT ANDROID)
     add_test_case(test_logging_filter_at_AWS_LL_NONE_s_logf_all_levels)
     add_test_case(test_logging_filter_at_AWS_LL_FATAL_s_logf_all_levels)
@@ -478,6 +486,7 @@ add_test_case(directory_move_src_non_existent_test)
 add_test_case(test_home_directory_not_null)
 add_test_case(test_normalize_posix_directory_separator)
 add_test_case(test_normalize_windows_directory_separator)
+add_test_case(test_byte_buf_init_from_file)
 
 add_test_case(promise_test_wait_forever)
 add_test_case(promise_test_wait_for_a_bit)
@@ -512,6 +521,13 @@ add_test_case(test_uri_encode_path_rfc3986)
 add_test_case(test_uri_encode_query)
 add_test_case(test_uri_decode)
 
+add_test_case(test_cross_process_lock_works_in_proc)
+add_test_case(test_cross_process_lock_works_cross_proc)
+#this one is here for use by test_instance_lock_works_cross_proc
+add_test_case(cross_process_lock_mp_test_runner)
+add_test_case(test_cross_process_lock_invalid_nonce_fails)
+
+
 generate_test_driver(${PROJECT_NAME}-tests)
 
 if(NOT MSVC AND NOT LEGACY_COMPILER_SUPPORT)

data/aws-crt-ffi/crt/aws-c-common/tests/alloc_test.c

@@ -48,10 +48,12 @@ static int s_test_alloc_nothing_fn(struct aws_allocator *allocator, void *ctx) {
     (void)allocator;
     (void)ctx;
 
-    struct aws_allocator test_allocator = {.mem_acquire = s_test_alloc_acquire,
-                                           .mem_release = s_test_alloc_release,
-                                           .mem_realloc = s_test_realloc,
-                                           .mem_calloc = s_test_calloc};
+    struct aws_allocator test_allocator = {
+        .mem_acquire = s_test_alloc_acquire,
+        .mem_release = s_test_alloc_release,
+        .mem_realloc = s_test_realloc,
+        .mem_calloc = s_test_calloc,
+    };
 
     /* realloc should handle the case correctly, return null, and free the memory */
     void *p = aws_mem_acquire(&test_allocator, 12);
@@ -126,39 +128,42 @@ static int s_sba_random_reallocs(struct aws_allocator *allocator, void *ctx) {
 }
 AWS_TEST_CASE(sba_random_reallocs, s_sba_random_reallocs)
 
-struct sba_thread_test_data {
-    struct aws_allocator *sba;
+struct allocator_thread_test_data {
+    struct aws_allocator *test_allocator;
     uint32_t thread_idx;
 };
 
-static void s_sba_threaded_alloc_worker(void *user_data) {
-    struct aws_allocator *sba = ((struct sba_thread_test_data *)user_data)->sba;
+static void s_threaded_alloc_worker(void *user_data) {
+    struct aws_allocator *test_allocator = ((struct allocator_thread_test_data *)user_data)->test_allocator;
 
     void *allocs[NUM_TEST_ALLOCS];
     for (size_t count = 0; count < NUM_TEST_ALLOCS / NUM_TEST_THREADS; ++count) {
         size_t size = aws_max_size(rand() % 512, 1);
-        void *alloc = aws_mem_acquire(sba, size);
+        void *alloc = aws_mem_acquire(test_allocator, size);
         AWS_FATAL_ASSERT(alloc);
         allocs[count] = alloc;
     }
 
     for (size_t count = 0; count < NUM_TEST_ALLOCS / NUM_TEST_THREADS; ++count) {
         void *alloc = allocs[count];
-        aws_mem_release(sba, alloc);
+        aws_mem_release(test_allocator, alloc);
     }
 }
 
-static void s_sba_thread_test(struct aws_allocator *allocator, void (*thread_fn)(void *), struct aws_allocator *sba) {
+static void s_thread_test(
+    struct aws_allocator *allocator,
+    void (*thread_fn)(void *),
+    struct aws_allocator *test_allocator) {
     const struct aws_thread_options *thread_options = aws_default_thread_options();
     struct aws_thread threads[NUM_TEST_THREADS];
-    struct sba_thread_test_data thread_data[NUM_TEST_THREADS];
+    struct allocator_thread_test_data thread_data[NUM_TEST_THREADS];
     AWS_ZERO_ARRAY(threads);
     AWS_ZERO_ARRAY(thread_data);
     for (size_t thread_idx = 0; thread_idx < AWS_ARRAY_SIZE(threads); ++thread_idx) {
         struct aws_thread *thread = &threads[thread_idx];
         aws_thread_init(thread, allocator);
-        struct sba_thread_test_data *data = &thread_data[thread_idx];
-        data->sba = sba;
+        struct allocator_thread_test_data *data = &thread_data[thread_idx];
+        data->test_allocator = test_allocator;
         data->thread_idx = (uint32_t)thread_idx;
         aws_thread_launch(thread, thread_fn, data, thread_options);
     }
@@ -175,7 +180,7 @@ static int s_sba_threaded_allocs_and_frees(struct aws_allocator *allocator, void
 
     struct aws_allocator *sba = aws_small_block_allocator_new(allocator, true);
 
-    s_sba_thread_test(allocator, s_sba_threaded_alloc_worker, sba);
+    s_thread_test(allocator, s_threaded_alloc_worker, sba);
 
     aws_small_block_allocator_destroy(sba);
 
@@ -183,9 +188,9 @@ static int s_sba_threaded_allocs_and_frees(struct aws_allocator *allocator, void
 }
 AWS_TEST_CASE(sba_threaded_allocs_and_frees, s_sba_threaded_allocs_and_frees)
 
-static void s_sba_threaded_realloc_worker(void *user_data) {
-    struct sba_thread_test_data *thread_data = user_data;
-    struct aws_allocator *sba = thread_data->sba;
+static void s_threaded_realloc_worker(void *user_data) {
+    struct allocator_thread_test_data *thread_data = user_data;
+    struct aws_allocator *test_allocator = thread_data->test_allocator;
     void *alloc = NULL;
     size_t size = 0;
     for (size_t count = 0; count < NUM_TEST_ALLOCS / NUM_TEST_THREADS; ++count) {
@@ -194,7 +199,7 @@ static void s_sba_threaded_realloc_worker(void *user_data) {
         if (old_size) {
             AWS_FATAL_ASSERT(0 == memcmp(alloc, &thread_data->thread_idx, 1));
         }
-        AWS_FATAL_ASSERT(0 == aws_mem_realloc(sba, &alloc, old_size, size));
+        AWS_FATAL_ASSERT(0 == aws_mem_realloc(test_allocator, &alloc, old_size, size));
         /* If there was a value, make sure it's still there */
         if (old_size && size) {
             AWS_FATAL_ASSERT(0 == memcmp(alloc, &thread_data->thread_idx, 1));
@@ -203,7 +208,7 @@ static void s_sba_threaded_realloc_worker(void *user_data) {
             memset(alloc, (int)thread_data->thread_idx, size);
         }
     }
-    AWS_FATAL_ASSERT(0 == aws_mem_realloc(sba, &alloc, size, 0));
+    AWS_FATAL_ASSERT(0 == aws_mem_realloc(test_allocator, &alloc, size, 0));
 }
 
 static int s_sba_threaded_reallocs(struct aws_allocator *allocator, void *ctx) {
@@ -212,7 +217,7 @@ static int s_sba_threaded_reallocs(struct aws_allocator *allocator, void *ctx) {
 
     struct aws_allocator *sba = aws_small_block_allocator_new(allocator, true);
 
-    s_sba_thread_test(allocator, s_sba_threaded_realloc_worker, sba);
+    s_thread_test(allocator, s_threaded_realloc_worker, sba);
 
     aws_small_block_allocator_destroy(sba);
 
@@ -313,10 +318,66 @@ static int s_sba_metrics_test(struct aws_allocator *allocator, void *ctx) {
 
     ASSERT_INT_EQUALS(0, aws_small_block_allocator_bytes_active(sba));
 
-    /* after freeing everything, we should have reliniquished all but one page in each bin */
+    /* after freeing everything, we should have relinquished all but one page in each bin */
     ASSERT_INT_EQUALS(5 * aws_small_block_allocator_page_size(sba), aws_small_block_allocator_bytes_reserved(sba));
 
     aws_small_block_allocator_destroy(sba);
     return 0;
 }
 AWS_TEST_CASE(sba_metrics, s_sba_metrics_test)
+
+/*
+ * Default allocator tests.
+ */
+static int s_default_threaded_reallocs(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+    srand(15);
+
+    s_thread_test(allocator, s_threaded_realloc_worker, allocator);
+
+    return 0;
+}
+AWS_TEST_CASE(default_threaded_reallocs, s_default_threaded_reallocs)
+
+static int s_default_threaded_allocs_and_frees(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+    srand(99);
+
+    s_thread_test(allocator, s_threaded_alloc_worker, allocator);
+
+    return 0;
+}
+AWS_TEST_CASE(default_threaded_allocs_and_frees, s_default_threaded_allocs_and_frees)
+
+/*
+ * No align allocator tests.
+ */
+static int s_aligned_threaded_reallocs(struct aws_allocator *allocator, void *ctx) {
+    (void)allocator;
+    (void)ctx;
+    srand(15);
+
+    struct aws_allocator *alloc = aws_mem_tracer_new(aws_aligned_allocator(), NULL, AWS_MEMTRACE_STACKS, 8);
+
+    s_thread_test(alloc, s_threaded_realloc_worker, alloc);
+
+    aws_mem_tracer_destroy(alloc);
+
+    return 0;
+}
+AWS_TEST_CASE(aligned_threaded_reallocs, s_aligned_threaded_reallocs)
+
+static int s_aligned_threaded_allocs_and_frees(struct aws_allocator *allocator, void *ctx) {
+    (void)allocator;
+    (void)ctx;
+    srand(99);
+
+    struct aws_allocator *alloc = aws_mem_tracer_new(aws_aligned_allocator(), NULL, AWS_MEMTRACE_STACKS, 8);
+
+    s_thread_test(alloc, s_threaded_alloc_worker, alloc);
+
+    aws_mem_tracer_destroy(alloc);
+
+    return 0;
+}
+AWS_TEST_CASE(aligned_threaded_allocs_and_frees, s_aligned_threaded_allocs_and_frees)

data/aws-crt-ffi/crt/aws-c-common/tests/cross_process_lock_tests.c

@@ -0,0 +1,116 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/common/cross_process_lock.h>
+#include <aws/common/environment.h>
+#include <aws/common/process.h>
+#include <aws/testing/aws_test_harness.h>
+
+static int s_test_cross_process_lock_works_in_proc(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+    aws_common_library_init(allocator);
+
+    struct aws_byte_cursor lock_nonce = aws_byte_cursor_from_c_str("lock_nonce");
+    struct aws_cross_process_lock *instance_lock = aws_cross_process_lock_try_acquire(allocator, lock_nonce);
+    ASSERT_NOT_NULL(instance_lock);
+
+    struct aws_cross_process_lock *should_be_null = aws_cross_process_lock_try_acquire(allocator, lock_nonce);
+    ASSERT_NULL(should_be_null);
+
+    aws_cross_process_lock_release(instance_lock);
+    struct aws_cross_process_lock *should_not_be_null = aws_cross_process_lock_try_acquire(allocator, lock_nonce);
+    ASSERT_NOT_NULL(should_not_be_null);
+    aws_cross_process_lock_release(should_not_be_null);
+
+    aws_common_library_clean_up();
+
+    return AWS_OP_SUCCESS;
+}
+AWS_TEST_CASE(test_cross_process_lock_works_in_proc, s_test_cross_process_lock_works_in_proc)
+
+static int s_cross_process_lock_mp_test_runner(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+    aws_common_library_init(allocator);
+
+    /* so the test runner doesn't actually run the portion of the test we want to test unless we're invoking it as a
+     * subprocess. */
+    struct aws_string *test_run_gate = aws_string_new_from_c_str(allocator, "aws_crt_test_run_gate");
+    struct aws_string *output_val = NULL;
+    if (aws_get_environment_value(allocator, test_run_gate, &output_val) == AWS_OP_SUCCESS && output_val) {
+        aws_string_destroy(output_val);
+        struct aws_byte_cursor lock_nonce = aws_byte_cursor_from_c_str("lock_mp_nonce");
+        struct aws_cross_process_lock *instance_lock = aws_cross_process_lock_try_acquire(allocator, lock_nonce);
+        ASSERT_NOT_NULL(instance_lock);
+
+        aws_cross_process_lock_release(instance_lock);
+    }
+    aws_string_destroy(test_run_gate);
+    aws_common_library_clean_up();
+
+    return AWS_OP_SUCCESS;
+}
+AWS_TEST_CASE(cross_process_lock_mp_test_runner, s_cross_process_lock_mp_test_runner)
+
+static int s_test_cross_process_lock_works_cross_proc(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+    aws_common_library_init(allocator);
+
+    struct aws_string *test_run_gate = aws_string_new_from_c_str(allocator, "aws_crt_test_run_gate");
+    struct aws_string *test_run_gate_val = aws_string_new_from_c_str(allocator, "ON");
+
+    /* so the test runner doesn't actually run the portion of the test we want to test unless we're invoking it from
+     * here. */
+    ASSERT_SUCCESS(aws_set_environment_value(test_run_gate, test_run_gate_val));
+    aws_string_destroy(test_run_gate_val);
+    aws_string_destroy(test_run_gate);
+
+    /* Invoke the test runner in a new process for ease so cmake automatically does the work for us. */
+    struct aws_run_command_options command_options = {
+#ifdef _WIN32
+        .command = "aws-c-common-tests cross_process_lock_mp_test_runner",
+#else
+        .command = "./aws-c-common-tests cross_process_lock_mp_test_runner",
+#endif /* _WIN32 */
+    };
+
+    struct aws_run_command_result result;
+    AWS_ZERO_STRUCT(result);
+
+    ASSERT_SUCCESS(aws_run_command(allocator, &command_options, &result));
+    ASSERT_TRUE(result.ret_code == 0);
+    aws_run_command_result_cleanup(&result);
+    AWS_ZERO_STRUCT(result);
+    struct aws_byte_cursor lock_nonce = aws_byte_cursor_from_c_str("lock_mp_nonce");
+    struct aws_cross_process_lock *instance_lock = aws_cross_process_lock_try_acquire(allocator, lock_nonce);
+    ASSERT_NOT_NULL(instance_lock);
+
+    ASSERT_SUCCESS(aws_run_command(allocator, &command_options, &result));
+    ASSERT_FALSE(result.ret_code == 0);
+    aws_run_command_result_cleanup(&result);
+
+    aws_cross_process_lock_release(instance_lock);
+    aws_common_library_clean_up();
+
+    return AWS_OP_SUCCESS;
+}
+AWS_TEST_CASE(test_cross_process_lock_works_cross_proc, s_test_cross_process_lock_works_cross_proc)
+
+static int s_test_cross_process_lock_invalid_nonce(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+    aws_common_library_init(allocator);
+#ifdef _WIN32
+    struct aws_byte_cursor lock_nonce = aws_byte_cursor_from_c_str("invalid\\lock_nonce");
+#else
+    struct aws_byte_cursor lock_nonce = aws_byte_cursor_from_c_str("invalid/lock_nonce");
+#endif /* _WIN32 */
+
+    struct aws_cross_process_lock *instance_lock = aws_cross_process_lock_try_acquire(allocator, lock_nonce);
+    ASSERT_NULL(instance_lock);
+    ASSERT_INT_EQUALS(AWS_ERROR_INVALID_ARGUMENT, aws_last_error());
+
+    aws_common_library_clean_up();
+
+    return AWS_OP_SUCCESS;
+}
+AWS_TEST_CASE(test_cross_process_lock_invalid_nonce_fails, s_test_cross_process_lock_invalid_nonce)