Implement an intelligent cache for the xpath expression string -> compiled operations (we cache the entire XPathExpression object). Add a test to ensure we are getting savings from this, and to measure how much.

kata198 · kata198 · commit 1fcdea064ac3 · 2019-11-25T23:27:07.000-05:00
Not in this patch, but additional measurements show that in a 75% hit
rate scenario, we only spend 45% as much time, or 2.25 times as fast vs
no cache, on the compiling portion.
diff --git a/AdvancedHTMLParser/xpath/_cache.py b/AdvancedHTMLParser/xpath/_cache.py
@@ -0,0 +1,171 @@
+'''
+    Copyright (c) 2019 Timothy Savannah under terms of LGPLv3. All Rights Reserved.
+
+    See LICENSE (https://gnu.org/licenses/lgpl-3.0.txt) for more information.
+
+    See: https://github.com/kata198/AdvancedHTMLParser for full information
+
+
+    ==INTERNAL==
+
+    xpath._cache.py - Internal module for caching recent XPath expression parsings
+'''
+# vim: set ts=4 sw=4 st=4 expandtab :
+
+import threading
+
+from hashlib import sha1
+
+from ..compat import ensureStringEncoded
+
+__all__ = ('XPathExpressionCache', 'XPathExpressionCacheType', )
+
+# MAX_CACHED_EXPRESSIONS - The maximum number of cached expressions before we perform a clean-up of the cache
+MAX_CACHED_EXPRESSIONS = 10
+
+# CLEAR_AT_ONE_TIME - The number of cached expressions that we clear from the cache upon exceeding #MAX_CACHED_EXPRESSIONS
+CLEAR_AT_ONE_TIME = 3
+
+class XPathExpressionCacheType(object):
+    '''
+        XPathExpressionCacheType - The type of the XPath Expression Cache.
+
+            This is meant to be used as a singleton, the instance being "XPathExpressionCache"
+    '''
+
+    def __init__(self):
+        '''
+            __init__ - Create this object
+        '''
+
+        self.cachedCompiledExpressions = {}
+        self.recentCachedExpressionStrs = []
+
+        self.cacheLock = threading.Lock()
+
+
+    @staticmethod
+    def getKeyForExpressionStr(expressionStr):
+        '''
+            getKeyForExpressionStr - Get a unique hash "key" for a given expression str,
+
+                as will be used to cache the compiled expression.
+
+
+                    @param expressionStr <str/unicode/bytes> - The XPath expression str
+
+
+                    @return <str> - The key
+        '''
+        expressionStr = ensureStringEncoded(expressionStr)
+
+        return sha1(expressionStr).hexdigest()
+
+
+    def getCachedExpression(self, expressionStr):
+        '''
+            getCachedExpression - Try to get a cached XPathExpression object for a given key
+
+
+                @param expressionStr <str> - The XPath expression str
+
+
+                @return <XPathExpression/None> - The XPathExpression object, if one was cached, otherwise None
+        '''
+        key = self.getKeyForExpressionStr(expressionStr)
+
+        self.cacheLock.acquire()
+        xpathExpressionObj = self.cachedCompiledExpressions.get(key, None)
+
+        if xpathExpressionObj is None:
+            self.cacheLock.release()
+            return None
+
+        # We got a match, mark it as hot
+        while True:
+            # Ensure we remove all references, if multiple got in somehow
+            try:
+                self.recentCachedExpressionStrs.remove(key)
+            except ValueError:
+                break
+
+        # Add single refernce to end (hot side) of list
+        self.recentCachedExpressionStrs.append(key)
+
+        self.cacheLock.release()
+
+        # And return the expression obj
+        return xpathExpressionObj
+
+
+    def applyCachedExpressionIfAvailable(self, expressionStr, xpathExpressionObj):
+        '''
+            applyCachedExpressionIfAvailable - Check if a cached compiled expression object is available, based on the xpath expression string,
+
+                and if it is, update the expression object's members with the cached version.
+
+
+                    @param expressionStr <str> - The XPath expression str
+
+                    @param xpathExpressionObj <xpath.expression.XPathExpression> - The expression object
+
+
+                    @return <bool> - True if did apply from cache, False if no match (expression needs to be compiled)
+        '''
+        cachedExpression = self.getCachedExpression(expressionStr)
+        if cachedExpression is None:
+            return False
+
+        xpathExpressionObj._copyOperationsFromXPathExpressionObj(cachedExpression)
+        return True
+
+
+    def setCachedExpression(self, expressionStr, xpathExpressionObj):
+        '''
+            setCachedExpression - Sets the expression object to be cached under a given string
+
+
+                @param expressionStr <str> - The XPath expression str
+
+                @param xpathExpressionObj <XPathExpression> - The XPathExpression object
+        '''
+        key = self.getKeyForExpressionStr(expressionStr)
+        self.cacheLock.acquire()
+        try:
+            while True:
+                # Ensure we remove all references, if multiple got in somehow
+                try:
+                    self.recentCachedExpressionStrs.remove(key)
+                except ValueError:
+                    break
+
+            self.cachedCompiledExpressions[key] = xpathExpressionObj
+            self.recentCachedExpressionStrs.append(key)
+
+            numCachedExpressionStrs = len(self.recentCachedExpressionStrs)
+            if numCachedExpressionStrs > MAX_CACHED_EXPRESSIONS:
+
+                numRemainingAfterClear = MAX_CACHED_EXPRESSIONS - CLEAR_AT_ONE_TIME
+
+                # Gather and remove overflow
+                keysToRemove = self.recentCachedExpressionStrs[ : len(self.recentCachedExpressionStrs) - numRemainingAfterClear ]
+                for keyToRemove in keysToRemove:
+                    try:
+                        del self.cachedCompiledExpressions[keyToRemove]
+                    except:
+                        pass
+
+                # Retain references to remaining
+                self.recentCachedExpressionStrs = self.recentCachedExpressionStrs[ -1 * numRemainingAfterClear : ]
+
+        except Exception as exc:
+            self.cacheLock.release()
+            raise exc
+
+        self.cacheLock.release()
+
+# XPathExpressionCache - The singleton instance of the XPath Expression Cache. Use this instead of creating a new XPathExpressionCacheType()
+XPathExpressionCache = XPathExpressionCacheType()
+
+
+# vim: set ts=4 sw=4 st=4 expandtab :
diff --git a/AdvancedHTMLParser/xpath/expression.py b/AdvancedHTMLParser/xpath/expression.py
@@ -10,13 +10,15 @@
 '''
 # vim: set ts=4 sw=4 st=4 expandtab :
 
+import copy
+
 from ..Tags import TagCollection, AdvancedTag
 
 from ._debug import getXPathDebug
 from .exceptions import XPathParseError
 from .operation import XPathOperation
 from .parsing import parseXPathStrIntoOperations
-
+from ._cache import XPathExpressionCache
 
 __all__ = ('XPathExpression', )
 
@@ -35,7 +37,28 @@ def __init__(self, xpathStr):
         '''
 
         self.xpathStr = xpathStr
