Merge remote-tracking branch 'origin/master' into checksum

Author: KredeGC

include/bitstream/stream/bit_reader.h

@@ -183,8 +183,9 @@ namespace bitstream
 
 			BS_ASSERT(m_Policy.extend(num_bits));
 
-			// Fast path
-			if (num_bits == 32U && m_ScratchBits == 0U)
+			// This is actually slower
+			// Possibly due to unlikely branching
+			/*if (num_bits == 32U && m_ScratchBits == 0U)
 			{
 				const uint32_t* ptr = m_Policy.get_buffer() + m_WordIndex;
 
@@ -193,7 +194,7 @@ namespace bitstream
 				m_WordIndex++;
 
 				return true;
-			}
+			}*/
 
 			if (m_ScratchBits < num_bits)
 			{

include/bitstream/stream/bit_writer.h

@@ -208,8 +208,9 @@ namespace bitstream
 
 			BS_ASSERT(m_Policy.extend(num_bits));
 
-			// Fast path
-			if (num_bits == 32U && m_ScratchBits == 0U)
+			// This is actually slower
+			// Possibly due to unlikely branching
+			/*if (num_bits == 32U && m_ScratchBits == 0U)
 			{
 				uint32_t* ptr = m_Policy.get_buffer() + m_WordIndex;
 
@@ -218,7 +219,7 @@ namespace bitstream
 				m_WordIndex++;
 
 				return true;
-			}
+			}*/
 
 			uint32_t offset = 64U - num_bits - m_ScratchBits;
 			uint64_t ls_value = static_cast<uint64_t>(value) << offset;
@@ -349,8 +350,8 @@ namespace bitstream
 		Policy m_Policy;
 
 		uint64_t m_Scratch;
-		uint32_t m_ScratchBits;
-		uint32_t m_WordIndex;
+		int m_ScratchBits;
+		size_t m_WordIndex;
 	};
 
 	using fixed_bit_writer = bit_writer<fixed_policy>;

include/bitstream/stream/stream_traits.h

@@ -51,7 +51,7 @@ namespace bitstream
 
 		uint32_t get_total_bits() const noexcept { return m_TotalBits; }
 
