WorkgroupWalkOrder

Change-Id: I923d2eb87804606ac85dfc1345410cb6340bce64

Author: gkluczek

IGC/AdaptorOCL/OCL/KernelAnnotations.hpp

@@ -292,6 +292,7 @@ struct ExecutionEnivronment
     bool   CompiledForGreaterThan4GBBuffers           = false;
     DWORD  FixedWorkgroupSize[3];
     DWORD  NumGRFRequired;
+	DWORD  WorkgroupWalkOrder[3] = { 3, 3, 3 };
 };
 
 struct KernelTypeProgramBinaryInfo

IGC/AdaptorOCL/OCL/sp/sp_g8.cpp

@@ -1925,6 +1925,11 @@ RETVAL CGen8OpenCLStateProcessor::CreatePatchList(
             patch.RequiredWorkGroupSizeZ = annotations.m_executionEnivronment.FixedWorkgroupSize[2];
         }
 
+		patch.WorkgroupWalkOrderDims = 0;
+		patch.WorkgroupWalkOrderDims |= annotations.m_executionEnivronment.WorkgroupWalkOrder[0];
+		patch.WorkgroupWalkOrderDims |= annotations.m_executionEnivronment.WorkgroupWalkOrder[1] << 2;
+		patch.WorkgroupWalkOrderDims |= annotations.m_executionEnivronment.WorkgroupWalkOrder[2] << 4;
+
         patch.CompiledSIMD32 = ( annotations.m_executionEnivronment.CompiledSIMDSize == 32 );
         patch.CompiledSIMD16 = ( annotations.m_executionEnivronment.CompiledSIMDSize == 16 );
         patch.CompiledSIMD8  = ( annotations.m_executionEnivronment.CompiledSIMDSize == 8 );

IGC/AdaptorOCL/ocl_igc_shared/executable_format/patch_list.h

