Optimize data acquisition loop

Author: aacuevas

Builds/VisualStudio2013/open-ephys.sln

@@ -32,4 +32,7 @@ Global
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(Performance) = preSolution
+		HasPerformanceSessions = true
+	EndGlobalSection
 EndGlobal

Builds/VisualStudio2013/open-ephys.vcxproj

@@ -208,6 +208,7 @@
       <AdditionalLibraryDirectories>../../Resources/windows-libs/HDF5/lib/x64;../../Resources/windows-libs/ZeroMQ/lib_x64;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <LargeAddressAware>true</LargeAddressAware>
       <AdditionalDependencies>setupapi.lib;opengl32.lib;glu32.lib;hdf5.lib;hdf5_cpp.lib;libzmq-v120-mt-4_0_4.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <Profile>true</Profile>
     </Link>
     <Bscmake>
       <SuppressStartupBanner>true</SuppressStartupBanner>

Resources/Bitfiles/rhd2000_usb3.bit

@@ -47,6 +47,8 @@
 #define DEBUG_EMULATE_HEADSTAGES 8
 #define DEBUG_EMULATE_64CH
 
+#define INIT_STEP ( evalBoard->isUSB3() ? 256 : 60)
+
 // Allocates memory for a 3-D array of doubles.
 void allocateDoubleArray3D(std::vector<std::vector<std::vector<double> > >& array3D,
                            int xSize, int ySize, int zSize)
@@ -88,6 +90,8 @@ RHD2000Thread::RHD2000Thread(SourceNode* sn) : DataThread(sn),
 	newScan(true), ledsEnabled(true)
 {
 	impedanceThread = new RHDImpedanceMeasure(this);
+	memset(auxBuffer, 0, sizeof(auxBuffer));
+	memset(auxSamples, 0, sizeof(auxSamples));
 
     for (int i=0; i < MAX_NUM_HEADSTAGES; i++)
         headstagesArray.add(new RHDHeadstage(static_cast<Rhd2000EvalBoard::BoardDataSource>(i)));
@@ -389,7 +393,7 @@ void RHD2000Thread::initializeBoard()
 
     // Since our longest command sequence is 60 commands, run the SPI interface for
     // 60 samples (64 for usb3 power-of two needs)
-    evalBoard->setMaxTimeStep(64);
+	evalBoard->setMaxTimeStep(INIT_STEP);
     evalBoard->setContinuousRunMode(false);
 
     // Start SPI interface
@@ -405,8 +409,7 @@ void RHD2000Thread::initializeBoard()
     // need to do anything with this, since it was only used for ADC calibration
     ScopedPointer<Rhd2000DataBlock> dataBlock = new Rhd2000DataBlock(evalBoard->getNumEnabledDataStreams(), evalBoard->isUSB3());
 
-    evalBoard->readDataBlock(dataBlock, 64);
-
+	evalBoard->readDataBlock(dataBlock, INIT_STEP);
     // Now that ADC calibration has been performed, we switch to the command sequence
     // that does not execute ADC calibration.
     evalBoard->selectAuxCommandBank(Rhd2000EvalBoard::PortA, Rhd2000EvalBoard::AuxCmd3,
@@ -508,7 +511,7 @@ void RHD2000Thread::scanPorts()
 
 	// Since our longest command sequence is 60 commands, we run the SPI
 	// interface for 60 samples. (64 for usb3 power-of two needs)
-	evalBoard->setMaxTimeStep(64);
+	evalBoard->setMaxTimeStep(INIT_STEP);
 	evalBoard->setContinuousRunMode(false);
 
 	ScopedPointer<Rhd2000DataBlock> dataBlock =
@@ -545,7 +548,7 @@ void RHD2000Thread::scanPorts()
 			;
 		}
 		// Read the resulting single data block from the USB interface.
-		evalBoard->readDataBlock(dataBlock, 64);
+		evalBoard->readDataBlock(dataBlock, INIT_STEP);
 
 		// Read the Intan chip ID number from each RHD2000 chip found.
 		// Record delay settings that yield good communication with the chip.
@@ -1413,12 +1416,14 @@ bool RHD2000Thread::startAcquisition()
         std::cout << "Flushing FIFO." << std::endl;
         evalBoard->flush();
         evalBoard->setContinuousRunMode(true);
+		evalBoard->printFIFOmetrics();
         evalBoard->run();
+		evalBoard->printFIFOmetrics();
     }
 
     blockSize = dataBlock->calculateDataBlockSizeInWords(evalBoard->getNumEnabledDataStreams(), evalBoard->isUSB3());
 	std::cout << "Expecting blocksize of " << blockSize << " for " << evalBoard->getNumEnabledDataStreams() << " streams" << std::endl;
