Merge pull request #249 from AlchemyViewer/rye/broken-rendering

Revert SIMD uuid to fix broken rendering

Author: RyeMutt

indra/llcommon/lluuid.cpp

@@ -935,7 +935,6 @@ void LLUUID::setNull()
     word[3] = 0;
 }
 
-#if !defined(LL_X86) && !defined(LL_ARM64)
 
 // Compare
 bool LLUUID::operator==(const LLUUID& rhs) const
@@ -988,6 +987,28 @@ bool LLUUID::isNull() const
     return !(word[0] | word[1] | word[2] | word[3]);
 }
 
+LLUUID::LLUUID(const char* in_string)
+{
+    if (!in_string || in_string[0] == 0)
+    {
+        setNull();
+        return;
+    }
+
+    set(in_string);
+}
+
+LLUUID::LLUUID(const std::string& in_string)
+{
+    if (in_string.empty())
+    {
+        setNull();
+        return;
+    }
+
+    set(in_string);
+}
+
 // IW: DON'T "optimize" these w/ U32s or you'll scoogie the sort order
 // IW: this will make me very sad
 bool LLUUID::operator<(const LLUUID& rhs) const
@@ -1016,30 +1037,6 @@ bool LLUUID::operator>(const LLUUID& rhs) const
     return (mData[UUID_BYTES - 1] > rhs.mData[UUID_BYTES - 1]);
 }
 
-#endif
-
-LLUUID::LLUUID(const char* in_string)
-{
-    if (!in_string || in_string[0] == 0)
-    {
-        setNull();
-        return;
-    }
-
-    set(in_string);
-}
-
-LLUUID::LLUUID(const std::string& in_string)
-{
-    if (in_string.empty())
-    {
-        setNull();
-        return;
-    }
-
-    set(in_string);
-}
-
 U16 LLUUID::getCRC16() const
 {
     // A UUID is 16 bytes, or 8 shorts.
@@ -1058,10 +1055,6 @@ U16 LLUUID::getCRC16() const
 
 U32 LLUUID::getCRC32() const
 {
-    U32 ret = 0;
-    for(U32 i = 0;i < 4;++i)
-    {
-        ret += (mData[i*4]) | (mData[i*4+1]) << 8 | (mData[i*4+2]) << 16 | (mData[i*4+3]) << 24;
-    }
-    return ret;
+    U32* tmp = (U32*)mData;
+    return tmp[0] + tmp[1] + tmp[2] + tmp[3];
 }

indra/llcommon/lluuid.h

@@ -26,20 +26,13 @@
 #ifndef LL_LLUUID_H
 #define LL_LLUUID_H
 
-#include "llpreprocessor.h"
-
 #include <iostream>
 #include <set>
 #include <vector>
 #include "stdtypes.h"
+#include "llpreprocessor.h"
 #include <boost/functional/hash.hpp>
 
-#if LL_ARM64
-#include "sse2neon.h"
-#elif LL_X86
-#include <immintrin.h>
-#endif
-
 class LLMutex;
 
 const S32 UUID_BYTES = 16;
@@ -83,15 +76,6 @@ class LL_COMMON_API LLUUID
     //
     // ACCESSORS
     //
-
-    // BEGIN BOOST
-    // Contains code from the Boost Library with license below.
-    /*
-     *            Copyright Andrey Semashev 2013.
-     * Distributed under the Boost Software License, Version 1.0.
-     *    (See accompanying file LICENSE_1_0.txt or copy at
-     *          http://www.boost.org/LICENSE_1_0.txt)
-     */
 private:
     // Derived from Boost.UUID hash impl
     inline std::uint64_t hash_mix_mx( std::uint64_t x ) const noexcept
@@ -135,97 +119,17 @@ class LL_COMMON_API LLUUID
         return id.getHash();
     }
 
-#if defined(LL_X86) || defined(LL_ARM64)
-    LL_FORCE_INLINE __m128i load_unaligned_si128(const U8* p) const
-    {
-        return _mm_loadu_si128(reinterpret_cast<const __m128i*>(p));
-    }
-
-    bool isNull() const // Faster than comparing to LLUUID::null.
-    {
-        __m128i mm = load_unaligned_si128(mData);
-#if defined(__AVX2__) || defined(__SSE4_1__) || defined(LL_ARM64)
-        return _mm_test_all_zeros(mm, mm) != 0;
-#else
-        mm = _mm_cmpeq_epi32(mm, _mm_setzero_si128());
-        return _mm_movemask_epi8(mm) == 0xFFFF;
-#endif
-    }
-
-    bool notNull() const // Faster than comparing to LLUUID::null.
-    {
-        return !isNull();
-    }
+    bool    isNull() const;         // Faster than comparing to LLUUID::null.
+    bool    notNull() const;        // Faster than comparing to LLUUID::null.
     // JC: This is dangerous.  It allows UUIDs to be cast automatically
     // to integers, among other things.  Use isNull() or notNull().
     //      operator bool() const;
 
