Fennix/Kernel
1
0
Fork 0
mirror of https://github.com/Fennix-Project/Kernel.git synced 2025-05-30 00:08:03 +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; LockData.AttemptingToGet = FunctionName;
Retry: Retry:
unsigned int i = 0; unsigned int i = 0;
while (IsLocked.Exchange(true, MemoryBorder::Acquire) && ++i < 0x10000000) while (IsLocked.Exchange(true, MemoryOrder::Acquire) && ++i < 0x10000000)
CPU::Pause(); CPU::Pause();
if (i >= 0x10000000) if (i >= 0x10000000)
{ {
@ -77,7 +77,7 @@ int LockClass::Unlock()
// IsLocked = false; // IsLocked = false;
__sync_synchronize(); __sync_synchronize();
IsLocked.Store(false, MemoryBorder::Release); IsLocked.Store(false, MemoryOrder::Release);
LockData.Count--; LockData.Count--;
IsLocked = false; IsLocked = false;
@ -114,7 +114,7 @@ int LockClass::TimeoutLock(const char *FunctionName, uint64_t Timeout)
Atomic<uint64_t> Target = 0; Atomic<uint64_t> Target = 0;
Retry: Retry:
unsigned int i = 0; unsigned int i = 0;
while (IsLocked.Exchange(true, MemoryBorder::Acquire) && ++i < 0x10000000) while (IsLocked.Exchange(true, MemoryOrder::Acquire) && ++i < 0x10000000)
CPU::Pause(); CPU::Pause();
if (i >= 0x10000000) if (i >= 0x10000000)
{ {

52
include/atomic.hpp
View File

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