/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 24 апр. 2024 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #include #include #include #include #include #include using namespace lsp; UTEST_BEGIN("runtime.ipc", shmutex) typedef struct context_t { ipc::Mutex lock; LSPString data; uatomic_t sequence_latch; size_t errors; void log(status_t code, const char *event, status_t expected) { lock.lock(); lsp_finally { lock.unlock(); }; data.append_ascii(event); data.append('='); if (code == expected) data.append_ascii("true"); else { data.fmt_append_ascii("false(code=%d)", int(code)); ++errors; } data.append(';'); } } context_t; static status_t thread_func1(void *arg) { ipc::SharedMutex mutex; context_t *ctx = static_cast(arg); wait_latch(ctx->sequence_latch, 0); ctx->log(mutex.open("test-lsp.lock"), "open1", STATUS_OK); atomic_add(&ctx->sequence_latch, 1); // 0 -> 1 // Sleep 500 ms and lock the mutex wait_latch(ctx->sequence_latch, 3); ipc::Thread::sleep(500); ctx->log(mutex.lock(), "SYNC1.lock", STATUS_OK); atomic_add(&ctx->sequence_latch, 1); // 3 -> 6 // Sleep 200 ms and unlock the mutex wait_latch(ctx->sequence_latch, 7); ipc::Thread::sleep(200); ctx->log(mutex.unlock(), "SYNC2.unlock", STATUS_OK); atomic_add(&ctx->sequence_latch, 1); // 7 -> 9 // Close the mutex wait_latch(ctx->sequence_latch, 10); ctx->log(mutex.close(), "close1", STATUS_OK); atomic_add(&ctx->sequence_latch, 1); // 10 -> 11 return STATUS_OK; } static status_t thread_func2(void *arg) { ipc::SharedMutex mutex; context_t *ctx = static_cast(arg); wait_latch(ctx->sequence_latch, 1); ctx->log(mutex.open("test-lsp.lock"), "open2", STATUS_OK); atomic_add(&ctx->sequence_latch, 1); // 1 -> 2 // Lock mutex immediately, sleep 500 ms and unlock it wait_latch(ctx->sequence_latch, 3); ctx->log(mutex.lock(), "lock2", STATUS_OK); ipc::Thread::sleep(500); ctx->log(mutex.unlock(), "SYNC1.unlock", STATUS_OK); atomic_add(&ctx->sequence_latch, 1); // 3 -> 6 // Call mutltiple times lock, succeed on last call wait_latch(ctx->sequence_latch, 6); ctx->log(mutex.try_lock(), "trylock2", STATUS_RETRY); ctx->log(mutex.lock(500), "timedlock2", STATUS_TIMED_OUT); atomic_add(&ctx->sequence_latch, 1); // 6 -> 7 // Succeed on timed mutex lock wait_latch(ctx->sequence_latch, 7); ctx->log(mutex.lock(800), "SYNC2.lock", STATUS_OK); atomic_add(&ctx->sequence_latch, 1); // 7 -> 9 // Sleep 200 milliseconds and unlock the mutex wait_latch(ctx->sequence_latch, 9); ipc::Thread::sleep(200); ctx->log(mutex.unlock(), "SYNC3.unlock", STATUS_OK); // Close the mutex wait_latch(ctx->sequence_latch, 11); ctx->log(mutex.close(), "close2", STATUS_OK); atomic_add(&ctx->sequence_latch, 1); // 11 -> 12 return STATUS_OK; } static void wait_latch(uatomic_t & latch, uatomic_t value) { while (atomic_load(&latch) != value) ipc::Thread::yield(); } void test_simple() { ipc::SharedMutex mutex; printf("Testing simple single-threaded mutex locks\n"); UTEST_ASSERT(mutex.lock() == STATUS_CLOSED); UTEST_ASSERT(mutex.lock(200) == STATUS_CLOSED); UTEST_ASSERT(mutex.try_lock() == STATUS_CLOSED); UTEST_ASSERT(mutex.unlock() == STATUS_CLOSED); UTEST_ASSERT(mutex.close() == STATUS_OK); UTEST_ASSERT(mutex.open("test-lsp.lock") == STATUS_OK); UTEST_ASSERT(mutex.unlock() == STATUS_BAD_STATE); UTEST_ASSERT(mutex.lock() == STATUS_OK); UTEST_ASSERT(mutex.lock() == STATUS_LOCKED); UTEST_ASSERT(mutex.unlock() == STATUS_OK); UTEST_ASSERT(mutex.unlock() == STATUS_BAD_STATE); UTEST_ASSERT(mutex.lock(200) == STATUS_OK); UTEST_ASSERT(mutex.lock(200) == STATUS_LOCKED); UTEST_ASSERT(mutex.unlock() == STATUS_OK); UTEST_ASSERT(mutex.unlock() == STATUS_BAD_STATE); UTEST_ASSERT(mutex.try_lock() == STATUS_OK); UTEST_ASSERT(mutex.try_lock() == STATUS_LOCKED); UTEST_ASSERT(mutex.unlock() == STATUS_OK); UTEST_ASSERT(mutex.unlock() == STATUS_BAD_STATE); UTEST_ASSERT(mutex.close() == STATUS_OK); } void test_multithreaded() { ipc::SharedMutex mutex; context_t ctx; atomic_store(&ctx.sequence_latch, uatomic_t(0)); ctx.errors = 0; printf("Testing simple multi-threaded mutex locks\n"); ctx.log(mutex.open("test-lsp.lock"), "open", STATUS_OK); ctx.log(mutex.lock(), "lock", STATUS_OK); ipc::Thread t1(thread_func1, &ctx); ipc::Thread t2(thread_func2, &ctx); ctx.log(STATUS_OK, "start", STATUS_OK); t1.start(); t2.start(); wait_latch(ctx.sequence_latch, 2); atomic_add(&ctx.sequence_latch, 1); // 2 -> 3 // Sleep 200 ms and unlock the mutex ctx.log(STATUS_OK, "sleep", STATUS_OK); ipc::Thread::sleep(200); ctx.log(STATUS_OK, "unlock", STATUS_OK); UTEST_ASSERT(mutex.unlock() == STATUS_OK); atomic_add(&ctx.sequence_latch, 1); // 3 -> 6 // Lock the mutex, unlock it and return result wait_latch(ctx.sequence_latch, 9); ctx.log(mutex.lock(), "SYNC3.lock", STATUS_OK); ctx.log(mutex.unlock(), "unlock", STATUS_OK); ctx.log(mutex.close(), "close", STATUS_OK); atomic_add(&ctx.sequence_latch, 1); // 9 -> 10 // Do final comparison wait_latch(ctx.sequence_latch, 12); printf("Result sequence: %s\n", ctx.data.get_ascii()); UTEST_ASSERT(ctx.errors == 0); } UTEST_MAIN { test_simple(); test_multithreaded(); } UTEST_END;