For real-time use of the buffer it is relevant to know how fast it can handle read and write requests. For a write request, the time depends on the number of channels and on the number of samples in the data block.

The following benchmarks have been run using the rt_benchmark script in the realtime directory on the following computers:

• fcdc334: Dell PC with Windows XP, P4 2.8 GHz, 1GB RAM
• mentat204, mentat205, mentat232: 64-bit Linux, Core 2 Quad 2.8 GHz, 8GB RAM
• laptop: 32-bit Linux, 1.6Ghz Pentium M, 512 MB RAM

The first name in the legend always refers to the machine where the rt_benchmark script was run from, whereas the other name behind the dash refers to the machine that contained the buffer, with the exception of dma, which means that the buffer was kept in the same Matlab instance, thus involving no TCP/IP communication.

The dramatic dip for the mentat2xx-localhost connections needs further investigation.

Update 19-08-2010: After implementing an alternative communication channel using local UNIX domain sockets, here is an updated figure for a single 64-bit Linux machine. Communication over local domain sockets is generally faster, but most importantly, it is more consistent across blocksizes and scales linearly like the DMA throughput.

The benchmarking results presented in the table below were determined with the demo_buffer and the test_benchmark command-line executables, both present in the directory fieldtrip/realtime/buffer/test. Both applications were running on the same computer, i.e. using the local TCP stack. The blocksize below is the number of channels times the number of samples per block in each write request. The result is expressed in samples per second, and was measured over multiple seconds. Each sample is 4 bytes.

The tests have been performed on and between the following computers:

• powerbook: Apple PowerBook G4 PPC 1.33GHz, 1.25GB RAM, OS X 10.4.11
• manzana: Apple Mac Pro 2x 2.66GHz Dual-Core Intel Xeon, 2GB RAM, OS X 10.5.8
• fcdc273: Dell PC with Windows XP, P4 2.8GHz, 2GB RAM

The best result above for statefull tcp corresponds with 60 kHz @ 32 channels or 15 kHz @ 128 channels.

You can replicate this benchmark within MATLAB using the following lines of code:

nchan      = 128;
blocksize  = 32;
dat        = randn(nchan, blocksize); % generate some random data

hdr        = [];
hdr.Fs     = 1200;
hdr.nChans = nchan;

target     = 'buffer://localhost:1972';

duration   = 10*hdr.Fs;               % total number of samples to write

ft_write_data(target, [], 'header', hdr, 'append', false);

tic; t0 = toc;
for i=1:round(duration/blocksize)
  ft_write_data(target, dat, 'header', hdr, 'append', true);
end
t1 = toc;

fprintf('nchan = %d, blocksize = %d: wrote %f samples per second\n', nchan, blocksize, (duration*hdr.nChans)/(t1-t0));

Note that the MATLAB interface to the buffer does not allow you to use a statefull connection or a DMA connection, it only provides the stateless TCP connection.

The following code can be used to determine the time of a single write operation.

nchan      = 32;
% target     = 'buffer://manzana:1972';
target     = 'buffer://localhost:1972';

blocksize  = [1:20 30:5:100 200:200:1000];
repeat     = 2;

hdr        = [];
hdr.Fs     = 256;
hdr.nChans = nchan;

ft_write_data(target, [], 'header', hdr, 'append', false);

stopwatch = tic;
for i=1:length(blocksize)
  disp(i)
  dat = randn(nchan, blocksize(i)); % generate some random data
  begtime(i) = toc(stopwatch);
  for j=1:repeat
    ft_write_data(target, dat, 'header', hdr, 'append', true);
  end
  endtime(i) = toc(stopwatch);
end

delay = (endtime-begtime)/repeat;
figure
plot(blocksize, delay, '.');