mirror of
https://github.com/samsonjs/media.git
synced 2026-04-04 11:05:47 +00:00
Disable cache span touching for offline
Currently SimpleCache will touch cache spans whenever it reads from them. With legacy SimpleCache setups this involves a potentially expensive file rename. With new SimpleCache setups it involves a more efficient but still non-free database write. For offline use cases, and more generally any use case where the eviction policy doesn't use last access timestamps, touching is not useful. This change allows the evictor to specify whether it needs cache spans to be touched or not. SimpleCache will only touch spans if the evictor requires it. Note: There is a potential change in behavior in cases where a cache uses an evictor that doesn't need cache spans to be touched, but then later switches to an evictor that does. The new evictor may temporarily make sub-optimal eviction decisions as a result. I think this is a very fair trade-off, since this scenario is unlikely to occur much, if at all, in practice, and even if it does occur the result isn't that bad. PiperOrigin-RevId: 244005682
This commit is contained in:
olly
Andrew Lewis
parent
d656782bd4
commit
e290f883d1
13 changed files with 96 additions and 79 deletions
|
|
@ -49,19 +49,18 @@ public interface Cache {
|
|||
void onSpanRemoved(Cache cache, CacheSpan span);
|
||||
|
||||
/**
|
||||
* Called when an existing {@link CacheSpan} is accessed, causing it to be replaced. The new
|
||||
* Called when an existing {@link CacheSpan} is touched, causing it to be replaced. The new
|
||||
* {@link CacheSpan} is guaranteed to represent the same data as the one it replaces, however
|
||||
* {@link CacheSpan#file} and {@link CacheSpan#lastAccessTimestamp} may have changed.
|
||||
* <p>
|
||||
* Note that for span replacement, {@link #onSpanAdded(Cache, CacheSpan)} and
|
||||
* {@link #onSpanRemoved(Cache, CacheSpan)} are not called in addition to this method.
|
||||
* {@link CacheSpan#file} and {@link CacheSpan#lastTouchTimestamp} may have changed.
|
||||
*
|
||||
* <p>Note that for span replacement, {@link #onSpanAdded(Cache, CacheSpan)} and {@link
|
||||
* #onSpanRemoved(Cache, CacheSpan)} are not called in addition to this method.
|
||||
*
|
||||
* @param cache The source of the event.
|
||||
* @param oldSpan The old {@link CacheSpan}, which has been removed from the cache.
|
||||
* @param newSpan The new {@link CacheSpan}, which has been added to the cache.
|
||||
*/
|
||||
void onSpanTouched(Cache cache, CacheSpan oldSpan, CacheSpan newSpan);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -23,6 +23,13 @@ import com.google.android.exoplayer2.C;
|
|||
*/
|
||||
public interface CacheEvictor extends Cache.Listener {
|
||||
|
||||
/**
|
||||
* Returns whether the evictor requires the {@link Cache} to touch {@link CacheSpan CacheSpans}
|
||||
* when it accesses them. Implementations that do not use {@link CacheSpan#lastTouchTimestamp}
|
||||
* should return {@code false}.
|
||||
*/
|
||||
boolean requiresCacheSpanTouches();
|
||||
|
||||
/**
|
||||
* Called when cache has been initialized.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -19,10 +19,10 @@ package com.google.android.exoplayer2.upstream.cache;
|
|||
/* package */ final class CacheFileMetadata {
|
||||
|
||||
public final long length;
|
||||
public final long lastAccessTimestamp;
|
||||
public final long lastTouchTimestamp;
|
||||
|
||||
public CacheFileMetadata(long length, long lastAccessTimestamp) {
|
||||
public CacheFileMetadata(long length, long lastTouchTimestamp) {
|
||||
this.length = length;
|
||||
this.lastAccessTimestamp = lastAccessTimestamp;
|
||||
this.lastTouchTimestamp = lastTouchTimestamp;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,17 +36,17 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
|
|||
|
||||
private static final String COLUMN_NAME = "name";
|
||||
private static final String COLUMN_LENGTH = "length";
|
||||
private static final String COLUMN_LAST_ACCESS_TIMESTAMP = "last_access_timestamp";
|
||||
private static final String COLUMN_LAST_TOUCH_TIMESTAMP = "last_touch_timestamp";
|
||||
|
||||
private static final int COLUMN_INDEX_NAME = 0;
|
||||
private static final int COLUMN_INDEX_LENGTH = 1;
|
||||
private static final int COLUMN_INDEX_LAST_ACCESS_TIMESTAMP = 2;
|
||||
private static final int COLUMN_INDEX_LAST_TOUCH_TIMESTAMP = 2;
|
||||
|
||||
private static final String WHERE_NAME_EQUALS = COLUMN_INDEX_NAME + " = ?";
|
||||
|
||||
private static final String[] COLUMNS =
|
||||
new String[] {
|
||||
COLUMN_NAME, COLUMN_LENGTH, COLUMN_LAST_ACCESS_TIMESTAMP,
|
||||
COLUMN_NAME, COLUMN_LENGTH, COLUMN_LAST_TOUCH_TIMESTAMP,
|
||||
};
|
||||
private static final String TABLE_SCHEMA =
|
||||
"("
|
||||
|
|
@ -54,7 +54,7 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
|
|||
+ " TEXT PRIMARY KEY NOT NULL,"
|
||||
+ COLUMN_LENGTH
|
||||
+ " INTEGER NOT NULL,"
|
||||
+ COLUMN_LAST_ACCESS_TIMESTAMP
|
||||
+ COLUMN_LAST_TOUCH_TIMESTAMP
|
||||
+ " INTEGER NOT NULL)";
|
||||
|
||||
private final DatabaseProvider databaseProvider;
|
||||
|
|
@ -141,8 +141,8 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
|
|||
while (cursor.moveToNext()) {
|
||||
String name = cursor.getString(COLUMN_INDEX_NAME);
|
||||
long length = cursor.getLong(COLUMN_INDEX_LENGTH);
|
||||
long lastAccessTimestamp = cursor.getLong(COLUMN_INDEX_LAST_ACCESS_TIMESTAMP);
|
||||
fileMetadata.put(name, new CacheFileMetadata(length, lastAccessTimestamp));
|
||||
long lastTouchTimestamp = cursor.getLong(COLUMN_INDEX_LAST_TOUCH_TIMESTAMP);
|
||||
fileMetadata.put(name, new CacheFileMetadata(length, lastTouchTimestamp));
|
||||
}
|
||||
return fileMetadata;
|
||||
} catch (SQLException e) {
|
||||
|
|
@ -155,17 +155,17 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
|
|||
*
|
||||
* @param name The name of the file.
|
||||
* @param length The file length.
|
||||
* @param lastAccessTimestamp The file last access timestamp.
|
||||
* @param lastTouchTimestamp The file last touch timestamp.
|
||||
* @throws DatabaseIOException If an error occurs setting the metadata.
|
||||
*/
|
||||
public void set(String name, long length, long lastAccessTimestamp) throws DatabaseIOException {
|
||||
public void set(String name, long length, long lastTouchTimestamp) throws DatabaseIOException {
|
||||
Assertions.checkNotNull(tableName);
|
||||
try {
|
||||
SQLiteDatabase writableDatabase = databaseProvider.getWritableDatabase();
|
||||
ContentValues values = new ContentValues();
|
||||
values.put(COLUMN_NAME, name);
|
||||
values.put(COLUMN_LENGTH, length);
|
||||
values.put(COLUMN_LAST_ACCESS_TIMESTAMP, lastAccessTimestamp);
|
||||
values.put(COLUMN_LAST_TOUCH_TIMESTAMP, lastTouchTimestamp);
|
||||
writableDatabase.replaceOrThrow(tableName, /* nullColumnHack= */ null, values);
|
||||
} catch (SQLException e) {
|
||||
throw new DatabaseIOException(e);
|
||||
|
|
|
|||
|
|
@ -45,13 +45,12 @@ public class CacheSpan implements Comparable<CacheSpan> {
|
|||
* The file corresponding to this {@link CacheSpan}, or null if {@link #isCached} is false.
|
||||
*/
|
||||
public final @Nullable File file;
|
||||
/**
|
||||
* The last access timestamp, or {@link C#TIME_UNSET} if {@link #isCached} is false.
|
||||
*/
|
||||
public final long lastAccessTimestamp;
|
||||
/** The last touch timestamp, or {@link C#TIME_UNSET} if {@link #isCached} is false. */
|
||||
public final long lastTouchTimestamp;
|
||||
|
||||
/**
|
||||
* Creates a hole CacheSpan which isn't cached, has no last access time and no file associated.
|
||||
* Creates a hole CacheSpan which isn't cached, has no last touch timestamp and no file
|
||||
* associated.
|
||||
*
|
||||
* @param key The cache key that uniquely identifies the original stream.
|
||||
* @param position The position of the {@link CacheSpan} in the original stream.
|
||||
|
|
@ -69,18 +68,18 @@ public class CacheSpan implements Comparable<CacheSpan> {
|
|||
* @param position The position of the {@link CacheSpan} in the original stream.
|
||||
* @param length The length of the {@link CacheSpan}, or {@link C#LENGTH_UNSET} if this is an
|
||||
* open-ended hole.
|
||||
* @param lastAccessTimestamp The last access timestamp, or {@link C#TIME_UNSET} if {@link
|
||||
* @param lastTouchTimestamp The last touch timestamp, or {@link C#TIME_UNSET} if {@link
|
||||
* #isCached} is false.
|
||||
* @param file The file corresponding to this {@link CacheSpan}, or null if it's a hole.
|
||||
*/
|
||||
public CacheSpan(
|
||||
String key, long position, long length, long lastAccessTimestamp, @Nullable File file) {
|
||||
String key, long position, long length, long lastTouchTimestamp, @Nullable File file) {
|
||||
this.key = key;
|
||||
this.position = position;
|
||||
this.length = length;
|
||||
this.isCached = file != null;
|
||||
this.file = file;
|
||||
this.lastAccessTimestamp = lastAccessTimestamp;
|
||||
this.lastTouchTimestamp = lastTouchTimestamp;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -141,30 +141,30 @@ import java.util.TreeSet;
|
|||
}
|
||||
|
||||
/**
|
||||
* Sets the given span's last access timestamp. The passed span becomes invalid after this call.
|
||||
* Sets the given span's last touch timestamp. The passed span becomes invalid after this call.
|
||||
*
|
||||
* @param cacheSpan Span to be copied and updated.
|
||||
* @param lastAccessTimestamp The new last access timestamp.
|
||||
* @param lastTouchTimestamp The new last touch timestamp.
|
||||
* @param updateFile Whether the span file should be renamed to have its timestamp match the new
|
||||
* last access time.
|
||||
* @return A span with the updated last access timestamp.
|
||||
* last touch time.
|
||||
* @return A span with the updated last touch timestamp.
|
||||
*/
|
||||
public SimpleCacheSpan setLastAccessTimestamp(
|
||||
SimpleCacheSpan cacheSpan, long lastAccessTimestamp, boolean updateFile) {
|
||||
public SimpleCacheSpan setLastTouchTimestamp(
|
||||
SimpleCacheSpan cacheSpan, long lastTouchTimestamp, boolean updateFile) {
|
||||
Assertions.checkState(cachedSpans.remove(cacheSpan));
|
||||
File file = cacheSpan.file;
|
||||
if (updateFile) {
|
||||
File directory = file.getParentFile();
|
||||
long position = cacheSpan.position;
|
||||
File newFile = SimpleCacheSpan.getCacheFile(directory, id, position, lastAccessTimestamp);
|
||||
File newFile = SimpleCacheSpan.getCacheFile(directory, id, position, lastTouchTimestamp);
|
||||
if (file.renameTo(newFile)) {
|
||||
file = newFile;
|
||||
} else {
|
||||
Log.w(TAG, "Failed to rename " + file + " to " + newFile + ".");
|
||||
Log.w(TAG, "Failed to rename " + file + " to " + newFile);
|
||||
}
|
||||
}
|
||||
SimpleCacheSpan newCacheSpan =
|
||||
cacheSpan.copyWithFileAndLastAccessTimestamp(file, lastAccessTimestamp);
|
||||
cacheSpan.copyWithFileAndLastTouchTimestamp(file, lastTouchTimestamp);
|
||||
cachedSpans.add(newCacheSpan);
|
||||
return newCacheSpan;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,6 +35,11 @@ public final class LeastRecentlyUsedCacheEvictor implements CacheEvictor, Compar
|
|||
this.leastRecentlyUsed = new TreeSet<>(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean requiresCacheSpanTouches() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onCacheInitialized() {
|
||||
// Do nothing.
|
||||
|
|
@ -68,12 +73,12 @@ public final class LeastRecentlyUsedCacheEvictor implements CacheEvictor, Compar
|
|||
|
||||
@Override
|
||||
public int compare(CacheSpan lhs, CacheSpan rhs) {
|
||||
long lastAccessTimestampDelta = lhs.lastAccessTimestamp - rhs.lastAccessTimestamp;
|
||||
if (lastAccessTimestampDelta == 0) {
|
||||
long lastTouchTimestampDelta = lhs.lastTouchTimestamp - rhs.lastTouchTimestamp;
|
||||
if (lastTouchTimestampDelta == 0) {
|
||||
// Use the standard compareTo method as a tie-break.
|
||||
return lhs.compareTo(rhs);
|
||||
}
|
||||
return lhs.lastAccessTimestamp < rhs.lastAccessTimestamp ? -1 : 1;
|
||||
return lhs.lastTouchTimestamp < rhs.lastTouchTimestamp ? -1 : 1;
|
||||
}
|
||||
|
||||
private void evictCache(Cache cache, long requiredSpace) {
|
||||
|
|
|
|||
|
|
@ -24,6 +24,11 @@ package com.google.android.exoplayer2.upstream.cache;
|
|||
*/
|
||||
public final class NoOpCacheEvictor implements CacheEvictor {
|
||||
|
||||
@Override
|
||||
public boolean requiresCacheSpanTouches() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onCacheInitialized() {
|
||||
// Do nothing.
|
||||
|
|
|
|||
|
|
@ -70,6 +70,7 @@ public final class SimpleCache implements Cache {
|
|||
@Nullable private final CacheFileMetadataIndex fileIndex;
|
||||
private final HashMap<String, ArrayList<Listener>> listeners;
|
||||
private final Random random;
|
||||
private final boolean touchCacheSpans;
|
||||
|
||||
private long uid;
|
||||
private long totalSpace;
|
||||
|
|
@ -279,6 +280,7 @@ public final class SimpleCache implements Cache {
|
|||
this.fileIndex = fileIndex;
|
||||
listeners = new HashMap<>();
|
||||
random = new Random();
|
||||
touchCacheSpans = evictor.requiresCacheSpanTouches();
|
||||
uid = UID_UNSET;
|
||||
|
||||
// Start cache initialization.
|
||||
|
|
@ -408,23 +410,26 @@ public final class SimpleCache implements Cache {
|
|||
|
||||
// Read case.
|
||||
if (span.isCached) {
|
||||
if (!touchCacheSpans) {
|
||||
return span;
|
||||
}
|
||||
String fileName = Assertions.checkNotNull(span.file).getName();
|
||||
long length = span.length;
|
||||
long lastAccessTimestamp = System.currentTimeMillis();
|
||||
long lastTouchTimestamp = System.currentTimeMillis();
|
||||
boolean updateFile = false;
|
||||
if (fileIndex != null) {
|
||||
try {
|
||||
fileIndex.set(fileName, length, lastAccessTimestamp);
|
||||
fileIndex.set(fileName, length, lastTouchTimestamp);
|
||||
} catch (IOException e) {
|
||||
throw new CacheException(e);
|
||||
Log.w(TAG, "Failed to update index with new touch timestamp.");
|
||||
}
|
||||
} else {
|
||||
// Updating the file itself to incorporate the new last access timestamp is much slower than
|
||||
// Updating the file itself to incorporate the new last touch timestamp is much slower than
|
||||
// updating the file index. Hence we only update the file if we don't have a file index.
|
||||
updateFile = true;
|
||||
}
|
||||
SimpleCacheSpan newSpan =
|
||||
contentIndex.get(key).setLastAccessTimestamp(span, lastAccessTimestamp, updateFile);
|
||||
contentIndex.get(key).setLastTouchTimestamp(span, lastTouchTimestamp, updateFile);
|
||||
notifySpanTouched(span, newSpan);
|
||||
return newSpan;
|
||||
}
|
||||
|
|
@ -459,8 +464,8 @@ public final class SimpleCache implements Cache {
|
|||
if (!fileDir.exists()) {
|
||||
fileDir.mkdir();
|
||||
}
|
||||
long lastAccessTimestamp = System.currentTimeMillis();
|
||||
return SimpleCacheSpan.getCacheFile(fileDir, cachedContent.id, position, lastAccessTimestamp);
|
||||
long lastTouchTimestamp = System.currentTimeMillis();
|
||||
return SimpleCacheSpan.getCacheFile(fileDir, cachedContent.id, position, lastTouchTimestamp);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -488,7 +493,7 @@ public final class SimpleCache implements Cache {
|
|||
if (fileIndex != null) {
|
||||
String fileName = file.getName();
|
||||
try {
|
||||
fileIndex.set(fileName, span.length, span.lastAccessTimestamp);
|
||||
fileIndex.set(fileName, span.length, span.lastTouchTimestamp);
|
||||
} catch (IOException e) {
|
||||
throw new CacheException(e);
|
||||
}
|
||||
|
|
@ -674,14 +679,14 @@ public final class SimpleCache implements Cache {
|
|||
continue;
|
||||
}
|
||||
long length = C.LENGTH_UNSET;
|
||||
long lastAccessTimestamp = C.TIME_UNSET;
|
||||
long lastTouchTimestamp = C.TIME_UNSET;
|
||||
CacheFileMetadata metadata = fileMetadata != null ? fileMetadata.remove(fileName) : null;
|
||||
if (metadata != null) {
|
||||
length = metadata.length;
|
||||
lastAccessTimestamp = metadata.lastAccessTimestamp;
|
||||
lastTouchTimestamp = metadata.lastTouchTimestamp;
|
||||
}
|
||||
SimpleCacheSpan span =
|
||||
SimpleCacheSpan.createCacheEntry(file, length, lastAccessTimestamp, contentIndex);
|
||||
SimpleCacheSpan.createCacheEntry(file, length, lastTouchTimestamp, contentIndex);
|
||||
if (span != null) {
|
||||
addSpan(span);
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -96,7 +96,7 @@ import java.util.regex.Pattern;
|
|||
*/
|
||||
@Nullable
|
||||
public static SimpleCacheSpan createCacheEntry(File file, long length, CachedContentIndex index) {
|
||||
return createCacheEntry(file, length, /* lastAccessTimestamp= */ C.TIME_UNSET, index);
|
||||
return createCacheEntry(file, length, /* lastTouchTimestamp= */ C.TIME_UNSET, index);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -106,14 +106,14 @@ import java.util.regex.Pattern;
|
|||
* @param length The length of the cache file in bytes, or {@link C#LENGTH_UNSET} to query the
|
||||
* underlying file system. Querying the underlying file system can be expensive, so callers
|
||||
* that already know the length of the file should pass it explicitly.
|
||||
* @param lastAccessTimestamp The last access timestamp, or {@link C#TIME_UNSET} to use the file
|
||||
* @param lastTouchTimestamp The last touch timestamp, or {@link C#TIME_UNSET} to use the file
|
||||
* timestamp.
|
||||
* @return The span, or null if the file name is not correctly formatted, or if the id is not
|
||||
* present in the content index, or if the length is 0.
|
||||
*/
|
||||
@Nullable
|
||||
public static SimpleCacheSpan createCacheEntry(
|
||||
File file, long length, long lastAccessTimestamp, CachedContentIndex index) {
|
||||
File file, long length, long lastTouchTimestamp, CachedContentIndex index) {
|
||||
String name = file.getName();
|
||||
if (!name.endsWith(SUFFIX)) {
|
||||
file = upgradeFile(file, index);
|
||||
|
|
@ -142,10 +142,10 @@ import java.util.regex.Pattern;
|
|||
}
|
||||
|
||||
long position = Long.parseLong(matcher.group(2));
|
||||
if (lastAccessTimestamp == C.TIME_UNSET) {
|
||||
lastAccessTimestamp = Long.parseLong(matcher.group(3));
|
||||
if (lastTouchTimestamp == C.TIME_UNSET) {
|
||||
lastTouchTimestamp = Long.parseLong(matcher.group(3));
|
||||
}
|
||||
return new SimpleCacheSpan(key, position, length, lastAccessTimestamp, file);
|
||||
return new SimpleCacheSpan(key, position, length, lastTouchTimestamp, file);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -187,26 +187,26 @@ import java.util.regex.Pattern;
|
|||
* @param position The position of the {@link CacheSpan} in the original stream.
|
||||
* @param length The length of the {@link CacheSpan}, or {@link C#LENGTH_UNSET} if this is an
|
||||
* open-ended hole.
|
||||
* @param lastAccessTimestamp The last access timestamp, or {@link C#TIME_UNSET} if {@link
|
||||
* @param lastTouchTimestamp The last touch timestamp, or {@link C#TIME_UNSET} if {@link
|
||||
* #isCached} is false.
|
||||
* @param file The file corresponding to this {@link CacheSpan}, or null if it's a hole.
|
||||
*/
|
||||
private SimpleCacheSpan(
|
||||
String key, long position, long length, long lastAccessTimestamp, @Nullable File file) {
|
||||
super(key, position, length, lastAccessTimestamp, file);
|
||||
String key, long position, long length, long lastTouchTimestamp, @Nullable File file) {
|
||||
super(key, position, length, lastTouchTimestamp, file);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a copy of this CacheSpan with a new file and last access timestamp.
|
||||
* Returns a copy of this CacheSpan with a new file and last touch timestamp.
|
||||
*
|
||||
* @param file The new file.
|
||||
* @param lastAccessTimestamp The new last access time.
|
||||
* @return A copy with the new file and last access timestamp.
|
||||
* @param lastTouchTimestamp The new last touch time.
|
||||
* @return A copy with the new file and last touch timestamp.
|
||||
* @throws IllegalStateException If called on a non-cached span (i.e. {@link #isCached} is false).
|
||||
*/
|
||||
public SimpleCacheSpan copyWithFileAndLastAccessTimestamp(File file, long lastAccessTimestamp) {
|
||||
public SimpleCacheSpan copyWithFileAndLastTouchTimestamp(File file, long lastTouchTimestamp) {
|
||||
Assertions.checkState(isCached);
|
||||
return new SimpleCacheSpan(key, position, length, lastAccessTimestamp, file);
|
||||
return new SimpleCacheSpan(key, position, length, lastTouchTimestamp, file);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ public class CachedContentIndexTest {
|
|||
cachedContent1.id,
|
||||
/* offset= */ 10,
|
||||
cacheFileLength,
|
||||
/* lastAccessTimestamp= */ 30);
|
||||
/* lastTouchTimestamp= */ 30);
|
||||
SimpleCacheSpan span = SimpleCacheSpan.createCacheEntry(cacheSpanFile, cacheFileLength, index);
|
||||
assertThat(span).isNotNull();
|
||||
cachedContent1.addSpan(span);
|
||||
|
|
@ -293,7 +293,7 @@ public class CachedContentIndexTest {
|
|||
cachedContent.id,
|
||||
/* offset= */ 10,
|
||||
cacheFileLength,
|
||||
/* lastAccessTimestamp= */ 30);
|
||||
/* lastTouchTimestamp= */ 30);
|
||||
SimpleCacheSpan span = SimpleCacheSpan.createCacheEntry(cacheFile, cacheFileLength, index);
|
||||
cachedContent.addSpan(span);
|
||||
|
||||
|
|
|
|||
|
|
@ -134,8 +134,8 @@ public final class CachedRegionTrackerTest {
|
|||
}
|
||||
|
||||
public static File createCacheSpanFile(
|
||||
File cacheDir, int id, long offset, int length, long lastAccessTimestamp) throws IOException {
|
||||
File cacheFile = SimpleCacheSpan.getCacheFile(cacheDir, id, offset, lastAccessTimestamp);
|
||||
File cacheDir, int id, long offset, int length, long lastTouchTimestamp) throws IOException {
|
||||
File cacheFile = SimpleCacheSpan.getCacheFile(cacheDir, id, offset, lastTouchTimestamp);
|
||||
createTestFile(cacheFile, length);
|
||||
return cacheFile;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,9 +38,8 @@ import org.junit.runner.RunWith;
|
|||
public class SimpleCacheSpanTest {
|
||||
|
||||
public static File createCacheSpanFile(
|
||||
File cacheDir, int id, long offset, long length, long lastAccessTimestamp)
|
||||
throws IOException {
|
||||
File cacheFile = SimpleCacheSpan.getCacheFile(cacheDir, id, offset, lastAccessTimestamp);
|
||||
File cacheDir, int id, long offset, long length, long lastTouchTimestamp) throws IOException {
|
||||
File cacheFile = SimpleCacheSpan.getCacheFile(cacheDir, id, offset, lastTouchTimestamp);
|
||||
createTestFile(cacheFile, length);
|
||||
return cacheFile;
|
||||
}
|
||||
|
|
@ -117,7 +116,7 @@ public class SimpleCacheSpanTest {
|
|||
SimpleCacheSpan cacheSpan = SimpleCacheSpan.createCacheEntry(file, file.length(), index);
|
||||
if (cacheSpan != null) {
|
||||
assertThat(cacheSpan.key).isEqualTo(key);
|
||||
cachedPositions.put(cacheSpan.position, cacheSpan.lastAccessTimestamp);
|
||||
cachedPositions.put(cacheSpan.position, cacheSpan.lastTouchTimestamp);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -140,12 +139,11 @@ public class SimpleCacheSpanTest {
|
|||
return file;
|
||||
}
|
||||
|
||||
private void assertCacheSpan(String key, long offset, long lastAccessTimestamp)
|
||||
private void assertCacheSpan(String key, long offset, long lastTouchTimestamp)
|
||||
throws IOException {
|
||||
int id = index.assignIdForKey(key);
|
||||
long cacheFileLength = 1;
|
||||
File cacheFile =
|
||||
createCacheSpanFile(cacheDir, id, offset, cacheFileLength, lastAccessTimestamp);
|
||||
File cacheFile = createCacheSpanFile(cacheDir, id, offset, cacheFileLength, lastTouchTimestamp);
|
||||
SimpleCacheSpan cacheSpan = SimpleCacheSpan.createCacheEntry(cacheFile, cacheFileLength, index);
|
||||
String message = cacheFile.toString();
|
||||
assertWithMessage(message).that(cacheSpan).isNotNull();
|
||||
|
|
@ -155,14 +153,13 @@ public class SimpleCacheSpanTest {
|
|||
assertWithMessage(message).that(cacheSpan.length).isEqualTo(1);
|
||||
assertWithMessage(message).that(cacheSpan.isCached).isTrue();
|
||||
assertWithMessage(message).that(cacheSpan.file).isEqualTo(cacheFile);
|
||||
assertWithMessage(message).that(cacheSpan.lastAccessTimestamp).isEqualTo(lastAccessTimestamp);
|
||||
assertWithMessage(message).that(cacheSpan.lastTouchTimestamp).isEqualTo(lastTouchTimestamp);
|
||||
}
|
||||
|
||||
private void assertNullCacheSpan(File parent, String key, long offset,
|
||||
long lastAccessTimestamp) {
|
||||
private void assertNullCacheSpan(File parent, String key, long offset, long lastTouchTimestamp) {
|
||||
long cacheFileLength = 0;
|
||||
File cacheFile = SimpleCacheSpan.getCacheFile(parent, index.assignIdForKey(key), offset,
|
||||
lastAccessTimestamp);
|
||||
File cacheFile =
|
||||
SimpleCacheSpan.getCacheFile(parent, index.assignIdForKey(key), offset, lastTouchTimestamp);
|
||||
CacheSpan cacheSpan = SimpleCacheSpan.createCacheEntry(cacheFile, cacheFileLength, index);
|
||||
assertWithMessage(cacheFile.toString()).that(cacheSpan).isNull();
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue