Russian Qt Forum

C++ (Qt)
#ifndef ATOMICDATA_H
#define ATOMICDATA_H
 
template <class T>
class AtomicData
{
public:
    AtomicData() : m_flag(0) {}
    AtomicData(const T &data) : m_flag(0), m_data(data) {}
    AtomicData(const AtomicData<T> &other) : m_flag(0), m_data(other.get()) {}
    void set(const T &data) {
        while (m_flag) {}
        m_flag = 1;
        m_data = data;
        m_flag = 0;
    }
    T get() const {
        while (m_flag & 1) {}
        m_flag = 2;
        T data = m_data;
        m_flag = 0;
        return data;
    }
private:
    mutable volatile char m_flag;
    T m_data;
    AtomicData<T> &operator=(const AtomicData<T> &);
};
 
#endif // ATOMICDATA_H
 

C++ (Qt)
        while (m_flag) {}
                      <- Здесь пробой
        m_flag = 1;
 

C++ (Qt)
while (m_flag++);  // <<-- Атомарна ли оно?
critical_section();
m_flag = 0; 
 

C++ (Qt)
shared_ptr<Data> ptr;
DataManager dataManager;
...
ptr = dataManager.data();
 

C++ (Qt)
shared_ptr<Data> ptr;
DataManager dataManager;
...
for (int i = 0; i < 100 ++i) {
 ptr = dataManager.data();
 ...
}
 

C++ (Qt)
    const SharedPointer<const Data> getDataSnapshot () const
    {
         ReadLocker lock;
         return m_data;
    }
 

C++ (Qt)
#ifndef ATOMICDATA_H
#define ATOMICDATA_H
 
#include <asm/atomic.h>
 
template <class T>
class AtomicData
{
private:
    AtomicData() {
        m_key1 = ATOMIC_INIT(-1);
        m_key2 = ATOMIC_INIT(-1);
    }
    void setData(const T &data) {
        while (!test_for_write(&m_key1, &m_key2));
        // critical section
        m_data = data;
 
        atomic_set(&m_key1, -1);
        atomic_set(&m_key2, -1);
    }
    T getData() const {
        while (!test_for_read(&m_key1));
        // critical section
        T res = m_data;
        atomic_set(&m_key1, -1);
        atomic_set(&m_key2, -1);
        return res;
    }
private:
    atomic_t m_key1;
    atomic_t m_key2;
    T m_data;
 
    static bool test_for_write(atomic_t *key1, atomic_t *key2) {
        bool res1 = atomic_inc_and_test(key1);
        bool res2 = atomic_inc_and_test(key2);
        atomic_set(key1, 0);
        atomic_set(key2, 0);
        return (res1 && res2);
    }
 
    static bool test_for_read(atomic_t *key1) {
        bool res = atomic_inc_and_test(key1);
        atomic_set(&m_key2, 0);
        atomic_set(key1, -1);
        return res;
    }
};
 
 
#endif // ATOMICDATA_H
 

C++ (Qt)
#ifndef ATOMICDATA_H
#define ATOMICDATA_H
 
#include <cstdatomic>
 
template <class T>
class AtomicData
{
private:
    typedef atomic<int> AtomicInt;
    AtomicData()  : m_key1(-1), m_key2(-1) {}
    void setData(const T &data) {
        while (!test_for_write(m_key1, m_key2));
        // critical section
        m_data = data;
 
        m_key1 = -1;
        m_key2 = -1;
    }
    T getData() const {
        while (!test_for_read(m_key1, m_key2));
        // critical section
        T res = m_data;
        m_key1 = -1;
        m_key2 = -1;
        return res;
    }
private:
    AtomicInt m_key1;
    AtomicInt m_key2;
    T m_data;
 
    static bool test_for_write(AtomicInt &key1, AtomicInt &key2) {
        bool res1 = (++key1 == 0);
        bool res2 = (++key2 == 0);
        key1 = 0;
        key2 = 0;
        return (res1 && res2);
    }
 
