public KeyCheckpointFileAsyncEnumerator <TKey, TValue> GetAsyncEnumerator <TKey, TValue>(
IStateSerializer <TKey> keySerializer,
string traceType,
Kernel32Types.PRIORITY_HINT priorityHint = Kernel32Types.PRIORITY_HINT.IoPriorityHintNormal)
{
return(this.KeyCheckpointFile.GetAsyncEnumerator <TKey, TValue>(keySerializer, traceType, priorityHint));
}
private void SetInformationTest(bool isLongPath, Kernel32Types.PRIORITY_HINT priorityHintOne, Kernel32Types.PRIORITY_HINT priorityHintTwo)
{
var folderPath = this.testPath;
if (isLongPath == true)
{
folderPath = this.ExtendPath(folderPath);
}
var filePath = Path.Combine(folderPath, this.testFileName);
Assert.IsTrue(!isLongPath || filePath.Length > 260, "file path must be greater than max path size.");
FabricDirectory.CreateDirectory(folderPath);
using (FileStream fileStream = FabricFile.Open(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read))
{
var fileHandle = fileStream.SafeFileHandle;
// Verify that the default is Normal.
this.VerifyPriorityHint(fileHandle, Kernel32Types.PRIORITY_HINT.IoPriorityHintNormal);
this.SetPriorityHint(fileHandle, priorityHintOne);
this.VerifyPriorityHint(fileHandle, priorityHintOne);
if (priorityHintTwo != Kernel32Types.PRIORITY_HINT.MaximumIoPriorityHintType)
{
this.SetPriorityHint(fileHandle, priorityHintTwo);
this.VerifyPriorityHint(fileHandle, priorityHintTwo);
}
}
}
/// <summary>
/// Reserved for private static ValueCheckpointFile.OpenAsync().
/// </summary>
private ValueCheckpointFile(string filename, Kernel32Types.PRIORITY_HINT priorityHint = Kernel32Types.PRIORITY_HINT.IoPriorityHintNormal)
{
// Open the file for read with asynchronous flag and 4096 cache size (C# default).
this.ReaderPool = new StreamPool(
() => FabricFile.Open(filename, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.Asynchronous | FileOptions.RandomAccess));
this.priorityHint = priorityHint;
}
/// <summary>
/// Create a new value checkpoint file with the given filename.
/// </summary>
/// <param name="filename">Path to the checkpoint file.</param>
/// <param name="fileId">File Id of the checkpoint file.</param>
/// <param name="traceType">trace id</param>
/// <param name="priorityHint">The priority hint.</param>
public ValueCheckpointFile(string filename, uint fileId, string traceType, Kernel32Types.PRIORITY_HINT priorityHint = Kernel32Types.PRIORITY_HINT.IoPriorityHintNormal)
: this(filename, priorityHint)
{
this.traceType = traceType;
this.Properties = new ValueCheckpointFileProperties()
{
FileId = fileId,
};
}
public KeyCheckpointFileAsyncEnumerator <TKey, TValue> GetAsyncEnumerator <TKey, TValue>(
IStateSerializer <TKey> keySerializer,
string traceType,
Kernel32Types.PRIORITY_HINT priorityHint = Kernel32Types.PRIORITY_HINT.IoPriorityHintNormal)
{
return(new KeyCheckpointFileAsyncEnumerator <TKey, TValue>(
this,
keySerializer,
this.Properties.KeysHandle.Offset,
this.Properties.KeysHandle.EndOffset,
traceType,
priorityHint));
}
private void SetPriorityHint(SafeFileHandle fileHandle, Kernel32Types.PRIORITY_HINT priorityHint)
{
Kernel32Types.FileInformation fileInformation = new Kernel32Types.FileInformation();
fileInformation.FILE_IO_PRIORITY_HINT_INFO.PriorityHint = priorityHint;
bool isSet = FabricFile.SetFileInformationByHandle(
fileHandle,
Kernel32Types.FILE_INFO_BY_HANDLE_CLASS.FileIoPriorityHintInfo,
ref fileInformation,
Marshal.SizeOf(fileInformation.FILE_IO_PRIORITY_HINT_INFO));
Assert.IsTrue(isSet);
}
/// <summary>
/// Reserved for private static ValueCheckpointFile.OpenAsync().
/// </summary>
private ValueCheckpointFile(string filename, Kernel32Types.PRIORITY_HINT priorityHint = Kernel32Types.PRIORITY_HINT.IoPriorityHintNormal)
{
// Open the file for read with asynchronous flag and 4096 cache size (C# default).
// Because of the issue at https://github.com/dotnet/corefx/issues/6007
// where asynchonous reads can internally be synchronous reads with wait calls, we can be
// bottlenecked by the limited number of I/O completion ports in overlapped I/O
// causing a lot of blocked threads and extreme slowdown when met with a large number
// of concurrent reads. Due to this, we chose to disable the FileOptions.Asynchronous option.
this.ReaderPool = new StreamPool(
() => FabricFile.Open(filename, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.RandomAccess));
this.priorityHint = priorityHint;
}
private void VerifyPriorityHint(SafeFileHandle fileHandle, Kernel32Types.PRIORITY_HINT priorityHint)
{
NTTypes.IO_STATUS_BLOCK statusBlock = new NTTypes.IO_STATUS_BLOCK();
NTTypes.FILE_IO_PRIORITY_HINT_INFORMATION ioPriorityHintInfo = new NTTypes.FILE_IO_PRIORITY_HINT_INFORMATION();
IntPtr ioPriorityHintInfoPtr = Marshal.AllocHGlobal(Marshal.SizeOf(ioPriorityHintInfo));
IntPtr queryStatus = FabricFile.NtQueryInformationFile(fileHandle, ref statusBlock, ioPriorityHintInfoPtr, (uint)Marshal.SizeOf(ioPriorityHintInfo), NTTypes.FILE_INFORMATION_CLASS.FileIoPriorityHintInformation);
bool isQuerySuccessful = (queryStatus == IntPtr.Zero) && (statusBlock.Status == 0);
Assert.IsTrue(isQuerySuccessful);
ioPriorityHintInfo = (NTTypes.FILE_IO_PRIORITY_HINT_INFORMATION)Marshal.PtrToStructure(ioPriorityHintInfoPtr, typeof(NTTypes.FILE_IO_PRIORITY_HINT_INFORMATION));
Assert.AreEqual <int>((int)ioPriorityHintInfo.PriorityHint, (int)priorityHint);
}
public static void SetIoPriorityHint(SafeFileHandle safeFileHandle, Kernel32Types.PRIORITY_HINT priorityHintInfo)
{
Kernel32Types.FileInformation fileInformation = new Kernel32Types.FileInformation();
fileInformation.FILE_IO_PRIORITY_HINT_INFO.PriorityHint = priorityHintInfo;
bool isSet = FabricFile.SetFileInformationByHandle(
safeFileHandle,
Kernel32Types.FILE_INFO_BY_HANDLE_CLASS.FileIoPriorityHintInfo,
ref fileInformation,
Marshal.SizeOf(fileInformation.FILE_IO_PRIORITY_HINT_INFO));
if (isSet == false)
{
int status = Marshal.GetLastWin32Error();
Assert(false, "SetFileInformationByHandle failed: ErrorCode: {0}", status);
}
}
public KeyCheckpointFileAsyncEnumerator(
KeyCheckpointFile keyCheckpointFile,
IStateSerializer <TKey> keySerializer,
long startOffset,
long endOffset,
string traceType,
Kernel32Types.PRIORITY_HINT priorityHint = Kernel32Types.PRIORITY_HINT.IoPriorityHintNormal)
{
this.traceType = traceType;
this.keyCheckpointFile = keyCheckpointFile;
this.stateZero = true;
this.index = -1;
this.keySerializer = keySerializer;
this.startOffset = startOffset;
this.endOffset = endOffset;
this.priorityHint = priorityHint;
}
public void SetIoPriority(Kernel32Types.PRIORITY_HINT priorityHint)
{
this.priorityHint = priorityHint;
}
public void SetValueFileIoPriority(Kernel32Types.PRIORITY_HINT priorityHint)
{
this.ValueCheckpointFile.SetIoPriority(priorityHint);
}
private void SetInformationTest(bool isLongPath, Kernel32Types.PRIORITY_HINT priorityHint)
{
this.SetInformationTest(isLongPath, priorityHint, Kernel32Types.PRIORITY_HINT.MaximumIoPriorityHintType);
}
