Testing new fallback layer for simd.

Author: RealTimeChris

Benchmarks/common.hpp

@@ -35,8 +35,8 @@
 static constexpr auto max_iterations{ 1400 };
 static constexpr auto measured_iterations{ 20 };
 #else
-static constexpr auto max_iterations{ 200 };
-static constexpr auto measured_iterations{ 25 };
+static constexpr auto max_iterations{ 2 };
+static constexpr auto measured_iterations{ 1 };
 #endif
 
 constexpr auto get_current_operating_system() {

Benchmarks/tests.hpp

@@ -23,6 +23,7 @@
 #pragma once
 
 #include "jsonifier.hpp"
+#include "simdjson.hpp"
 #include "glaze.hpp"
 
 namespace tests {
@@ -605,7 +606,7 @@ namespace tests {
 			return r;
 		}
 	};
-	/*
+
 	template<pod_type test_data_type, bool minified, size_t iterations, const bnch_swt::string_literal test_name_new>
 	struct json_test_helper<json_library::simdjson, test_type::parse_and_serialize, test_data_type, minified, iterations, test_name_new> {
 		JSONIFIER_INLINE static auto run(const test_data_type& test_data_new) {
@@ -776,7 +777,7 @@ namespace tests {
 			return r;
 		}
 	};
-	*/
+
 #if JSONIFIER_PLATFORM_MAC
 	constexpr bnch_swt::string_literal table_header = bnch_swt::string_literal{
 		R"(
@@ -868,7 +869,7 @@ In contrast, hash-based solutions offer a viable alternative by circumventing th
 			results_data glaze_results{};
 
 #if !defined(ASAN_ENABLED)
-			//simdjson_results = json_test_helper<json_library::simdjson, type, test_data_type, minified, iterations, test_name>::run(json_data_new);
+			simdjson_results = json_test_helper<json_library::simdjson, type, test_data_type, minified, iterations, test_name>::run(json_data_new);
 			if constexpr (!std::is_same_v<test_data_type, partial_test<partial_test_struct>> && !std::is_same_v<test_data_type, twitter_partial_message>) {
 				glaze_results = json_test_helper<json_library::glaze, type, test_data_type, minified, iterations, test_name>::run(json_data_new);
 				json_results.results.emplace_back(glaze_results);
@@ -934,7 +935,7 @@ In contrast, hash-based solutions offer a viable alternative by circumventing th
 			results_data simdjson_results{};
 			results_data glaze_results{};
 #if !defined(ASAN_ENABLED)
-			//simdjson_results = json_test_helper<json_library::simdjson, test_type::minify, std::string, false, iterations, test_name>::run(json_data_new);
+			simdjson_results = json_test_helper<json_library::simdjson, test_type::minify, std::string, false, iterations, test_name>::run(json_data_new);
 			glaze_results	 = json_test_helper<json_library::glaze, test_type::minify, std::string, false, iterations, test_name>::run(json_data_new);
 #endif
 			jsonifier_results = json_test_helper<json_library::jsonifier, test_type::minify, std::string, false, iterations, test_name>::run(json_data_new);

CMake/JsonifierDetectArchitecture.cmake

@@ -71,7 +71,7 @@ math(EXPR INSTRUCTION_PRESENT512 "( ${JSONIFIER_CPU_INSTRUCTIONS_NUMERIC} & 0x40
 if(INSTRUCTION_PRESENT512)
     math(EXPR JSONIFIER_CPU_INSTRUCTIONS "${JSONIFIER_CPU_INSTRUCTIONS} | 1 << 6" OUTPUT_FORMAT DECIMAL)
 elseif(INSTRUCTION_PRESENT256)
-    math(EXPR JSONIFIER_CPU_INSTRUCTIONS "${JSONIFIER_CPU_INSTRUCTIONS} | 1 << 5" OUTPUT_FORMAT DECIMAL)
+    math(EXPR JSONIFIER_CPU_INSTRUCTIONS "${JSONIFIER_CPU_INSTRUCTIONS} | 1 << 0" OUTPUT_FORMAT DECIMAL)
 elseif(INSTRUCTION_PRESENT128)
     math(EXPR JSONIFIER_CPU_INSTRUCTIONS "${JSONIFIER_CPU_INSTRUCTIONS} | 1 << 4" OUTPUT_FORMAT DECIMAL)
 endif() 

Include/jsonifier/Containers/Tuple.hpp

@@ -189,16 +189,6 @@ namespace jsonifier::internal {
 		}
 	};
 
-	enum class operation_types {
-		eq,
-		neq,
-		ss,
-		lt,
-		lte,
-		gt,
-		gte,
-	};
-
 	template<typename index_sequence, typename operation_type> struct comparison_op;
 
 	template<uint64_t... indices> struct comparison_op<std::integer_sequence<uint64_t, indices...>, eq_op> {
@@ -403,7 +393,7 @@ namespace jsonifier::internal {
 		using result_type	   = join_tuples_t<list_types...>;
 		using lists_tuple_type = type_list_t<list_types*...>;
 
-		static consteval uint64_t get_map_values() {
+		static consteval auto get_map_values() {
 			if constexpr (total > 0) {
 				struct tuple_cat_index_map {
 					uint64_t list_idx[total]{};
@@ -420,14 +410,14 @@ namespace jsonifier::internal {
 				return m;
 			} else {
 				struct tuple_cat_index_map {
-					uint64_t list_idx[1]{};
-					uint64_t local_idx[1]{};
+					uint64_t list_idx[2]{};
+					uint64_t local_idx[2]{};
 				};
-				return 0ULL;
+				return tuple_cat_index_map{};
 			}
 		}
 
-		static constexpr uint64_t map{ get_map_values() };
+		static constexpr auto map{ get_map_values() };
 
 		template<uint64_t index, typename list_type> JSONIFIER_INLINE static constexpr decltype(auto) get_individual_element(list_type&& list) {
 			auto* tuple_ptr = list[tag<map.list_idx[index]>{}];
@@ -454,8 +444,8 @@ namespace jsonifier::internal {
 
 namespace std {
 
-	template<size_t I, typename... Ts> struct tuple_element<I, std::tuple<Ts...>> {
-		using type = std::tuple_element_t<I, std::tuple<Ts...>>;
+	template<size_t I, typename... Ts> struct tuple_element<I, jsonifier::internal::tuple<Ts...>> {
+		using type = jsonifier::internal::tuple_element_t<I, jsonifier::internal::tuple<Ts...>>;
 	};
 
 	template<size_t I, typename  Ts> JSONIFIER_INLINE constexpr decltype(auto) get(Ts&& t) noexcept {