public void Post(SendOrPostCallback callback, object state)
{
lock (AsyncWorkQueue)
{
WorkRequest workRequest = new WorkRequest(callback, state, null);
AsyncWorkQueue.Enqueue(workRequest);
}
}
public Host1xDevice(SynchronizationManager syncMgr)
{
_syncptIncrMgr = new SyncptIncrManager(syncMgr);
_commandQueue = new AsyncWorkQueue <Command>(Process, "Ryujinx.Host1xProcessor");
Class = new Host1xClass(syncMgr);
_devices.RegisterDevice(ClassId.Host1x, Class);
}
public ThiDevice(ClassId classId, IDeviceState device, SyncptIncrManager syncptIncrMgr)
{
_classId = classId;
_device = device;
_syncptIncrMgr = syncptIncrMgr;
_commandQueue = new AsyncWorkQueue <CommandAction>(Process, $"Ryujinx.{classId}Processor");
_state = new DeviceState <ThiRegisters>(new Dictionary <string, RwCallback>
{
{ nameof(ThiRegisters.IncrSyncpt), new RwCallback(IncrSyncpt, null) },
{ nameof(ThiRegisters.Method1), new RwCallback(Method1, null) }
});
}
public void Execute()
{
lock (AsyncWorkQueue)
{
var workCount = AsyncWorkQueue.Count;
for (int i = 0; i < workCount; i++)
{
var work = AsyncWorkQueue.Dequeue();
work.Invoke();
}
}
}
public override bool Calculate()
{
LibNoise.ModuleBase noiseModule = null;
var mnode = !Inputs[0].IsValueNull ? Inputs[0].GetValue <NodeModuleBase>() : null;
if (mnode != null && mnode.DependenciesMet)
{
noiseModule = mnode.Module;
}
if (noiseModule != null)
{
if (_previewTexture == null)
{
_previewTexture = NodeModuleBase.GenerateDefaultTexture(_previewWidth, _previewHeight);
}
++_nextSequenceId;
int asyncId = _nextSequenceId;
AsyncWorkQueue.QueueBackgroundWork(GetType().Name, () =>
{
// expensive stuff
LibNoise.Noise2D noise2d = new LibNoise.Noise2D(_previewWidth, _previewHeight, noiseModule);
noise2d.GeneratePlanar(PreviewLeft, PreviewRight, PreviewTop, PreviewBottom, PreviewSeamless);
// when we're done, queue the texture creation
AsyncWorkQueue.QueueMainThreadWork(() =>
{
if (asyncId >= _textureSequenceId)
{
_textureSequenceId = asyncId;
_previewTexture = NodeModuleBase.CreateNoiseTexture(noise2d, Colorization);
NodeEditorFramework.NodeEditor.RepaintClients();
}
});
});
}
else
{
_previewTexture = NodeModuleBase.GenerateDefaultTexture(_previewWidth, _previewHeight);
}
NodeEditorFramework.NodeEditor.RepaintClients();
return(true);
}
/// <summary>
/// Create a new cache collection.
/// </summary>
/// <param name="baseCacheDirectory">The directory of the shader cache</param>
/// <param name="hashType">The hash type of the shader cache</param>
/// <param name="graphicsApi">The graphics api of the shader cache</param>
/// <param name="shaderProvider">The shader provider name of the shader cache</param>
/// <param name="cacheName">The name of the cache</param>
/// <param name="version">The version of the cache</param>
public CacheCollection(string baseCacheDirectory, CacheHashType hashType, CacheGraphicsApi graphicsApi, string shaderProvider, string cacheName, ulong version)
{
if (hashType != CacheHashType.XxHash128)
{
throw new NotImplementedException($"{hashType}");
}
_cacheDirectory = GenerateCachePath(baseCacheDirectory, graphicsApi, shaderProvider, cacheName);
_graphicsApi = graphicsApi;
_hashType = hashType;
_version = version;
_hashTable = new HashSet <Hash128>();
Load();
_fileWriterWorkerQueue = new AsyncWorkQueue <CacheFileOperationTask>(HandleCacheTask, $"CacheCollection.Worker.{cacheName}");
}
public override bool Calculate()
{
if (DependenciesMet)
{
PreGenerate();
if (_previewTexture == null)
{
_previewTexture = GenerateDefaultTexture(_previewWidth, _previewHeight);
}
++_nextSequenceId;
int asyncId = _nextSequenceId;
AsyncWorkQueue.QueueBackgroundWork(GetType().Name, () =>
{
// expensive stuff
LibNoise.Noise2D noise2d = new LibNoise.Noise2D(_previewWidth, _previewHeight, Module);
noise2d.GeneratePlanar(PreviewLeft, PreviewRight, PreviewTop, PreviewBottom, PreviewSeamless);
// when we're done, queue the texture creation
AsyncWorkQueue.QueueMainThreadWork(() =>
{
if (asyncId >= _textureSequenceId)
{
_textureSequenceId = asyncId;
_previewTexture = CreateNoiseTexture(noise2d, Colorization);
NodeEditorFramework.NodeEditor.RepaintClients();
}
});
});
}
else
{
_previewTexture = GenerateDefaultTexture(_previewWidth, _previewHeight);
}
NodeEditorFramework.NodeEditor.RepaintClients();
for (int i = 0; i < Outputs.Count; ++i)
{
Outputs[i].SetValue <NodeModuleBase>(this);
}
return(true);
}
public void Send(SendOrPostCallback callback, object state)
{
if (MainThreadID == Thread.CurrentThread.ManagedThreadId)
{
callback(state);
}
else
{
using (ManualResetEvent waitHandle = new ManualResetEvent(false))
{
lock (AsyncWorkQueue)
{
WorkRequest workRequest = new WorkRequest(callback, state, waitHandle);
AsyncWorkQueue.Enqueue(workRequest);
}
waitHandle.WaitOne();
}
}
}
/// <summary>
/// Creates a new background disk cache writer.
/// </summary>
/// <param name="context">GPU context</param>
/// <param name="hostStorage">Disk cache host storage</param>
public BackgroundDiskCacheWriter(GpuContext context, DiskCacheHostStorage hostStorage)
{
_context = context;
_hostStorage = hostStorage;
_fileWriterWorkerQueue = new AsyncWorkQueue <CacheFileOperationTask>(ProcessTask, "Gpu.BackgroundDiskCacheWriter");
}
public static void Test(IEnumerable<int> ids)
{
using (AsyncWorkQueue<Company> q = new AsyncWorkQueue<Company>(3))
{
foreach (int id in ids)
{
int myId = id;
q.Start(delegate {
Console.WriteLine("my id was ... " + myId);
Thread.Sleep( 111);
Console.WriteLine(" long runnint task ... " + myId);
return GetCompany(myId);
});
}
foreach (var result in q.GetResults())
{
if (result.IsError)
//handle / log errors here
throw result.Error;
Company tmpCompany = (Company)result.Value;
Console.WriteLine(tmpCompany.Id);
}
}
}
public static void Main(string[] args)
{
double numberOfRuns = 1000000.0;
//generator = new RandomAdapter();
generator = new UniformGenerator();
int factor = 3;
if (args.Length > 0)
{
factor = Convert.ToInt32(args[0]);
numberOfRuns = Convert.ToDouble(args[1]);
}
Console.WriteLine(string.Format("{0} workers used in this run of {1}", factor,numberOfRuns));
PointEstimate estimate = new PointEstimate();
Stopwatch sw = Stopwatch.StartNew();
using (var q = new AsyncWorkQueue<double>(factor))
{
for (int i=0;i<factor;i++) {
var id = i;
q.Start(delegate
{
SpreadsheetGear.IWorkbookSet workbookSet = SpreadsheetGear.Factory.GetWorkbookSet();
IWorkbook workbook = workbookSet.Workbooks.Open(@"c:\data\dev\Async\AsyncWorkQueueTest\AsyncWorkQueueTest\excel\helloWorld_template.xls");
for (long j = 0; j < numberOfRuns / factor; j++)
{
try
{
double annRevenue = generate(30, 70);
double annCosts = generate(5, 20);
double numYears = generate(2, 6);
var sheet = workbook.Worksheets["Hello"];
sheet.Cells["AnnRevenue"].Value = Convert.ToDouble(annRevenue);
sheet.Cells["AnnCosts"].Value = Convert.ToDouble(annCosts);
sheet.Cells["numYears"].Value = Convert.ToDouble(numYears);
var npvRange = sheet.Cells["npv"];
double npv = (double)npvRange.Value;
//Console.WriteLine("annRevenue = " + annRevenue + ", annCosts = " + annCosts + ", numYears = " + numYears+", NPV = "+npv);
estimate.nextValueIs(npv);
}
catch (Exception e)
{
Console.WriteLine("Process " + id + ", run " + j + ", exception thrown!");
Console.WriteLine(e.StackTrace);
}
}
return 0;
});
Console.WriteLine("Started delegate " + i);
}
Console.WriteLine("*** Done queueing.");
foreach (var result in q.GetResults())
{
if (result.IsError)
//handle / log errors here
throw result.Error;
}
SummaryStatistics statistics = estimate.computeConfidenceIntervalForPercent(99);
sw.Stop();
Console.WriteLine("Mean: " + statistics.pointEstimate + ", [" + statistics.cLower + ", " + statistics.cUpper + "]");
Console.WriteLine("Elapsed time = " + sw.Elapsed);
}
//Test(new List<int>() { 5, 6, 5, 4, 3, 2, 1 });
Console.ReadLine();
}
public UploadManager()
{
_workQueue = new AsyncWorkQueue<Uploader, UploadResult>(UPLOAD_WORKERS_COUNT);
_workQueue.WorkCompleted += Workqueue_UploadWorkCompleted;
_workQueue.StartWorking();
}
public ServerMetadataHandler(string sqliteFilePath) : base(sqliteFilePath)
{
this.WorkQueue = new AsyncWorkQueue();
}
public override bool Calculate()
{
LibNoise.ModuleBase noiseModule = null;
var mnode = !Inputs[0].IsValueNull ? Inputs[0].GetValue <NodeModuleBase>() : null;
if (mnode != null && mnode.DependenciesMet)
{
noiseModule = mnode.Module;
}
if (noiseModule != null)
{
if (_previewTexture == null)
{
_previewTexture = NodeModuleBase.GenerateDefaultTexture(_previewWidth, _previewHeight);
}
++_nextSequenceId;
int asyncId = _nextSequenceId;
AsyncWorkQueue.QueueBackgroundWork(GetType().Name, () =>
{
LibNoise.Noise2D noise2d = new LibNoise.Noise2D(_previewWidth, _previewHeight, noiseModule);
noise2d.GeneratePlanar(PreviewLeft, PreviewRight, PreviewTop, PreviewBottom, PreviewSeamless);
float[,] noiseData = noise2d.GetData();
bool[,] cellular = new bool[noiseData.GetLength(0), noiseData.GetLength(1)];
for (var x = 0; x < noiseData.GetLength(0); x++)
{
for (var y = 0; y < noiseData.GetLength(1); y++)
{
cellular[x, y] = noiseData[x, y] > Cutoff;
}
}
bool[,] dstMap = new bool[noiseData.GetLength(0), noiseData.GetLength(1)];
for (int i = 0; i < SmoothIterations; ++i)
{
SmoothMap(cellular, dstMap);
// swap the array references
bool[,] tmp = cellular;
cellular = dstMap;
dstMap = tmp;
}
// when we're done, queue the texture creation
AsyncWorkQueue.QueueMainThreadWork(() =>
{
if (asyncId >= _textureSequenceId)
{
_textureSequenceId = asyncId;
var pixels = new Color[cellular.GetLength(0) * cellular.GetLength(1)];
_previewTexture = new Texture2D(cellular.GetLength(0), cellular.GetLength(1));
_previewTexture.wrapMode = TextureWrapMode.Clamp;
_previewTexture.alphaIsTransparency = true;
for (var x = 0; x < noiseData.GetLength(0); x++)
{
for (var y = 0; y < noiseData.GetLength(1); y++)
{
pixels[x + y * noiseData.GetLength(0)] = cellular[x, y] ? Color.black : Color.white;
}
}
_previewTexture.SetPixels(pixels);
_previewTexture.Apply();
NodeEditorFramework.NodeEditor.RepaintClients();
}
});
});
}
else
{
_previewTexture = NodeModuleBase.GenerateDefaultTexture(_previewWidth, _previewHeight);
}
NodeEditorFramework.NodeEditor.RepaintClients();
return(true);
}
AsyncWorkQueue()
{
Instance = this;
}
public ServerBase(string name)
{
_ipcProcessor = new AsyncWorkQueue <IpcRequest>(Process, name);
}
