Stimulus[Buffer|Frame]: initial impl, unoptimized for mem use

include/user/spMcRingBuffer.h

@@ -2,13 +2,15 @@
 #define _SP_MC_RING_BUFFER_H
 
 #include <vector>
-#include <memory>
 #include <cstddef>
 #include <stdexcept>
-#include <algorithm>
+#include <string>
+#include <new>
+#include <user/stimulusFrame.h>
 #include <user/sequenceLock.h>
 
 namespace smo {
+namespace stim_buff {
 
 /**
  * @brief Single-producer, multi-consumer ring buffer w/per-slot sequence locks
@@ -20,120 +22,83 @@ namespace smo {
  */
 class SpMcRingBuffer
 {
-public:
-	class InputEngineConstraints
-	{
-	public:
-		InputEngineConstraints(
-			size_t slotStartAlignmentNBytes_,
-			size_t slotPadToNBytes_)
-		: slotStartAlignmentNBytes(slotStartAlignmentNBytes_),
-		  slotPadToNBytes(slotPadToNBytes_)
-		{}
-
-		~InputEngineConstraints() = default;
-
-		// Input-engine layout/constraints
-		size_t slotStartAlignmentNBytes;  // power-of-2 alignment (e.g., 4096)
-		size_t slotPadToNBytes;       // minimum size per slot
-	};
-
 public:
 	/**	EXPLANATION:
 	 * Constructor initializes the ring buffer with the given constraints and
-	 * number of slots. Calculates stride and allocates data buffer and sequence
+	 * number of buffers. Allocates slots vector with properly constructed
-	 * locks array.
+	 * StimulusFrame instances.
 	 */
 	explicit SpMcRingBuffer(
-		size_t nSlots_,
+		size_t nBuffers_,
-		const InputEngineConstraints& constraints_)
+		const StagingBuffer::IOEngineConstraints& inputEngineConstraints,
-	: nSlots(nSlots_), strideNBytes(0), bufferNBytes(0),
+		const StagingBuffer::IOEngineConstraints& outputEngineConstraints,
-	  constraints(constraints_)
+		size_t nSlotsPerStimFrame)
+	: nBuffers(nBuffers_),
+	// Default-construct all frames
+	slots(nBuffers)
 	{
-		if (nSlots == 0)
+		if (nBuffers == 0)
 		{
 			throw std::invalid_argument(std::string(__func__)
-				+ ": SpMcRingBuffer: nSlots must be > 0");
+				+ ": SpMcRingBuffer: nBuffers must be > 0");
 		}
 
-		computeStrideAndBufferSize();
+		// Re-invoke constructors w/placement new on default-constructed frames
-		// Allocate data buffer: bufferNBytes (aligned up to alignment)
+		for (size_t i = 0; i < nBuffers; ++i)
-		data.resize(bufferNBytes);
+		{
-		// Initialize sequence locks array: one lock per slot
+			slots[i].~StimulusFrame();  // Destroy default-constructed object
-		// Use unique_ptr array since SequenceLock is not copyable or movable
+			new (&slots[i]) StimulusFrame(
-		sequenceLocks = std::make_unique<SequenceLock[]>(nSlots);
+				inputEngineConstraints, outputEngineConstraints,
+				nSlotsPerStimFrame);
+		}
 	}
 
 	~SpMcRingBuffer() = default;
 
-	// Non-copyable, movable
+	// Non-copyable, non-movable (slots are non-movable)
 	SpMcRingBuffer(const SpMcRingBuffer&) = delete;
 	SpMcRingBuffer& operator=(const SpMcRingBuffer&) = delete;
-	SpMcRingBuffer(SpMcRingBuffer&&) = default;
+	SpMcRingBuffer(SpMcRingBuffer&&) = delete;
-	SpMcRingBuffer& operator=(SpMcRingBuffer&&) = default;
+	SpMcRingBuffer& operator=(SpMcRingBuffer&&) = delete;
 
 public:
 	/**
-	 * @brief Get a reference to data at the specified slot
+	 * @brief Get a reference to the StimulusFrame at the specified slot
 	 *
-	 * @tparam T The type of data stored in the slot
 	 * @param slotIndex The index of the slot (0-based)
-	 * @return Reference to T at the slot
+	 * @return Reference to StimulusFrame at the slot
-	 * @throws std::out_of_range if slotIndex >= nSlots
+	 * @throws std::out_of_range if slotIndex >= nBuffers
 	 */
-	template<typename T>
+	StimulusFrame& getDataAtSlot(size_t slotIndex)
-	T& getDataAtSlot(size_t slotIndex)
 	{
-		if (slotIndex >= nSlots)
+		if (slotIndex >= nBuffers)
 		{
 			throw std::out_of_range(std::string(__func__)
-				+ ": SpMcRingBuffer: slotIndex must be < nSlots");
+				+ ": SpMcRingBuffer: slotIndex must be < nBuffers");
 		}
-
+		return slots[slotIndex];
-		size_t offset = slotIndex * strideNBytes;
-		return *reinterpret_cast<T*>(data.data() + offset);
 	}
 
 	SequenceLock& getSequenceLockAtSlot(size_t slotIndex)
 	{
-		if (slotIndex >= nSlots)
+		if (slotIndex >= nBuffers)
 		{
 			throw std::out_of_range(std::string(__func__)
-				+ ": SpMcRingBuffer: slotIndex must be < nSlots");
+				+ ": SpMcRingBuffer: slotIndex must be < nBuffers");
 		}
