- added processor

git-svn-id: http://moon:8086/svn/software/trunk/libsrc/cpp@874 b431acfa-c32f-4a4a-93f1-934dc6c82436

radio/processor/Makefile

@@ -0,0 +1,25 @@
+MAKE_HOME := /home/jens/work/software/make
+
+CONFIG ?= debug
+TARGET ?= test01
+BUILD_DIR := ./build/${CONFIG}
+
+include ./processor.mk
+
+CXX_SRCS += test/test01.cpp
+LIBS := -lstdc++ -lm -larmadillo
+DEFINES += -DPROCESSOR_BUFFER_USE_EXCEPTIONS
+
+SRCS := ${CXX_SRCS} ${GCC_SRCS} 
+
+.PHONY: clean
+all: ${BUILD_DIR}/${TARGET}
+
+clean:
+	rm -rf ${BUILD_DIR}/*
+
+distclean:
+	rm -rf ${BUILD_DIR}
+
+
+include $(MAKE_HOME)/compile.mk

radio/processor/processor.mk

@@ -0,0 +1,6 @@
+
+PACKAGES += Processor-1.0
+
+CXX_SRCS += src/ABlock.cpp
+DEFINES +=
+INCLUDES += -I $(shell pwd)/src

radio/processor/src/ABlock.cpp

@@ -0,0 +1,9 @@
+#include "ABlock.hpp"
+
+void ABlock::process()
+{
+
+
+}
+
+

radio/processor/src/ABlock.hpp

@@ -0,0 +1,11 @@
+#ifndef __RADIO_ABLOCK_H__
+#define __RADIO_ABLOCK_H__
+
+class ABlock
+{
+    public:
+    void process();
+};
+
+#endif // __RADIO_ABLOCK_H__
+

radio/processor/src/Buffer.hpp

@@ -0,0 +1,93 @@
+#ifndef __PROCESSOR_BUFFER_HPP__
+#define __PROCESSOR_BUFFER_HPP__
+
+#include <stddef.h>
+#include <math.h>
+#include <exception>
+
+#ifdef PROCESSOR_BUFFER_USE_EXCEPTIONS
+#define RETURN_OR_EXCEPT(code) throw Buffer::Exception(code)
+#else
+#define RETURN_OR_EXCEPT(code) return code
+#endif
+
+template <typename T>
+class Buffer
+{
+	public:
+	enum Result
+	{
+		Ok=0,
+		Err_InvalidSize=1
+	};
+
+	class Exception : public std::exception
+	{
+		public:
+		Exception(Result code)
+		: std::exception()
+		, m_code(code)
+		{
+
+		}
+		const char* what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW
+		{
+			static std::string r = "Return code = " + std::to_string(m_code);
+			return r.c_str();
+		}
+		Result m_code;
+
+	};
+	Buffer(size_t capacity);
+	~Buffer();
+
+	size_t len();
+	size_t capacity();
+	void clear();
+
+	T* data_w();
+	T* data_r();
+	size_t write(const T* pData, size_t len);
+	size_t read(T* pData, size_t len);
+	Result consume(size_t len);
+	Result produce(size_t len);
+	void print(const char *prefix);
+
+	private:
+	size_t m_capacity;
+	size_t m_len;
+	size_t m_wi;
+	size_t m_ri;
+	T *m_data[2];
+	size_t m_bid;
+	void make_contigious()
+	{
+		if (m_len == 0)
+		{
+			return;
+		}
+		size_t cont_len = std::min(m_capacity - m_ri, m_len);
+		if (cont_len < m_len)
+		{
+			m_wi = m_len;
+			read(bufferStdBy(), m_len);
+			m_ri = 0;
+			m_len = m_wi;
+			m_bid = !m_bid & 1;
+		}
+	}
+	T *bufferActive()
+	{
+		return m_data[m_bid];
+	}
+
+	T *bufferStdBy()
+	{
+		return m_data[!m_bid & 1];
+	}
+};
+
+#include "Buffer.tcc"
+
+
+#endif // __PROCESSOR_BUFFER_HPP__

radio/processor/src/Buffer.tcc

@@ -0,0 +1,136 @@
+template<typename T>
+Buffer<T>::Buffer(size_t capacity)
+: m_capacity(capacity)
+, m_len(0)
+, m_wi(0)
+, m_ri(0)
+, m_data{nullptr, nullptr}
+{
+    m_data[0] = new T[capacity];
+    m_data[1] = new T[capacity];
+}
+
+template<typename T>
+Buffer<T>::~Buffer()
+{
+    delete [] m_data[0];
+    delete [] m_data[1];
+}
+
+template<typename T>
+size_t Buffer<T>::len()
+{
+    return m_len;
+}
+
+template<typename T>
+size_t Buffer<T>::capacity()
+{
+    return m_capacity;
+}
+
+template<typename T>
+void Buffer<T>::clear()
+{
+    m_len = 0;
+    m_wi = 0;
+    m_ri = 0;
+}
+
+template<typename T>
+T* Buffer<T>::data_w()
+{
+    return &bufferActive()[m_wi];
+}
+
+template<typename T>
+T* Buffer<T>::data_r()
+{
+    return &bufferActive()[m_ri];
+}
+
+template<typename T>
+size_t Buffer<T>::write(const T *pData, size_t len)
+{
+	len = std::min(m_capacity - m_len, len);
+	size_t numWritten = 0;
+	while(len)
+	{
+		size_t num_remain = m_capacity - m_wi;
+		size_t actual_len = std::min(num_remain, len);
+
+		memcpy(data_w(), pData, actual_len*sizeof(T));
+		produce(actual_len);
+		len -= actual_len;
+		pData += actual_len;
+		numWritten += actual_len;
+	}
+	return numWritten;
+
+}
+
+template<typename T>
+size_t Buffer<T>::read(T* pData, size_t len)
+{
+	len = std::min(m_len, len);
+	size_t numRead = 0;
+	while(len)
+	{
+		size_t num_remain = m_capacity - m_ri;
+		size_t actual_len = std::min(num_remain, len);
+
+		memcpy(pData, data_r(), actual_len*sizeof(T));
+		len -= actual_len;
+		pData += actual_len;
+		consume(actual_len);
+	}
+	return numRead;
+
+}
+
+template<typename T>
+typename Buffer<T>::Result Buffer<T>::consume(size_t len)
+{
+	if (len > m_len)
+	{
+		RETURN_OR_EXCEPT(Result::Err_InvalidSize);
+	}
+	m_len -= len;
+
+	m_ri += len;
+	if (m_ri >= m_capacity)
+	{
+		m_ri -= m_capacity;
+	}
+	return Result::Ok;
+}
+
+template<typename T>
+typename Buffer<T>::Result Buffer<T>::produce(size_t len)
+{
+	if (len > (m_capacity - m_len))
+	{
+		RETURN_OR_EXCEPT(Result::Err_InvalidSize);
+	}
+	m_len += len;
+
+	m_wi += len;
+	if (m_wi >= m_capacity)
+	{
+		m_wi -= m_capacity;
+	}
+	return Result::Ok;
+}
+
+template<typename T>
+void Buffer<T>::print(const char *prefix)
+{
+	make_contigious();
+	T *data = data_r();
+	printf("%s", prefix);
+	for (size_t i=0; i < m_len; i++)
+	{
+		printf("%f ", data[i]);
+	}
+	printf("\n");
+}

radio/processor/test/test01.cpp

@@ -0,0 +1,55 @@
+#include <cstdio>
+#include <armadillo>
+
+#include <Buffer.hpp>
+
+#ifndef LENGTH
+#define LENGTH(a) (sizeof(a)/sizeof(a[0]))
+#endif
+
+int main()
+{
+	printf("Hallo Welt!\n");
+
+	arma::mat myMat;
+//    myMat.as_col();
+
+	Buffer<double> buffer(8);
+	buffer.print("data 10: ");
+
+	{
+		double data[] = {1,2,3,4};
+		buffer.write(data, LENGTH(data));
+	}
+	buffer.print("data 20: ");
+	buffer.consume(4);
+
+	{
+		double data[] = {5,6,7,8,9,10,11,12};
+		buffer.write(data, LENGTH(data));
+	}
+	buffer.print("data 30: ");
+
+	buffer.consume(4);
+	buffer.print("data 40: ");
+
+	{
+		double data[] = {11,12, 13, 14};
+		buffer.write(data, LENGTH(data));
+	}
+	buffer.print("data 50: ");
+
+	buffer.consume(4);
+	buffer.print("data 60: ");
+
+	buffer.consume(4);
+	buffer.print("data 70: ");
+
+	{
+		double data[] = {1,2,3,4};
+		buffer.write(data, LENGTH(data));
+	}
+	buffer.print("data: ");
+
+	return 0;
+}