remove: code duplications

Author: Requiem

src/vmaware.hpp

@@ -1394,155 +1394,6 @@ struct VM {
         }
 
 
-        // we want to precompute hashes at compile time for C++11 and later, so we need to match the hardware _mm_crc32_u8
-        // it is based on CRC32-C (Castagnoli) polynomial
-        struct constexpr_hash {
-            static constexpr u32 crc32_bits(u32 crc, int bits) {
-                return (bits == 0) ? crc :
-                    crc32_bits((crc >> 1) ^ ((crc & 1) ? 0x82F63B78u : 0), bits - 1);
-            }
-            static constexpr u32 crc32_str(const char* s, u32 crc) {
-                return (*s == '\0') ? crc :
-                    crc32_str(s + 1, crc32_bits(crc ^ static_cast<u8>(*s), 8));
-            }
-            static constexpr u32 get(const char* s) {
-                return crc32_str(s, 0);
-            }
-        };
-
-
-        // this forces the compiler to calculate the hash when initializing the array while staying C++11 compatible
-        struct thread_entry {
-            u32 hash;
-            u32 threads;
-            constexpr thread_entry(const char* m, u32 t) : hash(constexpr_hash::get(m)), threads(t) {}
-        };
-
-
-        struct hasher {
-            static u32 crc32_sw(u32 crc, char data) {
-                crc ^= static_cast<u8>(data);
-                for (int i = 0; i < 8; ++i)
-                    crc = (crc >> 1) ^ ((crc & 1) ? 0x82F63B78u : 0);
-                return crc;
-            }
-
-            #if (CLANG || GCC)
-                __attribute__((__target__("crc32")))
-            #endif
-            static u32 crc32_hw(u32 crc, char data) {
-                return _mm_crc32_u8(crc, static_cast<u8>(data));
-            }
-
-            using hashfc = u32(*)(u32, char);
-
-            static hashfc get() {
-                // yes, vmaware runs on dinosaur cpus without sse4.2 pretty often
-                i32 regs[4];
-                cpu::cpuid(regs, 1);
-                const bool has_sse42 = (regs[2] & (1 << 20)) != 0;
-
-                return has_sse42 ? crc32_hw : crc32_sw;
-            }
-        };
-
-
-        static void lookup(
-            bool &found, 
-            const char* str, 
-            const thread_entry* thread_database,
-            const std::size_t& db_size,
-            std::size_t best_len,
-            const u8 max_token_length,
-            u32* z_series_threads,
-            u32& expected_threads,
-            const bool is_amd = false
-        ) {
-            const hasher::hashfc hash_func = util::hasher::get();
-
-            for (size_t i = 0; str[i] != '\0'; ) {
-                char c = str[i];
-                if (!((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))) {
-                    i++;
-                    continue;
-                }
-
-                u32 current_hash = 0;
-                size_t current_len = 0;
-                size_t j = i;
-
-                while (true) {
-                    char k = str[j];
-                    const bool is_valid = (k >= '0' && k <= '9') ||
-                        (k >= 'A' && k <= 'Z') ||
-                        (k >= 'a' && k <= 'z') ||
-                        (k == '-');  // models have hyphen
-                    if (!is_valid) break;
-
-                    if (current_len >= max_token_length) {
-                        while (str[j] != '\0' && str[j] != ' ') j++; // fast forward to space/null
-                        break;
-                    }
-
-                    if (is_amd) {
-                        // convert to lowercase on-the-fly to match compile-time keys
-                        if (k >= 'A' && k <= 'Z') k += 32;
-                    }
-
-                    /*
-                       models are usually 8 or more bytes long, i.e. i9-10900K
-                       so imagine we want to use u64, you hash the first 8 bytes i9-10900
-                       but then you are left with K. You have to handle the tail
-                       fetching 8 bytes would include the characters after the token, corrupting the hash
-                       so a byte-by-byte loop is the most optimal choice here
-                    */
-
-                    // since this technique is cross-platform, we cannot use a standard C++ try-catch block to catch a missing CPU instruction
-                    // we could use preprocessor directives and add an exception handler (VEH/SEH or SIGHANDLER) but nah
-                    current_hash = hash_func(current_hash, k);
-                    current_len++;
-                    j++;
-
-                    // boundary check, only verify match if the token has ended (next char is not alphanumeric)
-                    const char next = str[j];
-                    const bool next_is_alnum = (next >= '0' && next <= '9') ||
-                        (next >= 'A' && next <= 'Z') ||
-                        (next >= 'a' && next <= 'z');
-
-                    if (!next_is_alnum) {
-                        // Check specific Z1 Extreme token
-                        // Hash for "extreme" (CRC32-C) is 0x3D09D5B4
-                        if (
-                            is_amd && 
-                            (z_series_threads != nullptr) && 
-                            (current_hash == 0x3D09D5B4)
-                        ) { 
-                            *z_series_threads = 16; 
-                        }
-
-                        // since it's a contiguous block of integers in .rodata/.rdata, this is extremely fast
-                        for (std::size_t i = 0; i < db_size; ++i) {
-                            if (
-                                (thread_database[i].hash == current_hash) &&
-                                (current_len > best_len) 
-                            ) {
-                                best_len = current_len;
-                                expected_threads = thread_database[i].threads;
-                                found = true;
-                                
-                                // on intel, since hashing implies uniqueness in this dataset, you might say we could break 
-                                // here, but we continue to ensure we find the longest substring match if overlaps exist,
-                                // so like it finds both "i9-11900" and "i9-11900K" i.e.
-                            }
-                        }
-                    }
-                }
-                i = j;
-            }
-        }
-
-
-
         // wrapper for std::make_unique because it's not available for C++11
         template<typename T, typename... Args>
         [[nodiscard]] static std::unique_ptr<T> make_unique(Args&&... args) {