-		return sequenceLocks[slotIndex];
+		return slots[slotIndex].lock;
 	}
 
-private:
-	void computeStrideAndBufferSize()
-	{
-		// Stride is the maximum of alignment and padding
-		strideNBytes = std::max(
-			constraints.slotStartAlignmentNBytes,
-			constraints.slotPadToNBytes);
-
-		// Buffer size is nSlots * strideNBytes, aligned up to alignment
-		size_t rawSize = nSlots * strideNBytes;
-		bufferNBytes = ((rawSize + constraints.slotStartAlignmentNBytes - 1)
-		                / constraints.slotStartAlignmentNBytes)
-		               * constraints.slotStartAlignmentNBytes;
-	}
-
-	// Buffer data
-	std::vector<uint8_t> data;
-
-	// Sequence locks array: one lock per slot
-	// Use unique_ptr array since SequenceLock is not copyable or movable
-	std::unique_ptr<SequenceLock[]> sequenceLocks;
-
 public:
 	// Layout/invariants
-	size_t nSlots;
+	size_t nBuffers;
-	size_t strideNBytes;
+
-	size_t bufferNBytes;
+private:
-	InputEngineConstraints constraints;
+	// Frames vector: each frame contains a sequence lock and staging buffer
+	std::vector<StimulusFrame> slots;
 };
 
+} // namespace stim_buff
 } // namespace smo
 
 #endif // _SP_MC_RING_BUFFER_H

include/user/stagingBuffer.h

