Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(76)

Side by Side Diff: Source/platform/scheduler/Scheduler.h

Issue 490913002: Adding flow traces for blink scheduler events (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: Removal of accidental changes to Scheduler Tests Created 6 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #ifndef Scheduler_h 5 #ifndef Scheduler_h
6 #define Scheduler_h 6 #define Scheduler_h
7 7
8 #include "platform/PlatformExport.h" 8 #include "platform/PlatformExport.h"
9 #include "platform/TraceLocation.h" 9 #include "platform/TraceLocation.h"
10 #include "wtf/DoubleBufferedDeque.h" 10 #include "wtf/DoubleBufferedDeque.h"
11 #include "wtf/Functional.h" 11 #include "wtf/Functional.h"
12 #include "wtf/Noncopyable.h" 12 #include "wtf/Noncopyable.h"
13 #include "wtf/ThreadingPrimitives.h" 13 #include "wtf/ThreadingPrimitives.h"
14 14
15 namespace blink { 15 namespace blink {
16 class WebThread; 16 class WebThread;
17 } 17 }
18 18
19 namespace blink { 19 namespace blink {
20 20
21 typedef long long unsigned FlowTraceID;
Sami 2014/08/20 14:20:57 Probably better to use int64_t for this. Actually,
picksi1 2014/08/29 14:11:28 Changed to an int so keep atomicincrement happy
22
21 // The scheduler is an opinionated gateway for arranging work to be run on the 23 // The scheduler is an opinionated gateway for arranging work to be run on the
22 // main thread. It decides which tasks get priority over others based on a 24 // main thread. It decides which tasks get priority over others based on a
23 // scheduling policy and the overall system state. 25 // scheduling policy and the overall system state.
24 class PLATFORM_EXPORT Scheduler { 26 class PLATFORM_EXPORT Scheduler {
25 WTF_MAKE_NONCOPYABLE(Scheduler); 27 WTF_MAKE_NONCOPYABLE(Scheduler);
26 public: 28 public:
27 typedef Function<void()> Task; 29 typedef Function<void()> Task;
28 // An IdleTask is passed an allotted time in CLOCK_MONOTONIC milliseconds an d is expected to complete within this timeframe. 30 // An IdleTask is passed an allotted time in CLOCK_MONOTONIC milliseconds an d is expected to complete within this timeframe.
29 typedef Function<void(double allottedTimeMs)> IdleTask; 31 typedef Function<void(double allottedTimeMs)> IdleTask;
30 32
31 static Scheduler* shared(); 33 static Scheduler* shared();
32 static void initializeOnMainThread(); 34 static void initializeOnMainThread();
33 static void shutdown(); 35 static void shutdown();
34 36
35 // The following entrypoints are used to schedule different types of tasks 37 // The following entrypoints are used to schedule different types of tasks
36 // to be run on the main thread. They can be called from any thread. 38 // to be run on the main thread. They can be called from any thread.
37 void postInputTask(const TraceLocation&, const Task&); 39 void postInputTask(const TraceLocation&, const Task&);
38 void postCompositorTask(const TraceLocation&, const Task&); 40 void postCompositorTask(const TraceLocation&, const Task&);
39 void postTask(const TraceLocation&, const Task&); // For generic (low priori ty) tasks. 41 void postTask(const TraceLocation&, const Task&); // For generic (low priori ty) tasks.
42
40 void postIdleTask(const TraceLocation&, const IdleTask&); // For non-critica l tasks which may be reordered relative to other task types. 43 void postIdleTask(const TraceLocation&, const IdleTask&); // For non-critica l tasks which may be reordered relative to other task types.
41 44
42 // Returns true if there is high priority work pending on the main thread 45 // Returns true if there is high priority work pending on the main thread
43 // and the caller should yield to let the scheduler service that work. 46 // and the caller should yield to let the scheduler service that work.
44 // Can be called on any thread. 47 // Can be called on any thread.
45 bool shouldYieldForHighPriorityWork() const; 48 bool shouldYieldForHighPriorityWork() const;
46 49
47 // The shared timer can be used to schedule a periodic callback which may 50 // The shared timer can be used to schedule a periodic callback which may
48 // get preempted by higher priority work. 51 // get preempted by higher priority work.
49 void setSharedTimerFiredFunction(void (*function)()); 52 void setSharedTimerFiredFunction(void (*function)());
50 void setSharedTimerFireInterval(double); 53 void setSharedTimerFireInterval(double);
51 void stopSharedTimer(); 54 void stopSharedTimer();
52 55
53 private: 56 private:
54 class MainThreadPendingTaskRunner; 57 class MainThreadPendingTaskRunner;
55 class MainThreadPendingHighPriorityTaskRunner; 58 class MainThreadPendingHighPriorityTaskRunner;
56 friend class MainThreadPendingTaskRunner; 59 friend class MainThreadPendingTaskRunner;
57 friend class MainThreadPendingHighPriorityTaskRunner; 60 friend class MainThreadPendingHighPriorityTaskRunner;
58 61
59 Scheduler(); 62 Scheduler();
60 ~Scheduler(); 63 ~Scheduler();
61 64
62 void scheduleIdleTask(const TraceLocation&, const IdleTask&); 65 void scheduleIdleTask(const TraceLocation&, const IdleTask&);
63
64 static void sharedTimerAdapter(); 66 static void sharedTimerAdapter();
65 void tickSharedTimer(); 67 void tickSharedTimer();
66 68
69
67 bool hasPendingHighPriorityWork() const; 70 bool hasPendingHighPriorityWork() const;
68 void runHighPriorityTasks(); 71 void runHighPriorityTasks();
69 72
70 static Scheduler* s_sharedScheduler; 73 static Scheduler* s_sharedScheduler;
71 74
72 class TracedTask { 75 class TracedTask {
73 public: 76 public:
74 TracedTask(const Task& task, const TraceLocation& location) 77
75 : m_task(task) 78 enum Type {
76 , m_location(location) { } 79 Compositor,
80 Input,
81 MainThread,
82 TypeCount
83 };
84
85 TracedTask(const Task&, const TraceLocation&, Type);
86 static void setTypeName(Type, char const*);
77 87
78 void run(); 88 void run();
79 89
90 FlowTraceID m_FlowTraceID;
Sami 2014/08/20 14:20:57 s/m_FlowTraceID/m_flowTraceID/
picksi1 2014/08/29 14:11:28 This is no longer static in latest version
91
80 private: 92 private:
81 Task m_task; 93 Task m_task;
82 TraceLocation m_location; 94 TraceLocation m_location;
95 Type m_type;
Sami 2014/08/20 14:20:57 Instead of having a type enum, could we just pass
picksi1 2014/08/29 14:11:28 Done.
96 static FlowTraceID s_NextFlowTraceID;
97 static char const* s_typeNames[Type::TypeCount];
83 }; 98 };
84 99
85 // Should only be accessed from the main thread. 100 // Should only be accessed from the main thread.
86 void (*m_sharedTimerFunction)(); 101 void (*m_sharedTimerFunction)();
87 102
88 // These members can be accessed from any thread. 103 // These members can be accessed from any thread.
89 WebThread* m_mainThread; 104 WebThread* m_mainThread;
90 105
91 // This mutex protects calls to the pending task queues. 106 // This mutex protects calls to the pending task queues.
92 Mutex m_pendingTasksMutex; 107 Mutex m_pendingTasksMutex;
93 DoubleBufferedDeque<TracedTask> m_pendingInputTasks; 108 DoubleBufferedDeque<TracedTask> m_pendingInputTasks;
94 DoubleBufferedDeque<TracedTask> m_pendingCompositorTasks; 109 DoubleBufferedDeque<TracedTask> m_pendingCompositorTasks;
95 110
96 volatile int m_highPriorityTaskCount; 111 volatile int m_highPriorityTaskCount;
97 }; 112 };
98 113
99 } // namespace blink 114 } // namespace blink
100 115
101 #endif // Scheduler_h 116 #endif // Scheduler_h
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698