-
+	evalBoard->printFIFOmetrics();
     startThread();
 
 
@@ -1481,19 +1486,102 @@ bool RHD2000Thread::stopAcquisition()
 bool RHD2000Thread::updateBuffer()
 {
 	int chOffset;
+	unsigned char* bufferPtr;
     //cout << "Number of 16-bit words in FIFO: " << evalBoard->numWordsInFifo() << endl;
     //cout << "Block size: " << blockSize << endl;
-
-    bool return_code;
+   
 	//std::cout << "Current number of words: " <<  evalBoard->numWordsInFifo() << " for " << blockSize << std::endl;
-    if (evalBoard->numWordsInFifo() >= 189440)
+    if (evalBoard->isUSB3() || evalBoard->numWordsInFifo() >= blockSize)
     {
-        return_code = evalBoard->readDataBlock(dataBlock);
+		bool return_code;
+
+		return_code = evalBoard->readRawDataBlock(&bufferPtr);
 
-        for (int samp = 0; samp < dataBlock->getSamplesPerDataBlock(evalBoard->isUSB3()); samp++)
+		int index = 0;
+		int auxIndex, chanIndex;
+		int numStreams = enabledStreams.size();
+		int nSamps = Rhd2000DataBlock::getSamplesPerDataBlock(evalBoard->isUSB3());
+		
+		evalBoard->printFIFOmetrics();
+        for (int samp = 0; samp < nSamps; samp++)
         {
             int channel = -1;
 
+			if (!Rhd2000DataBlock::checkUsbHeader(bufferPtr, index))
+			{
+				cerr << "Error in Rhd2000EvalBoard::readDataBlock: Incorrect header." << endl;
+				break;
+			}
+
+			index += 8;
+			timestamp = Rhd2000DataBlock::convertUsbTimeStamp(bufferPtr,index);
+			index += 4;
+			auxIndex = index;
+			//skip the aux channels
+			index += numStreams * 6;
+			// do the neural data channels first
+			for (int dataStream = 0; dataStream < numStreams; dataStream++)
+			{
+				int nChans = numChannelsPerDataStream[dataStream];
+				chanIndex = index + 2*dataStream;
+				if ((chipId[dataStream] == CHIP_ID_RHD2132) && (nChans == 16)) //RHD2132 16ch. headstage
+				{
+					chanIndex += 2 * RHD2132_16CH_OFFSET*numStreams;
+				}
+				for (int chan = 0; chan < nChans; chan++)
+				{
+					channel++;
+					thisSample[channel] = float(Rhd2000DataBlock::convertUsbWord(bufferPtr, index) - 32768)*0.195f;
+					chanIndex += 2*numStreams;
+				}
+			}
+			index += 64 * numStreams;
+			//now we can do the aux channels
+			auxIndex += 2*numStreams;
+			for (int dataStream = 0; dataStream < numStreams; dataStream++)
+			{
+				if (chipId[dataStream] != CHIP_ID_RHD2164_B)
+				{
+					int auxNum = (samp+3) % 4;
+					if (auxNum < 3)
+					{
+						auxSamples[dataStream][auxNum] = float(Rhd2000DataBlock::convertUsbWord(bufferPtr, auxIndex) - 32768)*0.0000374;
+					}
+					for (int chan = 0; chan < 3; chan++)
+					{
+						channel++;
+						if (auxNum == 3)
+						{
+							auxBuffer[channel] = auxSamples[dataStream][chan];
+						}
+						thisSample[channel] = auxBuffer[channel];
+					}
+				}
+				auxIndex += 2;
+
+			}
+			index += 2 * numStreams;
+			if (acquireAdcChannels)
+			{
+				for (int adcChan = 0; adcChan < 8; ++adcChan)
+				{
+
+					channel++;
+					// ADC waveform units = volts
+					thisSample[channel] =
+						//0.000050354 * float(dataBlock->boardAdcData[adcChan][samp]);
+						0.00015258789 * float(Rhd2000DataBlock::convertUsbWord(bufferPtr, index)) - 5 - 0.4096; // account for +/-5V input range and DC offset
+					index += 2;
+				}
+			}
+			else
+			{
+				index += 16;
+			}
+			eventCode = Rhd2000DataBlock::convertUsbWord(bufferPtr, index);
+			index += 4;
+			dataBuffer->addToBuffer(thisSample, &timestamp, &eventCode, 1);
+#if 0
             // do the neural data channels first
             for (int dataStream = 0; dataStream < enabledStreams.size(); dataStream++)
             {
@@ -1584,14 +1672,13 @@ bool RHD2000Thread::updateBuffer()
             timestamp = dataBlock->timeStamp[samp];
             //timestamp = timestamp;
             eventCode = dataBlock->ttlIn[samp];
-
             dataBuffer->addToBuffer(thisSample, &timestamp, &eventCode, 1);
-
+#endif
         }
 
     }
 
-
+	
     if (dacOutputShouldChange)
     {
 		std::cout << "DAC" << std::endl;
@@ -1624,8 +1711,7 @@ bool RHD2000Thread::updateBuffer()
 
         dacOutputShouldChange = false;
     }
-
-
+	
     return true;
 
 }

Source/Processors/DataThreads/RHD2000Thread.cpp

@@ -149,6 +149,7 @@ class RHD2000Thread : public DataThread, public Timer
 
 	float thisSample[MAX_NUM_CHANNELS];
 	float auxBuffer[MAX_NUM_CHANNELS]; // aux inputs are only sampled every 4th sample, so use this to buffer the samples so they can be handles just like the regular neural channels later
+	float auxSamples[MAX_NUM_DATA_STREAMS_USB3][3];
 
     unsigned int blockSize;
 

Source/Processors/DataThreads/RHD2000Thread.h

@@ -22,7 +22,7 @@
 #define RHD2000DATABLOCK_H
 
 #define SAMPLES_PER_DATA_BLOCK_USB2 300 //modified by Open-ephys
-#define SAMPLES_PER_DATA_BLOCK_USB3 320
+#define SAMPLES_PER_DATA_BLOCK_USB3 256
 #define SAMPLES_PER_DATA_BLOCK(usb3) (usb3 ? SAMPLES_PER_DATA_BLOCK_USB3 : SAMPLES_PER_DATA_BLOCK_USB2)
 #define MAX_SAMPLES_PER_DATA_BLOCK (SAMPLES_PER_DATA_BLOCK_USB3 > SAMPLES_PER_DATA_BLOCK_USB2 ? SAMPLES_PER_DATA_BLOCK_USB3 : SAMPLES_PER_DATA_BLOCK_USB2)
 #define RHD2000_HEADER_MAGIC_NUMBER 0xc691199927021942
@@ -49,6 +49,10 @@ class Rhd2000DataBlock
     void print(int stream) const;
     void write(ofstream &saveOut, int numDataStreams) const;
 
+	static inline bool checkUsbHeader(unsigned char usbBuffer[], int index);
+	static inline unsigned int convertUsbTimeStamp(unsigned char usbBuffer[], int index);
+	static inline int convertUsbWord(unsigned char usbBuffer[], int index);
+
 private:
     void allocateIntArray3D(vector<vector<vector<int> > > &array3D, int xSize, int ySize, int zSize);
     void allocateIntArray2D(vector<vector<int> > &array2D, int xSize, int ySize);
@@ -57,9 +61,7 @@ class Rhd2000DataBlock
 
     void writeWordLittleEndian(ofstream &outputStream, int dataWord) const;
 
-    bool checkUsbHeader(unsigned char usbBuffer[], int index);
-    unsigned int convertUsbTimeStamp(unsigned char usbBuffer[], int index);
-    int convertUsbWord(unsigned char usbBuffer[], int index);
+    
 	const unsigned int samplesPerBlock;
 	bool usb3;
 };