@@ -31,6 +31,9 @@ public:
 	class IOEngineConstraints
 	{
 	public:
+		// Default constructor creates uninitialized constraints
+		IOEngineConstraints() = default;
+
 		IOEngineConstraints(
 			size_t slotStartAlignmentByteVal_,
 			size_t slotPadToNBytes_,
@@ -65,6 +68,12 @@ public:
 	};
 
 public:
+	/**	EXPLANATION:
+	 * Default constructor creates uninitialized buffer.
+	 * Must be properly initialized using placement new with the parameterized constructor.
+	 */
+	StagingBuffer() = default;
+
 	/**	EXPLANATION:
 	 * We use the input and output engine constraints to determine the total
 	 * amount of memory required internally to assemble a single frame with
@@ -144,6 +153,8 @@ private:
 	struct MmapDeleter
 	{
 		size_t size;
+		// Default constructor for use with default-constructed StagingBuffer
+		MmapDeleter() : size(0) {}
 		MmapDeleter(size_t s) : size(s) {}
 		
 		void operator()(uint8_t* ptr) const

include/user/stimulusBuffer.h

@@ -5,6 +5,7 @@
 #include <vector>
 #include <memory>
 #include <user/spMcRingBuffer.h>
+#include <user/stagingBuffer.h>
 #include "stimulusFrame.h"
 #include "deviceAttachmentSpec.h"
 
@@ -28,15 +29,16 @@ public:
 		const std::shared_ptr<device::DeviceAttachmentSpec>
 			&deviceAttachmentSpec,
 		int histbuffMs,
-		const SpMcRingBuffer::InputEngineConstraints& ringBufferConstraints)
+		const StagingBuffer::IOEngineConstraints& inputEngineConstraints,
+		const StagingBuffer::IOEngineConstraints& outputEngineConstraints,
+		size_t nSlotsPerStimFrame)
 	: parent(parent),
 	deviceAttachmentSpec(deviceAttachmentSpec),
 	histbuffMs(histbuffMs),
-	frames_(static_cast<size_t>(histbuffMs / CONFIG_STIMBUFF_FRAME_PERIOD_MS)),
-	ringBufferConstraints(ringBufferConstraints),
 	ringBuffer(
 		static_cast<size_t>(histbuffMs / CONFIG_STIMBUFF_FRAME_PERIOD_MS),
-		ringBufferConstraints)
+		inputEngineConstraints, outputEngineConstraints,
+		nSlotsPerStimFrame)
 	{}
 
 	virtual ~StimulusBuffer() = default;
@@ -51,10 +53,6 @@ public:
 	StimulusProducer& parent;
 	std::shared_ptr<device::DeviceAttachmentSpec> deviceAttachmentSpec;
 	int histbuffMs;
-	std::vector<StimulusFrame> frames_;
-
-protected:
-	SpMcRingBuffer::InputEngineConstraints ringBufferConstraints;
 	SpMcRingBuffer ringBuffer;
 };
 

include/user/stimulusFrame.h

@@ -2,6 +2,8 @@
 #define _ATTACHMENT_SUPPORT_STIMULUS_FRAME_H
 
 #include <cstdint>
+#include <user/stagingBuffer.h>
+#include <user/sequenceLock.h>
 
 namespace smo {
 namespace stim_buff {
@@ -61,7 +63,32 @@ typedef uint64_t SimultaneityStamp;
 class StimulusFrame
 {
 public:
+	/**	EXPLANATION:
+	 * Default constructor creates uninitialized frame.
+	 * Must be properly initialized using placement new with the parameterized constructor.
+	 */
+	StimulusFrame() = default;
+
+	StimulusFrame(
+		const StagingBuffer::IOEngineConstraints& inputEngineConstraints,
+		const StagingBuffer::IOEngineConstraints& outputEngineConstraints,
+		size_t nSlots)
+	: stagingBuffer(
+		inputEngineConstraints, outputEngineConstraints, nSlots)
+	{}
+
+	~StimulusFrame() = default;
+
+	// Non-copyable, movable
+	StimulusFrame(const StimulusFrame&) = delete;
+	StimulusFrame& operator=(const StimulusFrame&) = delete;
+	StimulusFrame(StimulusFrame&&) = default;
+	StimulusFrame& operator=(StimulusFrame&&) = default;
+
+public:
+	SequenceLock lock;
 	SimultaneityStamp simultaneityStamp;
+	StagingBuffer stagingBuffer;
 };
 
 } // namespace stim_buff

stimBuffApis/livoxGen1/meshStimulusBuffer.h

@@ -3,6 +3,7 @@
 
 #include <memory>
 #include <user/stimulusBuffer.h>
+#include <user/stagingBuffer.h>
 
 namespace smo {
 namespace stim_buff {
@@ -21,9 +22,12 @@ public:
 		StimulusProducer& parent,
 		const std::shared_ptr<device::DeviceAttachmentSpec>& deviceAttachmentSpec,
 		int histbuffMs,
-		const SpMcRingBuffer::InputEngineConstraints& ringBufferConstraints)
+		const StagingBuffer::IOEngineConstraints& inputEngineConstraints,
+		const StagingBuffer::IOEngineConstraints& outputEngineConstraints,
+		size_t nSlotsPerStimFrame)
 	:	StimulusBuffer(
-			parent, deviceAttachmentSpec, histbuffMs, ringBufferConstraints)
+			parent, deviceAttachmentSpec, histbuffMs,
+			inputEngineConstraints, outputEngineConstraints, nSlotsPerStimFrame)
 	{}
 
 	~MeshStimulusBuffer() = default;

stimBuffApis/livoxGen1/pcloudAmbienceStimulusBuffer.h

@@ -3,6 +3,7 @@
 
 #include <memory>
 #include <user/stimulusBuffer.h>
