Improve performance of an XSLT function in the for-each part

i have implemented an XSLT function that takes as inputs a node and its parent node and “gathers” the values of all those data items in the node and returns “True” if all of them are the same or “False” if they are different.
The implementation is the following:
<?xml version="1.0" encoding="UTF-8"?>
<!--
This file was generated by SOFTDEV team.

This function searches for the nodes with the given name under the given parent and outputs whether all are the same or not

-->
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:ns0="http://ecs.dgtaxud.ec">
	<xsl:template name="checkUniqueVales">
		<xsl:param name="nodeParentName" select="()"/>
		<xsl:param name="nodeName" select="()"/>
		<xsl:variable name="var1" as="xs:string*">
			<xsl:for-each select="//*[matches(local-name(), $nodeParentName)]//*[matches(local-name(), $nodeName)]">
				<xsl:sequence select="fn:string(.)"/>
			</xsl:for-each>
		</xsl:variable>
		<xsl:sequence select="xs:string((xs:string(fn:count(fn:distinct-values($var1))))='1')"/>
	</xsl:template>
</xsl:stylesheet>

This template checkUniqueValues is being called 4 times. It takes as an input two parameters, “nodeParentName” and “nodeName”, which represent the name of the parent node and the name of the target node, respectively. It then stores the values of all the target nodes that match the given “nodeName” and are children of the parent nodes that match the given “nodeParentName”.
Let me give you an example of with an xml
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<Group>
    <Item>
	  <ref>16</ref>
	  <countryOfDis>Italy</countryOfDis>
	  <countryOfDes>Spain</countryOfDes>
	  <Support>
		 <method>Transdoc</method>
      </Support>
	</Item>
    <Item>
	  <ref>16</ref>
	  <countryOfDis>Italy</countryOfDis>
	  <countryOfDes>Spain</countryOfDes>
	  <Support>
		 <method>Transdoc</method>
      </Support>
	</Item>
</Group>

This function wants to check if ref, countryOfDis countryOfDes and method under Support have the same values for each Item. It took us input the Item as nodeParentName and countryofDis or countryOfDes or method under Support as nodeName
The for each part when the message is big has a big countdown and this is causing issues. Maybe one idea is to somehow break the for each when we find for example two equals and then break from the for each but i dont think this is feasible in XSLT. Any ideas on how to implement this in an efficient way?

Thanks in advance

Performance depends on many factors, one important one being the XSLT processor that you are using - which you haven't told us.

You also haven't told us how often the checkUniqueValues template is being called.

Looking at this:

<xsl:for-each select="//*[matches(local-name(), $nodeParentName)]//*[matches(local-name(), $nodeName)]">

you're asking the processor to do a lot of work, and I wonder how much of it is really necessary?

Do you really need to match the two names using regular expressions, rather than an exact string match? And what's in the regular expressions, perhaps they can be simplified?

Do you really need to use "//" rather than "/"? You've basically got a quadratic operation here: for every descendant node, search all its descendant nodes, which is likely to be O(n^2) in the size of the tree.

