hash structure clean up

Change-Id: Ifc69fd8e14c399eac467b52398d88bfa53640daf

Author: fftzeng

IGC/common/LLVMUtils.cpp

@@ -135,7 +135,7 @@ IGCPassManager::~IGCPassManager()
 
 void DumpLLVMIR(IGC::CodeGenContext* pContext, const char* dumpName)
 {
-    SetCurrentDebugHash(pContext->hash.asmHash.value);
+    SetCurrentDebugHash(pContext->hash.asmHash);
     if (IGC_IS_FLAG_ENABLED(DumpLLVMIR))
     {
         pContext->getMetaDataUtils()->save(*pContext->getLLVMContext());

IGC/common/Types.hpp

@@ -31,62 +31,29 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "common/debug/Debug.hpp"
 
 // Forward declarations
-class AsmHash;
-class NosHash;
 class ShaderHash;
 namespace USC
 {
     struct ShaderD3D;
 }
 
 
-class AsmHash
-{
-public:
-    AsmHash()
-        : value(0)
-    {}
-    QWORD value;
-};
-
-class NosHash
-{
-public:
-    NosHash()
-        : value(0)
-    {}
-    QWORD value;
-};
-
-class PsoHash
-{
-public:
-    PsoHash()
-        : value(0)
-    {}
-
-    PsoHash(QWORD hash)
-        : value(hash)
-    {}
-
-    QWORD value;
-};
 
 class ShaderHash
 {
 public:
     ShaderHash()
-        : asmHash()
-        , nosHash()
-        , psoHash()
+        : asmHash(0)
+        , nosHash(0)
+        , psoHash(0)
     {}
-    QWORD getAsmHash() const { return asmHash.value; }
-    QWORD getNosHash() const { return nosHash.value; }
-    QWORD getPsoHash() const { return psoHash.value; }
+    QWORD getAsmHash() const { return asmHash; }
+    QWORD getNosHash() const { return nosHash; }
+    QWORD getPsoHash() const { return psoHash; }
 
-    AsmHash asmHash;
-    NosHash nosHash;
-    PsoHash psoHash;
+    QWORD asmHash;
+    QWORD nosHash;
+    QWORD psoHash;
 };
 
 enum class SIMDMode : unsigned char

IGC/common/debug/Dump.cpp

@@ -228,45 +228,45 @@ std::string DumpName::AbsolutePath(OutputFolderName folder) const
     {
 
         if (m_type.hasValue() && IGC_IS_FLAG_ENABLED(EnableShaderNumbering)) {
-            bool increment = shaderHashMap.insert({ m_hash->asmHash.value, shaderNum }).second;
+            bool increment = shaderHashMap.insert({ m_hash->asmHash, shaderNum }).second;
             //Need to serialize access to the shaderNum counter in case different threads need to dump the same shader at once.
             hashMapLock.lock();
             if (increment) shaderNum++;
             hashMapLock.unlock();
             ss << "_"
-               << shaderHashMap[m_hash->asmHash.value]
+               << shaderHashMap[m_hash->asmHash]
                << "_";
         }
 
         ss << (underscore ? "_" : "")
             << "asm"
             << std::hex
             << std::setfill('0')
-            << std::setw(sizeof(m_hash->asmHash.value) * CHAR_BIT / 4)
-            << m_hash->asmHash.value
+            << std::setw(sizeof(m_hash->asmHash) * CHAR_BIT / 4)
+            << m_hash->asmHash
             << std::dec
             << std::setfill(' ');
 
-        if (m_hash->nosHash.value != 0)
+        if (m_hash->nosHash != 0)
         {
             ss << "_"
                << "nos"
                << std::hex
                << std::setfill('0')
-               << std::setw(sizeof(m_hash->nosHash.value) * CHAR_BIT / 4)
-               << m_hash->nosHash.value
+               << std::setw(sizeof(m_hash->nosHash) * CHAR_BIT / 4)
+               << m_hash->nosHash
                << std::dec
                << std::setfill(' ');
         }
 
-        if (m_hash->psoHash.value != 0)
+        if (m_hash->psoHash != 0)
         {
             ss << "_"
                 << "pso"
                 << std::hex
                 << std::setfill('0')
-                << std::setw(sizeof(m_hash->psoHash.value) * CHAR_BIT / 4)
-                << m_hash->psoHash.value
+                << std::setw(sizeof(m_hash->psoHash) * CHAR_BIT / 4)
+                << m_hash->psoHash
                 << std::dec
                 << std::setfill(' ');
         }
@@ -614,41 +614,19 @@ void PrintDebugMsg(
 #endif
 }
 
-
-AsmHash AsmHashOCL(const UINT* pShaderCode, size_t size)
-{
-    AsmHash hash;
-    hash.value = iSTD::Hash(reinterpret_cast<const DWORD*>(pShaderCode), int_cast<DWORD>(size));
-    return hash;
-}
-
 ShaderHash ShaderHashOCL(const UINT* pShaderCode, size_t size)
 {
     ShaderHash hash;
-    hash.asmHash = AsmHashOCL(pShaderCode, size);
-    hash.nosHash = NosHash();
+    hash.asmHash = iSTD::Hash(reinterpret_cast<const DWORD*>(pShaderCode), int_cast<DWORD>(size));
+    hash.nosHash = 0;
     return hash;
 }
 
-AsmHash AsmHashOGL(QWORD hash)
-{
-    AsmHash asmHash;
-    asmHash.value = hash;
-    return asmHash;
-}
-
-NosHash NosHashOGL(QWORD hash)
-{
-    NosHash nosHash;
-    nosHash.value = hash;
-    return nosHash;
-}
-
 ShaderHash ShaderHashOGL(QWORD glslHash, QWORD nosHash)
 {
     ShaderHash shaderHash;
-    shaderHash.asmHash = AsmHashOGL(glslHash);
-    shaderHash.nosHash = NosHashOGL(nosHash);
+    shaderHash.asmHash = glslHash;
+    shaderHash.nosHash = nosHash;
     return shaderHash;
 }
 

IGC/common/debug/Dump.hpp

@@ -174,11 +174,8 @@ inline FILE* OpenDumpFile(
     return fp;
 }
 
-AsmHash AsmHashOCL(const UINT* pShaderCode, size_t size);
 ShaderHash ShaderHashOCL(const UINT* pShaderCode, size_t size);
 
-AsmHash    AsmHashOGL(QWORD hash);
-NosHash    NosHashOGL(QWORD hash);
 ShaderHash ShaderHashOGL(QWORD glslHash, QWORD nosHash);
 
 } // namespace Debug