+#include <user/stagingBuffer.h>
 
 namespace smo {
 namespace stim_buff {
@@ -21,9 +22,12 @@ public:
 		StimulusProducer& parent,
 		const std::shared_ptr<device::DeviceAttachmentSpec>& deviceAttachmentSpec,
 		int histbuffMs,
-		const SpMcRingBuffer::InputEngineConstraints& ringBufferConstraints)
+		const StagingBuffer::IOEngineConstraints& inputEngineConstraints,
+		const StagingBuffer::IOEngineConstraints& outputEngineConstraints,
+		size_t nSlotsPerStimFrame)
 	:	StimulusBuffer(
-			parent, deviceAttachmentSpec, histbuffMs, ringBufferConstraints)
+			parent, deviceAttachmentSpec, histbuffMs,
+			inputEngineConstraints, outputEngineConstraints, nSlotsPerStimFrame)
 	{}
 
 	~PcloudAmbienceStimulusBuffer() = default;

stimBuffApis/livoxGen1/pcloudIntensityStimulusBuffer.h

@@ -3,6 +3,7 @@
 
 #include <memory>
 #include <user/stimulusBuffer.h>
+#include <user/stagingBuffer.h>
 
 namespace smo {
 namespace stim_buff {
@@ -22,9 +23,12 @@ public:
 		const std::shared_ptr<device::DeviceAttachmentSpec>
 			&deviceAttachmentSpec,
 		int histbuffMs,
-		const SpMcRingBuffer::InputEngineConstraints& ringBufferConstraints)
+		const StagingBuffer::IOEngineConstraints& inputEngineConstraints,
+		const StagingBuffer::IOEngineConstraints& outputEngineConstraints,
+		size_t nSlotsPerStimFrame)
 	:	StimulusBuffer(
-			parent, deviceAttachmentSpec, histbuffMs, ringBufferConstraints)
+			parent, deviceAttachmentSpec, histbuffMs,
+			inputEngineConstraints, outputEngineConstraints, nSlotsPerStimFrame)
 	{}
 
 	~PcloudIntensityStimulusBuffer() = default;

stimBuffApis/livoxGen1/pcloudStimulusProducer.cpp

@@ -7,8 +7,9 @@
 #include <componentThread.h>
 #include <asynchronousLoop.h>
 #include <user/stimulusFrame.h>
-#include "pcloudStimulusProducer.h"
 #include <user/frameAssemblyDesc.h>