Source/Processors/DataThreads/rhythm-api/rhd2000datablock.h

@@ -29,6 +29,7 @@
 #include "rhd2000datablock.h"
 
 #include "okFrontPanelDLL.h"
+#include <Windows.h>
 
 using namespace std;
 
@@ -685,6 +686,10 @@ void Rhd2000EvalBoard::resetBoard()
 		dev->UpdateWireIns();
 		dev->ActivateTriggerIn(TrigInOpenEphys, 16);
 		cout << "Blocksize set to " << USB3_BLOCK_SIZE << endl;
+		dev->SetWireInValue(WireInMultiUse, DDR_BLOCK_SIZE);
+		dev->UpdateWireIns();
+		dev->ActivateTriggerIn(TrigInOpenEphys, 17);
+		cout << "DDR burst set to " << DDR_BLOCK_SIZE << endl;
 	}
 }
 
@@ -720,6 +725,7 @@ void Rhd2000EvalBoard::run()
 {
 	dev->UpdateWireOuts();
 	std::cout << "Block size: " << dev->GetWireOutValue(0x26) << std::endl;
+	std::cout << "Burst len: " << dev->GetWireOutValue(0x27) << std::endl;
     dev->ActivateTriggerIn(TrigInSpiStart, 0);
 }
 
@@ -1392,6 +1398,7 @@ void Rhd2000EvalBoard::flush()
 		while (numWordsInFifo() > 0) {
 			dev->ReadFromBlockPipeOut(PipeOutData, USB3_BLOCK_SIZE, USB3_BLOCK_SIZE *max(2 * numWordsInFifo() / USB3_BLOCK_SIZE, (unsigned int)1), usbBuffer);
 			cout << "Flush phase B: " << numWordsInFifo() << endl;
+			printFIFOmetrics();
 		}
 		dev->SetWireInValue(WireInResetRun, 0, 1 << 16);
 		dev->UpdateWireIns();
