Add some testing programs

Author: tstenner

CMakeLists.txt

@@ -345,6 +345,12 @@ if(NOT WIN32 AND LSL_TOOLS)
 	target_link_libraries(blackhole PRIVATE Threads::Threads)
 	target_include_directories(blackhole PRIVATE "thirdparty/asio/")
 	installLSLApp(blackhole)
+	add_executable(spike testing/spike.cpp)
+	target_link_libraries(spike PRIVATE lsl)
+	installLSLApp(spike)
+	add_executable(flood testing/flood.c)
+	target_link_libraries(flood PRIVATE lsl)
+	installLSLApp(flood)
 endif()
 
 set(LSL_INSTALL_ROOT ${CMAKE_CURRENT_BINARY_DIR})

testing/flood.c

@@ -0,0 +1,61 @@
+#include <lsl_c.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static double start_t;
+static int64_t samples_pushed = 0;
+
+void handle_signal(int signal) {
+	double time = lsl_local_clock() - start_t;
+	printf("%ld samples pushed in %fs, %d samples/s\n", samples_pushed, time,
+		(int)(samples_pushed / time));
+	if (signal == SIGTERM || signal == SIGINT) exit(0);
+	start_t = lsl_local_clock();
+	samples_pushed = 0;
+}
+
+int main(int argc, char *argv[]) {
+	signal(SIGTERM, handle_signal);
+	signal(SIGINT, handle_signal);
+#ifdef SIGUSR1
+	signal(SIGUSR1, handle_signal);
+#endif
+#ifdef SIGCONT
+	signal(SIGCONT, handle_signal);
+#endif
+	printf("LSL inlet stress tester. Sends [nchan] uint16 channels as fast as possible.\n");
+	printf("Usage: %s [streamname] [nchan=56] [chunksize=500]\n", argv[0]);
+	printf("Using lsl %d, lsl_library_info: %s\n\n", lsl_library_version(), lsl_library_info());
+
+	const char *name = argc > 1 ? argv[1] : "Flood";
+	const int nchan = argc > 2 ? strtol(argv[2], NULL, 10) : 56;
+	const int samples_per_chunk = argc > 3 ? strtol(argv[3], NULL, 10) : 500;
+	const char uid[] = "325wqer4354";
+
+	/* declare a new streaminfo (name: SendDataC / argument 1, content type: EEG, 8 channels, 500
+	 * Hz, float values, some made-up device id (can also be empty) */
+	lsl_streaminfo info = lsl_create_streaminfo(name, "Bench", nchan, 50000, cft_int16, uid);
+
+	/* make a new outlet (chunking: default, buffering: 360 seconds) */
+	lsl_outlet outlet = lsl_create_outlet_ex(info, 0, 360, transp_sync_blocking);
+	char *infoxml = lsl_get_xml(lsl_get_info(outlet));
+	printf("Streaminfo: %s\n", infoxml);
+	lsl_destroy_string(infoxml);
+
+	const int buf_elements = nchan * samples_per_chunk;
+	int16_t *buf = malloc(buf_elements * 2);
+	memset(buf, 0xab, buf_elements * sizeof(buf[0]));
+
+	printf("Now sending data...\n");
+	start_t = lsl_local_clock();
+
+	for (int t = 0;; t++) {
+		lsl_push_chunk_s(outlet, buf, buf_elements);
+		samples_pushed += samples_per_chunk;
+	}
+	lsl_destroy_outlet(outlet);
+	return 0;
+}

testing/spike.cpp

@@ -0,0 +1,50 @@
+#include "lsl_cpp.h"
+#include <chrono>
+#include <iostream>
+#include <random>
+#include <cstdlib>
+#include <thread>
+
+using namespace std::chrono_literals;
+
+const char *channels[] = {"C3", "C4", "Cz", "FPz", "POz", "CPz", "O1", "O2"};
+
+int main(int argc, char *argv[]) {
+	int n_channels = argc > 1 ? std::stoi(argv[1]) : 200;
+	int samplingrate = argc > 2 ? std::stoi(argv[2]) : 50000;
+	int max_buffered = argc > 3 ? std::stoi(argv[3]) : 360;
+	bool sync = argc > 4 ? std::stoi(argv[4]) > 0 : true;
+
+	try {
+		lsl::stream_info info("Spike", "bench", n_channels, samplingrate, lsl::cf_int16, "Spike");
+		lsl::stream_outlet outlet(
+			info, 0, max_buffered, sync ? transp_sync_blocking : transp_default);
+
+		std::vector<int16_t> chunk(n_channels * samplingrate / 1000, 5);
+
+		const auto t_start = std::chrono::high_resolution_clock::now();
+		auto next_sample_time = t_start;
+		const auto time_per_chunk = std::chrono::microseconds(8 / samplingrate);
+
+		// send data forever
+		std::cout << "Now sending data... " << std::endl;
+		for (unsigned t = 0;; t++) {
+			if (t % 3 == 0) {
+				for (int s = 0; s < 5; ++s)
+					outlet.push_chunk_multiplexed(chunk);
+				// Wait until the next expected sample time.
+			} else {
+				for (int s = 0; s < 10; ++s) {
+					outlet.push_sample(chunk.data());
+					std::this_thread::sleep_for(100us);
+				}
+			}
+			next_sample_time += time_per_chunk;
+			std::this_thread::sleep_until(next_sample_time);
+		}
+
+	} catch (std::exception &e) { std::cerr << "Got an exception: " << e.what() << std::endl; }
+	std::cout << "Press any key to exit. " << std::endl;
+	std::cin.get();
+	return 0;
+}