예제 #1
0
    def testConcreteFunctionDictRetainsInsertedKeys(self):
        cache = function_cache.FunctionCache()

        key_1, deletion_observer_1 = function_context.make_cache_key(1)
        self.assertIsNone(cache.lookup(key_1, False))

        key_2, deletion_observer_2 = function_context.make_cache_key(2)
        key_3, _ = function_context.make_cache_key(3)

        cache.add(key_1, deletion_observer_1, "test_1")
        cache.add(key_2, deletion_observer_2, "test_2")

        self.assertEqual(cache.lookup(key_1, False), "test_1")
        self.assertEqual(cache.lookup(key_2, False), "test_2")
        self.assertIsNone(cache.lookup(key_3, False))
예제 #2
0
    def testClearRemovesAllConcreteFunctions(self):
        cache = function_cache.FunctionCache()

        key_1, deletion_observer_1 = function_context.make_cache_key(1)
        key_2, deletion_observer_2 = function_context.make_cache_key(2)
        key_3, _ = function_context.make_cache_key(3)

        cache.add(key_1, deletion_observer_1, "test_1")
        cache.add(key_2, deletion_observer_2, "test_2")

        self.assertEqual(cache.lookup(key_1, False), "test_1")
        self.assertEqual(cache.lookup(key_2, False), "test_2")
        self.assertIsNone(cache.lookup(key_3, False))

        cache.clear()

        self.assertIsNone(cache.lookup(key_1, False))
        self.assertIsNone(cache.lookup(key_2, False))
        self.assertIsNone(cache.lookup(key_3, False))
예제 #3
0
    def testWeakRefDeletionAlsoDeletesConcreteFunction(self):
        if not function_cache.DELETE_WITH_WEAKREF:
            self.skipTest("Weakref-Based Deletion is disabled")

        dummy_object = DummyClass()
        key, deletion_observer = function_context.make_cache_key(dummy_object)

        cache = function_cache.FunctionCache()
        cache.add(key, deletion_observer, "testing")
        self.assertEqual(cache.lookup(key, False), "testing")

        del dummy_object
        self.assertIsNone(cache.lookup(key, False))
예제 #4
0
    def testMultipleObjectsWeakRefDeletion(self):
        if not function_cache.DELETE_WITH_WEAKREF:
            self.skipTest("Weakref-Based Deletion is disabled")

        dummy_object_1 = DummyClass()
        dummy_object_2 = DummyClass()
        key, deletion_observer = function_context.make_cache_key(
            (dummy_object_1, dummy_object_2))

        cache = function_cache.FunctionCache()
        cache.add(key, deletion_observer, "testing")
        self.assertEqual(cache.lookup(key, False), "testing")

        del dummy_object_1
        self.assertIsNone(cache.lookup(key, False))

        del dummy_object_2
        self.assertIsNone(cache.lookup(key, False))
예제 #5
0
    def testDeleteRemovesConcreteFunctions(self):
        cache = function_cache.FunctionCache()
        key_1, deletion_observer_1 = function_context.make_cache_key(1)
        cache.add(key_1, deletion_observer_1, "test_1")
        self.assertEqual(cache.lookup(key_1, False), "test_1")
        cache.delete(key_1)
        self.assertIsNone(cache.lookup(key_1, False))

        key_2 = function_cache.FunctionCacheKey(MockSubtypeOf2(2), None)
        cache.add(key_2, trace_type.WeakrefDeletionObserver(), "test_2")
        self.assertEqual(cache.lookup(key_2, False), "test_2")

        key_3 = function_cache.FunctionCacheKey(MockSubtypeOf2(3), None)
        self.assertEqual(cache.lookup(key_3, True), "test_2")

        cache.delete(key_2)
        self.assertIsNone(cache.lookup(key_2, False))
        self.assertIsNone(cache.lookup(key_3, True))
