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); }