/*
* Copyright (C) 2024 Linux Studio Plugins Project
* (C) 2024 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 25 февр. 2019 г.
*
* 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
#ifdef PLATFORM_WINDOWS
#include
#include
#endif /* PLATFORM_WINDOWS */
namespace lsp
{
namespace ipc
{
#if defined(PLATFORM_WINDOWS)
namespace detail
{
struct CRITICAL_SECTION: public ::CRITICAL_SECTION
{
};
} /* namespace detail */
Mutex::Mutex()
{
hMutex = new detail::CRITICAL_SECTION;
if (hMutex != NULL)
InitializeCriticalSectionAndSpinCount(hMutex, 0x10);
}
Mutex::~Mutex()
{
if (hMutex != NULL)
{
DeleteCriticalSection(hMutex);
delete hMutex;
}
}
bool Mutex::lock() const
{
EnterCriticalSection(hMutex);
return true;
}
bool Mutex::try_lock() const
{
return TryEnterCriticalSection(hMutex);
}
bool Mutex::unlock() const
{
HANDLE thread = reinterpret_cast(GetCurrentThreadId());
if (hMutex->OwningThread != thread)
return false;
if (hMutex->RecursionCount <= 0)
return false;
LeaveCriticalSection(hMutex);
return true;
}
#elif defined(PLATFORM_LINUX)
static inline int futex(
int *addr,
int futex_op,
int val,
const struct timespec *timeout,
volatile int *addr2,
int val3)
{
return syscall(SYS_futex, addr, futex_op, val, timeout, addr2, val3);
}
bool Mutex::lock() const
{
int res;
// Check that we already own the mutex
pthread_t tid = pthread_self();
if (nThreadId == tid)
{
++nLocks;
return true;
}
// Perform the wait until another thread releases the mutex
while (!atomic_cas(&nLock, 1, 0))
{
// Issue wait
res = futex(
&nLock, // addr: address
FUTEX_WAIT, // futex_op: WAIT for the notification related to the address
0, // val: value to test for
NULL, // timeout: infinite wait
NULL, // addr2: unused
0); // val3: unused
if ((res == ENOSYS) || (res == EAGAIN))
sched_yield();
}
// Update lock state
nThreadId = tid;
++nLocks;
return true;
}
bool Mutex::try_lock() const
{
// Check that we already own the mutex
pthread_t tid = pthread_self();
if (nThreadId == tid)
{
++nLocks;
return true;
}
if (!atomic_cas(&nLock, 1, 0))
return false;
// Update lock state
nThreadId = tid;
++nLocks;
return true;
}
bool Mutex::unlock() const
{
if (nThreadId != pthread_self())
return false;
// Update the lock state
if (--nLocks)
return true;
nThreadId = -1;
if (atomic_cas(&nLock, 0, 1))
{
futex(
&nLock, // addr: address
FUTEX_WAKE, // futex_op: WAKEUP listeners at the specified address
1, // val: Number of listeners to wake up
NULL, // timeout: unused
0, // addr2: unused
0); // val3: unused
}
return true;
}
#else
Mutex::Mutex()
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&sMutex, &attr);
pthread_mutexattr_destroy(&attr);
}
Mutex::~Mutex()
{
pthread_mutex_destroy(&sMutex);
}
#endif /* PLATFORM_LINUX */
} /* namespace ipc */
} /* namespace lsp */