Speed up caching logic

[gaffney2010]

The caching is inefficient when prob_end is used. The current paradigm caches by players and number of turns in match, for non-stochastic. But this ignores the fact that you can read a shorter match from the result of a longer match. For example if we have a 20-turn match cached, and we wish to run a 19-turn match, we COULD just read the first 19 moves from the 20-turn match, but the current paradigm would completely re-run because no 19-turn match has been run yet.

I changed the code to

1. Cache on player-pairs only.
2. Only re-run a match if the cache is shorter than the desired match. In that case overwrite the cached value.
3. Sliced the cached value after reading, so as to get the first n moves, as desired.

I ran the code below and found an 80% speed-up. I don't think this adds complexity, and keying on player-pairs only is simpler and more natural.

Experimental code:

import axelrod as axl
import time

MATCH_SIMS = 100

player1, player2 = axl.Cooperator(), axl.DBS()
players = (player1, player2)
match = axl.Match(players, prob_end=0.01)

start_time = time.time()
prev_time = time.time()
for _ in range(MATCH_SIMS):
  match.play()
  print("Running simulation {} of {}.  Played {} rounds.  It took {} secs.".format(
      _, MATCH_SIMS, len(match.result), time.time() - prev_time))
  prev_time = time.time()
end_time = time.time()
print("================")
print("Total time for {} simulations: {} secs.".format(MATCH_SIMS, end_time - start_time))

[marcharper]

Looks really nice to me. Can you add a test that ensures that when a longer run happens that the cache is overwritten with the longer run, similar to the newly added test?

[gaffney2010]

Looks really nice to me. Can you add a test that ensures that when a longer run happens that the cache is overwritten with the longer run, similar to the newly added test?

Added.

[drvinceknight]

Nice! Thanks @gaffney2010 👍