-		bool extend(uint32_t num_bits)
+		bool extend(uint32_t num_bits) noexcept
 		{
 			if (!can_serialize_bits(num_bits))
 				return false;

include/bitstream/traits/integral_traits.h

@@ -19,6 +19,101 @@ namespace bitstream
 	template<typename T, T = (std::numeric_limits<T>::min)(), T = (std::numeric_limits<T>::max)()>
 	struct bounded_int;
 
+#pragma region const integral types
+	/**
+	 * @brief A trait used to serialize integer values with compiletime bounds
+	 * @tparam T A type matching an integer value
+	 * @tparam Min The lower bound. Inclusive
+	 * @tparam Max The upper bound. Inclusive
+	*/
+	template<typename T, T Min, T Max>
+	struct serialize_traits<bounded_int<T, Min, Max>, typename std::enable_if_t<std::is_integral_v<T> && !std::is_const_v<T>>>
+	{
+		static_assert(sizeof(T) <= 8, "Integers larger than 8 bytes are currently not supported. You will have to write this functionality yourself");
+
+		/**
+		 * @brief Writes an integer into the @p writer
+		 * @param writer The stream to write to
+		 * @param value The value to serialize
+		 * @return Success
+		*/
+		template<typename Stream>
+		typename utility::is_writing_t<Stream>
+		static serialize(Stream& writer, in<T> value) noexcept
+		{
+			static_assert(Min < Max);
+
+			BS_ASSERT(value >= Min && value <= Max);
+
+			constexpr uint32_t num_bits = utility::bits_in_range(Min, Max);
+
+			static_assert(num_bits <= sizeof(T) * 8);
+
+			if constexpr (sizeof(T) > 4 && num_bits > 32)
+			{
+				// If the given range is bigger than a word (32 bits)
+				uint32_t unsigned_value = static_cast<uint32_t>(value - Min);
+				BS_ASSERT(writer.serialize_bits(unsigned_value, 32));
+
+				unsigned_value = static_cast<uint32_t>((value - Min) >> 32);
+				BS_ASSERT(writer.serialize_bits(unsigned_value, num_bits - 32));
+			}
+			else
+			{
+				// If the given range is smaller than or equal to a word (32 bits)
+				uint32_t unsigned_value = static_cast<uint32_t>(value - Min);
+				BS_ASSERT(writer.serialize_bits(unsigned_value, num_bits));
+			}
+
+			return true;
+		}
+
+		/**
+		 * @brief Reads an integer from the @p writer into @p value
+		 * @param reader The stream to read from
+		 * @param value The value to serialize
+		 * @return Success
+		*/
+		template<typename Stream>
+		typename utility::is_reading_t<Stream>
+		static serialize(Stream& reader, T& value) noexcept
+		{
+			static_assert(Min < Max);
+
+			constexpr uint32_t num_bits = utility::bits_in_range(Min, Max);
+
+			static_assert(num_bits <= sizeof(T) * 8);
+
+			if constexpr (sizeof(T) > 4 && num_bits > 32)
+			{
+				// If the given range is bigger than a word (32 bits)
+				value = 0;
+				uint32_t unsigned_value;
+
+				BS_ASSERT(reader.serialize_bits(unsigned_value, 32));
+				value |= static_cast<T>(unsigned_value);
+
+				BS_ASSERT(reader.serialize_bits(unsigned_value, num_bits - 32));
+				value |= static_cast<T>(unsigned_value) << 32;
+
+				value += Min;
+			}
+			else
+			{
+				// If the given range is smaller than or equal to a word (32 bits)
+				uint32_t unsigned_value;
+				BS_ASSERT(reader.serialize_bits(unsigned_value, num_bits));
+
+				value = static_cast<T>(unsigned_value) + Min;
+			}
+
+			BS_ASSERT(value >= Min && value <= Max);
+
+			return true;
+		}
+	};
+#pragma endregion
+
 #pragma region integral types
 	/**
 	 * @brief A trait used to serialize integer values with runtime bounds
@@ -39,7 +134,7 @@ namespace bitstream
 		*/
 		template<typename Stream>
 		typename utility::is_writing_t<Stream>
-		static serialize(Stream& writer, in<T> value, T min = (std::numeric_limits<T>::min)(), T max = (std::numeric_limits<T>::max)()) noexcept
+		static serialize(Stream& writer, in<T> value, T min, T max) noexcept
 		{
 			BS_ASSERT(min < max);
 
@@ -81,7 +176,7 @@ namespace bitstream
 		*/
 		template<typename Stream>
 		typename utility::is_reading_t<Stream>
-		static serialize(Stream& reader, T& value, T min = (std::numeric_limits<T>::min)(), T max = (std::numeric_limits<T>::max)()) noexcept
+		static serialize(Stream& reader, T& value, T min, T max) noexcept
 		{
 			BS_ASSERT(min < max);
 
@@ -121,100 +216,17 @@ namespace bitstream
 
 			return true;
 		}
-	};
-#pragma endregion
-
-#pragma region const integral types
-	/**
-	 * @brief A trait used to serialize integer values with compiletime bounds
-	 * @tparam T A type matching an integer value
-	 * @tparam Min The lower bound. Inclusive
-	 * @tparam Max The upper bound. Inclusive
-	*/
-	template<typename T, T Min, T Max>
-	struct serialize_traits<bounded_int<T, Min, Max>, typename std::enable_if_t<std::is_integral_v<T> && !std::is_const_v<T>>>
-	{
-		static_assert(sizeof(T) <= 8, "Integers larger than 8 bytes are currently not supported. You will have to write this functionality yourself");
 
 		/**
-		 * @brief Writes an integer into the @p writer
-		 * @param writer The stream to write to
+		 * @brief Writes or reads an integer into the @p stream
+		 * @param stream The stream to serialize to/from
 		 * @param value The value to serialize
 		 * @return Success
 		*/
-		template<typename Stream>
-		typename utility::is_writing_t<Stream>
-		static serialize(Stream& writer, in<T> value) noexcept
+		template<typename Stream, typename U>
+		static bool serialize(Stream& stream, U&& value) noexcept
 		{
-			static_assert(Min < Max);
-            
-            BS_ASSERT(value >= Min && value <= Max);
-
-			constexpr uint32_t num_bits = utility::bits_in_range(Min, Max);
-
-			static_assert(num_bits <= sizeof(T) * 8);
-
-			if constexpr (sizeof(T) > 4 && num_bits > 32)
-			{
-				// If the given range is bigger than a word (32 bits)
-				uint32_t unsigned_value = static_cast<uint32_t>(value - Min);
-				BS_ASSERT(writer.serialize_bits(unsigned_value, 32));
-
-				unsigned_value = static_cast<uint32_t>((value - Min) >> 32);
-				BS_ASSERT(writer.serialize_bits(unsigned_value, num_bits - 32));
-			}
-			else
-			{
-				// If the given range is smaller than or equal to a word (32 bits)
-				uint32_t unsigned_value = static_cast<uint32_t>(value - Min);
-				BS_ASSERT(writer.serialize_bits(unsigned_value, num_bits));
-			}
-
-			return true;
-		}
-
-		/**
-		 * @brief Reads an integer from the @p writer into @p value
-		 * @param reader The stream to read from
-		 * @param value The value to serialize
-		 * @return Success
-		*/
-		template<typename Stream>
-		typename utility::is_reading_t<Stream>
-		static serialize(Stream& reader, T& value) noexcept
-		{
-			static_assert(Min < Max);
-
-			constexpr uint32_t num_bits = utility::bits_in_range(Min, Max);
-
-			static_assert(num_bits <= sizeof(T) * 8);
-
-			if constexpr (sizeof(T) > 4 && num_bits > 32)
-			{
-				// If the given range is bigger than a word (32 bits)
-				value = 0;
-				uint32_t unsigned_value;
-
-				BS_ASSERT(reader.serialize_bits(unsigned_value, 32));
-				value |= static_cast<T>(unsigned_value);
-
-				BS_ASSERT(reader.serialize_bits(unsigned_value, num_bits - 32));
-				value |= static_cast<T>(unsigned_value) << 32;
-
-				value += Min;
-			}
-			else
-			{
-				// If the given range is smaller than or equal to a word (32 bits)
-				uint32_t unsigned_value;
-				BS_ASSERT(reader.serialize_bits(unsigned_value, num_bits));
-
-				value = static_cast<T>(unsigned_value) + Min;
-			}
-            
-            BS_ASSERT(value >= Min && value <= Max);
-
-			return true;
+			return serialize_traits<bounded_int<T>>::serialize(stream, std::forward<U>(value));
 		}
 	};
 #pragma endregion

include/bitstream/utility/assert.h

@@ -10,9 +10,9 @@
 #define BS_BREAKPOINT() throw
 #endif
 
-#define BS_ASSERT(x) if (!(x)) { BS_BREAKPOINT(); return false; }
+#define BS_ASSERT(...) if (!(__VA_ARGS__)) { BS_BREAKPOINT(); return false; }
 #else // BS_DEBUG_BREAK
-#define BS_ASSERT(x) if (!(x)) { return false; }
+#define BS_ASSERT(...) if (!(__VA_ARGS__)) { return false; }
 
 #define BS_BREAKPOINT() throw
 #endif // BS_DEBUG_BREAK

src/test/fast_serialization_test.cpp

@@ -23,12 +23,12 @@ namespace bitstream::test::performance
 
         auto end = std::chrono::steady_clock::now();
 
-        auto start_time = std::chrono::time_point_cast<std::chrono::microseconds>(start).time_since_epoch();
-        auto end_time = std::chrono::time_point_cast<std::chrono::microseconds>(end).time_since_epoch();
+        auto start_time = std::chrono::time_point_cast<std::chrono::nanoseconds>(start).time_since_epoch();
+        auto end_time = std::chrono::time_point_cast<std::chrono::nanoseconds>(end).time_since_epoch();
 
-        auto time = (end - start).count();
+        auto time = (end_time - start_time).count();
 
-        std::cout << "  ->time spent: " << time << "us\n";
+        std::cout << "  ->time spent: " << time << "ns\n";
 
         BS_TEST_ASSERT(status);
     }
