atomic.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Author:  Giovanni Santini
// Mail:    giovanni.santini@proton.me
// Github:  @San7o
 
#pragma once
 
#include <tenno/mutex.hpp>
 
namespace tenno
{
 
template <typename T> class atomic;
 
/* general case */
template <typename T> class atomic
{
public:
  using value_type = T;
  const bool is_always_lock_free = false;
 
  atomic() noexcept = default;
  ~atomic() noexcept = default;
  atomic(const atomic &) = delete;
  atomic &operator=(const atomic &) = delete;
  atomic &operator=(const atomic &) volatile = delete;
 
  inline bool is_lock_free() const noexcept
  {
    return this->is_always_lock_free;
  }
 
  inline void store(T desired) noexcept
  {
    tenno::lock_guard<tenno::mutex> lock(this->_mutex);
    this->_value = desired;
  }
 
  inline T load() noexcept
  {
    tenno::lock_guard<tenno::mutex> lock(this->_mutex);
    return this->_value;
  }
 
  operator T() noexcept
  {
    return this->load();
  }
 
  inline T exchange(T desired) noexcept
  {
    tenno::lock_guard<tenno::mutex> lock(this->_mutex);
    T old = this->_value;
    this->_value = desired;
    return old;
  }
 
  inline bool compare_exchange_weak(const T &expected, T desired) noexcept
  {
    tenno::lock_guard<tenno::mutex> lock(this->_mutex);
    if (this->_value == expected)
    {
      this->_value = desired;
      return true;
    }
    return false;
  }
 
  inline bool compare_exchange_strong(const T &expected, T desired) noexcept
  {
    tenno::lock_guard<tenno::mutex> lock(this->_mutex);
    if (this->_value == expected)
    {
      this->_value = desired;
      return true;
    }
    return false;
  }
 
  // TODO
  // - wait
  // - notify_one
  // - notify_all
 
private:
  T _value;
  tenno::mutex _mutex;
};
 
/* general pointer */
template <typename U> class atomic<U *>
{
public:
  using value_type = U *;
  const bool is_always_lock_free = false;
 
  atomic() noexcept = default;
  ~atomic() noexcept = default;
  atomic(const atomic &) = delete;
  atomic &operator=(const atomic &) = delete;
  atomic &operator=(const atomic &) volatile = delete;
 
  inline bool is_lock_free() const noexcept
  {
    return this->is_always_lock_free;
  }
 
  inline void store(U *desired) noexcept
  {
    tenno::lock_guard<tenno::mutex> lock(this->_mutex);
    this->_value = desired;
  }
 
  inline U load() noexcept
  {
    tenno::lock_guard<tenno::mutex> lock(this->_mutex);
    return *this->_value;
  }
 
  operator U() noexcept
  {
    return this->load();
  }
 
  inline U exchange(U *desired) noexcept
  {
    tenno::lock_guard<tenno::mutex> lock(this->_mutex);
    U old = *this->_value;
    this->_value = desired;
    return old;
  }
 
  inline bool compare_exchange_weak(const U *expected, U *desired) noexcept
  {
    tenno::lock_guard<tenno::mutex> lock(this->_mutex);
    if (this->_value != nullptr && *this->_value == *expected)
    {
      *this->_value = *desired;
      return true;
    }
    return false;
  }
 
  inline bool compare_exchange_strong(const U *expected, U *desired) noexcept
  {
    tenno::lock_guard<tenno::mutex> lock(this->_mutex);
    if (this->_value != nullptr && *this->_value == *expected)
    {
      *this->_value = *desired;
      return true;
    }
    return false;
  }
 
private:
  U *_value;
  tenno::mutex _mutex;
};
 
/* int specialization */
template <> class atomic<int>
{
public:
  using value_type = int;
  const bool is_always_lock_free = true;
 
  atomic() noexcept = default;
  ~atomic() noexcept = default;
  atomic(const atomic &) = delete;
  atomic &operator=(const atomic &) = delete;
  atomic &operator=(const atomic &) volatile = delete;
 
  inline bool is_lock_free() const noexcept
  {
    return this->is_always_lock_free;
  }
 
  inline void store(int desired) noexcept
  {
    asm volatile("lock xchg %0, %1" : "+m"(this->_value), "+r"(desired));
  }
 
  inline int load() noexcept
  {
    int out = 0;
    asm volatile("lock add %1, %0" : "+m"(out), "+r"(this->_value));
    return out;
  }
 
  operator int() noexcept
  {
    return this->load();
  }
 
  inline int exchange(int desired) noexcept
  {
    asm volatile("lock xchg %0, %1" : "+m"(this->_value), "+r"(desired));
    return desired;
  }
 
  inline bool compare_exchange_weak(int &expected, int desired) noexcept
  {
    bool success;
    asm volatile("lock cmpxchg %[desired], %[target]\n\t"
                 "sete %[success]\n\t"
                 : [success] "=r"(success), "=m"(this->_value)
                 : [target] "m"(this->_value),
                   "a"(expected), [desired] "r"(desired)
                 : "memory", "cc");
    return success;
  }
 
  inline bool compare_exchange_strong(int &expected, int desired) noexcept
  {
    bool success = false;
    while (!success)
    {
      asm volatile("lock cmpxchg %[desired], %[target]\n\t"
                   "sete %[success]\n\t"
                   : [success] "=r"(success), "=m"(this->_value)
                   : [target] "m"(this->_value),
                     "a"(expected), [desired] "r"(desired)
                   : "memory", "cc");
    }
    return true;
  }
 
private:
  int _value;
};
 
/* char specialization */
 
template <> class atomic<char>
{
public:
  using value_type = char;
  const bool is_always_lock_free = true;
 
  atomic() noexcept = default;
  ~atomic() noexcept = default;
  atomic(const atomic &) = delete;
  atomic &operator=(const atomic &) = delete;
  atomic &operator=(const atomic &) volatile = delete;
 
  inline bool is_lock_free() const noexcept
  {
    return this->is_always_lock_free;
  }
 
  inline void store(char desired) noexcept
  {
    asm volatile("lock xchg %0, %1" : "+m"(this->_value), "+r"(desired));
  }
 
  inline char load() noexcept
  {
    char out = 0;
    asm volatile("lock add %1, %0" : "+m"(out), "+r"(this->_value));
    return out;
  }
 
  operator char() noexcept
  {
    return this->load();
  }
 
  inline char exchange(char desired) noexcept
  {
    asm volatile("lock xchg %0, %1" : "+m"(this->_value), "+r"(desired));
    return desired;
  }
 
  inline bool compare_exchange_weak(char &expected, char desired) noexcept
  {
    bool success;
    asm volatile("lock cmpxchg %[desired], %[target]\n\t"
                 "sete %[success]\n\t"
                 : [success] "=r"(success), "=m"(this->_value)
                 : [target] "m"(this->_value),
                   "a"(expected), [desired] "r"(desired)
                 : "memory", "cc");
    return success;
  }
 
  inline bool compare_exchange_strong(char &expected, char desired) noexcept
  {
    bool success = false;
    while (!success)
    {
      asm volatile("lock cmpxchg %[desired], %[target]\n\t"
                   "sete %[success]\n\t"
                   : [success] "=r"(success), "=m"(this->_value)
                   : [target] "m"(this->_value),
                     "a"(expected), [desired] "r"(desired)
                   : "memory", "cc");
    }
    return true;
  }
 
private:
  char _value;
};
 
/* long specialization */
 
template <> class atomic<long>
{
public:
  using value_type = long;
  const bool is_always_lock_free = true;
 
  atomic() noexcept = default;
  ~atomic() noexcept = default;
  atomic(const atomic &) = delete;
  atomic &operator=(const atomic &) = delete;
  atomic &operator=(const atomic &) volatile = delete;
 
  inline bool is_lock_free() const noexcept
  {
    return this->is_always_lock_free;
  }
 
  inline void store(long desired) noexcept
  {
    asm volatile("lock xchg %0, %1" : "+m"(this->_value), "+r"(desired));
  }
 
  inline long load() noexcept
  {
    long out = 0;
    asm volatile("lock add %1, %0" : "+m"(out), "+r"(this->_value));
    return out;
  }
 
  operator long() noexcept
  {
    return this->load();
  }
 
  inline long exchange(long desired) noexcept
  {
    asm volatile("lock xchg %0, %1" : "+m"(this->_value), "+r"(desired));
    return desired;
  }
 
  inline bool compare_exchange_weak(long &expected, long desired) noexcept
  {
    bool success;
    asm volatile("lock cmpxchg %[desired], %[target]\n\t"
                 "sete %[success]\n\t"
                 : [success] "=r"(success), "=m"(this->_value)
                 : [target] "m"(this->_value),
                   "a"(expected), [desired] "r"(desired)
                 : "memory", "cc");
    return success;
  }
 
  inline bool compare_exchange_strong(long &expected, long desired) noexcept
  {
    bool success = false;
    while (!success)
    {
      asm volatile("lock cmpxchg %[desired], %[target]\n\t"
                   "sete %[success]\n\t"
                   : [success] "=r"(success), "=m"(this->_value)
                   : [target] "m"(this->_value),
                     "a"(expected), [desired] "r"(desired)
                   : "memory", "cc");
    }
    return true;
  }
 
private:
  long _value;
};
 
} // namespace tenno