@@ -1426,6 +1433,7 @@ bool Rhd2000EvalBoard::readDataBlock(Rhd2000DataBlock *dataBlock, int nSamples)
 	{
 		//std::cout << "usb3 read : " << numBytesToRead << " in " << USB3_BLOCK_SIZE << " blocks" << std::endl;
 		res = dev->ReadFromBlockPipeOut(PipeOutData, USB3_BLOCK_SIZE, numBytesToRead, usbBuffer);
+		
 	}
 	else
 	{
@@ -1441,6 +1449,39 @@ bool Rhd2000EvalBoard::readDataBlock(Rhd2000DataBlock *dataBlock, int nSamples)
     return true;
 }
 
+bool Rhd2000EvalBoard::readRawDataBlock(unsigned char** bufferPtr, int nSamples)
+{
+	unsigned int numBytesToRead;
+	long res;
+
+	numBytesToRead = 2 * Rhd2000DataBlock::calculateDataBlockSizeInWords(numDataStreams, usb3, nSamples);
+
+	if (numBytesToRead > USB_BUFFER_SIZE) {
+		cerr << "Error in Rhd2000EvalBoard::readDataBlock: USB buffer size exceeded.  " <<
+			"Increase value of USB_BUFFER_SIZE." << endl;
+		*bufferPtr = nullptr;
+		return false;
+	}
+
+	if (usb3)
+	{
+		//std::cout << "usb3 read : " << numBytesToRead << " in " << USB3_BLOCK_SIZE << " blocks" << std::endl;
+		res = dev->ReadFromBlockPipeOut(PipeOutData, USB3_BLOCK_SIZE, numBytesToRead, usbBuffer);
+
+	}
+	else
+	{
+		//std::cout << "usb2 read: " << numBytesToRead << std::endl;
+		res = dev->ReadFromPipeOut(PipeOutData, numBytesToRead, usbBuffer);
+	}
+	if (res == ok_Timeout)
+	{
+		cerr << "CRITICAL: Timeout on pipe read. Check block and buffer sizes." << endl;
+	}
+	*bufferPtr = usbBuffer;
+	return true;
+}
+
 // Reads a certain number of USB data blocks, if the specified number is available, and appends them
 // to queue.  Returns true if data blocks were available.
 bool Rhd2000EvalBoard::readDataBlocks(int numBlocks, queue<Rhd2000DataBlock> &dataQueue)
@@ -1618,4 +1659,10 @@ void Rhd2000EvalBoard::enableBoardLeds(bool enable)
 bool Rhd2000EvalBoard::isUSB3()
 {
 	return usb3;
+}
+
+void Rhd2000EvalBoard::printFIFOmetrics()
+{
+	dev->UpdateWireOuts();
+	std::cout << "In FIFO: " << dev->GetWireOutValue(0x28) << " DDR: " << dev->GetWireOutValue(0x2a) << " Out FIFO: " << dev->GetWireOutValue(0x29) << std::endl;
 }

Source/Processors/DataThreads/rhythm-api/rhd2000evalboard.cpp

@@ -30,7 +30,8 @@
 
 #define MAX_NUM_DATA_STREAMS(u3) ( u3 ? MAX_NUM_DATA_STREAMS_USB3 : MAX_NUM_DATA_STREAMS_USB2 )
 
-#define USB3_BLOCK_SIZE	256
+#define USB3_BLOCK_SIZE	2048
+#define DDR_BLOCK_SIZE 32
 
 #include <queue>
 
@@ -166,6 +167,8 @@ class Rhd2000EvalBoard
 	bool isStreamEnabled(int streamIndex);
 	void enableBoardLeds(bool enable);
 	bool isUSB3();
+	void printFIFOmetrics();
+	bool readRawDataBlock(unsigned char** bufferPtr, int nSamples = -1);
 
 private:
     okCFrontPanel *dev;