1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
#ifndef __EVENTPIPE_CONFIGURATION_H__
#define __EVENTPIPE_CONFIGURATION_H__
#ifdef FEATURE_PERFTRACING
#include "eventpipe.h"
#include "slist.h"
class EventPipeSessionProvider;
class EventPipeEvent;
class EventPipeEventInstance;
class EventPipeProvider;
struct EventPipeProviderConfiguration;
class EventPipeSession;
class EventPipeSessionProvider;
enum class EventPipeEventLevel
{
LogAlways,
Critical,
Error,
Warning,
Informational,
Verbose
};
class EventPipeConfiguration
{
public:
EventPipeConfiguration();
~EventPipeConfiguration();
// Perform initialization that cannot be performed in the constructor.
void Initialize();
// Create a new provider.
EventPipeProvider* CreateProvider(const SString &providerName, EventPipeCallback pCallbackFunction, void *pCallbackData);
// Delete a provider.
void DeleteProvider(EventPipeProvider *pProvider);
// Register a provider.
bool RegisterProvider(EventPipeProvider &provider);
// Unregister a provider.
bool UnregisterProvider(EventPipeProvider &provider);
// Get the provider with the specified provider ID if it exists.
EventPipeProvider* GetProvider(const SString &providerID);
// Create a new session.
EventPipeSession* CreateSession(unsigned int circularBufferSizeInMB, EventPipeProviderConfiguration *pProviders, unsigned int numProviders);
// Delete a session.
void DeleteSession(EventPipeSession *pSession);
// Get the configured size of the circular buffer.
size_t GetCircularBufferSize() const;
// Enable a session in the event pipe.
void Enable(EventPipeSession *pSession);
// Disable a session in the event pipe.
void Disable(EventPipeSession *pSession);
// Get the status of the event pipe.
bool Enabled() const;
// Determine if rundown is enabled.
bool RundownEnabled() const;
// Enable rundown using the specified configuration.
void EnableRundown(EventPipeSession *pSession);
// Get the event used to write metadata to the event stream.
EventPipeEventInstance* BuildEventMetadataEvent(EventPipeEventInstance &sourceInstance, unsigned int metdataId);
// Delete deferred providers.
void DeleteDeferredProviders();
// Determine if the specified thread is the rundown thread.
// Used during rundown to ignore events from all other threads so that we don't corrupt the trace file.
inline bool IsRundownThread(Thread *pThread)
{
LIMITED_METHOD_CONTRACT;
return (pThread == m_pRundownThread);
}
private:
// Get the provider without taking the lock.
EventPipeProvider* GetProviderNoLock(const SString &providerID);
// Get the enabled provider.
EventPipeSessionProvider* GetSessionProvider(EventPipeSession *pSession, EventPipeProvider *pProvider);
// The one and only EventPipe session.
EventPipeSession *m_pSession;
// Determines whether or not the event pipe is enabled.
Volatile<bool> m_enabled;
// The list of event pipe providers.
SList<SListElem<EventPipeProvider*>> *m_pProviderList;
// The provider used to write configuration events to the event stream.
EventPipeProvider *m_pConfigProvider;
// The event used to write event information to the event stream.
EventPipeEvent *m_pMetadataEvent;
// The provider name for the configuration event pipe provider.
// This provider is used to emit configuration events.
const static WCHAR* s_configurationProviderName;
// True if rundown is enabled.
Volatile<bool> m_rundownEnabled;
// The rundown thread. If rundown is not enabled, this is NULL.
Thread *m_pRundownThread;
};
#endif // FEATURE_PERFTRACING
#endif // __EVENTPIPE_CONFIGURATION_H__
|
