Beispiel #1
0
        public static void Main(string[] args)
        {
            ChromeTrace.Init();

            Random randOne   = new Random();
            Random randTwo   = new Random(randOne.Next());
            Random randThree = new Random(randTwo.Next());


            Thread threadOne   = new Thread(() => DoTheStuff(5, randOne, "Session One"));
            Thread threadTwo   = new Thread(() => DoTheStuff(5, randTwo, "Session One"));
            Thread threadThree = new Thread(() => DoTheStuff(5, randThree, "Session Two"));

            threadOne.Start();
            threadTwo.Start();
            threadThree.Start();

            threadOne.Join();
            threadTwo.Join();
            threadThree.Join();
        }
Beispiel #2
0
        public static void DoTheStuff(int reps, Random rand, string session)
        {
            if (reps <= 0)
            {
                return;
            }

            using (ChromeTrace.Profile("Test " + reps % 2, session))
            {
                int sleep = 1000 + rand.Next(1000);

                Console.WriteLine("Night night!");

                System.Threading.Thread.Sleep(sleep);

                Console.WriteLine($"Woke up after {sleep} ms");
            }

            System.Threading.Thread.Sleep(rand.Next(100));
            DoTheStuff(reps - 1, rand, session);
        }
Beispiel #3
0
        public bool Init(String name, Stream stream)
        {
            Durable.InitSettings(Board.TimeSettings);

            String text = new StreamReader(stream).ReadToEnd();

            ChromeTrace trace = JsonConvert.DeserializeObject <ChromeTrace>(text);

            Dictionary <ulong, List <TraceEvent> > threads = new Dictionary <ulong, List <TraceEvent> >();

            foreach (TraceEvent ev in trace.traceEvents)
            {
                // Complete Event
                if (ev.ph == "X")
                {
                    List <TraceEvent> events = null;
                    if (!threads.TryGetValue(ev.tid, out events))
                    {
                        events = new List <TraceEvent>();
                        threads.Add(ev.tid, events);
                    }
                    events.Add(ev);
                }
            }

            Durable range = new Durable(long.MaxValue, long.MinValue);

            Dictionary <string, EventDescription> descriptions = new Dictionary <string, EventDescription>();

            foreach (KeyValuePair <ulong, List <TraceEvent> > pair in threads)
            {
                ulong             tid    = pair.Key;
                List <TraceEvent> events = pair.Value;

                List <Entry> entries = new List <Entry>(events.Count);
                List <Tag>   tags    = new List <Tag>(events.Count);

                foreach (TraceEvent ev in events)
                {
                    String args = ev.args != null?ev.args.ToString().Replace("\n", "").Replace("\r", "") : null;

                    String context   = GenerateShortContext(args);
                    String extraName = GenerateShortName(context);

                    String fullName = ev.name;
                    if (!String.IsNullOrWhiteSpace(extraName))
                    {
                        fullName = String.Format("{0} - {1}", ev.name, extraName);
                    }

                    EventDescription desc = null;
                    if (!descriptions.TryGetValue(fullName, out desc))
                    {
                        desc = new EventDescription(fullName)
                        {
                            Color = EventDescription.GenerateRandomColor(ev.name, RandomColorBrightnessVariance)
                        };
                        descriptions.Add(fullName, desc);
                    }

                    entries.Add(new Entry(desc, (long)ev.ts, (long)(ev.ts + ev.dur)));

                    if (!String.IsNullOrWhiteSpace(context))
                    {
                        tags.Add(new Tag()
                        {
                            Description = new EventDescription(context), Time = new Tick()
                            {
                                Start = (long)ev.ts
                            }
                        });
                    }
                }

                entries.Sort();
                tags.Sort();

                ThreadData threadData = MainGroup.AddThread(new ThreadDescription()
                {
                    Name = String.Format("Thread #{0}", tid), ThreadID = tid, ProcessID = 0, Origin = ThreadDescription.Source.Game
                });
                threadData.TagsPack = new TagsPack(tags);

                EventFrame frame = new EventFrame(new FrameHeader(new Durable(entries.Min(e => e.Start), entries.Max(e => e.Finish)), threadData.Description.ThreadIndex), entries, MainGroup);
                entries.ForEach(e => e.Frame = frame);

                range.Start  = Math.Min(range.Start, frame.Start);
                range.Finish = Math.Max(range.Finish, frame.Finish);

                threadData.Events.Add(frame);
            }

            Board.TimeSlice       = range;
            Board.MainThreadIndex = 0;
            MainFrame             = new EventFrame(new FrameHeader(Board.TimeSlice), new List <Entry> {
            }, MainGroup);

            return(true);
        }