public void RegisterFirstPass(TraceJob traceJob)
{
traceJob.EtwTraceEventSource.Kernel.SystemConfigCPU +=
e => PublishSysConfigAttribute(traceJob, nameof(e.NumberOfProcessors), e.NumberOfProcessors);
traceJob.EtwTraceEventSource.Kernel.SystemConfigCPU +=
e => PublishSysConfigAttribute(traceJob, "CpuCount", e.NumberOfProcessors);
traceJob.EtwTraceEventSource.Kernel.SystemConfigCPU +=
e => PublishSysConfigAttribute(traceJob, nameof(e.ComputerName), e.ComputerName);
traceJob.EtwTraceEventSource.Kernel.SystemConfigCPU +=
e => PublishSysConfigAttribute(traceJob, "PrimaryDnsSuffix", e.DomainName);
traceJob.EtwTraceEventSource.Kernel.SystemConfigCPU +=
e => PublishSysConfigAttribute(traceJob, nameof(e.MHz), e.MHz);
traceJob.EtwTraceEventSource.Kernel.SystemConfigCPU +=
e => PublishSysConfigAttribute(traceJob, nameof(e.MemSize), e.MemSize);
traceJob.EtwTraceEventSource.Kernel.SystemConfigCPU +=
e => PublishSysConfigAttribute(traceJob, nameof(e.PageSize), e.PageSize);
traceJob.EtwTraceEventSource.Kernel.SysConfigBuildInfo +=
e => PublishSysConfigAttribute(traceJob, nameof(e.BuildLab), e.BuildLab);
traceJob.EtwTraceEventSource.Kernel.SysConfigBuildInfo +=
e => PublishSysConfigAttribute(traceJob, nameof(e.ProductName), e.ProductName);
traceJob.EtwTraceEventSource.Kernel.SysConfigBuildInfo +=
e => PublishSysConfigAttribute(traceJob, nameof(e.InstallDate), e.InstallDate);
traceJob.EtwTraceEventSource.Kernel.SysConfigSystemPaths +=
e => PublishSysConfigAttribute(traceJob, nameof(e.SystemDirectory), e.SystemDirectory);
traceJob.EtwTraceEventSource.Kernel.SysConfigSystemPaths +=
e => PublishSysConfigAttribute(traceJob, nameof(e.SystemWindowsDirectory), e.SystemWindowsDirectory);
}
public void TestIcuPackageMetadata(string packageFileName)
{
var packagePath = Path.Combine(Environment.CurrentDirectory, "TestData", packageFileName);
using (var traceJob = new TraceJob(packagePath))
{
traceJob.StageForProcessing();
var trace = traceJob.Trace;
Assert.True(
new[] {"CLINTH-SP3", "WIN7-32", "BX-WIN81"}.Contains(trace.ComputerName,
StringComparer.OrdinalIgnoreCase)
);
Assert.True(trace.TracePackageTime.Year == 2016);
if (packageFileName.Contains("UserInitiated"))
{
Assert.True(trace.GetTraceAttributes().Any(ta => ta.Name == CluePackageAdapter.NameOfIcuUserNoteAttribute));
}
if (!packageFileName.StartsWith("BxrR", StringComparison.OrdinalIgnoreCase))
{
Assert.True(
trace.GetTraceAttributes().Any(
ta => ta.Name == CluePackageAdapter.NameOfIcuMetaEmailReportToAttribute));
}
if (packageFileName.StartsWith("BxrR", StringComparison.OrdinalIgnoreCase))
{
Assert.True(
trace.GetTraceAttributes().Any(
ta => ta.Name == "OSInstallDateWMI" && ta.StringValue != null && ta.DateTimeValue != null));
}
Assert.True(
trace.GetTraceAttributes().Any(
ta => string.Equals(ta.Name, "Trigger", StringComparison.OrdinalIgnoreCase)));
}
}
private void Update()
{
if (!_isRendering)
{
return;
}
for (int i = 0; _pixelIndex < _pass.TotalPixels && i < _maxJobsPerFrame; i++)
{
var tj = new TraceJob();
tj.Fibs = _fibs;
tj.Scene = _scene;
tj.Camera = _camera;
tj.Resolution = _pass.Resolution;
tj.RaysPerPixel = 8;
tj.MaxDepth = 8;
tj.PixelIndex = _pixelIndex;
tj.RenderResult = _renderTargets[i];
var h = new TraceJobHandle();
h.RenderTargetIndex = i;
h.PixelIndex = _pixelIndex;
h.JobHandle = tj.Schedule();
_handles.Enqueue(h);
_pixelIndex++;
}
JobHandle.ScheduleBatchedJobs();
}
private static void PublishSysConfigAttribute(TraceJob traceJob, string propertyName, DateTime value)
{
traceJob.PublishMeasurement(
new TraceModel.TraceAttribute
{
Name = propertyName,
DateTimeValue = value
}
);
}
public override void Initialize(TraceJob traceJob)
{
if (!WptInterop.IsXperfInstalled())
{
Logging.LogDebugMessage("xperf not found. skipping disk IO processing");
return;
}
_diskIoTempFiles = WptInterop.RunXPerfAllProcessing(traceJob.EtwTraceEventSource.LogFileName);
PreTraceEventProcessing += ProcessDiskIoLog;
}
private static void PublishSysConfigAttribute(TraceJob traceJob, string propertyName, int intValue)
{
traceJob.PublishMeasurement(
new TraceModel.TraceAttribute
{
Name = propertyName,
WholeNumberValue = intValue
}
);
}
public void GroupPolicyTest(string relativePath)
{
var sourcePath = Path.Combine(Environment.CurrentDirectory, relativePath);
var destPath = Path.Combine(Path.GetTempPath(), nameof(GroupPolicyTest) + ".zip");
File.Copy(sourcePath, destPath, true);
using (var tj = new TraceJob(destPath))
{
tj.StageForProcessing();
tj.RegisterProcessorByType<GroupPolicyActionProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
var t = tj.Measure();
Assert.NotNull(t);
Assert.NotEmpty(t.GetMeasurements<GroupPolicyAction>());
}
}
private void Awake()
{
const int vertResolution = 1080;
const float aspect = 16f / 9f;
const float vfov = 50f;
const float aperture = 0.002f;
int horiResolution = (int)math.round(vertResolution * aspect);
_fullQuality.Resolution = new int2(horiResolution, vertResolution);
_debugQuality.Resolution = _fullQuality.Resolution;
var position = new float3(10f, 1.5f, -2f);
var lookDir = new float3(12, 1, -10) - position;
var focus = math.length(lookDir);
var rotation = quaternion.LookRotation(lookDir / focus, new float3(0, 1, 0));
_camera = new Camera(vfov, aspect, aperture, focus);
_camera.Position = position;
_camera.Rotation = rotation;
Debug.Log("Resolution = " + _fullQuality.Resolution);
int totalPixels = (int)(_fullQuality.Resolution.x * _fullQuality.Resolution.y);
_screen = new NativeArray <float3>(totalPixels, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
_clear = new ClearJob();
_clear.Buffer = _screen;
_scene = MakeScene();
_fibs = new NativeArray <float3>(4096, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
Math.GenerateFibonacciSphere(_fibs);
_trace = new TraceJob();
_trace.Screen = _screen;
_trace.Fibs = _fibs;
_trace.Camera = _camera;
_trace.Scene = _scene;
_trace.RayCounter = new NativeArray <ulong>(1, Allocator.Persistent, NativeArrayOptions.ClearMemory);
_tex = new Texture2D((int)_fullQuality.Resolution.x, (int)_fullQuality.Resolution.y, TextureFormat.ARGB32, false, true);
_tex.filterMode = FilterMode.Point;
Debug.Log(-2.5f % 1f);
}
public void BasicCalipersRunningTest(string relativePath)
{
var expectedCompletionSeconds = 45;
var expectedCompletionTime = DateTime.UtcNow.AddSeconds(expectedCompletionSeconds);
var sourcePath = Path.Combine(Environment.CurrentDirectory, relativePath);
var destPath = Path.Combine(Path.GetTempPath(), nameof(BasicCalipersRunningTest) + ".zip");
File.Copy(sourcePath, destPath, true);
using (var tj = new TraceJob(destPath))
{
tj.StageForProcessing();
tj.RegisterCaliperByType<CpuSampled>(null);
tj.RegisterCaliperByType<BootPhase>();
tj.RegisterProcessorByType<WinlogonSubscriberProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
tj.RegisterProcessorByType<GroupPolicyActionProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
tj.RegisterProcessorByType<DiskIoProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
tj.RegisterProcessorByType<NetworkInterfaceProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
tj.RegisterProcessorByType<ProcessLifetimeProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
//tj.RegisterProcessorByType<BootPhaseProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
tj.RegisterProcessorByType<SystemSleepProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
tj.RegisterProcessorByType<ServiceTransitionProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
tj.RegisterProcessorByType<NetworkInterfaceProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
tj.RegisterProcessorByType<DiskProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
var t = tj.Measure();
Assert.NotNull(t);
Assert.True(expectedCompletionTime > DateTime.UtcNow);
Assert.NotEmpty(t.GetMeasurements<IMeasurement>());
Assert.NotEmpty(t.GetMeasurements<WinlogonSubscriberTask>());
Assert.NotEmpty(t.GetMeasurements<GroupPolicyAction>());
Assert.NotEmpty(t.GetMeasurements<DiskIo>());
Assert.NotEmpty(t.GetMeasurements<MeasureTrace.TraceModel.CpuSampled>());
Assert.NotEmpty(t.GetMeasurements<ProcessLifetime>());
Assert.NotEmpty(t.GetMeasurements<MeasureTrace.TraceModel.BootPhase>());
Assert.NotEmpty(t.GetMeasurements<ServiceTransition>());
Assert.NotEmpty(t.GetMeasurements<TerminalSession>());
Assert.NotEmpty(t.GetMeasurements<NetworkInterface>());
Assert.NotEmpty(t.GetMeasurements<PhysicalDisk>());
Assert.NotEmpty(t.GetMeasurements<LogicalDisk>());
Assert.False(t.GetMeasurements<SystemSleep>().Any());
Assert.True(string.Equals(t.PackageFileNameFull, destPath, StringComparison.OrdinalIgnoreCase));
var packageRelName = Path.GetFileName(destPath);
Assert.True(string.Equals(t.PackageFileNameFull, destPath, StringComparison.OrdinalIgnoreCase));
Assert.True(string.Equals(Path.GetFileName(t.PackageFileNameFull), packageRelName, StringComparison.OrdinalIgnoreCase));
}
}
public void RegisterCalipersAllKnownTest(string relativePath)
{
var expectedGapInMeasurementTypes = 1;
if (!WptInterop.IsXperfInstalled()) expectedGapInMeasurementTypes++;
var sourcePath = Path.Combine(Environment.CurrentDirectory, relativePath);
var destPath = Path.Combine(Path.GetTempPath(), nameof(RegisterCalipersAllKnownTest) + ".zip");
File.Copy(sourcePath, destPath, true);
using (var tj = new TraceJob(destPath))
{
//tj.RegisterProcessorByType<BootPhaseProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
tj.StageForProcessing();
tj.RegisterCalipersAllKnown();
var t = tj.Measure();
Assert.NotNull(t);
var knownMeasurementTypes = t.GetKnownMeasurementTypes().ToList();
var presentMeasurementTypes = t.GetPresentMeasurementTypes().ToList();
Assert.True(knownMeasurementTypes.Count == presentMeasurementTypes.Count + expectedGapInMeasurementTypes);
}
}
public void CpuSampledCaliperTest(string relativePath)
{
var sourcePath = Path.Combine(Environment.CurrentDirectory, relativePath);
var destPath = Path.Combine(Path.GetTempPath(), nameof(CpuSampledCaliperTest) + ".zip");
File.Copy(sourcePath, destPath, true);
using (var tj = new TraceJob(destPath))
{
tj.RegisterCaliperByType<CpuSampled>(null);
var t = tj.Measure();
Assert.NotNull(t);
Assert.True(
t.GetMeasurements<MeasureTrace.TraceModel.CpuSampled>().OrderBy(m => m.Weight).Last().ProcessName ==
"mscorsvw");
Assert.True(
t.GetMeasurements<MeasureTrace.TraceModel.CpuSampled>()
.Where(q => q.ProcessName == "MonitoringHost" && q.Weight > 0.03)
.Any());
}
}
public void BasicFileOpeningTest(string arg)
{
var pathToTest = string.Empty;
Trace trace;
try
{
pathToTest = Path.Combine(Environment.CurrentDirectory, arg);
using (var tj = new TraceJob(pathToTest))
{
trace = tj.Measure();
Assert.NotNull(trace);
}
Assert.True(!Directory.Exists(pathToTest.Remove(pathToTest.Length - 4)));
}
catch (Exception e)
{
if (pathToTest.Contains("GarbageData.zip")) Assert.IsType<InvalidDataException>(e);
else if (pathToTest.Contains("GarbageData.etl")) Assert.IsType<ApplicationException>(e);
else if (arg == null) Assert.IsType<ArgumentNullException>(e);
else Assert.IsType<FileNotFoundException>(e);
return;
}
Assert.NotNull(trace);
}
public void RegisterSecondPass(TraceJob traceJob)
{
traceJob.RegisterProcessorByType<TerminalSessionProcessor>(ProcessorTypeCollisionOption.UseExistingIfFound);
traceJob.OnNewMeasurementOfType<TraceModel.BootPhase>(bp => _alreadyRegisteredBootPhases.Add(bp));
traceJob.OnNewMeasurementOfType<TerminalSession>(ts =>
{
if (
_alreadyRegisteredBootPhases.Any(
em => em.BootPhaseType == BootPhaseType.FromLogonUntilDesktopAppears)) return;
if (ts.ExplorerProcessId == 0) return;
traceJob.PublishMeasurement(
new TraceModel.BootPhase
{
BootPhaseObserver = BootPhaseObserver.MeasureTrace,
BootPhaseType = BootPhaseType.FromLogonUntilDesktopAppears,
DurationMSec = ts.LogonCredentialEntryToShellReady
}
);
traceJob.PublishMeasurement(
new TraceModel.BootPhase
{
BootPhaseObserver = BootPhaseObserver.MeasureTrace,
BootPhaseType = BootPhaseType.FromPowerOnUntilDesktopAppears,
DurationMSec = ts.ShellReadyOffsetMSec
}
);
});
traceJob.EtwTraceEventSource.Registered.AddCallbackForProviderEvents((pn, en) =>
{
if (!string.Equals(pn, WinlogonProviderName, StringComparison.OrdinalIgnoreCase))
return EventFilterResponse.RejectProvider;
return EventFilterResponse.AcceptEvent;
}, e =>
{
if ((WinlogonSystemBootEventId == (int) e.ID || WinlogonWelcomeScreenStartId == (int) e.ID) &&
_countOfPowerOnToReadyForLogon < 1)
{
_countOfPowerOnToReadyForLogon++;
traceJob.PublishMeasurement(new TraceModel.BootPhase
{
BootPhaseObserver = BootPhaseObserver.MeasureTrace,
BootPhaseType = BootPhaseType.FromPowerOnUntilReadyForLogon,
DurationMSec = e.TimeStampRelativeMSec
});
}
});
traceJob.EtwTraceEventSource.Registered.AddCallbackForProviderEvents((pn, en) =>
{
if (!string.Equals(pn, PerfTrackProviderName, StringComparison.OrdinalIgnoreCase))
return EventFilterResponse.RejectProvider;
return EventFilterResponse.AcceptEvent;
}, e =>
{
if (PerfTrackIdleDetectionInfoEventId == (int) e.ID &&
_alreadyRegisteredBootPhases.All(
bp => bp.BootPhaseType != BootPhaseType.FromDesktopAppearsUntilDesktopResponsive))
{
var accumulatedIdleMs = Convert.ToInt32(e.PayloadValue(0));
if (IdleAccumulationCutoffMs > accumulatedIdleMs) return;
var postBootEndOffsetMinusAccumulatedIdle = e.TimeStampRelativeMSec - accumulatedIdleMs;
var bootToDesktop =
_alreadyRegisteredBootPhases.FirstOrDefault(
bp => bp.BootPhaseType == BootPhaseType.FromPowerOnUntilDesktopAppears);
if (bootToDesktop == null) return;
var postBootOnlyRawDurationMs = postBootEndOffsetMinusAccumulatedIdle - bootToDesktop.DurationMSec;
var postBootDurationCleaned = CalculateRollOffPostBootValue(postBootOnlyRawDurationMs.Value);
var desktopAppearsToDestkopResponsive = new TraceModel.BootPhase
{
BootPhaseObserver = BootPhaseObserver.MeasureTrace,
BootPhaseType = BootPhaseType.FromDesktopAppearsUntilDesktopResponsive,
DurationMSec = postBootDurationCleaned
};
traceJob.PublishMeasurement(desktopAppearsToDestkopResponsive);
traceJob.PublishMeasurement(new TraceModel.BootPhase
{
BootPhaseObserver = BootPhaseObserver.MeasureTrace,
BootPhaseType = BootPhaseType.FromPowerOnUntilDesktopResponsive,
DurationMSec = bootToDesktop.DurationMSec + desktopAppearsToDestkopResponsive.DurationMSec
});
}
});
}
public void RegisterFirstPass(TraceJob traceJob)
{
//_traceJob = traceJob;
}
//public ETWTraceEventSource EtwTraceEventSource { get; set; }
public abstract void Initialize(TraceJob traceJob);
public void RegisterFirstPass(TraceJob traceJob)
{
_traceJob = traceJob;
traceJob.EtwTraceEventSource.Kernel.SystemConfigCPU += data => _cpuCoreCount = data.NumberOfProcessors;
}
public static int MeasureOneBatch(ProcessingConfig processingConfig, MeasurementStoreConfig storeConfig)
{
RichLog.Log.StartMeasureAndSaveTraces();
var measuredCount = 0;
var measuringTasks = new List <Task>();
var measuringResults = new ConcurrentBag <Trace>();
using (var store = new MeasurementStore(storeConfig))
{
var inScopeTraces = store.Traces.Include(t => t.ProcessingRecords)
.Where(
t =>
t.ProcessingRecords.OrderBy(pr => pr.StateChangeTime).Last().ProcessingState ==
ProcessingState.Moved)
.Take(processingConfig.ParallelMeasuringThrottle);
foreach (var t in inScopeTraces)
{
RichLog.Log.StartMeasureAndSaveItem(t.PackageFileNameFull);
measuringTasks.Add(
Task.Run(() =>
{
Trace traceOut = null;
try
{
using (var tj = new TraceJob(t))
{
tj.StageForProcessing();
tj.RegisterCalipersAllKnown();
traceOut = tj.Measure();
}
}
finally
{
measuredCount++;
if (traceOut == null)
{
traceOut = t;
}
measuringResults.Add(traceOut);
}
}));
}
}
try
{
Task.WaitAll(measuringTasks.ToArray());
}
catch (AggregateException ae)
{
foreach (var e in ae.InnerExceptions)
{
RichLog.Log.TraceAnalyzeFailureDuringProcessEndToEnd(e.Message, e.ToString());
}
}
using (var store = new MeasurementStore(storeConfig))
{
foreach (var t in measuringResults)
{
var addedRows = store.SaveTraceAndMeasurements((MeasuredTrace)t);
store.ProcessingRecords.Add(new ProcessingRecord
{
MeasuredTrace = (MeasuredTrace)t,
StateChangeTime = DateTime.UtcNow,
ProcessingState = ProcessingState.Measured,
Path = t.PackageFileNameFull
});
store.SaveChanges();
RichLog.Log.StopMeasureAndSaveItem(t.PackageFileNameFull, addedRows);
}
}
RichLog.Log.StopMeasureAndSaveTraces(measuredCount);
return(measuredCount);
}
public void RegisterSecondPass(TraceJob traceJob)
{
traceJob.EtwTraceEventSource.Kernel.PerfInfoSample += OnCpuSample;
traceJob.EtwTraceEventSource.Completed += RolloverTimeSliceOnCompletion;
}
public void RegisterSecondPass(TraceJob traceJob)
{
}
