public async Task PutObject_NoActiveReferences_ForceOneEviction_VerifyCorrectEviction()
{
int contentSize = 2 * 1024 * 1024; // 2MB
int cacheSize = 6 * 1024 * 1024; // 6MB
string cacheSizeVal = cacheSize.ToString();
IEnvironment environment = new TestEnvironment();
environment.SetEnvironmentVariable(FunctionDataCacheConstants.FunctionDataCacheMaximumSizeBytesSettingName, cacheSizeVal);
environment.SetEnvironmentVariable(FunctionDataCacheConstants.FunctionDataCacheEnabledSettingName, "1");
using (ISharedMemoryManager manager = new SharedMemoryManager(_loggerFactory, _mapAccessor))
using (FunctionDataCache cache = new FunctionDataCache(manager, _loggerFactory, environment))
{
// Prepare content
byte[] content = TestUtils.GetRandomBytesInArray(contentSize);
// Put into shared memory as three distinct objects
SharedMemoryMetadata metadata1 = await manager.PutObjectAsync(content);
SharedMemoryMetadata metadata2 = await manager.PutObjectAsync(content);
SharedMemoryMetadata metadata3 = await manager.PutObjectAsync(content);
// Put the three objects into the cache
FunctionDataCacheKey key1 = new FunctionDataCacheKey("foo1", "bar1");
FunctionDataCacheKey key2 = new FunctionDataCacheKey("foo2", "bar2");
FunctionDataCacheKey key3 = new FunctionDataCacheKey("foo3", "bar3");
Assert.True(cache.TryPut(key1, metadata1, isIncrementActiveReference: false, isDeleteOnFailure: false));
Assert.True(cache.TryPut(key2, metadata2, isIncrementActiveReference: false, isDeleteOnFailure: false));
Assert.True(cache.TryPut(key3, metadata3, isIncrementActiveReference: false, isDeleteOnFailure: false));
// Verify that the cache is full
Assert.Equal(0, cache.RemainingCapacityBytes);
// At this point, the cache is full.
// We will create another object and try to insert it.
// This should be inserted (as another object will be evicted to make room for this).
SharedMemoryMetadata metadata4 = await manager.PutObjectAsync(content);
FunctionDataCacheKey key4 = new FunctionDataCacheKey("foo4", "bar4");
Assert.True(cache.TryPut(key4, metadata4, isIncrementActiveReference: false, isDeleteOnFailure: false));
// The first object should be evicted (least recently used) by now
Assert.False(cache.TryGet(key1, isIncrementActiveReference: false, out var _));
// Try to open the shared memory map of the first object and ensure it is removed and cannot be opened
Assert.False(_mapAccessor.TryOpen(metadata1.MemoryMapName, out var _));
// The last three objects (the first two added before eviction and the one resulting in eviction) should be present
Assert.True(cache.TryGet(key2, isIncrementActiveReference: false, out var _));
Assert.True(cache.TryGet(key3, isIncrementActiveReference: false, out var _));
Assert.True(cache.TryGet(key4, isIncrementActiveReference: false, out var _));
// Verify that the cache is full
Assert.Equal(0, cache.RemainingCapacityBytes);
}
}
/// <summary>
/// Helper method to open a <see cref="SharedMemoryMap"/> for tests.
/// </summary>
/// <param name="mapName">Name of the <see cref="MemoryMappedFile"/> backing the <see cref="SharedMemoryMap"/>.</param>
/// <returns><see cref="SharedMemoryMap"/> that was opened, <see cref="null"/> in case of failure.</returns>
private SharedMemoryMap Open(string mapName)
{
if (_mapAccessor.TryOpen(mapName, out MemoryMappedFile mmf))
{
return(new SharedMemoryMap(_loggerFactory, _mapAccessor, mapName, mmf));
}
return(null);
}
/// <summary>
/// Open a <see cref="SharedMemoryMap"/> with the given name.
/// </summary>
/// <param name="mapName">Size of <see cref="SharedMemoryMap"/> to open.</param>
/// <returns><see cref="SharedMemoryMap"/> if opened successfully, <see cref="null"/> otherwise.</returns>
private SharedMemoryMap Open(string mapName)
{
if (_mapAccessor.TryOpen(mapName, out MemoryMappedFile mmf))
{
return(new SharedMemoryMap(_loggerFactory, _mapAccessor, mapName, mmf));
}
_logger.LogTrace("Cannot open shared memory map: {MapName}", mapName);
return(null);
}
public async Task FreeSharedMemoryMap_VerifySuccess()
{
// Prepare content
string content = "foobar";
using (SharedMemoryManager manager = new SharedMemoryManager(_loggerFactory, _mapAccessor))
{
// Put content into shared memory
SharedMemoryMetadata metadata = await manager.PutObjectAsync(content);
string mapName = metadata.MemoryMapName;
// Free the shared memory map and try top open it after freeing; should not open
Assert.True(manager.TryFreeSharedMemoryMap(mapName));
Assert.False(_mapAccessor.TryOpen(mapName, out _));
}
}
public void Create_Open_VerifyOpened()
{
long size = 1024;
string mapName = Guid.NewGuid().ToString();
// Create
Assert.True(_mapAccessor.TryCreate(mapName, size, out MemoryMappedFile mmf1));
Assert.NotNull(mmf1);
// Open
Assert.True(_mapAccessor.TryOpen(mapName, out MemoryMappedFile mmf2));
Assert.NotNull(mmf2);
_mapAccessor.Delete(mapName, mmf1);
_mapAccessor.Delete(mapName, mmf2);
}