@@ -47,7 +47,11 @@ namespace bitstream::test::performance
         // Should just use straight memcpy
         profile_time([&]
         {
-            return writer.serialize_bytes(reinterpret_cast<uint8_t*>(numbers), 1024U * 8U * sizeof(uint32_t));
+            BS_ASSERT(writer.serialize_bytes(reinterpret_cast<uint8_t*>(numbers), 1024U * 8U * sizeof(uint32_t)));
+
+            writer.flush();
+
+            return true;
         });
     }
 
@@ -66,7 +70,11 @@ namespace bitstream::test::performance
         // Has to use serialize_bits individually
         profile_time([&]
         {
-            return writer.serialize_bytes(reinterpret_cast<uint8_t*>(numbers), 1024U * 8U * sizeof(uint32_t));
+            BS_ASSERT(writer.serialize_bytes(reinterpret_cast<uint8_t*>(numbers), 1024U * 8U * sizeof(uint32_t)));
+
+            writer.flush();
+
+            return true;
         });
     }
 
@@ -80,10 +88,11 @@ namespace bitstream::test::performance
         {
             for (uint32_t i = 0U; i < 1024U; i++)
             {
-                if (!writer.serialize_bits(24U, 32U))
-                    return false;
+                BS_ASSERT(writer.serialize_bits(24U, 32U));
             }
 
+            writer.flush();
+
             return true;
         });
     }
@@ -98,10 +107,11 @@ namespace bitstream::test::performance
         {
             for (uint32_t i = 0U; i < 1024U; i++)
             {
-                if (!writer.serialize_bits(24U, 31U))
-                    return false;
+                BS_ASSERT(writer.serialize_bits(24U, 31U));
             }
 
+            writer.flush();
+
             return true;
         });
     }