An obvious improvement (which an optimizing engine might do for you, but it's best to assume not) is to write it as

//*[matches(local-name(), $nodeName)][ancestor::*[matches(local-name(), $nodeParentName)]

because then you're saying "for each descendant node, search all its ancestors", and the number of ancestors is usually very much smaller than the number of descendants.

Next step: rather than searching all the ancestors using a regular expression, identify them in advance:

<xsl:variable name="matching-ancestors"
select="//*[matches(local-name(), $nodeParentName)]"/>

and then

<xsl:for-each select="//*[matches(local-name(), $nodeName)]
                         [ancestor::* intersect $matching-ancestors"/>

Another optimization would be to collect all the local names of elements in the document, do a distinct-values() to make the list unique, filter the list of names to retain only those that match the regular expression, then search for elements with those specific names. This would greatly reduce the number of regular expression matches you are doing (basically to 2 matches per distinct element name in the document).

In XSLT 3 you have xsl:iterate with xsl:break, thus if you really think you have a large data set where manual iteration and breaking helps to improve performance then here is an example:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="3.0"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
exclude-result-prefixes="#all"
xmlns:mf="http://example.com/mf"
expand-text="yes">
<xsl:function name="mf:check-unique-values" as="xs:boolean">
<xsl:param name="context-node" as="node()"/>
<xsl:param name="parent-element-name" as="xs:string"/>
<xsl:param name="element-name" as="xs:string"/>
<xsl:variable name="elements" as="element()*">
<xsl:evaluate xpath="'.//' || $parent-element-name || '/' || $element-name" context-item="$context-node"/>
</xsl:variable>
<xsl:iterate select="$elements">
<xsl:param name="unique" as="xs:boolean" select="true()"/>
<xsl:param name="value" as="item()?" select="()"/>
<xsl:on-completion select="$unique"/>
<xsl:choose>
<xsl:when test="empty($value) or $value = data(.)">
<xsl:next-iteration>
<xsl:with-param name="value" select="data(.)"/>
</xsl:next-iteration>
</xsl:when>
<xsl:otherwise>
<xsl:break select="false()"/>
</xsl:otherwise>
</xsl:choose>
</xsl:iterate>
</xsl:function>
<xsl:template match="root">
<unique-items>{mf:check-unique-values(., 'items', 'item')}</unique-items>
<unique-items>{mf:check-unique-values(., 'values', 'value')}</unique-items>
</xsl:template>
<xsl:mode on-no-match="shallow-copy"/>
<xsl:output indent="yes"/>
</xsl:stylesheet>

XSLT 3 online fiddle.

On the other hand, as long as you use normal XPath and XSLT with path expressions instead of matches comparisons, I would think that nowadays XSLT/XPath 2 or 3 implementations are perhaps smart enough to optimize the evaluatation of e.g. count(distinct-values(//items/item)) = 1 to some evaluation approach that doesn't necessarily need to check all //items/item.

And your code

<xsl:template name="checkUniqueVales">
<xsl:param name="nodeParentName" select="()"/>
<xsl:param name="nodeName" select="()"/>
<xsl:variable name="var1" as="xs:string*">
<xsl:for-each select="//*[matches(local-name(), $nodeParentName)]//*[matches(local-name(), $nodeName)]">
<xsl:sequence select="fn:string(.)"/>
</xsl:for-each>
</xsl:variable>
<xsl:sequence select="xs:string((xs:string(fn:count(fn:distinct-values($var1))))='1')"/>
</xsl:template>

might be better written as e.g.

<xsl:template name="checkUniqueValues">
<xsl:param name="nodeParentName" select="()"/>
<xsl:param name="nodeName" select="()"/>
<xsl:sequence select="count(distinct-values(//*[matches(local-name(), $nodeParentName)]//*[matches(local-name(), $nodeName)]))=1"/>
</xsl:template>

Whether that helps the XSLT 2 processor optimizing the evaluation needs to be tested, I would think the main culprit is usin e.g. //*[matches(..)//*[matches(..) instead of normal element path expressions. Thus instead of using a function or a named template where you pass in two element names it might considerable be easier and hopefully faster to directly use an XPath expression of e.g. count(distinct-values(//foo//bar)) = 1 or count(distinct-values(//items//item)) = 1 instead of doing <xsl:call-template name="checkUniqueValues">..</xsl:call-template>.

After your latest edit it seems there is a known input format and you now the exact node nodes and paths you want to check, it all sounds like grouping with a composite key to me if you really want to check whether you have unique Items in terms of three child elements and one descendant element; in XSLT 3 you can easily use composite="yes" and a sequence of key values in group-by:

  <xsl:template match="Group">
<xsl:copy>
<xsl:for-each-group select="Item" composite="yes" group-by="ref, countryOfDis, countryOfDes, Support/method">
<group key="{current-grouping-key()}" unique="{count(current-group()) = 1}"/>
</xsl:for-each-group>
</xsl:copy>
</xsl:template>

In XSLT 2 you can use a single key concatenating the four elements:

  <xsl:template match="Group">
<xsl:copy>
<xsl:for-each-group select="Item" group-by="string-join((ref, countryOfDis, countryOfDes, Support/method), '|')">
<group key="{current-grouping-key()}" unique="{count(current-group()) = 1}"/>
</xsl:for-each-group>
</xsl:copy>
</xsl:template>