    static bool test_for_read(AtomicInt &key1, AtomicInt &key2) {
        bool res = (++key1 == 0);
        key2 = 0;
        key1 = -1;
        return res;
    }
};
 

C++ (Qt)
    static bool test_for_read(AtomicInt &key1, AtomicInt &key2) {
        bool res = (++key1 == 0);
        key2 = 0;
        key1 = -1;
        return res;
    }
};
 

C++ (Qt)
res1 = (++key == 0)
 

C++ (Qt)
    T getData() const {
        while (!test_for_read(m_key1, m_key2));
        // critical section
        T res = m_data;
        m_key1 = -1;
        m_key2 = -1;
        return res;
    }
 

C++ (Qt)
    static bool test_for_write(AtomicInt &key1, AtomicInt &key2) {
        bool res1 = (++key1 == 0);
        bool res2 = (++key2 == 0);
        key1 = 0;
        key2 = 0;
        return (res1 && res2); 
    }
 

C++ (Qt)
    static bool test_for_read(AtomicInt &key1, AtomicInt &key2) {
        bool res = (++key1 == 0);
        key2 = 0;
        key1 = -1;
        return res;
    }
};
 

C++ (Qt)
bool AcquireWrite( AtomicInt & state )
{
  if (state > 0) return false;
  return CompareAndSwap(&state, 0, STATE_WRITE);
}
 
void ReleaseWrite( AtomicInt & state )
{
  state = 0;
}
 
bool AcquireRead( AtomicInt & state )
{
  int temp = state;
  if (temp == STATE_WRITE) return false;
  return CompareAndSwap(&state, temp, temp + 1);
}
 
void ReleaseRead( AtomicInt & state )
{
  assert(state > 0);
  --state;
}
 

C++ (Qt)
	const Data data() const
	{
		const Data result = m_data1; /*B*/
 
		while (result != m_data1 || result != m_data2)
			result = m_data1;
 
		return result;
	}
 

C++ (Qt)
#ifndef ATOMICDATA_H
#define ATOMICDATA_H
 
#include <assert.h>
#include <cstdatomic>
 
template <class T>
class AtomicData
{
public:
    typedef atomic<int> AtomicInt;
    AtomicData()  : m_count_readers(0), m_state_write(-1) {}
 
    void setData(const T &data) {
        while (!acquireWrite(m_count_readers, m_state_write));
        m_data = data;
        releaseWrite(m_state_write);
    }
    T getData() const {
        while (!acquireRead(m_count_readers, m_state_write));
        T data = m_data;
        releaseRead(m_count_readers, m_state_write);
        return data;
    }
private:
    AtomicInt m_count_readers;
    AtomicInt m_state_write;
    T m_data;
 
    static bool acquireWrite(AtomicInt &readers, AtomicInt &state_write) {
 
        bool tmp = (++state_write == 0);
        state_write = 0;
 
        return (tmp && !readers);
    }
    //-------------------------------------------------------------------------
 
    static void releaseWrite(AtomicInt &state_write) {
        state_write = -1;
    }
    //-------------------------------------------------------------------------
 
    static bool acquireRead(AtomicInt &readers, AtomicInt &state_write) {
 
        if (!readers)
            readers = (state_write == -1);
        else
            readers++;
 
        return readers;
    }
    //-------------------------------------------------------------------------
 
    static void releaseRead(AtomicInt &readers, AtomicInt &state_write) {
        if (--readers == 0)
            state_write = -1;
    }
    //-------------------------------------------------------------------------
};
 
 
#endif // ATOMICDATA_H
 

C++ (Qt)
        if (!readers)
            readers = (state_write == -1);
 

C++ (Qt)
static bool acquireRead(AtomicInt &readers, AtomicInt &state_write) {
 
        if (!readers)
            readers = 1; // атомарно
            int tmp = (state_write == -1); // атомарно
            readers = tmp; // атомарно
        else
            readers++;
 
        return readers;
    }
 

C++ (Qt)
static bool acquireRead(AtomicInt &readers, AtomicInt &state_write) {
 
        if (!readers) {
            int tmp = (++state_write == 0);
            readers = tmp;
        }
        else
            readers++;
 
        return readers;
    }
 

