public static List<object> StartConcurrent(params ConcurrentAction[] actions)
{
var allWait = new PointerContainer { Marker = actions.Length - 1 };
var startWait = new AutoResetEvent(false);
var endWait = new AutoResetEvent(false);
foreach (var action in actions)
{
action.EventStarted = startWait;
action.EventTerminated = endWait;
action.WaitCount = allWait;
var th = new Thread(RunSingleAction);
th.Start(action);
}
startWait.Set();
//Wait for threads to start
Thread.Sleep(1000);
endWait.WaitOne(60 * 1000);
var resultList = new List<object>();
foreach (var action in actions)
{
resultList.Add(action.Result);
}
return resultList;
}
public FixedFieldSpec(ModuleContainer module, TypeSpec declaringType, IMemberDefinition definition, FieldInfo info, FieldSpec element, Modifiers modifiers)
: base(declaringType, definition, PointerContainer.MakeType(module, element.MemberType), info, modifiers)
{
this.element = element;
// It's never CLS-Compliant
state &= ~StateFlags.CLSCompliant_Undetected;
}
/// <summary>
/// Handles the <see cref="Facade.Interactor"/> untouching state.
/// </summary>
/// <param name="interactable">The Interactable being touched.</param>
protected virtual void HasUntouched(InteractableFacade interactable)
{
EnablePointerContainer.SetActive(true);
if (!DisablePointerOnInteractorTouch || ShouldIgnoreEnablePointer)
{
return;
}
PointerContainer.SetActive(true);
}
/// <summary>
/// Handles the <see cref="Facade.Interactor"/> touching state.
/// </summary>
/// <param name="interactable">The Interactable being touched.</param>
protected virtual void HasTouched(InteractableFacade interactable)
{
if (!DisablePointerOnInteractorTouch)
{
return;
}
PointerContainer.SetActive(false);
EnablePointerContainer.SetActive(false);
}
private unsafe ContentCharData LoadToOneBuffer(byte *ptr, List <long> splitIndexes, long length)
{
var maxCount = Encoding.UTF8.GetMaxCharCount((int)length);
var container = new PointerContainer();
var result = new char[maxCount];
fixed(char *charPtr = result)
{
container.data = charPtr;
}
// Note: loading into multiple char[] arrays and combining them affterwards takes +50% more time.
// Do the character count sequentially. Doing multiple reads at the same time slows down cold access
// to a file. This does slow down access to cached files by about 25%.
var charSizes = new int[splitIndexes.Count];
for (var i = 0; i < splitIndexes.Count - 1; i++)
{
var startPos = splitIndexes[i];
var endPos = splitIndexes[i + 1];
charSizes[i] = Encoding.UTF8.GetCharCount(ptr + startPos, (int)(endPos - startPos));
}
// Doing this in parallel obviously assumes that the entire file will be cached in memory.
// But since we're loading everything into a char[] array anyways that doesn't seem like an
// unreasonable assumption.
// Even if this does not run in parallel, we still get the speedup from the reduced copying.
// Only one copy is ever made, namely from byte* -> char[].
var dataLength = 0;
Parallel.For(0, splitIndexes.Count - 1, (i) =>
{
var startPos = (int)splitIndexes[i];
var endPos = (int)splitIndexes[i + 1];
var charOffset = charSizes.Take(i).Sum();
var len = Encoding.UTF8.GetChars(ptr + startPos, endPos - startPos, container.data + charOffset, result.Length - charOffset);
Interlocked.Add(ref dataLength, len);
});
return(new ContentCharData(result, dataLength));
}
