Behaviour when expireAfterCreate returns 0

[mkurz]

Hi,

when "putting" an element in the cache and/but having expireAfterCreate returning 0, does that mean

• it is guaranteed an immediately call to get for the corresponding key used will always be a cache miss?
• such an element will not even be put in the cache at all by caffeine (because it would not make sense)?

Asking because we do have a special case where we sometimes need to rely such behaviour.
Thanks!

[ben-manes]

I believe it is (1), where the entry is added but immediately expirable so that the next read/write will have a miss. That's the most straightforward code as (2) might require special conditionals, etc. to ensure it was interpreted correctly. A get is a computation and expiration is calculated after the value was obtained, so all of the expensive work was performed and therefore (2) probably wouldn't provide any benefit?

[mkurz]

Thanks for your answer. I am not saying it should work like described in (2), I was just guessing how the current implementation may work, so it was more a question which of (1) or (2) it is. I am totally OK if the entry actually does get added but immediately expires so that the next read/write will always have a miss. If I can rely on that we are absolutely fine. For us it's just important that either (1) or (2) is the behaviour, no matter which one of both it actually is.

[ben-manes]

Yes, though technically the evaluation uses the Ticker so you could time travel in tests and resurrect the entry. It defaults to System.nanoTime() which is monatomic, unlike currentTimeMillis, and I don't think you'll get the same value twice. I believe that negative expiration is also allowed as it applies blind arithmetic and is not asserted to be non-negative (not sure if that is good or bad).

[mkurz]

Thanks.

....and I don't think you'll get the same value twice.

jshell> while (true) { System.out.println(System.nanoTime() - System.nanoTime()); }
-42
0 <--
...

Not sure if that test is really appropriate but it looks like that two calls two System.nanoTime() actually do return the same value. Or am I missing something?

So the question is: I guess there is somewhere a condition in your code to check if an entry is expired or not. So if we return 0 from expireAfterCreate and assuming an immediate read from the cache happens with the same nanoTime value, is that entry now really expired? Or is it still valid in that "moment" and only expires with "moment" + 1? You get what I mean? Can you point me to that code?

[ben-manes]

Since the zero expiration test shows it is expired without adjusting the FakeTicker, I believe it is "moment". You can check in a new test though.

caffeine/caffeine/src/main/java/com/github/benmanes/caffeine/cache/BoundedLocalCache.java

Lines 961 to 970 in 3d07724

	/** Returns if the entry has expired. */
	@SuppressWarnings("ShortCircuitBoolean")
	boolean hasExpired(Node<K, V> node, long now) {
	if (isComputingAsync(node)) {
	return false;
	}
	return (expiresAfterAccess() && (now - node.getAccessTime() >= expiresAfterAccessNanos()))
	| (expiresAfterWrite() && (now - node.getWriteTime() >= expiresAfterWriteNanos()))
	| (expiresVariable() && (now - node.getVariableTime() >= 0));
	}

caffeine/caffeine/src/test/java/com/github/benmanes/caffeine/cache/ExpirationTest.java

Lines 88 to 108 in 3d07724

	@Test(dataProvider = "caches")
	@CacheSpec(mustExpireWithAnyOf = { AFTER_ACCESS, AFTER_WRITE, VARIABLE },
	expiry = { CacheExpiry.DISABLED, CacheExpiry.CREATE, CacheExpiry.WRITE, CacheExpiry.ACCESS },
	expireAfterAccess = {Expire.DISABLED, Expire.IMMEDIATELY},
	expireAfterWrite = {Expire.DISABLED, Expire.IMMEDIATELY},
	expiryTime = Expire.IMMEDIATELY, population = Population.EMPTY,
	evictionListener = { Listener.CONSUMING, Listener.DISABLED, Listener.REJECTING })
	public void expire_zero(Cache<Int, Int> cache, CacheContext context) {
	cache.put(context.absentKey(), context.absentValue());
	if (context.isZeroWeighted() && context.isGuava()) {
	// Guava translates to maximumSize=0, which won't evict
	assertThat(cache).hasSize(1);
	assertThat(context).notifications().isEmpty();
	} else {
	runVariableExpiration(context);
	assertThat(cache).isEmpty();
	assertThat(context).notifications().withCause(EXPIRED)
	.contains(context.absentKey(), context.absentValue())
	.exclusively();
	}
	}

[mkurz]

Thanks this looks good! Since AFAIK you always add (+) the expire value, those >= / >= 0 indicate for me that even comparing in the same "nano moment" and substracting the two values will end up being 0 and you treat 0 as expired in hasExpired (returns true). That's what I wanted to see.
Thanks!