comparison base/RingBuffer.h @ 835:1d439494604c

Memory barriers in ringbuffer

 #define _RINGBUFFER_H_
 
 #include <sys/types.h>
 
 #include "system/System.h"
-#include "Scavenger.h"
 
 #include <cstring> // memcpy, memset &c
 
 //#define DEBUG_RINGBUFFER 1
 

      * (This is the argument n passed to the constructor.)
      */
     size_t getSize() const;
 
     /**
-     * Resize the ring buffer.  This also empties it.  Actually swaps
-     * in a new, larger buffer; the old buffer is scavenged after a
-     * seemly delay.  Should be called from the write thread.
-     */
-    void resize(size_t newSize);
+     * Return a new ring buffer (allocated with "new" -- caller must
+     * delete when no longer needed) of the given size, containing the
+     * same data as this one as perceived by reader 0 of this buffer.
+     * If another thread reads from or writes to this buffer during
+     * the call, the contents of the new buffer may be incomplete or
+     * inconsistent.  If this buffer's data will not fit in the new
+     * size, the contents are undefined.
+     */
+    RingBuffer<T, N> *resized(size_t newSize) const;
 
     /**
      * Lock the ring buffer into physical memory.  Returns true
      * for success.
      */

     size_t  m_writer;
     size_t *m_readers;
     size_t  m_size;
     size_t  m_spare;
 
-    static Scavenger<ScavengerArrayWrapper<T> > m_scavenger;
-
 private:
     RingBuffer(const RingBuffer &); // not provided
     RingBuffer &operator=(const RingBuffer &); // not provided
 };
-
-template <typename T, int N>
-Scavenger<ScavengerArrayWrapper<T> > RingBuffer<T, N>::m_scavenger;
 
 template <typename T, int N>
 RingBuffer<T, N>::RingBuffer(size_t n) :
     m_buffer(new T[n + 1]),
     m_mlocked(false),

     std::cerr << "&m_readers = " << &m_readers << std::endl;
     std::cerr << "&m_size = " << &m_size << std::endl;
 */
     
     for (int i = 0; i < N; ++i) m_readers[i] = 0;
-
-    m_scavenger.scavenge();
 }
 
 template <typename T, int N>
 RingBuffer<T, N>::~RingBuffer()
 {

 
     if (m_mlocked) {
 	MUNLOCK((void *)m_buffer, m_size * sizeof(T));
     }
     delete[] m_buffer;
-
-    m_scavenger.scavenge();
 }
 
 template <typename T, int N>
 size_t
 RingBuffer<T, N>::getSize() const

 
     return m_size - 1;
 }
 
 template <typename T, int N>
-void
-RingBuffer<T, N>::resize(size_t newSize)
-{
-#ifdef DEBUG_RINGBUFFER
-    std::cerr << "RingBuffer<T," << N << ">[" << this << "]::resize(" << newSize << ")" << std::endl;
-#endif
-
-    m_scavenger.scavenge();
-
-    if (m_mlocked) {
-	MUNLOCK((void *)m_buffer, m_size * sizeof(T));
-    }
-
-    m_scavenger.claim(new ScavengerArrayWrapper<T>(m_buffer));
-
-    reset();
-    m_buffer = new T[newSize + 1];
-    m_size = newSize + 1;
-
-    if (m_mlocked) {
-	if (MLOCK((void *)m_buffer, m_size * sizeof(T))) {
-	    m_mlocked = false;
-	}
-    }
+RingBuffer<T, N> *
+RingBuffer<T, N>::resized(size_t newSize) const
+{
+#ifdef DEBUG_RINGBUFFER
+    std::cerr << "RingBuffer<T," << N << ">[" << this << "]::resized(" << newSize << ")" << std::endl;
+#endif
+
+    RingBuffer<T, N> *newBuffer = new RingBuffer<T, N>(newSize);
+
+    int w = m_writer;
+    int r = m_readers[0];
+
+    while (r != w) {
+        T value = m_buffer[r];
+        newBuffer->write(&value, 1);
+        if (++r == m_size) r = 0;
+    }
+
+    return newBuffer;
 }
 
 template <typename T, int N>
 bool
 RingBuffer<T, N>::mlock()

     } else {
 	memcpy(destination, m_buffer + m_readers[R], here * sizeof(T));
 	memcpy(destination + here, m_buffer, (n - here) * sizeof(T));
     }
 
+    MBARRIER();
     m_readers[R] = (m_readers[R] + n) % m_size;
 
 #ifdef DEBUG_RINGBUFFER
     std::cerr << "RingBuffer<T," << N << ">[" << this << "]::read: read " << n << ", reader now " << m_readers[R] << std::endl;
 #endif

 	for (size_t i = 0; i < (n - here); ++i) {
 	    destination[i + here] += m_buffer[i];
 	}
     }
 
+    MBARRIER();
     m_readers[R] = (m_readers[R] + n) % m_size;
     return n;
 }
 
 template <typename T, int N>

 	T t;
 	memset(&t, 0, sizeof(T));
 	return t;
     }
     T value = m_buffer[m_readers[R]];
+    MBARRIER();
     if (++m_readers[R] == m_size) m_readers[R] = 0;
     return value;
 }
 
 template <typename T, int N>

     } else {
 	memcpy(m_buffer + m_writer, source, here * sizeof(T));
 	memcpy(m_buffer, source + here, (n - here) * sizeof(T));
     }
 
+    MBARRIER();
     m_writer = (m_writer + n) % m_size;
 
 #ifdef DEBUG_RINGBUFFER
     std::cerr << "RingBuffer<T," << N << ">[" << this << "]::write: wrote " << n << ", writer now " << m_writer << std::endl;
 #endif

 	memset(m_buffer + m_writer, 0, n * sizeof(T));
     } else {
 	memset(m_buffer + m_writer, 0, here * sizeof(T));
 	memset(m_buffer, 0, (n - here) * sizeof(T));
     }
-
+    
+    MBARRIER();
     m_writer = (m_writer + n) % m_size;
     return n;
 }
 
 #endif // _RINGBUFFER_H_