Optimize endianness operations

Move endianness detection / helpers to utils/endian.hpp
Pre-compute endian conversion performance once
Optimize single-byte writes/reads

Author: tstenner

CMakeLists.txt

@@ -97,6 +97,8 @@ add_library(lslobj OBJECT
 	src/udp_server.h
 	src/util/cast.hpp
 	src/util/cast.cpp
+	src/util/endian.cpp
+	src/util/endian.hpp
 	src/util/inireader.hpp
 	src/util/inireader.cpp
 	src/util/strfuns.hpp

src/data_receiver.cpp

@@ -5,6 +5,7 @@
 #include "sample.h"
 #include "socket_utils.h"
 #include "util/cast.hpp"
+#include "util/endian.hpp"
 #include "util/strfuns.hpp"
 #include <chrono>
 #include <exception>
@@ -155,7 +156,7 @@ void data_receiver::data_thread() {
 
 				// --- protocol negotiation ---
 
-				int use_byte_order = 0; // which byte order we shall use (0=portable byte order)
+				bool reverse_byte_order = false; // perform little <-> big endian conversion?
 				int data_protocol_version = 100;  // which protocol version we shall use for data
 												  // transmission (100=version 1.00)
 				bool suppress_subnormals = false; // whether we shall suppress subnormal numbers
@@ -225,12 +226,13 @@ void data_receiver::data_thread() {
 										rest = trim(hdrline.substr(colon + 1));
 							// get the header information
 							if (type == "byte-order") {
-								use_byte_order = std::stoi(rest);
-								if (use_byte_order == 2134 && LSL_BYTE_ORDER != 2134 &&
-									format_sizes[conn_.type_info().channel_format()] >= 8)
+								int use_byte_order = std::stoi(rest);
+								auto value_size = format_sizes[conn_.type_info().channel_format()];
+								if (!lsl::can_convert_endian(use_byte_order, value_size))
 									throw std::runtime_error(
 										"The byte order conversion requested by the other party is "
 										"not supported.");
+								reverse_byte_order = use_byte_order != LSL_BYTE_ORDER;
 							}
 							if (type == "suppress-subnormals")
 								suppress_subnormals = lsl::from_string<bool>(rest);
@@ -280,8 +282,8 @@ void data_receiver::data_thread() {
 							received(fac.new_sample(0.0, false));
 						expected->assign_test_pattern(test_pattern);
 						if (data_protocol_version >= 110)
-							received->load_streambuf(
-								buffer, data_protocol_version, use_byte_order, suppress_subnormals);
+							received->load_streambuf(buffer, data_protocol_version,
+								reverse_byte_order, suppress_subnormals);
 						else
 							*inarch >> *received;
 
@@ -310,7 +312,7 @@ void data_receiver::data_thread() {
 					sample_p samp(factory->new_sample(0.0, false));
 					if (data_protocol_version >= 110)
 						samp->load_streambuf(
-							buffer, data_protocol_version, use_byte_order, suppress_subnormals);
+							buffer, data_protocol_version, reverse_byte_order, suppress_subnormals);
 					else
 						*inarch >> *samp;
 					// deduce timestamp if necessary

src/sample.cpp

@@ -154,57 +154,69 @@ void save_raw(std::streambuf &sb, const void *address, std::size_t count) {
 		throw std::runtime_error("Output stream error.");
 }
 
+void save_byte(std::streambuf& sb, uint8_t v) {
+	if (sb.sputc(*reinterpret_cast<const char *>(&v)) == std::streambuf::traits_type::eof())
+		throw std::runtime_error("Output stream error.");
+}
+
 /// Helper function to load raw binary data from a stream buffer.
 void load_raw(std::streambuf &sb, void *address, std::size_t count) {
 	if ((std::size_t)sb.sgetn((char *)address, (std::streamsize)count) != count)
 		throw std::runtime_error("Input stream error.");
 }
 
+uint8_t load_byte(std::streambuf &sb) {
+	auto res = sb.sbumpc();
+	if(res == std::streambuf::traits_type::eof())
+		throw std::runtime_error("Input stream error.");
+	return static_cast<uint8_t>(res);
+}
+
 /// Load a value from a stream buffer with correct endian treatment.
-template <typename T> T load_value(std::streambuf &sb, int use_byte_order) {
+template <typename T> T load_value(std::streambuf &sb, bool reverse_byte_order) {
 	T tmp;
 	load_raw(sb, &tmp, sizeof(T));
-	if (sizeof(T) > 1 && use_byte_order != LSL_BYTE_ORDER) endian_reverse_inplace(tmp);
+	if (sizeof(T) > 1 && reverse_byte_order) endian_reverse_inplace(tmp);
 	return tmp;
 }
 
 /// Save a value to a stream buffer with correct endian treatment.
-template <typename T> void save_value(std::streambuf &sb, T v, int use_byte_order) {
-	if (use_byte_order != LSL_BYTE_ORDER) endian_reverse_inplace(v);
+template <typename T> void save_value(std::streambuf &sb, T v, bool reverse_byte_order) {
+	if (sizeof(T) > 1 && reverse_byte_order) endian_reverse_inplace(v);
 	save_raw(sb, &v, sizeof(T));
 }
 
 void sample::save_streambuf(
-	std::streambuf &sb, int /*protocol_version*/, int use_byte_order, void *scratchpad) const {
+	std::streambuf &sb, int /*protocol_version*/, bool reverse_byte_order, void *scratchpad) const {
 	// write sample header
 	if (timestamp == DEDUCED_TIMESTAMP) {
-		save_value(sb, TAG_DEDUCED_TIMESTAMP, use_byte_order);
+		save_byte(sb, TAG_DEDUCED_TIMESTAMP);
 	} else {
-		save_value(sb, TAG_TRANSMITTED_TIMESTAMP, use_byte_order);
-		save_value(sb, timestamp, use_byte_order);
+		save_byte(sb, TAG_TRANSMITTED_TIMESTAMP);
+		save_value(sb, timestamp, reverse_byte_order);
 	}
 	// write channel data
 	if (format_ == cft_string) {
 		for (const auto &str : samplevals<std::string>(*this)) {
 			// write string length as variable-length integer
 			if (str.size() <= 0xFF) {
-				save_value(sb, (uint8_t)sizeof(uint8_t), use_byte_order);
-				save_value(sb, static_cast<uint8_t>(str.size()), use_byte_order);
+				save_byte(sb, static_cast<uint8_t>(sizeof(uint8_t)));
+				save_byte(sb, static_cast<uint8_t>(str.size()));
 			} else {
 				if (str.size() <= 0xFFFFFFFF) {
-					save_value(sb, (uint8_t)sizeof(uint32_t), use_byte_order);
-					save_value(sb, static_cast<uint32_t>(str.size()), use_byte_order);
+					save_byte(sb, static_cast<uint8_t>(sizeof(uint32_t)));
+					save_value(sb, static_cast<uint32_t>(str.size()), reverse_byte_order);
 				} else {
-					save_value(sb, (uint8_t)sizeof(uint64_t), use_byte_order);
-					save_value(sb, static_cast<std::size_t>(str.size()), use_byte_order);
+					save_byte(sb, static_cast<uint8_t>(sizeof(uint64_t)));
+					save_value(sb, static_cast<std::size_t>(str.size()), reverse_byte_order);
 				}
 			}
 			// write string contents
 			if (!str.empty()) save_raw(sb, str.data(), str.size());
 		}
 	} else {
 		// write numeric data in binary
-		if (use_byte_order == LSL_BYTE_ORDER || format_sizes[format_] == 1) {
+		if (!reverse_byte_order || format_sizes[format_] == 1) {
 			save_raw(sb, &data_, datasize());
 		} else {
 			memcpy(scratchpad, &data_, datasize());
@@ -215,31 +227,31 @@ void sample::save_streambuf(
 }
 
 void sample::load_streambuf(
-	std::streambuf &sb, int /*unused*/, int use_byte_order, bool suppress_subnormals) {
+	std::streambuf &sb, int /*unused*/, bool reverse_byte_order, bool suppress_subnormals) {
 	// read sample header
-	if (load_value<uint8_t>(sb, use_byte_order) == TAG_DEDUCED_TIMESTAMP)
+	if (load_byte(sb) == TAG_DEDUCED_TIMESTAMP)
 		// deduce the timestamp
 		timestamp = DEDUCED_TIMESTAMP;
 	else
 		// read the time stamp
-		timestamp = load_value<double>(sb, use_byte_order);
+		timestamp = load_value<double>(sb, reverse_byte_order);
 
 	// read channel data
 	if (format_ == cft_string) {
 		for (auto &str : samplevals<std::string>(*this)) {
 			// read string length as variable-length integer
 			std::size_t len = 0;
-			auto lenbytes = load_value<uint8_t>(sb, use_byte_order);
+			auto lenbytes = load_byte(sb);
 
 			if (sizeof(std::size_t) < 8 && lenbytes > sizeof(std::size_t))
 				throw std::runtime_error(
 					"This platform does not support strings of 64-bit length.");
 			switch (lenbytes) {
-			case sizeof(uint8_t): len = load_value<uint8_t>(sb, use_byte_order); break;
-			case sizeof(uint16_t): len = load_value<uint16_t>(sb, use_byte_order); break;
-			case sizeof(uint32_t): len = load_value<uint32_t>(sb, use_byte_order); break;
+			case sizeof(uint8_t): len = load_byte(sb); break;
+			case sizeof(uint16_t): len = load_value<uint16_t>(sb, reverse_byte_order); break;
+			case sizeof(uint32_t): len = load_value<uint32_t>(sb, reverse_byte_order); break;
 #ifndef BOOST_NO_INT64_T
-			case sizeof(uint64_t): len = load_value<uint64_t>(sb, use_byte_order); break;
+			case sizeof(uint64_t): len = load_value<uint64_t>(sb, reverse_byte_order); break;
 #endif
 			default: throw std::runtime_error("Stream contents corrupted (invalid varlen int).");
 			}
@@ -250,8 +262,8 @@ void sample::load_streambuf(
 	} else {
 		// read numeric channel data
 		load_raw(sb, &data_, datasize());
-		if (use_byte_order != LSL_BYTE_ORDER && format_sizes[format_] > 1)
-			convert_endian(&data_, num_channels_, format_sizes[format_]);
+		if (reverse_byte_order && format_sizes[format_] > 1)
+			convert_endian(&data_, num_channels(), format_sizes[format_]);
 		if (suppress_subnormals && format_float[format_]) {
 			if (format_ == cft_float32) {
 				for (auto &val : samplevals<uint32_t>(*this))

src/sample.h

@@ -3,19 +3,15 @@
 #include "common.h"
 #include "forward.h"
 #include "util/cast.hpp"
+#include "util/endian.hpp"
 #include <atomic>
 #include <cstdint>
-#include <boost/endian/detail/order.hpp>
 #include <iosfwd>
 #include <limits>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
 
-// Determine target byte order / endianness
-using byteorder = lslboost::endian::order;
-static_assert(byteorder::native == byteorder::little || byteorder::native == byteorder::big, "Unsupported byteorder");
-const int LSL_BYTE_ORDER = (byteorder::native == byteorder::little) ? 1234 : 4321;
 
 namespace lsl {
 // assert that the target CPU can represent the double-precision timestamp format required by LSL
@@ -144,12 +140,12 @@ class sample {
 	// === serialization functions ===
 
 	/// Serialize a sample to a stream buffer (protocol 1.10).
-	void save_streambuf(std::streambuf &sb, int protocol_version, int use_byte_order,
+	void save_streambuf(std::streambuf &sb, int protocol_version, bool reverse_byte_order,
 		void *scratchpad = nullptr) const;
 
 	/// Deserialize a sample from a stream buffer (protocol 1.10).
-	void load_streambuf(
-		std::streambuf &sb, int protocol_version, int use_byte_order, bool suppress_subnormals);
+	void load_streambuf(std::streambuf &sb, int protocol_version, bool reverse_byte_order,
+		bool suppress_subnormals);
 
 	/// Convert the endianness of channel data in-place.
 	static void convert_endian(void *data, uint32_t n, uint32_t width);

src/socket_utils.cpp

@@ -1,17 +1,6 @@
 #include "socket_utils.h"
 #include "api_config.h"
 #include "common.h"
-#include <boost/endian/conversion.hpp>
-
-double lsl::measure_endian_performance() {
-	const double measure_duration = 0.01;
-	const double t_end = lsl_clock() + measure_duration;
-	uint64_t data = 0x01020304;
-	double k;
-	for (k = 0; ((int)k & 0xFF) != 0 || lsl_clock() < t_end; k++)
-		lslboost::endian::endian_reverse_inplace(data);
-	return k;
-}
 
 template <typename Socket, typename Protocol>
 uint16_t bind_port_in_range_(Socket &sock, Protocol protocol) {

src/socket_utils.h

@@ -15,9 +15,6 @@ uint16_t bind_port_in_range(asio::ip::udp::socket &sock, asio::ip::udp protocol)
 /// Bind and listen to an acceptor on a free port in the configured port range or throw an error.
 uint16_t bind_and_listen_to_port_in_range(
 	asio::ip::tcp::acceptor &acc, asio::ip::tcp protocol, int backlog);
-
-/// Measure the endian conversion performance of this machine.
-double measure_endian_performance();
 } // namespace lsl
 
 #endif

src/tcp_server.cpp

@@ -6,6 +6,7 @@
 #include "socket_utils.h"
 #include "stream_info_impl.h"
 #include "util/cast.hpp"
+#include "util/endian.hpp"
 #include "util/strfuns.hpp"
 #include <asio/io_context.hpp>
 #include <asio/ip/host_name.hpp>
@@ -34,6 +35,8 @@
 #define NO_EXPLICIT_TEMPLATE_INSTANTIATION
 #include "portable_archive/portable_oarchive.hpp"
 
+using std::size_t;
+
 namespace lsl {
 /**
  * Active session with a TCP client.
@@ -127,9 +130,8 @@ class client_session : public std::enable_shared_from_this<client_session> {
 	char *scratch_{nullptr};
 	/// protocol version to use for transmission
 	int data_protocol_version_{100};
-	/// byte order to use (0=portable, 1234=little endian, 4321=big endian, 2134=PDP endian,
-	/// unsupported)
-	int use_byte_order_{LSL_BYTE_ORDER};
+	/// is the client's endianness reversed (big<->little endian)
+	bool reverse_byte_order_{false};
 	/// our chunk granularity
 	int chunk_granularity_{0};
 	/// maximum number of samples buffered
@@ -423,6 +425,9 @@ void client_session::handle_read_feedparams(
 
 			// determine the parameters for data transmission
 			bool client_suppress_subnormals = false;
+
+			lsl::Endianness use_byte_order = LSL_BYTE_ORDER;
+
 			// use least common denominator data protocol version
 			data_protocol_version_ = std::min(
 				api_config::get_instance()->use_protocol_version(), client_protocol_version);
@@ -436,21 +441,21 @@ void client_session::handle_read_feedparams(
 				!client_has_ieee754_floats)
 				data_protocol_version_ = 100;
 			if (data_protocol_version_ >= 110) {
-				// decide on the byte order if conflicting
-				if (LSL_BYTE_ORDER != client_byte_order) {
-					if (client_byte_order == 2134 && client_value_size >= 8) {
-						// since we have no implementation for this byte order conversion let
-						// the client do it
-						use_byte_order_ = LSL_BYTE_ORDER;
-					} else {
-						// let the faster party perform the endian conversion
-						use_byte_order_ = (client_value_size <= 1 || (measure_endian_performance() >
-																		 client_endian_performance))
-											  ? client_byte_order
-											  : LSL_BYTE_ORDER;
-					}
-				} else
-					use_byte_order_ = LSL_BYTE_ORDER;
+
+				// enable endian conversion when
+				// 1. our byte ordering is different from the client's *and*
+				// 2. we can actually perform the conversion *and*
+				// 3. the sample format is wide enough for endianness to matter *and*
+				// 4. we're faster at converting than the client
+				if (LSL_BYTE_ORDER != client_byte_order &&						  // (1)
+					lsl::can_convert_endian(client_byte_order, client_value_size) // (2)
+					&& client_value_size > 1 &&									  // (3)
+					(measure_endian_performance() > client_endian_performance))	  // (4)
+				{
+					use_byte_order = static_cast<lsl::Endianness>(client_byte_order);
+					reverse_byte_order_ = true;
+				}
+
 				// determine if subnormal suppression needs to be enabled
 				client_suppress_subnormals =
 					(format_subnormal[format] && !client_supports_subnormals);
@@ -461,7 +466,7 @@ void client_session::handle_read_feedparams(
 			response_stream << "LSL/" << api_config::get_instance()->use_protocol_version()
 							<< " 200 OK\r\n";
 			response_stream << "UID: " << serv_->info_->uid() << "\r\n";
-			response_stream << "Byte-Order: " << use_byte_order_ << "\r\n";
+			response_stream << "Byte-Order: " << use_byte_order << "\r\n";
 			response_stream << "Suppress-Subnormals: " << client_suppress_subnormals << "\r\n";
 			response_stream << "Data-Protocol-Version: " << data_protocol_version_ << "\r\n";
 			response_stream << "\r\n" << std::flush;
@@ -489,7 +494,8 @@ void client_session::handle_read_feedparams(
 			lsl::sample_p temp(fac.new_sample(0.0, false));
 			temp->assign_test_pattern(test_pattern);
 			if (data_protocol_version_ >= 110)
-				temp->save_streambuf(feedbuf_, data_protocol_version_, use_byte_order_, scratch_);
+				temp->save_streambuf(
+					feedbuf_, data_protocol_version_, reverse_byte_order_, scratch_);
 			else
 				*outarch_ << *temp;
 		}
@@ -543,7 +549,7 @@ void client_session::transfer_samples_thread(std::shared_ptr<client_session> /*k
 				// serialize the sample into the stream
 				if (data_protocol_version_ >= 110)
 					samp->save_streambuf(
-						feedbuf_, data_protocol_version_, use_byte_order_, scratch_);
+						feedbuf_, data_protocol_version_, reverse_byte_order_, scratch_);
 				else
 					*outarch_ << *samp;
 				// if the sample is marked as force-push or the configured chunk size is reached

src/util/endian.cpp

@@ -0,0 +1,12 @@
+#include "endian.hpp"
+#include "../common.h"
+
+double lsl::measure_endian_performance() {
+	const double measure_duration = 0.01;
+	const double t_end = lsl_clock() + measure_duration;
+	uint64_t data = 0x01020304;
+	double k;
+	for (k = 0; ((int)k & 0xFF) != 0 || lsl_clock() < t_end; k++)
+		lslboost::endian::endian_reverse_inplace(data);
+	return k;
+}