Hi folks I'm trying (in vain so far) to find a suitable circular_buffer that allows chunked reads/writes which I can use in boost asio. This is my use case: I have 2 threads, Thread 1 reads data from a socket (boost::asio::tp::tcp::socket) and writes it into a buffer (boost::asio::mutable_buffer) Thread 2 reads the buffer and parses out individual messages. Thread 2 shouldn't care about what Thread 1 is doing, specifically whether or not it has completed (or is in the process of) more writes than what Thread 2 has read. All Thread 2 should receive is a small packet of information (the interface being perhaps only iterator begin() and size_t size() ) relating to the chunk of data that was written into the buffer. Reading from the iterator should be safe (ie: it should wrap when it reaches the end of the buffer) Writing into the buffer shouldn't invalidate the iterators that were created previously (which were passed to the 2nd thread) I have an implementation from before I started using boost::asio, which is below. It's quite clearly not standard compliant, but it worked for me. Is there anything out there that works like I've described? Is there an alternative method which I should pursue rather than "chunked circular buffers"? Will I be able to create something like I've pasted below successfully to work with boost asio, or are there issues I'm unaware of? (The reason I ask this question is because I find it surprising that something like this doesn't exist already) Any and all help greatly appreciated. TIA Steve #ifndef _ring_buf_h_ #define _ring_buf_h_ #include <errno.h> #include <boost/thread/mutex.hpp> namespace ring { typedef unsigned char byte; static const uint32_t RING_SIZE = 2 * 1024 * 1024; // 2 meg class iterator { private: const byte* buf; int cur; size_t buf_size; public: iterator() : buf(), cur(), buf_size() {} iterator(const byte* _buf, int _cur, size_t _buf_size) : buf(_buf), cur(_cur), buf_size(_buf_size) {} const byte& operator*() const { return buf[cur % RING_SIZE]; } const byte& operator[](int n) const { return buf[(cur + n) % RING_SIZE]; } iterator& operator+=(int n) { cur += n; buf_size -= n; return *this; } iterator& operator++() { ++cur; --buf_size; return *this; } // post-inc iterator operator++(int) { iterator tmp(*this); ++cur; --buf_size; return tmp; } // pre-inc bool operator==(iterator b) const { return cur == b.cur; } bool operator!=(iterator b) const { return cur != b.cur; } size_t size() const { return buf_size; } int offset() const { return cur; } }; //---------------------------------------------------------------- inline iterator operator+(iterator a, int b) { return a += b; } inline iterator operator+(int b, iterator a) { return a += b; } class buffer { mutable boost::mutex mtx; byte buf[RING_SIZE]; unsigned beg; unsigned end; // may wrap, wrapping is blessed for unsigned types only public: buffer() : beg(), end() { memset(buf, 0, RING_SIZE); } // create an iterator object whose size = unread data in buf iterator data() const { boost::mutex::scoped_lock l(mtx); return iterator(buf, beg % RING_SIZE, end - beg); } // free space in ring unsigned size() const { boost::mutex::scoped_lock l(mtx); return end - beg; } // frees up space in the ring (called once data has been read) void adv(unsigned n) { boost::mutex::scoped_lock l(mtx); beg += n; } // read data from a file descriptor into the buffer // returns: // -errno for error // 0 for EOF // > 0 for successful reads int read(int fd) { mtx.lock(); unsigned free = RING_SIZE - (end - beg); if (!free) { mtx.unlock(); return -ENOMEM; // must never get here } unsigned free_end = std::min(free, RING_SIZE - end % RING_SIZE); unsigned free_beg = free - free_end; iovec io[] = { { (char*)buf + end % RING_SIZE, free_end }, { (char*)buf, free_beg } }; mtx.unlock(); ssize_t n = readv(fd, io, sizeof io / sizeof *io); if (n == -1) return -errno; mtx.lock(); end += n; mtx.unlock(); return n; } }; //---------------------------------------------------------------- } // namespace ring #endif