@@ -34,7 +34,7 @@ Abstract:   Contains common patch structure definitions
 namespace iOpenCL
 {
 
-const uint32_t CURRENT_ICBE_VERSION = 1053;
+const uint32_t CURRENT_ICBE_VERSION = 1054;
 
 const uint32_t MAGIC_CL = 0x494E5443;      // 'I', 'N', 'T', 'C'
 const uint32_t INVALID_INDEX = 0xFFFFFFFF;

IGC/AdaptorOCL/ocl_igc_shared/executable_format/patch_shared.h

@@ -203,10 +203,11 @@ struct SPatchExecutionEnvironment :
     uint32_t    SubgroupIndependentForwardProgressRequired;
     uint32_t    CompiledForGreaterThan4GBBuffers;
     uint32_t    NumGRFRequired;
+	uint32_t    WorkgroupWalkOrderDims; // dim0 : [0 : 1]; dim1 : [2 : 3]; dim2 : [4 : 5]
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert(sizeof(SPatchExecutionEnvironment) == (80 + sizeof(SPatchItemHeader)), "The size of SPatchExecutionEnvironment is not what is expected");
+static_assert(sizeof(SPatchExecutionEnvironment) == (84 + sizeof(SPatchItemHeader)), "The size of SPatchExecutionEnvironment is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchString

IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp

@@ -438,6 +438,11 @@ void COpenCLKernel::CreateKernelAttributeInfo()
     {
         m_kernelInfo.m_kernelAttributeInfo += " " + getSubGroupSizeString(subGroupSize);
     }
+	WorkgroupWalkOrderMetaDataHandle workgroupWalkOrder = funcInfoMD->getWorkgroupWalkOrder();
+	if (workgroupWalkOrder->hasValue())
+	{
+		m_kernelInfo.m_kernelAttributeInfo += " " + getWorkgroupWalkOrderString(workgroupWalkOrder);
+	}
     ThreadGroupSizeMetaDataHandle threadGroupSize = funcInfoMD->getThreadGroupSize();
     if (threadGroupSize->hasValue())
     {
@@ -477,6 +482,15 @@ std::string COpenCLKernel::getSubGroupSizeString(SubGroupSizeMetaDataHandle& sub
     subTypeString += ")";
     return subTypeString;
 }
+std::string COpenCLKernel::getWorkgroupWalkOrderString(WorkgroupWalkOrderMetaDataHandle& workgroupWalkOrder)
+{
+	std::string subTypeString = "intel_reqd_workgroup_walk_order(";
+	subTypeString += utostr(workgroupWalkOrder->getDim0()) + ",";
+	subTypeString += utostr(workgroupWalkOrder->getDim1()) + ",";
+	subTypeString += utostr(workgroupWalkOrder->getDim2()) + ",";
+	subTypeString += ")";
+	return subTypeString;
+}
 std::string COpenCLKernel::getVecTypeHintString(VectorTypeHintMetaDataHandle& vecTypeHintInfo)
 {
     std::string vecTypeString = "vec_type_hint(";
@@ -1493,6 +1507,7 @@ void COpenCLKernel::FillKernel()
     FunctionInfoMetaDataHandle funcInfoMD = m_pMdUtils->getFunctionsInfoItem(entry);
     ThreadGroupSizeMetaDataHandle threadGroupSize = funcInfoMD->getThreadGroupSize();
     SubGroupSizeMetaDataHandle subGroupSize = funcInfoMD->getSubGroupSize();
+	WorkgroupWalkOrderMetaDataHandle workgroupWalkOrder = funcInfoMD->getWorkgroupWalkOrder();
     if(threadGroupSize->hasValue())
     {
         m_kernelInfo.m_executionEnivronment.HasFixedWorkGroupSize = true;
@@ -1504,6 +1519,13 @@ void COpenCLKernel::FillKernel()
     {
         m_kernelInfo.m_executionEnivronment.CompiledSIMDSize = subGroupSize->getSIMD_size();
     }
+
+	if (workgroupWalkOrder->hasValue())
+	{
+		m_kernelInfo.m_executionEnivronment.WorkgroupWalkOrder[0] = workgroupWalkOrder->getDim0();
+		m_kernelInfo.m_executionEnivronment.WorkgroupWalkOrder[1] = workgroupWalkOrder->getDim1();
+		m_kernelInfo.m_executionEnivronment.WorkgroupWalkOrder[2] = workgroupWalkOrder->getDim2();
+	}
 
     auto &FuncMap = m_Context->getModuleMetaData()->FuncMD;
     auto FuncIter = FuncMap.find(entry);

IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.hpp

@@ -96,6 +96,7 @@ class COpenCLKernel : public CShader
     std::string getVecTypeHintString(IGC::IGCMD::VectorTypeHintMetaDataHandle& vecTypeHintInfo);
     std::string getThreadGroupSizeString(IGC::IGCMD::ThreadGroupSizeMetaDataHandle& threadGroupSize, bool isHint);
     std::string getSubGroupSizeString(IGC::IGCMD::SubGroupSizeMetaDataHandle& subGroupSize);
+	std::string getWorkgroupWalkOrderString(IGC::IGCMD::WorkgroupWalkOrderMetaDataHandle& workgroupWalkOrder);
     // Create annotation for printf strings.
     void CreatePrintfStringAnnotations();
 

IGC/Compiler/MetaDataApi/MetaDataApi.cpp

@@ -1517,6 +1517,160 @@ llvm::Metadata* SubGroupSizeMetaData::getSIMD_sizeNode( const llvm::MDNode* pPar
     return pParentNode->getOperand(0 + offset).get();
 }
 
+
+
+///
+// Ctor - loads the WorkgroupWalkOrderMetaData from the given metadata node
+//
+WorkgroupWalkOrderMetaData::WorkgroupWalkOrderMetaData(const llvm::MDNode* pNode, bool hasId) :
+	_Mybase(pNode, hasId),
+	m_Dim0(getDim0Node(pNode)),
+	m_Dim1(getDim1Node(pNode)),
+	m_Dim2(getDim2Node(pNode)),
+	m_pNode(pNode)
+{}
+
+///
+// Default Ctor - creates the empty, not named SubGroupSizeMetaData object
+//
+WorkgroupWalkOrderMetaData::WorkgroupWalkOrderMetaData() :
+	m_pNode(NULL)
+{}
+
+///
+// Ctor - creates the empty, named SubGroupSizeMetaData object
+//
+WorkgroupWalkOrderMetaData::WorkgroupWalkOrderMetaData(const char* name) :
+	_Mybase(name),
+	m_pNode(NULL)
+{}
+
+bool WorkgroupWalkOrderMetaData::hasValue() const
+{
+	if (m_Dim0.hasValue())
+	{
+		return true;
+	}
+
+	if (m_Dim1.hasValue())
+	{
+		return true;
+	}
+
+	if (m_Dim2.hasValue())
+	{
+		return true;
+	}
+
+	return NULL != m_pNode || dirty();
+}
+
+///
+// Returns true if any of the SubGroupSizeMetaData`s members has changed
+bool WorkgroupWalkOrderMetaData::dirty() const
+{
+	if (m_Dim0.dirty())
+	{
+		return true;
+	}
+
+	if (m_Dim1.dirty())
+	{
+		return true;
+	}
+
+	if (m_Dim2.dirty())
+	{
+		return true;
+	}
+	return false;
+}
+
+///
+// Discards the changes done to the SubGroupSizeMetaData instance
+void WorkgroupWalkOrderMetaData::discardChanges()
+{
+	m_Dim0.discardChanges();
+	m_Dim1.discardChanges();
+	m_Dim2.discardChanges();
+}
+
+///
+// Generates the new MDNode hierarchy for the given structure
+llvm::Metadata* WorkgroupWalkOrderMetaData::generateNode(llvm::LLVMContext& context) const
+{
+	llvm::SmallVector<llvm::Metadata*, 5> args;
+
+	llvm::Metadata* pIDNode = _Mybase::generateNode(context);
+	if (NULL != pIDNode)
+	{
+		args.push_back(pIDNode);
+	}
+
+	args.push_back(m_Dim0.generateNode(context));
+	args.push_back(m_Dim1.generateNode(context));
+	args.push_back(m_Dim2.generateNode(context));
+
+	return llvm::MDNode::get(context, args);
+}
+
+///
+// Saves the structure changes to the given MDNode
+void WorkgroupWalkOrderMetaData::save(llvm::LLVMContext& context, llvm::MDNode* pNode) const
+{
+	assert(pNode && "The target node should be valid pointer");
+
+	// we assume that underlying metadata node has not changed under our foot
+	if (pNode == m_pNode && !dirty())
+	{
+		return;
+	}
+#if 0
+	// check that we could save the new information to the given node without regenerating it
+	if (!compatibleWith(pNode))
+	{
+		pNode->replaceAllUsesWith(generateNode(context));
+		return;
+	}
+#endif
+
+	m_Dim0.save(context, llvm::cast<llvm::MDNode>(getDim0Node(pNode)));
+	m_Dim1.save(context, llvm::cast<llvm::MDNode>(getDim1Node(pNode)));
+	m_Dim2.save(context, llvm::cast<llvm::MDNode>(getDim2Node(pNode)));
+}
+
+llvm::Metadata* WorkgroupWalkOrderMetaData::getDim0Node(const llvm::MDNode* pParentNode) const
+{
+	if (!pParentNode)
+	{
+		return NULL;
+	}
+
+	unsigned int offset = _Mybase::getStartIndex();
+	return pParentNode->getOperand(0 + offset).get();
+}
+
+llvm::Metadata* WorkgroupWalkOrderMetaData::getDim1Node(const llvm::MDNode* pParentNode) const
+{
+	if (!pParentNode)
+	{
+		return NULL;
+	}
+
+	unsigned int offset = _Mybase::getStartIndex();
+	return pParentNode->getOperand(1 + offset).get();
+}
+
+llvm::Metadata* WorkgroupWalkOrderMetaData::getDim2Node(const llvm::MDNode* pParentNode) const
+{
+	if (!pParentNode)
+	{
+		return NULL;
+	}
+
+	unsigned int offset = _Mybase::getStartIndex();
+	return pParentNode->getOperand(2 + offset).get();
+}
 
 
 ///
@@ -2242,6 +2396,7 @@ FunctionInfoMetaData::FunctionInfoMetaData(const llvm::MDNode* pNode, bool hasId
     m_ThreadGroupSize(ThreadGroupSizeMetaData::get(getThreadGroupSizeNode(pNode), true)),        
     m_ThreadGroupSizeHint(ThreadGroupSizeMetaData::get(getThreadGroupSizeHintNode(pNode), true)),        
     m_SubGroupSize(SubGroupSizeMetaData::get(getSubGroupSizeNode(pNode), true)),        
+	m_WorkgroupWalkOrder(WorkgroupWalkOrderMetaData::get(getWorkgroupWalkOrderNode(pNode), true)),
     m_LocalIDPresent(getLocalIDPresentNode(pNode)),        
     m_GroupIDPresent(getGroupIDPresentNode(pNode)),        
     m_GlobalOffsetPresent(getGlobalOffsetPresentNode(pNode)),        
@@ -2270,6 +2425,7 @@ FunctionInfoMetaData::FunctionInfoMetaData():    m_Type("function_type"),
     m_ThreadGroupSize(ThreadGroupSizeMetaDataHandle::ObjectType::get("thread_group_size")),        
     m_ThreadGroupSizeHint(ThreadGroupSizeMetaDataHandle::ObjectType::get("thread_group_size_hint")),        
     m_SubGroupSize(SubGroupSizeMetaDataHandle::ObjectType::get("sub_group_size")),        
+	m_WorkgroupWalkOrder(WorkgroupWalkOrderMetaDataHandle::ObjectType::get("intel_reqd_workgroup_walk_order")),
     m_LocalIDPresent("local_id_present"),        
     m_GroupIDPresent("group_id_present"),        
     m_GlobalOffsetPresent("global_offset_present"),        
@@ -2300,6 +2456,7 @@ FunctionInfoMetaData::FunctionInfoMetaData(const char* name):
     m_ThreadGroupSize(ThreadGroupSizeMetaDataHandle::ObjectType::get("thread_group_size")),        
     m_ThreadGroupSizeHint(ThreadGroupSizeMetaDataHandle::ObjectType::get("thread_group_size_hint")),        
     m_SubGroupSize(SubGroupSizeMetaDataHandle::ObjectType::get("sub_group_size")),        
+	m_WorkgroupWalkOrder(WorkgroupWalkOrderMetaDataHandle::ObjectType::get("intel_reqd_workgroup_walk_order")),
     m_LocalIDPresent("local_id_present"),        
     m_GroupIDPresent("group_id_present"),        
     m_GlobalOffsetPresent("global_offset_present"),        
@@ -2356,6 +2513,12 @@ bool FunctionInfoMetaData::hasValue() const
     {
         return true;
     }
+
+
+	if (m_WorkgroupWalkOrder->hasValue())
+	{
+		return true;
+	}
 
 
     if (m_LocalIDPresent.hasValue())
@@ -2482,7 +2645,11 @@ bool FunctionInfoMetaData::dirty() const
     if( m_SubGroupSize.dirty() )
     {
         return true;
-    }        
+    }   
+	if (m_WorkgroupWalkOrder.dirty())
+	{
+		return true;
+	}
     if( m_LocalIDPresent.dirty() )
     {
         return true;
@@ -2560,6 +2727,7 @@ void FunctionInfoMetaData::discardChanges()
     m_ThreadGroupSize.discardChanges();        
     m_ThreadGroupSizeHint.discardChanges();        
     m_SubGroupSize.discardChanges();        
+	m_WorkgroupWalkOrder.discardChanges();
     m_LocalIDPresent.discardChanges();        
     m_GroupIDPresent.discardChanges();        
     m_GlobalOffsetPresent.discardChanges();        
@@ -2617,6 +2785,11 @@ llvm::Metadata* FunctionInfoMetaData::generateNode(llvm::LLVMContext& context) c
         args.push_back(m_SubGroupSize.generateNode(context));
     }
 
+	if (m_WorkgroupWalkOrder->hasValue())
+	{
+		args.push_back(m_WorkgroupWalkOrder.generateNode(context));
+	}
+
     if (isLocalIDPresentHasValue())
     {
         args.push_back(m_LocalIDPresent.generateNode(context));
@@ -2731,6 +2904,7 @@ void FunctionInfoMetaData::save(llvm::LLVMContext& context, llvm::MDNode* pNode)
     m_ThreadGroupSize.save(context, llvm::cast<llvm::MDNode>(getThreadGroupSizeNode(pNode)));        
     m_ThreadGroupSizeHint.save(context, llvm::cast<llvm::MDNode>(getThreadGroupSizeHintNode(pNode)));        
     m_SubGroupSize.save(context, llvm::cast<llvm::MDNode>(getSubGroupSizeNode(pNode)));        
+	m_WorkgroupWalkOrder.save(context, llvm::cast<llvm::MDNode>(getSubGroupSizeNode(pNode)));
     m_LocalIDPresent.save(context, llvm::cast<llvm::MDNode>(getLocalIDPresentNode(pNode)));        
     m_GroupIDPresent.save(context, llvm::cast<llvm::MDNode>(getGroupIDPresentNode(pNode)));        
     m_GlobalOffsetPresent.save(context, llvm::cast<llvm::MDNode>(getGlobalOffsetPresentNode(pNode)));        
@@ -2857,6 +3031,24 @@ llvm::MDNode* FunctionInfoMetaData::getSubGroupSizeNode( const llvm::MDNode* pPa
     }
     return NULL;
 }
+
+llvm::MDNode* FunctionInfoMetaData::getWorkgroupWalkOrderNode(const llvm::MDNode* pParentNode) const
+{
+	if (!pParentNode)
+	{
+		return NULL;
+	}
+
+	unsigned int offset = _Mybase::getStartIndex();
+	for (NodeIterator i = NodeIterator(pParentNode, 0 + offset), e = NodeIterator(pParentNode); i != e; ++i)
+	{
+		if (isNamedNode(i.get(), "sub_group_size"))
+		{
+			return llvm::dyn_cast<llvm::MDNode>(i.get());
+		}
+	}
+	return NULL;
+}
 
 llvm::Metadata* FunctionInfoMetaData::getLocalIDPresentNode( const llvm::MDNode* pParentNode) const
 {