-        self.orderedOperations = parseXPathStrIntoOperations(self.xpathStr)
+
+        # Check if we've recently compiled this string, and copy the compiled operations, if so.
+        wasCached = XPathExpressionCache.applyCachedExpressionIfAvailable( xpathStr, self )
+
+        if wasCached is False:
+            # No cached entity found, compile this string
+            self.orderedOperations = parseXPathStrIntoOperations(self.xpathStr)
+
+            # Save compiled expression in the expression cache
+            XPathExpressionCache.setCachedExpression( xpathStr, self )
+
+
+    def _copyOperationsFromXPathExpressionObj(self, otherXPathExpressionObj):
+        '''
+            _copyOperationsFromXPathExpressionObj - Copies the operations from another XPathExpression object onto this one.
+
+                This will clear the current set of operations on this object, replacing it with a copy from the provided object.
+
+
+                @param otherXPathExpressionObj <XPathExpression> - Another XPathExpression object
+        '''
+        self.orderedOperations = copy.copy( otherXPathExpressionObj.orderedOperations )
 
 
     def evaluate(self, pathRoot):
diff --git a/tests/AdvancedHTMLParserTests/test_XPath.py b/tests/AdvancedHTMLParserTests/test_XPath.py
@@ -3,6 +3,7 @@
     Test some xpath!
 '''
 
+import time
 import subprocess
 import sys
 
@@ -446,6 +447,51 @@ def test_xpathContains(self):
         assert item3Found is True , 'Expected to find div id="item3" but did not!'
 
 
+    def test_xpathCache(self):
+        '''
+            test_xpathCache - Test that the cache is working
+        '''
+
+        startTime = time.time()
+
+        for i in range(200):
+            # Generate three based off a repeating xpath string
+            puddingNameSpans = self.parser.getElementsByXPathExpression('//span[ @name = "itemName" and contains( text(), "Pudding" ) ]')
+            item3Ems = self.parser.getElementsByXPathExpression('''//*[ @id = "it" || "em" || "3" ]''')
+            puddingNameEms = self.parser.getElementsByXPathExpression('//*[ (@name = "itemName") and contains( text(), "Pudding" ) ]')
+            # and one random junk that will never hit on cache
+            junkX = self.parser.getElementsByXPathExpression('''//*[ @id = "it" || "em" || "3" || "%d" || "%d" ]''' %(i, (i+1)*3) )
+
+        endTime = time.time()
+
+        timeWithCache = endTime - startTime
+
+        # Temporarily disable caching by nuking getCachedExpression to always return "miss"
+        from AdvancedHTMLParser.xpath._cache import XPathExpressionCache
+        oldGetCachedExpression = XPathExpressionCache.getCachedExpression
+        XPathExpressionCache.getCachedExpression = lambda expressionStr : None
+
+        startTime = time.time()
+
+        for i in range(200):
+            puddingNameSpans = self.parser.getElementsByXPathExpression('//span[ @name = "itemName" and contains( text(), "Pudding" ) ]')
+            item3Ems = self.parser.getElementsByXPathExpression('''//*[ @id = "it" || "em" || "3" ]''')
+            puddingNameEms = self.parser.getElementsByXPathExpression('//*[ (@name = "itemName") and contains( text(), "Pudding" ) ]')
+            junkX = self.parser.getElementsByXPathExpression('''//*[ @id = "it" || "em" || "3" || "%d" || "%d" ]''' %(i, (i+1)*3) )
+
+        endTime = time.time()
+
+        timeWithoutCache = endTime - startTime
+
+        # Restore caching
+        XPathExpressionCache.getCachedExpression = oldGetCachedExpression
+
+        timeWithoutCache = round(timeWithoutCache, 7)
+        timeWithCache = round(timeWithCache, 7)
+        print ( "No Cache: %.7f" %( timeWithoutCache, ))
+        print ( "W/ Cache: %.7f" %( timeWithCache, ))
+
+        assert timeWithCache < timeWithoutCache , 'Expected compiling XPath strings to be faster when caching the compiled result, but was not.\nTime with cache   : %.7f\nTime without cache: %.7f' %( timeWithCache, timeWithoutCache)
 
 if __name__ == '__main__':
     sys.exit(subprocess.Popen('GoodTests.py -n1 "%s" %s' %(sys.argv[0], ' '.join(['"%s"' %(arg.replace('"', '\\"'), ) for arg in sys.argv[1:]]) ), shell=True).wait())
