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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
/*
* Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
// NOTE To minimize diff with upstream tensorflow, disable clang-format
// clang-format off
// NOTE This header is derived from the following file (in TensorFlow v1.12)
// 'externals/tensorflow/tensorflow/lite/profiling/profile_buffer.h
#ifndef TENSORFLOW_CONTRIB_LITE_PROFILING_PROFILE_BUFFER_H_
#define TENSORFLOW_CONTRIB_LITE_PROFILING_PROFILE_BUFFER_H_
#include <cstddef>
#include <cstdint>
#include "profiling/time.h"
namespace tflite {
namespace profiling {
// A profiling event.
struct ProfileEvent {
// Describes the type of event.
// The event_metadata field may contain additional data for interpreting
// the event.
enum class EventType {
// Default event type, the metadata field has no special significance.
DEFAULT = 0,
// The event is an operator invocation and the event_metadata field is the
// index of operator node.
OPERATOR_INVOKE_EVENT = 1
};
// Label of the event. This usually describes the event.
const char* tag;
// Timestamp in microseconds when the event began.
uint64_t begin_timestamp_us;
// Timestamp in microseconds when the event ended.
uint64_t end_timestamp_us;
// The field containing the type of event. This must be one of the event types
// in EventType.
EventType event_type;
// Extra data describing the details of the event.
uint32_t event_metadata;
};
} // namespace profiling
} // namespace tflite
#ifdef TFLITE_PROFILING_ENABLED
#include <sys/time.h>
#include <vector>
namespace tflite {
namespace profiling {
constexpr uint32_t kInvalidEventHandle = static_cast<uint32_t>(~0) - 1;
// A ring buffer of profile events.
// This class is not thread safe.
class ProfileBuffer {
public:
ProfileBuffer(uint32_t max_num_entries, bool enabled)
: enabled_(enabled), current_index_(0), event_buffer_(max_num_entries) {}
// Adds an event to the buffer with begin timestamp set to the current
// timestamp. Returns a handle to event that can be used to call EndEvent. If
// buffer is disabled this has no affect.
// The tag of the event should remain valid till the buffer is valid.
uint32_t BeginEvent(const char* tag, ProfileEvent::EventType event_type,
uint32_t event_metadata) {
if (!enabled_) {
return kInvalidEventHandle;
}
uint64_t timestamp = time::NowMicros();
int index = current_index_ % event_buffer_.size();
event_buffer_[index].tag = tag;
event_buffer_[index].event_type = event_type;
event_buffer_[index].event_metadata = event_metadata;
event_buffer_[index].begin_timestamp_us = timestamp;
event_buffer_[index].end_timestamp_us = 0;
current_index_++;
return index;
}
// Sets the enabled state of buffer to |enabled|
void SetEnabled(bool enabled) { enabled_ = enabled; }
// Sets the end timestamp for event for the handle to current time.
// If the buffer is disabled or previous event has been overwritten this
// operation has not effect.
void EndEvent(uint32_t event_handle) {
if (!enabled_ || event_handle == kInvalidEventHandle ||
event_handle > current_index_) {
return;
}
const uint32_t max_size = event_buffer_.size();
if (current_index_ > (max_size + event_handle)) {
// Ignore, buffer has already overflowed.
return;
}
int event_index = event_handle % max_size;
event_buffer_[event_index].end_timestamp_us = time::NowMicros();
}
// Returns the size of the buffer.
size_t Size() const {
return (current_index_ >= event_buffer_.size()) ? event_buffer_.size()
: current_index_;
}
// Resets the buffer.
void Reset() {
enabled_ = false;
current_index_ = 0;
}
// Returns the profile event at the given index. If the index is invalid a
// nullptr is returned. The return event may get overwritten if more events
// are added to buffer.
const struct ProfileEvent* const At(int index) const {
size_t size = Size();
if (index >= size) {
return nullptr;
}
const uint32_t max_size = event_buffer_.size();
uint32_t start =
(current_index_ > max_size) ? current_index_ % max_size : max_size;
index = (index + start) % max_size;
return &event_buffer_[index];
}
private:
bool enabled_;
uint32_t current_index_;
std::vector<ProfileEvent> event_buffer_;
};
} // namespace profiling
} // namespace tflite
#endif // TFLITE_PROFILING_ENABLED
#endif // TENSORFLOW_CONTRIB_LITE_PROFILING_PROFILE_BUFFER_H_
// clang-format on
|
