public void Queue(MainLoopTask task)
{
DelegateTask dTask = cache.Dequeue();
dTask.Task = task;
Queue(dTask);
}
public void Queue(MainLoopTask task)
{
var dTask = _cache.Dequeue();
dTask.Task = task;
Queue(dTask);
}
static void Time(MainLoopTask task, string title)
{
long start = Environment.TickCount;
task();
Console.WriteLine("{0} - {1}ms", title, Environment.TickCount - start);
}
public void Initialise()
{
isBlocking = false;
job = null;
jobResult = null;
storedException = null;
task = null;
timeout = null;
timeoutResult = false;
}
/// <summary> Queues an action that is asynchronously executed. </summary>
public void Queue(MainLoopTask action)
{
SchedulerTask task = new SchedulerTask();
task.Task = action;
lock (tasks) {
tasks.Enqueue(task);
handle.Set();
}
}
public void QueueWait(MainLoopTask task)
{
DelegateTask dTask = cache.Dequeue();
dTask.Task = task;
try
{
QueueWait(dTask);
}
finally
{
cache.Enqueue(dTask);
}
}
public void QueueWait(MainLoopTask task)
{
var dTask = _cache.Dequeue();
dTask.Task = task;
try
{
QueueWait(dTask);
}
finally
{
_cache.Enqueue(dTask);
}
}
public void QueueWait(MainLoopTask task)
{
DelegateTask dTask = cache.Dequeue();
dTask.Task = task;
try
{
QueueWait(dTask);
}
finally
{
cache.Enqueue(dTask);
}
}
public void QueueWait(MainLoopTask task)
{
if (IsInCurrentThread())
{
task();
return;
}
var dTask = _cache.Dequeue();
dTask.Task = task;
try
{
QueueWait(dTask);
}
finally
{
_cache.Enqueue(dTask);
}
}
internal DiskManager(ClientEngine engine, PieceWriter writer)
{
this.bufferedReads = new Queue <BufferedIO>();
this.bufferedWrites = new Queue <BufferedIO>();
this.cache = new Cache <BufferedIO>(true).Synchronize();
this.engine = engine;
this.readLimiter = new RateLimiter();
this.readMonitor = new SpeedMonitor();
this.writeMonitor = new SpeedMonitor();
this.writeLimiter = new RateLimiter();
this.writer = writer;
LoopTask = delegate {
if (disposed)
{
return;
}
while (this.bufferedWrites.Count > 0 && writeLimiter.TryProcess(bufferedWrites.Peek().buffer.Length / 2048))
{
BufferedIO write;
lock (bufferLock)
write = this.bufferedWrites.Dequeue();
try
{
PerformWrite(write);
cache.Enqueue(write);
}
catch (Exception ex)
{
Logger.Log(null, "Write error: {0}", ex.Message);
if (write.Manager != null)
{
SetError(write.Manager, Reason.WriteFailure, ex);
}
}
}
while (this.bufferedReads.Count > 0 && readLimiter.TryProcess(bufferedReads.Peek().Count / 2048))
{
BufferedIO read;
lock (bufferLock)
read = this.bufferedReads.Dequeue();
try
{
PerformRead(read);
cache.Enqueue(read);
}
catch (Exception ex)
{
Logger.Log(null, "Read error: {0}", ex.Message);
if (read.Manager != null)
{
SetError(read.Manager, Reason.ReadFailure, ex);
}
}
}
};
IOLoop.QueueTimeout(TimeSpan.FromSeconds(1), delegate {
if (disposed)
{
return(false);
}
readMonitor.Tick();
writeMonitor.Tick();
LoopTask();
return(true);
});
}
public void Queue(MainLoopTask task)
{
var dTask = _cache.Dequeue();
dTask.Task = task;
Queue(dTask);
}
public void QueueWait(MainLoopTask task)
{
if (IsInCurrentThread())
{
task();
return;
}
var dTask = _cache.Dequeue();
dTask.Task = task;
try
{
QueueWait(dTask);
}
finally
{
_cache.Enqueue(dTask);
}
}
internal DiskManager(ClientEngine engine, PieceWriter writer)
{
_bufferedReads = new Queue <BufferedIO>();
_bufferedWrites = new Queue <BufferedIO>();
_cache = new Cache <BufferedIO>(true).Synchronize();
_engine = engine;
ReadLimiter = new RateLimiter();
_readMonitor = new SpeedMonitor();
_writeMonitor = new SpeedMonitor();
WriteLimiter = new RateLimiter();
_writer = writer;
_loopTask = delegate {
if (_disposed)
{
return;
}
while (_bufferedWrites.Count > 0 && WriteLimiter.TryProcess(_bufferedWrites.Peek().buffer.Length / 2048))
{
BufferedIO write;
lock (_bufferLock)
write = _bufferedWrites.Dequeue();
try
{
PerformWrite(write);
_cache.Enqueue(write);
}
catch (Exception ex)
{
if (write.Manager != null)
{
SetError(write.Manager, Reason.WriteFailure, ex);
}
}
}
while (_bufferedReads.Count > 0 && ReadLimiter.TryProcess(_bufferedReads.Peek().Count / 2048))
{
BufferedIO read;
lock (_bufferLock)
read = _bufferedReads.Dequeue();
try
{
PerformRead(read);
_cache.Enqueue(read);
}
catch (Exception ex)
{
if (read.Manager != null)
{
SetError(read.Manager, Reason.ReadFailure, ex);
}
}
}
};
IOLoop.QueueTimeout(TimeSpan.FromSeconds(1), () =>
{
if (_disposed)
{
return(false);
}
_readMonitor.Tick();
_writeMonitor.Tick();
_loopTask();
return(true);
});
}
internal DiskManager(ClientEngine engine, PieceWriter writer)
{
this.bufferedReads = new Queue<BufferedIO>();
this.bufferedWrites = new Queue<BufferedIO>();
this.cache = new Cache<BufferedIO>(true).Synchronize ();
this.engine = engine;
this.readLimiter = new RateLimiter();
this.readMonitor = new SpeedMonitor();
this.writeMonitor = new SpeedMonitor();
this.writeLimiter = new RateLimiter();
this.writer = writer;
LoopTask = delegate {
if (disposed)
return;
while (this.bufferedWrites.Count > 0 && writeLimiter.TryProcess(bufferedWrites.Peek ().buffer.Length / 2048))
{
BufferedIO write;
lock (bufferLock)
write = this.bufferedWrites.Dequeue();
try
{
PerformWrite(write);
cache.Enqueue (write);
}
catch (Exception ex)
{
if (write.Manager != null)
SetError(write.Manager, Reason.WriteFailure, ex);
}
}
while (this.bufferedReads.Count > 0 && readLimiter.TryProcess(bufferedReads.Peek().Count / 2048))
{
BufferedIO read;
lock(bufferLock)
read = this.bufferedReads.Dequeue();
try
{
PerformRead(read);
cache.Enqueue (read);
}
catch (Exception ex)
{
if(read.Manager != null)
SetError(read.Manager, Reason.ReadFailure, ex);
}
}
};
IOLoop.QueueTimeout(TimeSpan.FromSeconds(1), delegate {
if (disposed)
return false;
readMonitor.Tick();
writeMonitor.Tick();
LoopTask();
return true;
});
}
static void Time(MainLoopTask task, string title)
{
long start = Environment.TickCount;
task();
Console.WriteLine("{0} - {1}ms", title, Environment.TickCount - start);
}
public void Queue(MainLoopTask task)
{
DelegateTask dTask = cache.Dequeue();
dTask.Task = task;
Queue(dTask);
}
public void Initialise()
{
isBlocking = false;
job = null;
jobResult = null;
storedException = null;
task = null;
timeout = null;
timeoutResult = false;
}