-    bool operator==(const LLUUID& rhs) const
-    {
-        __m128i mm_left = load_unaligned_si128(mData);
-        __m128i mm_right = load_unaligned_si128(rhs.mData);
-
-#if defined(__AVX2__) || defined(__SSE4_1__) || defined(LL_ARM64)
-        __m128i mm = _mm_xor_si128(mm_left, mm_right);
-        return _mm_test_all_zeros(mm, mm) != 0;
-#else
-        __m128i mm_cmp = _mm_cmpeq_epi32(mm_left, mm_right);
-        return _mm_movemask_epi8(mm_cmp) == 0xFFFF;
-#endif
-    }
-
-    bool operator!=(const LLUUID& rhs) const
-    {
-        return !((*this) == rhs);
-    }
-
-    bool operator<(const LLUUID& rhs) const
-    {
-        __m128i mm_left = load_unaligned_si128(mData);
-        __m128i mm_right = load_unaligned_si128(rhs.mData);
-
-        // To emulate lexicographical_compare behavior we have to perform two comparisons - the forward and reverse one.
-        // Then we know which bytes are equivalent and which ones are different, and for those different the comparison results
-        // will be opposite. Then we'll be able to find the first differing comparison result (for both forward and reverse ways),
-        // and depending on which way it is for, this will be the result of the operation. There are a few notes to consider:
-        //
-        // 1. Due to little endian byte order the first bytes go into the lower part of the xmm registers,
-        //    so the comparison results in the least significant bits will actually be the most signigicant for the final operation result.
-        //    This means we have to determine which of the comparison results have the least significant bit on, and this is achieved with
-        //    the "(x - 1) ^ x" trick.
-        // 2. Because there is only signed comparison in SSE/AVX, we have to invert byte comparison results whenever signs of the corresponding
-        //    bytes are different. I.e. in signed comparison it's -1 < 1, but in unsigned it is the opposite (255 > 1). To do that we XOR left and right,
-        //    making the most significant bit of each byte 1 if the signs are different, and later apply this mask with another XOR to the comparison results.
-        // 3. pcmpgtw compares for "greater" relation, so we swap the arguments to get what we need.
-
-        const __m128i mm_signs_mask = _mm_xor_si128(mm_left, mm_right);
-
-        __m128i mm_cmp = _mm_cmpgt_epi8(mm_right, mm_left), mm_rcmp = _mm_cmpgt_epi8(mm_left, mm_right);
-
-        mm_cmp = _mm_xor_si128(mm_signs_mask, mm_cmp);
-        mm_rcmp = _mm_xor_si128(mm_signs_mask, mm_rcmp);
 
-        uint32_t cmp = static_cast<uint32_t>(_mm_movemask_epi8(mm_cmp)), rcmp = static_cast<uint32_t>(_mm_movemask_epi8(mm_rcmp));
-
-        cmp = (cmp - 1u) ^ cmp;
-        rcmp = (rcmp - 1u) ^ rcmp;
-
-        return cmp < rcmp;
-    }
-
-    bool operator>(const LLUUID& rhs) const
-    {
-        return rhs < (*this);
-    }
-    // END BOOST
-#else // Non-intrinsic path
-    bool    isNull() const;         // Faster than comparing to LLUUID::null.
-    bool    notNull() const;        // Faster than comparing to LLUUID::null.
-    bool    operator==(const LLUUID& rhs) const;
-    bool    operator!=(const LLUUID& rhs) const;
-    bool    operator<(const LLUUID& rhs) const;
-    bool    operator>(const LLUUID& rhs) const;
-#endif
+    bool    operator==(const LLUUID &rhs) const;
+    bool    operator!=(const LLUUID &rhs) const;
+    bool    operator<(const LLUUID &rhs) const;
+    bool    operator>(const LLUUID &rhs) const;
 
     // xor functions. Useful since any two random uuids xored together
     // will yield a determinate third random unique id that can be

indra/llprimitive/llmaterialid.cpp

@@ -61,8 +61,6 @@ LLMaterialID::LLMaterialID(const LLUUID& lluid)
     set(lluid.mData);
 }
 
-#if !defined(LL_X86) && !defined(LL_ARM64)
-
 bool LLMaterialID::operator == (const LLMaterialID& pOtherMaterialID) const
 {
     return (compareToOtherMaterialID(pOtherMaterialID) == 0);
@@ -98,8 +96,6 @@ bool LLMaterialID::isNull() const
     return (compareToOtherMaterialID(LLMaterialID::null) == 0);
 }
 
-#endif
-
 const U8* LLMaterialID::get() const
 {
     return mID;
@@ -138,7 +134,7 @@ std::string LLMaterialID::asString() const
         {
             materialIDString += "-";
         }
-        const U32* value = reinterpret_cast<const U32*>(&get()[i * sizeof(U32)]);
+        const U32 *value = reinterpret_cast<const U32*>(&get()[i * sizeof(U32)]);
         materialIDString += llformat("%08x", *value);
     }
     return materialIDString;
@@ -163,8 +159,6 @@ void LLMaterialID::parseFromBinary (const LLSD::Binary& pMaterialID)
     memcpy(mID, &pMaterialID[0], MATERIAL_ID_SIZE * sizeof(U8));
 }
 
-#if !defined(LL_X86) && !defined(LL_ARM64)
-
 int LLMaterialID::compareToOtherMaterialID(const LLMaterialID& pOtherMaterialID) const
 {
     int retVal = 0;
@@ -178,5 +172,3 @@ int LLMaterialID::compareToOtherMaterialID(const LLMaterialID& pOtherMaterialID)
 
     return retVal;
 }
-
-#endif