public void Run(CancellationToken cancellationToken, ProfilingType profilingType) { Guard.NotNull(cancellationToken, nameof(cancellationToken)); if (thread != null) { throw new InvalidOperationException(); } thread = new Thread(() => { try { Profiler profiler = profilingType != ProfilingType.None ? new Profiler(name, profilingType) : null; Do(cancellationToken, profiler); } catch (Exception error) { this.error = error; cancellationToken.Cancel(); } finally { outputChannel.Finish(); } }) { Name = name, IsBackground = true }; thread.Start(); }
public void LogValue <T>(T value, ProfilingType profilingType) { if (AllowProfiling(profilingType)) { LogValueInternal(value, profilingType); } }
public Profiler(string name, ProfilingType profilingType) { Guard.NotNullOrWhiteSpace(name, nameof(name)); this.name = name; this.profilingType = profilingType; }
public void BeginWatch(ProfilingType profilingType) { if (AllowProfiling(profilingType)) { watch.Reset(); watch.Start(); } }
public void EndWatch(ProfilingType profilingType) { if (AllowProfiling(profilingType)) { watch.Stop(); double timeMicro = (double)watch.ElapsedTicks / Stopwatch.Frequency * 1000 * 1000; LogValueInternal(timeMicro, profilingType); } }
/// <summary> /// (Windows only) Use the Timeline profiling type. /// If not specified, the Sampling type is used. /// </summary> /// <param name="askUacElevationIfRequired">If false and a profiling session requires administrative privileges, the method throws an exception. If true, dotTrace will ask for UAC elevation and continue the session.</param> /// <returns></returns> public Config UseTimelineProfilingType(bool askUacElevationIfRequired = false) { if (Helper.Platform != PlatformId.Windows) { throw new InvalidOperationException("The Timeline profiling type is supported only on Windows platform"); } Type = ProfilingType.Timeline; AskUacElevationIfRequired = askUacElevationIfRequired; return(this); }
public DotTraceProcess(string exePath, string savePath, TimeSpan interval, ProfilingType profilingType) { _process = new Process(); _savePath = savePath; _interval = interval; var pid = Process.GetCurrentProcess().Id; _process.StartInfo.FileName = exePath; _process.StartInfo.Arguments = $"attach {pid} --profiling-type={profilingType} --save-to=\"{savePath}\" --timeout={interval.TotalSeconds}s"; Log.Info($"{_process.StartInfo.FileName} {_process.StartInfo.Arguments}"); }
static void Process(dynamic options, Func <dynamic, string> getSrc, Func <dynamic, string> getDest, RunAsEnumerable.Action runAsEnumerable, RunAsPipeline.Action runAsPipeline) { string src = getSrc(options); string dest = getDest(options); int jobCount = options.JobCount?.Value ?? Constants.DEFAULT_JOB_COUNT; jobCount = Math.Max(jobCount, 1); jobCount = Math.Min(jobCount, Constants.MAX_JOB_COUNT); int chunkSize = options.ChunkSize?.Value ?? Constants.DEFAULT_CHUNK_SIZE; chunkSize = Math.Max(chunkSize, Constants.MIN_CHUNK_SIZE); chunkSize = Math.Min(chunkSize, Constants.MAX_CHUNK_SIZE); var loggers = new Loggers(); if (options.LogChunks != null) { loggers.ChunkLogger = new ChunkLogger(); } else if (options.LogJobs != null) { loggers.JobLogger = new JobLogger(); } else { loggers.DefaultLogger = new DefaultLogger(); } Action <BinaryReader, BinaryWriter> processor; if (options.UsePipeline != null) { ProfilingType profilingType = options.ProfilePipeline?.Value ?? ProfilingType.None; processor = (reader, writer) => runAsPipeline(reader, writer, jobCount, chunkSize, _cancellationToken, loggers, profilingType); } else { processor = (reader, writer) => runAsEnumerable(reader, writer, jobCount, chunkSize, _cancellationToken, loggers); } ProcessFile(src, dest, processor); }
public void Run(CancellationToken cancellationToken, ProfilingType profilingType) { if (cancellationToken == null) { cancellationToken = new CancellationToken(); } foreach (var routine in routines) { routine.Run(cancellationToken, profilingType); } var errors = routines .Select(routine => routine.Wait()) .Where(error => error != null) .ToList(); if (errors.Count > 0) { throw new AggregateException(errors); } }
public async Task StartTracing(TimeSpan?interval, ProfilingType profilingType) { await _connector.StartTracing(_cancellationTokenSource.Token, interval, profilingType); }
public static void Decompress(BinaryReader reader, BinaryWriter writer, int jobCount, int chunkSize = Constants.DEFAULT_CHUNK_SIZE, CancellationToken cancellationToken = null, Loggers loggers = null, ProfilingType profilingType = ProfilingType.None) { Guard.NotNull(reader, nameof(reader)); Guard.NotNull(writer, nameof(writer)); Guard.NotZeroOrNegative(jobCount, nameof(jobCount)); Guard.NotZeroOrNegative(chunkSize, nameof(chunkSize)); Console.WriteLine("Decompress as Pipeline"); int index = 0; IDefaultLogger defaultLogger = loggers?.DefaultLogger; ChunkSource.ReadHeader(reader, out int chunkCount); var chunkEnumerator = ChunkSource.ReadChunkCompressed(reader, chunkCount).GetEnumerator(); Pipeline <Chunk> .FromSource("source", (out Chunk chunk) => { bool next = chunkEnumerator.MoveNext(); chunk = next ? chunkEnumerator.Current : null; return(next); }) .PipeMany("zip", ChunkConverter.Unzip, jobCount) .ToTarget("target", (Chunk chunk) => { ChunkTarget.WriteChunk(chunk, writer, chunkSize); if (profilingType == ProfilingType.None) { defaultLogger?.LogChunksProcessed(++index, chunkCount); } }) .Run(cancellationToken, profilingType); }
void LogValueInternal <T>(T value, ProfilingType profilingType) { Console.WriteLine($"{profilingType.ToString().ToUpper()} - {name} : {value}"); }
bool AllowProfiling(ProfilingType profilingType) { return(this.profilingType.HasFlag(profilingType)); }