C++ (Qt)
#ifndef SPINLOCK_H
#define SPINLOCK_H
 
#include <assert.h>
#include <cstdatomic>
 
template <class T>
class SpinLock
{
public:
    typedef atomic<int> AtomicInt;
    SpinLock()  : m_count_readers(0), m_state_write(-1) {}
 
    void setData(const T &data) {
        while (!acquireWrite(m_count_readers, m_state_write));
        m_data = data;
        releaseWrite(m_state_write);
    }
    T getData() const {
        while (!acquireRead(m_count_readers, m_state_write));
        T data = m_data;
        releaseRead(m_count_readers, m_state_write);
        return data;
    }
private:
    AtomicInt m_count_readers;
    AtomicInt m_state_write;
    T m_data;
 
    static bool acquireWrite(AtomicInt &readers, AtomicInt &state_write) {
 
        bool tmp = (++state_write == 0);
        state_write = 0;
 
        return (tmp && !readers);
    }
    //-------------------------------------------------------------------------
 
    static void releaseWrite(AtomicInt &state_write) {
        state_write = -1;
    }
    //-------------------------------------------------------------------------
 
    static bool acquireRead(AtomicInt &readers, AtomicInt &state_write) {
 
        if (!readers) {
            int tmp = (++state_write == 0);
            readers = tmp;
        }
        else
            readers++;
 
        return readers;
    }
    //-------------------------------------------------------------------------
 
    static void releaseRead(AtomicInt &readers, AtomicInt &state_write) {
        if (--readers == 0)
            state_write = -1;
    }
    //-------------------------------------------------------------------------
};
 
#endif // SPINLOCK_H
 

C++ (Qt)
#ifndef SPINLOCK_H
#define SPINLOCK_H
 
#include <assert.h>
#include <cstdatomic>
 
template <class T>
class SpinLock
{
public:
    typedef atomic<int> AtomicInt;
    SpinLock()  : m_count_readers(0), m_state_write(-1) {}
 
    void setData(const T &data) {
        while (!acquireWrite(m_count_readers, m_state_write));
        m_data = data;
        releaseWrite(m_state_write);
    }
    T getData() const {
        while (!acquireRead(m_count_readers, m_state_write));
        T data = m_data;
        releaseRead(m_count_readers, m_state_write);
        return data;
    }
private:
    AtomicInt m_count_readers;
    AtomicInt m_state_write;
    T m_data;
 
    static bool acquireWrite(AtomicInt &readers, AtomicInt &state_write) {
 
        bool tmp = (++state_write == 0);
        state_write = 0;
 
        return (tmp && !readers);
    }
    //-------------------------------------------------------------------------
 
    static void releaseWrite(AtomicInt &state_write) {
        state_write = -1;
    }
    //-------------------------------------------------------------------------
 
    static bool acquireRead(AtomicInt &readers, AtomicInt &state_write) {
 
        readers++;
        bool tmp = (++state_write == 0);
        state_write = 0;
 
        if (tmp) {
            state_write = -1;
            return true;
        }
        readers--;
        return false;
    }
    //-------------------------------------------------------------------------
 
    static void releaseRead(AtomicInt &readers, AtomicInt &state_write) {
        if(--readers == 0)
            state_write = -1;
    }
    //-------------------------------------------------------------------------
};
 
 
#endif // SPINLOCK_H
 

C++ (Qt)
static bool acquireWrite(AtomicInt &readers, AtomicInt &state_write) {
 
        bool tmp = (++state_write == 0);
        if (tmp && !readers)
            return true;
 
        state_write = 0;
        return false;
    }
 

C++ (Qt)
#ifndef SPINLOCK_H
#define SPINLOCK_H
 
#include <assert.h>
#include <cstdatomic>
 
template <class T>
class SpinLock
{
public:
    typedef atomic<int> AtomicInt;
    SpinLock()  : m_key(-1), m_state(STATE_FREE) {}
 
