B ›³ëbÐ$ã@s`dZdaiaGdd„dƒZGdd„deƒZGdd„deƒZddd „Zd d „Zd d „Zdd„Z dS)a| Decorator-based memoizer to count caching stats. A decorator-based implementation to count hits and misses of the computed values that various methods cache in memory. Use of this modules assumes that wrapped methods be coded to cache their values in a consistent way. In particular, it requires that the class uses a dictionary named "_memo" to store the cached values. Here is an example of wrapping a method that returns a computed value, with no input parameters:: @SCons.Memoize.CountMethodCall def foo(self): try: # Memoization return self._memo['foo'] # Memoization except KeyError: # Memoization pass # Memoization result = self.compute_foo_value() self._memo['foo'] = result # Memoization return result Here is an example of wrapping a method that will return different values based on one or more input arguments:: def _bar_key(self, argument): # Memoization return argument # Memoization @SCons.Memoize.CountDictCall(_bar_key) def bar(self, argument): memo_key = argument # Memoization try: # Memoization memo_dict = self._memo['bar'] # Memoization except KeyError: # Memoization memo_dict = {} # Memoization self._memo['dict'] = memo_dict # Memoization else: # Memoization try: # Memoization return memo_dict[memo_key] # Memoization except KeyError: # Memoization pass # Memoization result = self.compute_bar_value(argument) memo_dict[memo_key] = result # Memoization return result Deciding what to cache is tricky, because different configurations can have radically different performance tradeoffs, and because the tradeoffs involved are often so non-obvious. Consequently, deciding whether or not to cache a given method will likely be more of an art than a science, but should still be based on available data from this module. Here are some VERY GENERAL guidelines about deciding whether or not to cache return values from a method that's being called a lot: -- The first question to ask is, "Can we change the calling code so this method isn't called so often?" Sometimes this can be done by changing the algorithm. Sometimes the *caller* should be memoized, not the method you're looking at. -- The memoized function should be timed with multiple configurations to make sure it doesn't inadvertently slow down some other configuration. -- When memoizing values based on a dictionary key composed of input arguments, you don't need to use all of the arguments if some of them don't affect the return values. Nc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S) ÚCounterzñ Base class for counting memoization hits and misses. We expect that the initialization in a matching decorator will fill in the correct class name and method name that represents the name of the function being counted. cCs||_||_d|_d|_dS)z éN)Úcls_nameÚ method_nameÚhitÚmiss)Úselfrr©rú,lib/python3.7/site-packages/SCons/Memoize.pyÚ__init__rszCounter.__init__cCs|jd|jS)NÚ.)rr)rrrr Úkeyysz Counter.keycCstd |j|j| ¡¡ƒdS)Nz# {:7d} hits {:7d} misses {}())ÚprintÚformatrrr )rrrr Údisplay{szCounter.displaycCs*y| ¡| ¡kStk r$dSXdS)NT)r ÚAttributeError)rÚotherrrr Ú__eq__}szCounter.__eq__N)Ú__name__Ú __module__Ú __qualname__Ú__doc__r r rrrrrr rjs rc@seZdZdZdd„ZdS)Ú CountValuezÿ A counter class for simple, atomic memoized values. A CountValue object should be instantiated in a decorator for each of the class's methods that memoizes its return value by simply storing the return value in its _memo dictionary. cOs2|d}|j|jkr"|jd|_n |jd|_dS)ze Counts whether the memoized value has already been set (a hit) or not (a miss). réN)rÚ_memorr)rÚargsÚkwÚobjrrr Úcount‹s zCountValue.countN)rrrrrrrrr rƒsrcs(eZdZdZ‡fdd„Zdd„Z‡ZS)Ú CountDicta_ A counter class for memoized values stored in a dictionary, with keys based on the method's input arguments. A CountDict object is instantiated in a decorator for each of the class's methods that memoizes its return value in a dictionary, indexed by some key that can be computed from one or more of its input arguments. cstƒ ||¡||_dS)z N)Úsuperr Úkeymaker)rrrr )Ú __class__rr r ŸszCountDict.__init__cOsl|d}y|j|j}Wn tk r8|jd|_Yn0X|j||Ž}||kr\|jd|_n |jd|_dS)z„ Counts whether the computed key value is already present in the memoization dictionary (a hit) or not (a miss). rrN)rrÚKeyErrorrr r)rrrrZ memo_dictr rrr r¤s zCountDict.count)rrrrr rÚ __classcell__rr)r!r r•s  rcCs.|r t|ƒxttƒD]}t| ¡qWdS)zL Dump the hit/miss count for all the counters collected so far. N)r ÚsortedÚ CounterListr)ÚtitleZcounterrrr ÚDump´sr'cCsdadS)Nr)Ú use_memoizerrrrr ÚEnableMemoization½sr)cs$tr‡fdd„}ˆj|_|SˆSdS)a Decorator for counting memoizer hits/misses while retrieving a simple value in a class method. It wraps the given method fn and uses a CountValue object to keep track of the caching statistics. Wrapping gets enabled by calling EnableMemoization(). csT|jjdˆj}|tkr.t|jjˆjƒt|<t|j|f|ž|Žˆ|f|ž|ŽS)Nr )r!rr%rr)rrÚkwargsr )Úfnrr ÚwrapperÉs z CountMethodCall..wrapperN)r(r)r+r,r)r+r ÚCountMethodCallÁs  r-cs‡fdd„}|S)aÐ Decorator for counting memoizer hits/misses while accessing dictionary values with a key-generating function. Like CountMethodCall above, it wraps the given method fn and uses a CountDict object to keep track of the caching statistics. The dict-key function keyfunc has to get passed in the decorator call and gets stored in the CountDict instance. Wrapping gets enabled by calling EnableMemoization(). cs&tr‡‡fdd„}ˆj|_|SˆSdS)NcsV|jjdˆj}|tkr0t|jjˆjˆƒt|<t|j|f|ž|Žˆ|f|ž|ŽS)Nr )r!rr%rr)rrr*r )r+Úkeyfuncrr r,ás z1CountDictCall..decorator..wrapper)r(r)r+r,)r.)r+r Ú decoratorßs z CountDictCall..decoratorr)r.r/r)r.r Ú CountDictCallÕs r0)N) rr(r%rrrr'r)r-r0rrrr Úbs