예제 #6
0
  def benchmarkCacheHit50thKeyUnknownSubtype(self):
    # If there are 50 keys and we get a key that has a subtype in cache but
    # the cache has never observed the key before (no memory for the subtype).

    cache = function_cache.FunctionCache()
    args_per_call = 5
    num_total_checks = 50

    keys = []
    for i in range(num_total_checks - 1):
      args = []
      for j in range(args_per_call):
        args.append(array_ops.zeros([i, j]))
      keys.append(function_context.make_cache_key(args))

    def setup():
      cache.clear()
      for key in keys:
        cache.add(*key, "testing")
      cache.add(
          function_cache.FunctionCacheKey(MockSubtypeOf2(3),
                                          MockEmptyCaptureSnapshot(), None),
          trace_type.WeakrefDeletionObserver(), "testing")

    iterations = 10000
    lookup_key = function_cache.FunctionCacheKey(MockSubtypeOf2(2),
                                                 MockEmptyCaptureSnapshot(),
                                                 None)
    subtyping_time = sum(
        timeit.repeat(
            stmt=lambda: cache.lookup(lookup_key, True),
            setup=setup,
            repeat=iterations,
            number=1))

    self.report_benchmark(
        name="cache_hit_50th_key_unknown_subtype",
        iters=iterations,
        wall_time=subtyping_time,
        metrics=[{
            "name": "cache_hit_50th_key_unknown_subtype_avg_ms",
            "value": subtyping_time / iterations * 1000
        }])
예제 #7
0
    def benchmarkCacheHit50thKeyEqual(self):
        # If there are 50 keys and we get a new key that is equal to a key that is
        # in the cache.

        cache = function_cache.FunctionCache()
        args_per_call = 5
        num_total_checks = 50

        keys = []
        for i in range(num_total_checks):
            args = []
            for j in range(args_per_call):
                args.append(array_ops.zeros([i, j]))
            keys.append(function_context.make_cache_key(args))

        for key in keys:
            cache.add(*key, "testing")

        iterations = 10000
        subtyping_time = timeit.timeit(lambda: cache.lookup(keys[-1][0], True),
                                       number=iterations)
        equality_time = timeit.timeit(lambda: cache.lookup(keys[-1][0], False),
                                      number=iterations)

        self.report_benchmark(
            name="cache_hit_50th_key_equal",
            iters=iterations,
            wall_time=subtyping_time + equality_time,
            metrics=[{
                "name": "cache_hit_50th_key_equal_subtype_avg_ms",
                "value": subtyping_time / iterations * 1000
            }, {
                "name": "cache_hit_50th_key_equal_equality_avg_ms",
                "value": equality_time / iterations * 1000
            }, {
                "name": "cache_hit_50th_key_subtype_over_equality_ratio",
                "value": subtyping_time / equality_time
            }])
예제 #8
0
    def benchmarkCacheHit50thKeyKnownSubtype(self):
        # If there are 50 keys and we get a key that has a subtype in cache and
        # the cache has observed the key before (to memorize the subtype).

        cache = function_cache.FunctionCache()
        args_per_call = 5
        num_total_checks = 50

        keys = []
        for i in range(num_total_checks - 1):
            args = []
            for j in range(args_per_call):
                args.append(array_ops.zeros([i, j]))
            keys.append(function_context.make_cache_key(args))

        for key in keys:
            cache.add(*key, "testing")
        cache.add(function_cache.FunctionCacheKey(MockSubtypeOf2(2), None),
                  trace_type.WeakrefDeletionObserver(), "testing")
        cache.lookup(function_cache.FunctionCacheKey(MockSubtypeOf2(3), None),
                     True)

        iterations = 10000
        lookup_key = function_cache.FunctionCacheKey(MockSubtypeOf2(2), None)
        subtyping_time = timeit.timeit(lambda: cache.lookup(lookup_key, True),
                                       number=iterations)

        self.report_benchmark(name="cache_hit_50th_key_known_subtype",
                              iters=iterations,
                              wall_time=subtyping_time,
                              metrics=[{
                                  "name":
                                  "cache_hit_50th_key_known_subtype_avg_ms",
                                  "value":
                                  subtyping_time / iterations * 1000
                              }])
예제 #9
0
 def second(o):
     return function_context.make_cache_key(o)