void UpdateSend()
{
if (filename == null || filename == "")
{
return;
}
string json = File.ReadAllText(filename);
List <ReceivedMessage> messages = JsonConvert.DeserializeObject <List <ReceivedMessage> >(json);
udp_.StartClient(address, port);
count = 0;
double start = MonotonicTimestamp.Now().Seconds();
foreach (var message in messages)
{
double now;
do
{
now = MonotonicTimestamp.Now().Seconds() - start;
} while (now < message.time);
/*if (now < message.time)
* System.Threading.Thread.Sleep(1000 * (int)(message.time - now));*/
udp_.Send(message.buffer, message.buffer.Length);
count++;
}
udp_.Stop();
thread_.Stop();
}
public void StopTimingExecution()
{
if (mStart == null)
{
throw new InvalidOperationException("Execution timing has not been started");
}
if (mEnd == null)
{
mEnd = MonotonicTimestamp.Now();
}
}
void UpdateMessage()
{
while (udp_.messageCount > 0)
{
if (!received)
{
received = true;
baseTime = MonotonicTimestamp.Now().Seconds();
}
double now = MonotonicTimestamp.Now().Seconds();
var buf = udp_.Receive();
var message = new ReceivedMessage();
message.buffer = buf;
message.time = now - baseTime;
messages.Add(message);
count++;
}
}
private async Task ProcessStatsBatchAsync(IEnumerable <StandardExecutionPerformanceMonitorWriteRequest> currentBatch)
{
MonotonicTimestamp startWrite = MonotonicTimestamp
.Now();
List <TaskPerformanceStats> executionTimeInfoBatch =
new List <TaskPerformanceStats>();
try
{
foreach (StandardExecutionPerformanceMonitorWriteRequest rq in currentBatch)
{
executionTimeInfoBatch.Add(new TaskPerformanceStats(rq.PayloadType, rq.DurationMilliseconds));
}
await mStatsWriter.WriteAsync(executionTimeInfoBatch);
foreach (StandardExecutionPerformanceMonitorWriteRequest rq in currentBatch)
{
rq.SetCompleted(1);
}
IncrementPerfMonWriteCount(MonotonicTimestamp
.Since(startWrite));
}
catch (Exception exc)
{
foreach (StandardExecutionPerformanceMonitorWriteRequest rq in currentBatch)
{
rq.SetFailed(exc);
if (rq.CanBeRetried)
{
mStatsProcessingQueue.Add(rq);
}
}
mLogger.Error("Error processing performance stats batch", exc);
}
}
private async Task ProcessResultBatchAsync(Queue <PostgreSqlTaskResultQueueProcessRequest> currentBatch)
{
MonotonicTimestamp startWrite = MonotonicTimestamp
.Now();
//An explicit choice has been made not to use transactions
// since failing to update a result MUST NOT
// cause the other successful updates to be rolled back.
using (NpgsqlConnection conn = await OpenConnectionAsync(CancellationToken.None))
using (NpgsqlCommand updateCmd = new NpgsqlCommand(mUpdateSql, conn))
{
NpgsqlParameter pStatus = updateCmd.Parameters
.Add("t_status", NpgsqlDbType.Integer);
NpgsqlParameter pLastError = updateCmd.Parameters
.Add("t_last_error", NpgsqlDbType.Text);
NpgsqlParameter pErrorCount = updateCmd.Parameters
.Add("t_error_count", NpgsqlDbType.Integer);
NpgsqlParameter pLastErrorIsRecoverable = updateCmd.Parameters
.Add("t_last_error_recoverable", NpgsqlDbType.Boolean);
NpgsqlParameter pProcessingTime = updateCmd.Parameters
.Add("t_processing_time_milliseconds", NpgsqlDbType.Bigint);
NpgsqlParameter pFinalizedAt = updateCmd.Parameters
.Add("t_processing_finalized_at_ts", NpgsqlDbType.TimestampTz);
NpgsqlParameter pId = updateCmd.Parameters
.Add("t_id", NpgsqlDbType.Uuid);
await updateCmd.PrepareAsync();
while (currentBatch.Count > 0)
{
PostgreSqlTaskResultQueueProcessRequest processRq =
currentBatch.Dequeue();
try
{
pStatus.Value = ( int )processRq.ResultToUpdate.Status;
string strLastError = processRq.ResultToUpdate.LastError.ToJson();
if (strLastError != null)
{
pLastError.Value = strLastError;
}
else
{
pLastError.Value = DBNull.Value;
}
pErrorCount.Value = processRq.ResultToUpdate.ErrorCount;
pLastErrorIsRecoverable.Value = processRq.ResultToUpdate.LastErrorIsRecoverable;
pProcessingTime.Value = processRq.ResultToUpdate.ProcessingTimeMilliseconds;
if (processRq.ResultToUpdate.ProcessingFinalizedAtTs.HasValue)
{
pFinalizedAt.Value = processRq.ResultToUpdate.ProcessingFinalizedAtTs;
}
else
{
pFinalizedAt.Value = DBNull.Value;
}
pId.Value = processRq.ResultToUpdate.Id;
int affectedRows = await updateCmd.ExecuteNonQueryAsync();
processRq.SetCompleted(affectedRows);
IncrementResultWriteCount(MonotonicTimestamp
.Since(startWrite));
}
catch (OperationCanceledException)
{
processRq.SetCancelled();
throw;
}
catch (Exception exc)
{
processRq.SetFailed(exc);
if (processRq.CanBeRetried)
{
mResultProcessingQueue.Add(processRq);
}
mLogger.Error("Error processing result", exc);
}
}
await conn.CloseAsync();
}
}
public async Task <IQueuedTaskToken> DequeueAsync(params string[] selectTaskTypes)
{
NpgsqlConnection conn = null;
QueuedTask dequeuedTask = null;
QueuedTaskResult dequeuedTaskResult = null;
PostgreSqlQueuedTaskToken dequeuedTaskToken = null;
MonotonicTimestamp startDequeue;
DateTimeOffset refNow = mTimestampProvider.GetNow();
CheckNotDisposedOrThrow();
try
{
mLogger.DebugFormat("Begin dequeue task. Looking for types: {0}.",
string.Join <string>(",", selectTaskTypes));
startDequeue = MonotonicTimestamp
.Now();
conn = await OpenQueueConnectionAsync();
if (conn == null)
{
return(null);
}
using (NpgsqlTransaction tx = conn.BeginTransaction(IsolationLevel.ReadCommitted))
{
//1. Dequeue means that we acquire lock on a task in the queue
// with the guarantee that nobody else did, and respecting
// the priority and static locks (basically the task_locked_until which says
// that it should not be pulled out of the queue until the
// current abstract time reaches that tick value)
dequeuedTask = await TryDequeueTaskAsync(selectTaskTypes, refNow, conn, tx);
if (dequeuedTask != null)
{
//2. Mark the task as being "Processing" and pull result info
// The result is stored separately and it's what allows us to remove
// the task from the queue at step #2,
// whils also tracking it's processing status and previous results
dequeuedTaskResult = await TryUpdateTaskResultAsync(dequeuedTask, conn, tx);
if (dequeuedTaskResult != null)
{
await tx.CommitAsync();
dequeuedTaskToken = new PostgreSqlQueuedTaskToken(dequeuedTask,
dequeuedTaskResult,
refNow);
}
}
if (dequeuedTaskToken != null)
{
IncrementDequeueCount(MonotonicTimestamp.Since(startDequeue));
}
else
{
await tx.RollbackAsync();
}
}
}
finally
{
if (conn != null)
{
await conn.CloseAsync();
conn.Dispose();
}
}
return(dequeuedTaskToken);
}
public void StartTimingExecution()
{
mStart = MonotonicTimestamp.Now();
mEnd = null;
}