    void setData(const T &data) {
        while (!acquireWrite(m_key, m_state));
        m_data = data;
        releaseWrite(m_key, m_state);
    }
    T getData() const {
        while (!acquireRead(m_key, m_state));
        T data = m_data;
        releaseRead(m_key, m_state);
        return data;
    }
private:
    enum { STATE_FREE = 0, STATE_READ = 1, STATE_WRITE = 2, STATE_READ_AND_WRITE = 3 };
    AtomicInt m_key;
    AtomicInt m_state;
    T m_data;
    //-------------------------------------------------------------------------
 
    static bool acquireWrite(AtomicInt &key, AtomicInt &state) {
 
        int tmp = (state |= STATE_WRITE);
        if (tmp == STATE_READ_AND_WRITE) {
            state = STATE_READ;
            return false;
        }
        bool tmp2 = (++key == 0);
        key = 0;
        return tmp2;
    }
    //-------------------------------------------------------------------------
 
    static void releaseWrite(AtomicInt &key, AtomicInt &state) {
        state = STATE_FREE;
        key = -1;
    }
    //-------------------------------------------------------------------------
 
    static bool acquireRead(AtomicInt &/*key*/, AtomicInt &state) {
 
        int tmp = (state |= STATE_READ);
        if (tmp == STATE_READ)
            return true;
        state = STATE_WRITE;
        return false;
 
    }
    //-------------------------------------------------------------------------
 
    static void releaseRead(AtomicInt &/*key*/, AtomicInt &state) {
       state = STATE_FREE;
    }
    //-------------------------------------------------------------------------
};
 
 
#endif // SPINLOCK_H
 

C++ (Qt)
#ifndef SPINLOCK_H
#define SPINLOCK_H
 
#include <assert.h>
#include <cstdatomic>
 
template <class T>
class SpinLock
{
public:
    typedef atomic<int> AtomicInt;
    SpinLock()  : m_key(-1), m_state(STATE_FREE), m_counter(0) {}
 
    void setData(const T &data) {
        while (!acquireWrite(m_key, m_state));
        m_data = data;
        releaseWrite(m_key, m_state);
    }
    T getData() const {
        while (!acquireRead(m_counter, m_state));
        T data = m_data;
        releaseRead(m_counter, m_state);
        return data;
    }
private:
    enum { STATE_FREE = 0, STATE_READ = 1, STATE_WRITE = 2, STATE_READ_AND_WRITE = 3 };
    AtomicInt m_key;
    AtomicInt m_state;
    AtomicInt m_counter;
    T m_data;
    //-------------------------------------------------------------------------
 
    static bool acquireWrite(AtomicInt &key, AtomicInt &state) {
 
        int tmp = (state |= STATE_WRITE);
        if (tmp == STATE_READ_AND_WRITE) {
            state = STATE_READ;
            return false;
        }
        bool tmp2 = (++key == 0);
        key = 0;
        return tmp2;
    }
    //-------------------------------------------------------------------------
 
    static void releaseWrite(AtomicInt &key, AtomicInt &state) {
        state = STATE_FREE;
        key = -1;
    }
    //-------------------------------------------------------------------------
 
    static bool acquireRead(AtomicInt &counter, AtomicInt &state) {
 
        int tmp = (state |= STATE_READ);
        if (tmp == STATE_READ) {
            counter++;
            return true;
        }
        state = STATE_WRITE;
        return false;
 
    }
    //-------------------------------------------------------------------------
 
    static void releaseRead(AtomicInt &counter, AtomicInt &state) {
        if (--counter == 0)
            state = STATE_FREE;
    }
    //-------------------------------------------------------------------------
};
 
 
#endif // SPINLOCK_H
 

C++ (Qt)
#define FLAG_WRITE      1   //  флаг запись 
#define FLAG_PENDING   2   //  запрос запись 
#define FLAG_WRITE_PENDING   (FLAG_WRITE | FLAG_PENDING)    
#define NUM_READERS(a)  ((a) >> 2)
 
