Add dual-instance aliases of single-instance variables

Add support for creating dual-instance aliases of single-instance
variables to allow simd32 variables that are consecutive in GRFs.

Author: mmerecki

IGC/Compiler/CISACodeGen/CISABuilder.cpp

@@ -5870,6 +5870,30 @@ namespace IGC
                 }
             }
         }
+        else if (var->GetSingleInstanceAlias() != NULL)
+        {
+            CVariable* singleInstanceVar = var->GetSingleInstanceAlias();
+            IGC_ASSERT(singleInstanceVar->GetNumberInstance() == 1);
+            IGC_ASSERT((singleInstanceVar->GetNumberElement() % var->GetNumberInstance()) == 0);
+            IGC_ASSERT(singleInstanceVar->GetNumberElement() == var->GetNumberElement() * var->GetNumberInstance());
+            for (uint i = 0; i < var->GetNumberInstance(); i++)
+            {
+                // Multi-instance aliases use VISA offset mechanism for the
+                // second instance.
+                int instanceOffset =
+                    i * var->GetNumberElement() *
+                    CEncoder::GetCISADataTypeSize(var->GetType());
+
+                V(vKernel->CreateVISAGenVar(
+                    var->visaGenVariable[i],
+                    var->getVisaCString(),
+                    var->GetNumberElement(),
+                    var->GetType(),
+                    GetVISAAlign(singleInstanceVar), // Use parent's align as we create an alias of the parent.
+                    singleInstanceVar->visaGenVariable[0],
+                    instanceOffset));
+            }
+        }
         else
         {
             uint num_elts = var->GetNumberElement();

IGC/Compiler/CISACodeGen/CShader.cpp

@@ -3855,6 +3855,19 @@ CVariable* CShader::GetNewAlias(
     return alias;
 }
 
+// Create a multi-instance alias of a single-instance variable.
+CVariable* CShader::GetNewAlias(CVariable* var, uint16_t numInstances)
+{
+    IGC_ASSERT_MESSAGE(false == var->IsImmediate(), "Trying to create an alias of an immediate");
+    IGC_ASSERT(var->GetNumberInstance() == 1);
+    IGC_ASSERT(var->GetSingleInstanceAlias() == nullptr);
+    IGC_ASSERT(var->GetAlias() == nullptr);
+    IGC_ASSERT(numInstances > 1);
+    CVariable* alias = new (Allocator)CVariable(var, numInstances);
+    encoder.CreateVISAVar(alias);
+    return alias;
+}
+
 // createAliasIfNeeded() returns the Var that is either BaseVar or
 // its alias of the same size.
 //

IGC/Compiler/CISACodeGen/CVariable.cpp

@@ -47,6 +47,7 @@ CVariable::CVariable(
     const CName &name) :
     m_immediateValue(0),
     m_alias(nullptr),
+    m_singleInstanceAlias(nullptr),
     m_nbElement(nbElement),
     m_aliasOffset(0),
     m_numberOfInstance(int_cast<uint8_t>(numberOfInstance)),
@@ -100,6 +101,7 @@ CVariable::CVariable(
     UniformArgWrap uniform) :
     m_immediateValue(0),
     m_alias(var),
+    m_singleInstanceAlias(var->m_singleInstanceAlias),
     m_aliasOffset(offset),
     m_numberOfInstance(var->m_numberOfInstance),
     m_type(type),
@@ -134,12 +136,43 @@ CVariable::CVariable(
     IGC_ASSERT_MESSAGE(var->m_varType == EVARTYPE_GENERAL, "only general variable can have alias");
 }
 
+/// CVariable constructor for multi-instance alias of a single-instance variable
+///
+CVariable::CVariable(
+    CVariable* var,
+    uint16_t numInstances) :
+    m_immediateValue(0),
+    m_alias(nullptr),
+    m_singleInstanceAlias(var),
+    m_aliasOffset(0),
+    m_nbElement(var->m_nbElement / numInstances),
+    m_numberOfInstance(numInstances),
+    m_type(var->m_type),
+    m_varType(EVARTYPE_GENERAL),
+    m_align(var->m_align),
+    m_uniform(var->m_uniform),
+    m_isImmediate(false),
+    m_subspanUse(var->m_subspanUse),
+    m_uniformVector(false),
+    m_undef(false),
+    m_isUnpacked(false),
+    m_llvmName(var->m_llvmName)
+{
+    IGC_ASSERT(var->m_varType == EVARTYPE_GENERAL);
+    IGC_ASSERT(var->GetNumberInstance() == 1);
+    IGC_ASSERT(var->GetSingleInstanceAlias() == nullptr);
+    IGC_ASSERT(var->GetAlias() == nullptr);
+    IGC_ASSERT(numInstances > 1);
+    IGC_ASSERT((var->m_nbElement % numInstances) == 0);
+}
+
 /// CVariable constructor, for immediate
 ///
 CVariable::CVariable(
     uint64_t immediate, VISA_Type type, uint16_t nbElem, bool undef) :
     m_immediateValue(immediate),
     m_alias(nullptr),
+    m_singleInstanceAlias(nullptr),
     m_aliasOffset(0),
     m_nbElement(nbElem),
     m_numberOfInstance(1),

IGC/Compiler/CISACodeGen/CVariable.hpp

@@ -174,6 +174,11 @@ namespace IGC {
             CVariable* var, VISA_Type type, uint16_t offset,
             uint16_t numElements, UniformArgWrap uniform);
 
+        // Create a multi-instance alias of single-instance variable. Instances
+        // of the alias variable point to consecutive sub-regions of the parent
+        // variable.
+        CVariable(CVariable* var, uint16_t numInstances);
+
         // general variable
         CVariable(
             uint16_t nbElement,
@@ -189,6 +194,7 @@ namespace IGC {
         CVariable(const CVariable& V, const CName& name = CName()) :
             m_immediateValue(V.m_immediateValue),
             m_alias(nullptr),
+            m_singleInstanceAlias(nullptr),
             m_nbElement(V.m_nbElement),
             m_aliasOffset(0),
             m_numberOfInstance(V.m_numberOfInstance),
@@ -225,6 +231,7 @@ namespace IGC {
         uint GetElemSize() const { return GetCISADataTypeSize(m_type); }
 
         CVariable* GetAlias() const { return m_alias; }
+        CVariable* GetSingleInstanceAlias() const { return m_singleInstanceAlias; }
         uint16_t GetAliasOffset() const { return m_aliasOffset; }
         VISA_Type GetType() const { return m_type; }
         e_varType GetVarType() const { return m_varType; }
@@ -342,6 +349,7 @@ namespace IGC {
         const uint64_t      m_immediateValue;
 
         CVariable*          m_alias;
+        CVariable*          m_singleInstanceAlias;
 
         uint16_t            m_nbElement;
         uint16_t            m_aliasOffset;

IGC/Compiler/CISACodeGen/ShaderCodeGen.hpp

@@ -210,6 +210,8 @@ class CShader
     CVariable* GetNewVector(llvm::Value* val, e_alignment preferredAlign = EALIGN_AUTO);
     CVariable* GetNewAlias(CVariable* var, VISA_Type type, uint16_t offset, uint16_t numElements);
     CVariable* GetNewAlias(CVariable* var, VISA_Type type, uint16_t offset, uint16_t numElements, bool uniform);
+    // Create a multi-instance alias of a single-instance variable.
+    CVariable* GetNewAlias(CVariable* var, uint16_t numInstances);
 
     // If BaseVar's type matches V's, return BaseVar; otherwise, create an new
     // alias CVariable to BaseVar. The newly-created alias CVariable's size