internal void Increment(TraceEvent data)
{
#if DEBUG
// Debug.Assert((byte)data.opcode != unchecked((byte)-1)); // Means PrepForCallback not done.
Debug.Assert(data.TaskName != "ERRORTASK");
Debug.Assert(data.OpcodeName != "ERROROPCODE");
#endif
Count++;
TaskStats task = this[data.TaskName];
if (task.ProviderName == null)
{
task.ProviderName = data.ProviderName;
}
CallStackIndex index = data.CallStackIndex();
bool hasStack = (index != CallStackIndex.Invalid);
if (hasStack)
{
StackCount++;
}
task.Increment(data.OpcodeName, hasStack);
StackWalkTraceData asStackWalk = data as StackWalkTraceData;
if (asStackWalk != null)
{
StackWalkStats stackWalkStats = task.ExtraData as StackWalkStats;
if (stackWalkStats == null)
{
stackWalkStats = new StackWalkStats();
task.ExtraData = stackWalkStats;
}
stackWalkStats.Log(asStackWalk);
}
}
/// <summary>
/// Run the task, record statistics.
/// </summary>
/// <param name="reportStats"></param>
/// <returns>Number of work items done by this task.</returns>
public int RunAndMaybeStats(bool reportStats)
{
int count;
if (!reportStats || ShouldNotRecordStats)
{
Setup();
count = DoLogic();
count = disableCounting ? 0 : count;
TearDown();
return(count);
}
if (reportStats && depth <= maxDepthLogStart && !ShouldNeverLogAtStart)
{
Console.WriteLine("------------> starting task: " + GetName());
}
Setup();
Points pnts = runData.Points;
TaskStats ts = pnts.MarkTaskStart(this, runData.Config.RoundNumber);
count = DoLogic();
count = disableCounting ? 0 : count;
pnts.MarkTaskEnd(ts, count);
TearDown();
return(count);
}
private int DoParallelTasks()
{
TaskStats stats = RunData.Points.CurrentStats;
InitTasksArray();
ParallelTask[] t = runningParallelTasks = new ParallelTask[repetitions * tasks.Count];
// prepare threads
int index = 0;
for (int k = 0; k < repetitions; k++)
{
for (int i = 0; i < tasksArray.Length; i++)
{
PerfTask task = (PerfTask)(tasksArray[i].Clone());
t[index++] = new ParallelTask(this, task);
}
}
// run threads
StartThreads(t);
if (Stop)
{
foreach (ParallelTask task in t)
{
task.Task.StopNow();
}
}
// wait for all threads to complete
int count = 0;
for (int i = 0; i < t.Length; i++)
{
t[i].Join();
count += t[i].Count;
if (t[i].Task is TaskSequence sub && sub.countsByTime != null)
{
if (countsByTime == null)
{
countsByTime = new int[sub.countsByTime.Length];
}
else if (countsByTime.Length < sub.countsByTime.Length)
{
countsByTime = ArrayUtil.Grow(countsByTime, sub.countsByTime.Length);
}
for (int j = 0; j < sub.countsByTime.Length; j++)
{
countsByTime[j] += sub.countsByTime[j];
}
}
}
if (countsByTime != null)
{
stats.SetCountsByTime(countsByTime, logByTimeMsec);
}
// return total count
return(count);
}
static private void CreateTaskStats(TaskHolder statsHolder)
{
//TextAsset csvText = (TextAsset)AssetDatabase.LoadAssetAtPath(CSV_FOLDER + "/database - task.csv", typeof(TextAsset));
string csvText = System.IO.File.ReadAllText(Application.streamingAssetsPath + "/ExternalDatabase/CSV/" + ParameterFlag.CSVFileName.Task);
CSVFile csvFile = new CSVFile(csvText);
AssetDatabase.CreateFolder(ASSETS_FOLDER + "/Asset", "Task");
int csvCount = csvFile.length;
for (int i = 0; i < csvCount; i++)
{
string id = csvFile.Get <string>(i, "ID");
if (string.IsNullOrEmpty(id))
{
continue;
}
TaskStats c_prefab = ScriptableObjectUtility.CreateAsset <TaskStats>(ASSETS_FOLDER + "/Asset/Task/", "[TaskStats] " + id);
EditorUtility.SetDirty(c_prefab);
c_prefab.id = id;
c_prefab.tag = csvFile.Get <string>(i, "Tag");
c_prefab.label = csvFile.Get <string>(i, "Name");
c_prefab.cost = csvFile.Get <string>(i, "Cost");
c_prefab.effect = csvFile.Get <string>(i, "Effect");
c_prefab.desc = csvFile.Get <string>(i, "Description");
statsHolder.stpObjectHolder.Add(c_prefab);
}
}
private void SetInfo(TaskStats taskStat)
{
title.text = taskStat.label;
description.text = "";
string effectString = TaskCalculationHelper.GetDictPureString(TaskCalculationHelper.ParseRawString(taskStat.effect));
string costString = TaskCalculationHelper.GetDictPureString(TaskCalculationHelper.ParseRawString(taskStat.cost));
description.text += "Effect : " + effectString;
description.text += "Cost : " + costString;
}
public TaskStats this[string taskName]
{
get
{
TaskStats ret;
if (!Tasks.TryGetValue(taskName, out ret))
{
ret = new TaskStats();
ret.Name = taskName;
Tasks.Add(taskName, ret);
}
return(ret);
}
}
public ActionResult Stat()
{
var intervalTask = IntervalTask.Current;
var vm = new TaskStats
{
Counter = App.Counter.ToString(),
TimerWokeup = formatDateTime(intervalTask.TimerWokeup),
TimerStarted = formatDateTime(intervalTask.TimerStarted),
TaskStarted = formatDateTime(intervalTask.TaskStarted),
TaskEnded = formatDateTime(intervalTask.TaskEnded)
};
return(Json(vm));
}
public TaskInfo(
TaskStatus taskStatus,
DateTime lastHeartbeat,
OutputBufferInfo outputBuffers,
HashSet <PlanNodeId> noMoreSplits,
TaskStats stats,
bool needsPlan,
bool complete
)
{
this.TaskStatus = taskStatus ?? throw new ArgumentNullException("taskStatus");
this.LastHeartbeat = lastHeartbeat;
this.OutputBuffers = outputBuffers ?? throw new ArgumentNullException("outputBuffers");
this.NoMoreSplits = noMoreSplits ?? throw new ArgumentNullException("noMoreSplits");
this.Stats = stats ?? throw new ArgumentNullException("stats");
this.NeedsPlan = needsPlan;
this.Complete = complete;
}
public IEnumerable <TaskStats> GetJobStatsInGroup(string groupName)
{
var groupJobsStats = new List <TaskStats>();
var jobNames = _clockServiceStats.GetJobNamesForGroup(groupName).Result;
foreach (var job in jobNames)
{
var stats = new TaskStats();
var taskBase = _clockServiceStats.GetTaskBase(job, groupName).Result;
stats.TaskId = taskBase.TaskId;
stats.Endpoint = taskBase.Endpoint;
stats.StartDate = taskBase.StartDate;
stats.Id = taskBase.Id;
stats.Type = taskBase.Type;
stats.Group = groupName;
groupJobsStats.Add(stats);
}
return(groupJobsStats);
}
/// <summary>
/// Compute a report line for the given task stat.
/// </summary>
/// <param name="longestOp">Size of longest op name in the table.</param>
/// <param name="stat">Task stat to be printed.</param>
/// <returns>The report line.</returns>
protected virtual string TaskReportLine(string longestOp, TaskStats stat)
{
PerfTask task = stat.Task;
StringBuilder sb = new StringBuilder();
sb.Append(Formatter.Format(task.GetName(), longestOp));
string round = (stat.Round >= 0 ? "" + stat.Round : "-");
sb.Append(Formatter.FormatPaddLeft(round, ROUND));
sb.Append(RunData.Config.GetColsValuesForValsByRound(stat.Round));
sb.Append(Formatter.Format(stat.NumRuns, RUNCNT));
sb.Append(Formatter.Format(stat.Count / stat.NumRuns, RECCNT));
long elapsed = (stat.Elapsed > 0 ? stat.Elapsed : 1); // assume at least 1ms
sb.Append(Formatter.Format(2, (float)(stat.Count * 1000.0 / elapsed), RECSEC));
sb.Append(Formatter.Format(2, (float)stat.Elapsed / 1000, ELAPSED));
sb.Append(Formatter.Format(0, (float)stat.MaxUsedMem / stat.NumRuns, USEDMEM));
sb.Append(Formatter.Format(0, (float)stat.MaxTotMem / stat.NumRuns, TOTMEM));
return(sb.ToString());
}
public void SetUp(TaskStats taskStat)
{
_taskStat = taskStat;
SetInfo(_taskStat);
}
public static TaskInfo CreateInitialTask(TaskId taskId, Uri location, string nodeId, IEnumerable <BufferInfo> bufferStates, TaskStats taskStats)
{
return(new TaskInfo(
TaskStatus.InitialTaskStatus(taskId, location, nodeId),
DateTime.Now,
new OutputBufferInfo("UNINITIALIZED", BufferState.OPEN, true, true, 0, 0, 0, 0, bufferStates),
new HashSet <PlanNodeId>(),
taskStats,
true,
false
));
}