bool AcquireWrite( AtomicInt & state )
{
  int curValue = state;
  if (curValue & FLAG_WRITE)   // кто-то уже пишет?
    return false; 
 
  if (!NUM_READERS(curValue))                // нет читающих, пытаемся захватить по записи
   return CompareAndSwap(&state, curValue, FLAG_WRITE_PENDING);
 
  if ((curValue & FLAG_PENDING) == 0)   // пытаемся долить запрос на запись
   CompareAndSwap(&state, curValue, curValue | FLAG_PENDING);
 
  return false;
}
 
bool AcquireRead( AtomicInt & state )
{
  int curValue = state;
  if (curValue & FLAG_WRITE_PENDING)   // кто-то пишет или хочет писать
    return false; 
 
  return CompareAndSwap(&state, curValue, (NUM_READERS(curValue) + 1) << 2);
}
 
void Release( AtomicInt & state )
{
  int curValue = state;
  if (curValue & FLAG_WRITE) {  // сброс записи
   assert(NUM_READERS(curValue) == 0);
   state = 0;        
  }
 
  else {     // уменьшаем число читающих, но не должны потерять FLAG_PENDING, поэтому while
    assert(NUM_READERS(curValue) > 0);
    while (true) {
      curValue = state;
      int newValue = (curValue & FLAG_WRITE_PENDING) | ((NUM_READERS(curValue) - 1) << 2);
      if (CompareAndSwap(&state, curValue, newValue))
       return;
    }
  }
}
 

C++ (Qt)
struct mutex
{
   atomic_int n = 0;
   int level = 1;
 
   lock ()
   {
       int nn = ++n; //atomic pre increment
       while (nn != level);
   }
 
   unlock ()
   {
      ++level; //non-atomic, but protected by our newborn mutex!
   }
};
 

C++ (Qt)
struct mutex
{
   atomic_int n = 0;
   int level = 1;
 
   lock ()
   {
       int nn = ++n; //atomic pre increment
       while (nn != level);
   }
 
   unlock ()
   {
      level = nn + 1; //non-atomic, but protected by our newborn mutex!
   }
};
 

C++ (Qt)
struct semaphore
{
   volatile int n;
 
   semaphore( int _n ) : n(_n) {}
 
   void acquire( void )
   {
       while (true) {   // нагреваем процессор...
        int value = n;
        if (value && CompareAndSwap(&n, value, value - 1)) break;
       }
   }
 
   void release( void )
   {
     ++n;
   }
};
 

C++ (Qt)
struct mutex
{
   atomic_int n = 0;
   int level = 1;
 
   lock ()
   {
       int nn = ++n; //atomic pre increment
       while (nn != level);
   }
 
   unlock ()
   {
      level = nn + 1; //non-atomic, but protected by our newborn mutex!
   }
};
 

C++ (Qt)
void unlock ()
{
    level++;
}
 

C++ (Qt)
class mutex
{
   atomic_int key = -1;
 public:
   lock ()
   {
       int tmp = 0;
       do {
          tmp = ++key;
          if (tmp) key--;
      } while (tmp != 0);
   }
 
   unlock ()
   {
      key = -1;
   }
};
 

C++ (Qt)
struct rw_lock
{
   bool m_writer = false;
   int m_readers = 0;
   mutex m_mutex;
 
   lock_read ()
   {
      while (true)
      {
          scoped_lock sl (m_mutex);
          if (!m_writer)
          {
             ++m_readers;
             return;
          }
      }
   }
 
   unlock_read ()
   {
      scoped_lock sl (m_mutex);
      --m_readers;
   }
 
   lock_write ()
   {
      while (true)
      {
          scoped_lock sl (m_mutex);
          if (!m_readers && !m_writer)
          {
             m_writer = true;
             return;
          }
      }
   }
 
   unlock_write ()
   {
      scoped_lock sl (m_mutex);
      m_write = false;
   }
};
 

C++ (Qt)
void lock() {
        int key = 0;
        do {
            key = ++m_key;
            if (key > 0) m_key--;
        } while (key != 0);
    }
 
    void unlock() {
        m_key = -1;
    }