livetrax/libs/pbd/pbd/ringbuffer.h

/*
 * Copyright (C) 2000-2015 Paul Davis <paul@linuxaudiosystems.com>
 * Copyright (C) 2006-2007 Taybin Rutkin <taybin@taybin.com>
 * Copyright (C) 2008-2009 David Robillard <d@drobilla.net>
 * Copyright (C) 2013-2019 Robin Gareus <robin@gareus.org>
 * Copyright (C) 2013 John Emmas <john@creativepost.co.uk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef ringbuffer_h
#define ringbuffer_h

#include <cstring>

#include "pbd/libpbd_visibility.h"
#include "pbd/g_atomic_compat.h"

namespace PBD {

template<class T>
class /*LIBPBD_API*/ RingBuffer
{
public:
	RingBuffer (guint sz) {
#if 0
		size = ffs(sz); /* find first [bit] set is a single inlined assembly instruction. But it looks like the API rounds up so... */
#endif
		guint power_of_two;
		for (power_of_two = 1; 1U<<power_of_two < sz; power_of_two++) {}
		size = 1<<power_of_two;
		size_mask = size;
		size_mask -= 1;
		buf = new T[size];
		reset ();
	}

	virtual ~RingBuffer() {
		delete [] buf;
	}

	void reset () {
		/* !!! NOT THREAD SAFE !!! */
		g_atomic_int_set (&write_idx, 0);
		g_atomic_int_set (&read_idx, 0);
	}

	void set (guint r, guint w) {
		/* !!! NOT THREAD SAFE !!! */
		g_atomic_int_set (&write_idx, w);
		g_atomic_int_set (&read_idx, r);
	}

	guint read  (T *dest, guint cnt);
	guint write (T const * src,  guint cnt);

	struct rw_vector {
		T *buf[2];
		guint len[2];
	};

	void get_read_vector (rw_vector *);
	void get_write_vector (rw_vector *);

	void decrement_read_idx (guint cnt) {
		g_atomic_int_set (&read_idx, (g_atomic_int_get(&read_idx) - cnt) & size_mask);
	}

	void increment_read_idx (guint cnt) {
		g_atomic_int_set (&read_idx, (g_atomic_int_get(&read_idx) + cnt) & size_mask);
	}

	void increment_write_idx (guint cnt) {
		g_atomic_int_set (&write_idx,  (g_atomic_int_get(&write_idx) + cnt) & size_mask);
	}

	guint write_space () const {
		guint w, r;

		w = g_atomic_int_get (&write_idx);
		r = g_atomic_int_get (&read_idx);

		if (w > r) {
			return ((r - w + size) & size_mask) - 1;
		} else if (w < r) {
			return (r - w) - 1;
		} else {
			return size - 1;
		}
	}

	guint read_space () const {
		guint w, r;

		w = g_atomic_int_get (&write_idx);
		r = g_atomic_int_get (&read_idx);

		if (w > r) {
			return w - r;
		} else {
			return (w - r + size) & size_mask;
		}
	}

	T *buffer () { return buf; }
	guint get_write_idx () const { return g_atomic_int_get (&write_idx); }
	guint get_read_idx () const { return g_atomic_int_get (&read_idx); }
	guint bufsize () const { return size; }

protected:
	T *buf;
	guint size;
	guint size_mask;
	mutable GATOMIC_QUAL gint write_idx;
	mutable GATOMIC_QUAL gint read_idx;

private:
	RingBuffer (RingBuffer const&);
};

template<class T> /*LIBPBD_API*/ guint
RingBuffer<T>::read (T *dest, guint cnt)
{
	guint free_cnt;
	guint cnt2;
	guint to_read;
	guint n1, n2;
	guint priv_read_idx;

	priv_read_idx = g_atomic_int_get (&read_idx);

	if ((free_cnt = read_space ()) == 0) {
		return 0;
	}

	to_read = cnt > free_cnt ? free_cnt : cnt;

	cnt2 = priv_read_idx + to_read;

	if (cnt2 > size) {
		n1 = size - priv_read_idx;
		n2 = cnt2 & size_mask;
	} else {
		n1 = to_read;
		n2 = 0;
	}

	memcpy (dest, &buf[priv_read_idx], n1 * sizeof (T));
	priv_read_idx = (priv_read_idx + n1) & size_mask;

	if (n2) {
		memcpy (dest+n1, buf, n2 * sizeof (T));
		priv_read_idx = n2;
	}

	g_atomic_int_set (&read_idx, priv_read_idx);
	return to_read;
}

template<class T> /*LIBPBD_API*/ guint
RingBuffer<T>::write (T const *src, guint cnt)

{
	guint free_cnt;
	guint cnt2;
	guint to_write;
	guint n1, n2;
	guint priv_write_idx;

	priv_write_idx = g_atomic_int_get (&write_idx);

	if ((free_cnt = write_space ()) == 0) {
		return 0;
	}

	to_write = cnt > free_cnt ? free_cnt : cnt;

	cnt2 = priv_write_idx + to_write;

	if (cnt2 > size) {
		n1 = size - priv_write_idx;
		n2 = cnt2 & size_mask;
	} else {
		n1 = to_write;
		n2 = 0;
	}

	memcpy (&buf[priv_write_idx], src, n1 * sizeof (T));
	priv_write_idx = (priv_write_idx + n1) & size_mask;

	if (n2) {
		memcpy (buf, src+n1, n2 * sizeof (T));
		priv_write_idx = n2;
	}

	g_atomic_int_set (&write_idx, priv_write_idx);
	return to_write;
}

template<class T> /*LIBPBD_API*/ void
RingBuffer<T>::get_read_vector (typename RingBuffer<T>::rw_vector *vec)

{
	guint free_cnt;
	guint cnt2;
	guint w, r;

	w = g_atomic_int_get (&write_idx);
	r = g_atomic_int_get (&read_idx);

	if (w > r) {
		free_cnt = w - r;
	} else {
		free_cnt = (w - r + size) & size_mask;
	}

	cnt2 = r + free_cnt;

	if (cnt2 > size) {
		/* Two part vector: the rest of the buffer after the
		   current write ptr, plus some from the start of
		   the buffer.
		*/

		vec->buf[0] = &buf[r];
		vec->len[0] = size - r;
		vec->buf[1] = buf;
		vec->len[1] = cnt2 & size_mask;

	} else {

		/* Single part vector: just the rest of the buffer */

		vec->buf[0] = &buf[r];
		vec->len[0] = free_cnt;
		vec->buf[1] = 0;
		vec->len[1] = 0;
	}
}

template<class T> /*LIBPBD_API*/ void
RingBuffer<T>::get_write_vector (typename RingBuffer<T>::rw_vector *vec)

{
	guint free_cnt;
	guint cnt2;
	guint w, r;

	w = g_atomic_int_get (&write_idx);
	r = g_atomic_int_get (&read_idx);

	if (w > r) {
		free_cnt = ((r - w + size) & size_mask) - 1;
	} else if (w < r) {
		free_cnt = (r - w) - 1;
	} else {
		free_cnt = size - 1;
	}

	cnt2 = w + free_cnt;

	if (cnt2 > size) {

		/* Two part vector: the rest of the buffer after the
		   current write ptr, plus some from the start of
		   the buffer.
		*/

		vec->buf[0] = &buf[w];
		vec->len[0] = size - w;
		vec->buf[1] = buf;
		vec->len[1] = cnt2 & size_mask;
	} else {
		vec->buf[0] = &buf[w];
		vec->len[0] = free_cnt;
		vec->len[1] = 0;
	}
}

} /* end namespace */

#endif /* __ringbuffer_h__ */