Fennix/Kernel
1
0
Fork 0
mirror of https://github.com/Fennix-Project/Kernel.git synced 2025-05-28 15:34:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Renamed enum, oops

Browse Source
This commit is contained in:
Alex 2023-02-14 03:51:39 +02:00
parent 9416bd5cb9
commit a21c2063ae
Signed by untrusted user who does not match committer: enderice2
GPG Key ID: EACC3AD603BAB4DD
2 changed files with 29 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Core/Lock.cpp
View File

@ -49,7 +49,7 @@ int LockClass::Lock(const char *FunctionName)
LockData.AttemptingToGet = FunctionName;
Retry:
unsigned int i = 0;
while (IsLocked.Exchange(true, MemoryBorder::Acquire) && ++i < 0x10000000)
while (IsLocked.Exchange(true, MemoryOrder::Acquire) && ++i < 0x10000000)
CPU::Pause();
if (i >= 0x10000000)
{
@ -77,7 +77,7 @@ int LockClass::Unlock()
// IsLocked = false;
__sync_synchronize();
IsLocked.Store(false, MemoryBorder::Release);
IsLocked.Store(false, MemoryOrder::Release);
LockData.Count--;
IsLocked = false;
@ -114,7 +114,7 @@ int LockClass::TimeoutLock(const char *FunctionName, uint64_t Timeout)
Atomic<uint64_t> Target = 0;
Retry:
unsigned int i = 0;
while (IsLocked.Exchange(true, MemoryBorder::Acquire) && ++i < 0x10000000)
while (IsLocked.Exchange(true, MemoryOrder::Acquire) && ++i < 0x10000000)
CPU::Pause();
if (i >= 0x10000000)
{

52
include/atomic.hpp
View File

@ -5,10 +5,10 @@
#define builtin_atomic_n(name) __atomic_##name##_n
#define builtin_atomic(name) __atomic_##name
enum MemoryBorder
enum MemoryOrder
{
/**
* @brief Relaxed memory border
* @brief Relaxed memory order
*
* This memory ordering specifies that the
* operation on the atomic variable has no
@ -19,7 +19,7 @@ enum MemoryBorder
Relaxed = __ATOMIC_RELAXED,
/**
* @brief Acquire memory border
* @brief Acquire memory order
*
* This memory ordering specifies that subsequent
* memory accesses after the atomic operation
@ -30,7 +30,7 @@ enum MemoryBorder
Acquire = __ATOMIC_ACQUIRE,
/**
* @brief Release memory border
* @brief Release memory order
*
* This memory ordering specifies that previous
* memory accesses before the atomic operation
@ -41,7 +41,7 @@ enum MemoryBorder
Release = __ATOMIC_RELEASE,
/**
* @brief Acquire and release memory border
* @brief Acquire and release memory order
*
* This memory ordering combines both the acquire
* and release memory orderings. This ordering
@ -51,7 +51,7 @@ enum MemoryBorder
AcqRel = __ATOMIC_ACQ_REL,
/**
* @brief Sequentially consistent memory border
* @brief Sequentially consistent memory order
*
* This memory ordering is a combination of
* @see AcqRel and the additional
@ -72,10 +72,10 @@ public:
/**
* @brief Load the value of the atomic variable
*
* @param Order The memory border to use
* @param Order The memory order to use
* @return T The value of the atomic variable
*/
T Load(MemoryBorder Order = MemoryBorder::SeqCst)
T Load(MemoryOrder Order = MemoryOrder::SeqCst)
{
return builtin_atomic_n(load)(&m_Value, Order);
}
@ -84,9 +84,9 @@ public:
* @brief Store a value to the atomic variable
*
* @param v The value to store
* @param Order The memory border to use
* @param Order The memory order to use
*/
void Store(T v, MemoryBorder Order = MemoryBorder::SeqCst)
void Store(T v, MemoryOrder Order = MemoryOrder::SeqCst)
{
return builtin_atomic_n(store)(&m_Value, v, Order);
}
@ -95,10 +95,10 @@ public:
* @brief Exchange the value of the atomic variable
*
* @param v The value to exchange
* @param Order The memory border to use
* @param Order The memory order to use
* @return T The old value of the atomic variable
*/
T Exchange(T v, MemoryBorder Order = MemoryBorder::SeqCst)
T Exchange(T v, MemoryOrder Order = MemoryOrder::SeqCst)
{
return builtin_atomic_n(exchange)(&m_Value, v, Order);
}
@ -108,11 +108,11 @@ public:
*
* @param Expected The expected value
* @param Desired The desired value
* @param Order The memory border to use
* @param Order The memory order to use
* @return true If the exchange was successful
* @return false If the exchange was not successful
*/
bool CompareExchange(T &Expected, T Desired, MemoryBorder Order = MemoryBorder::SeqCst)
bool CompareExchange(T &Expected, T Desired, MemoryOrder Order = MemoryOrder::SeqCst)
{
return builtin_atomic_n(compare_exchange)(&m_Value, &Expected, Desired, true, Order, Order);
}
@ -121,10 +121,10 @@ public:
* @brief Fetch and add the value of the atomic variable
*
* @param v The value to add
* @param Order The memory border to use
* @param Order The memory order to use
* @return T The old value of the atomic variable
*/
T FetchAdd(T v, MemoryBorder Order = MemoryBorder::SeqCst)
T FetchAdd(T v, MemoryOrder Order = MemoryOrder::SeqCst)
{
return builtin_atomic(fetch_add)(&m_Value, v, Order);
}
@ -133,10 +133,10 @@ public:
* @brief Fetch and subtract the value of the atomic variable
*
* @param v The value to subtract
* @param Order The memory border to use
* @param Order The memory order to use
* @return T The old value of the atomic variable
*/
T FetchSub(T v, MemoryBorder Order = MemoryBorder::SeqCst)
T FetchSub(T v, MemoryOrder Order = MemoryOrder::SeqCst)
{
return builtin_atomic(fetch_sub)(&m_Value, v, Order);
}
@ -145,10 +145,10 @@ public:
* @brief Fetch and and the value of the atomic variable
*
* @param v The value to and
* @param Order The memory border to use
* @param Order The memory order to use
* @return T The old value of the atomic variable
*/
T FetchAnd(T v, MemoryBorder Order = MemoryBorder::SeqCst)
T FetchAnd(T v, MemoryOrder Order = MemoryOrder::SeqCst)
{
return builtin_atomic(fetch_and)(&m_Value, v, Order);
}
@ -157,10 +157,10 @@ public:
* @brief Fetch and or the value of the atomic variable
*
* @param v The value to or
* @param Order The memory border to use
* @param Order The memory order to use
* @return T The old value of the atomic variable
*/
T FetchOr(T v, MemoryBorder Order = MemoryBorder::SeqCst)
T FetchOr(T v, MemoryOrder Order = MemoryOrder::SeqCst)
{
return builtin_atomic(fetch_or)(&m_Value, v, Order);
}
@ -169,10 +169,10 @@ public:
* @brief Fetch and xor the value of the atomic variable
*
* @param v The value to xor
* @param Order The memory border to use
* @param Order The memory order to use
* @return T The old value of the atomic variable
*/
T FetchXor(T v, MemoryBorder Order = MemoryBorder::SeqCst)
T FetchXor(T v, MemoryOrder Order = MemoryOrder::SeqCst)
{
return builtin_atomic(fetch_xor)(&m_Value, v, Order);
}
@ -181,10 +181,10 @@ public:
* @brief Fetch and nand the value of the atomic variable
*
* @param v The value to nand
* @param Order The memory border to use
* @param Order The memory order to use
* @return T The old value of the atomic variable
*/
T FetchNand(T v, MemoryBorder Order = MemoryBorder::SeqCst)
T FetchNand(T v, MemoryOrder Order = MemoryOrder::SeqCst)
{
return builtin_atomic(fetch_nand)(&m_Value, v, Order);
}