+#include <livoxProto1/device.h>
+#include "pcloudStimulusProducer.h"
 
 namespace smo {
 namespace stim_buff {
@@ -16,8 +17,15 @@ namespace stim_buff {
 extern const SmoCallbacks* smoHooksPtr;
 
 // OpenCL kernels are used to collate and produce our StimFrames.
-static SpMcRingBuffer::InputEngineConstraints openClInputConstraints(
+static StagingBuffer::IOEngineConstraints openClInputConstraints(
-	static_cast<size_t>(sysconf(_SC_PAGE_SIZE)), sizeof(void *));
+	// slotStartAlignmentByteVal (page alignment)
+	sizeof(float) * 3,
+	// slotPadToNBytes (pointer size)
+	sizeof(void *),
+	// frameStartAlignmentByteVal (page alignment)
+	static_cast<size_t>(sysconf(_SC_PAGE_SIZE)),
+	// framePadToNBytes (pointer size)
+	static_cast<size_t>(sysconf(_SC_PAGE_SIZE)));
 
 static StagingBuffer::IOEngineConstraints openClIntensityInputConstraints(
 	// slotStartAlignmentByteVal (page alignment)
@@ -27,7 +35,17 @@ static StagingBuffer::IOEngineConstraints openClIntensityInputConstraints(
 	// frameStartAlignmentByteVal (page alignment)
 	static_cast<size_t>(sysconf(_SC_PAGE_SIZE)),
 	// framePadToNBytes (pointer size)
-	sizeof(void *));
+	static_cast<size_t>(sysconf(_SC_PAGE_SIZE)));
+
+static StagingBuffer::IOEngineConstraints openClAmbienceInputConstraints(
+	// slotStartAlignmentByteVal (page alignment)
+	sizeof(float),
+	// slotPadToNBytes (pointer size)
+	sizeof(void *),
+	// frameStartAlignmentByteVal (page alignment)
+	static_cast<size_t>(sysconf(_SC_PAGE_SIZE)),
+	// framePadToNBytes (pointer size)
+	static_cast<size_t>(sysconf(_SC_PAGE_SIZE)));
 
 PcloudStimulusProducer::PcloudStimulusProducer(
 	const std::shared_ptr<device::DeviceAttachmentSpec> &deviceAttachmentSpec,
@@ -37,6 +55,7 @@ PcloudStimulusProducer::PcloudStimulusProducer(
 :	StimulusProducer(
 		deviceAttachmentSpec,
 		device->componentThread->getIoService()),
+nDgramsPerStagingBufferFrame(nDgramsPerStagingBufferFrame),
 device(device),
 formatDesc(formatDesc),
 openClCollatingAndMeshingEngine(*this),
@@ -46,6 +65,10 @@ assemblyBuffer(
 	nDgramsPerStagingBufferFrame),
 ioUringAssemblyEngine(*this, nDgramsPerStagingBufferFrame),
 collationBuffer(
+	StagingBuffer::IOEngineConstraints::openClInputConstraints,
+	StagingBuffer::IOEngineConstraints::openClInputConstraints,
+	nDgramsPerStagingBufferFrame),
+tempStimulusFrame(
 	StagingBuffer::IOEngineConstraints::openClInputConstraints,
 	StagingBuffer::IOEngineConstraints::openClInputConstraints,
 	nDgramsPerStagingBufferFrame)
@@ -181,30 +204,47 @@ PcloudStimulusProducer::getOrCreateAttachedStimulusBuffer(
 	// Parse qualeIfaceApi to determine buffer type
 	const std::string& qualeIfaceApi = deviceAttachmentSpec->qualeIfaceApi;
 
+	// Calculate nPointsPerStimFrame based on return mode
+	size_t nPointsPerDgram = livoxProto1::Device::getNPointsPerDgram(
+		static_cast<int>(device->currentReturnMode));
+	size_t nPointsPerStimFrame = this->nDgramsPerStagingBufferFrame
+		* nPointsPerDgram;
+
 	if (qualeIfaceApi == "mesh")
 	{
+std::cout << __func__ << ": $$$$$$$ Creating MeshStimulusBuffer" << std::endl;
 		auto meshBuffer = std::make_shared<MeshStimulusBuffer>(
-			*this, deviceAttachmentSpec, histbuffMs, openClInputConstraints);
+			*this, deviceAttachmentSpec, histbuffMs,
+			openClInputConstraints, openClInputConstraints,
+			nPointsPerStimFrame);
 
+std::cout << __func__ << ": $$$$$$$ Created MeshStimulusBuffer" << std::endl;
 		meshStimulusBuffer = meshBuffer;
 		attachedStimulusBuffers.push_back(meshBuffer);
 		return meshBuffer;
 	}
 	else if (qualeIfaceApi == "pcloudIntensity")
 	{
+std::cout << __func__ << ": $$$$$$$ Creating PcloudIntensityStimulusBuffer" << std::endl;
 		auto intensityBuffer = std::make_shared<PcloudIntensityStimulusBuffer>(
 			*this, deviceAttachmentSpec, histbuffMs,
-			openClInputConstraints);
+			openClIntensityInputConstraints, openClIntensityInputConstraints,
+			nPointsPerStimFrame);
 
+std::cout << __func__ << ": $$$$$$$ Created PcloudIntensityStimulusBuffer" << std::endl;
 		intensityStimulusBuffer = intensityBuffer;
 		attachedStimulusBuffers.push_back(intensityBuffer);
 		return intensityBuffer;
 	}
 	else if (qualeIfaceApi == "pcloudAmbience")
 	{
+std::cout << __func__ << ": $$$$$$$ Creating PcloudAmbienceStimulusBuffer" << std::endl;
 		auto ambienceBuffer = std::make_shared<PcloudAmbienceStimulusBuffer>(
-			*this, deviceAttachmentSpec, histbuffMs, openClInputConstraints);
+			*this, deviceAttachmentSpec, histbuffMs,
+			openClAmbienceInputConstraints, openClAmbienceInputConstraints,
+			nDgramsPerStagingBufferFrame);
 
+std::cout << __func__ << ": $$$$$$$ Created PcloudAmbienceStimulusBuffer" << std::endl;
 		ambienceStimulusBuffer = ambienceBuffer;
 		attachedStimulusBuffers.push_back(ambienceBuffer);
 		return ambienceBuffer;

stimBuffApis/livoxGen1/pcloudStimulusProducer.h

@@ -79,6 +79,7 @@ protected:
 public:
 	void produceFrameReq(smo::Callback<produceFrameReqCbFn> callback);
 
+	size_t nDgramsPerStagingBufferFrame;
 	std::shared_ptr<livoxProto1::Device> device;
 	PcloudFormatDesc formatDesc;
 	OpenClCollatingAndMeshingEngine openClCollatingAndMeshingEngine;