Refactor monitoring gauge and sampler API to an object-based API.
PiperOrigin-RevId: 244258066
This commit is contained in:
Xiao Yu
TensorFlower Gardener
parent
01d0542ed6
commit
a193adb709
@ -99,59 +99,6 @@ bool TFE_ProfilerClientStartTracing(const char* service_addr,
|
||||
return s.ok();
|
||||
}
|
||||
|
||||
static tensorflow::mutex gauges_map_lock(tensorflow::LINKER_INITIALIZED);
|
||||
|
||||
static std::unordered_map<string,
|
||||
tensorflow::monitoring::Gauge<tensorflow::int64, 1>*>*
|
||||
get_gauges_map() EXCLUSIVE_LOCKS_REQUIRED(gauges_map_lock) {
|
||||
static std::unordered_map<
|
||||
string, tensorflow::monitoring::Gauge<tensorflow::int64, 1>*>*
|
||||
gauges_map = new std::unordered_map<
|
||||
string, tensorflow::monitoring::Gauge<tensorflow::int64, 1>*>;
|
||||
return gauges_map;
|
||||
}
|
||||
|
||||
static tensorflow::mutex samplers_map_lock(tensorflow::LINKER_INITIALIZED);
|
||||
|
||||
static std::unordered_map<string, tensorflow::monitoring::Sampler<1>*>*
|
||||
get_samplers_map() EXCLUSIVE_LOCKS_REQUIRED(samplers_map_lock) {
|
||||
static std::unordered_map<string, tensorflow::monitoring::Sampler<1>*>*
|
||||
samplers_map =
|
||||
new std::unordered_map<string, tensorflow::monitoring::Sampler<1>*>;
|
||||
return samplers_map;
|
||||
}
|
||||
|
||||
void TFE_MonitoringSetGauge(const char* name, const char* label,
|
||||
int64_t value) {
|
||||
tensorflow::mutex_lock l(gauges_map_lock);
|
||||
auto gauges_map = get_gauges_map();
|
||||
if (gauges_map->find(name) == gauges_map->end()) {
|
||||
gauges_map->emplace(
|
||||
name, tensorflow::monitoring::Gauge<tensorflow::int64, 1>::New(
|
||||
name,
|
||||
tensorflow::strings::StrCat(
|
||||
name, " :Gauge metric collected from Python API."),
|
||||
"metric_descriptor"));
|
||||
}
|
||||
gauges_map->at(name)->GetCell(label)->Set(value);
|
||||
}
|
||||
|
||||
void TFE_MonitoringAddSampler(const char* name, const char* label,
|
||||
double value) {
|
||||
tensorflow::mutex_lock l(samplers_map_lock);
|
||||
auto samplers_map = get_samplers_map();
|
||||
if (samplers_map->find(name) == samplers_map->end()) {
|
||||
samplers_map->emplace(
|
||||
name, tensorflow::monitoring::Sampler<1>::New(
|
||||
{name,
|
||||
tensorflow::strings::StrCat(
|
||||
name, " :Counter metric collected from Python API."),
|
||||
"metric_descriptor"},
|
||||
{tensorflow::monitoring::Buckets::Exponential(1, 2, 30)}));
|
||||
}
|
||||
samplers_map->at(name)->GetCell(label)->Add(value);
|
||||
}
|
||||
|
||||
void TFE_MonitoringCounterCellIncrementBy(TFE_MonitoringCounterCell* cell,
|
||||
int64_t value) {
|
||||
cell->cell.IncrementBy(value);
|
||||
@ -166,6 +113,10 @@ TFE_MonitoringCounter0* TFE_MonitoringNewCounter0(const char* name,
|
||||
const char* description) {
|
||||
auto* result = new TFE_MonitoringCounter0({name, description});
|
||||
Set_TF_Status_from_Status(status, result->counter->GetStatus());
|
||||
if (!result->counter->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -185,6 +136,10 @@ TFE_MonitoringCounter1* TFE_MonitoringNewCounter1(const char* name,
|
||||
const char* label1) {
|
||||
auto* result = new TFE_MonitoringCounter1({name, description, label1});
|
||||
Set_TF_Status_from_Status(status, result->counter->GetStatus());
|
||||
if (!result->counter->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -206,6 +161,10 @@ TFE_MonitoringCounter2* TFE_MonitoringNewCounter2(const char* name,
|
||||
auto* result =
|
||||
new TFE_MonitoringCounter2({name, description, label1, label2});
|
||||
Set_TF_Status_from_Status(status, result->counter->GetStatus());
|
||||
if (!result->counter->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -218,3 +177,344 @@ TFE_MonitoringCounterCell* TFE_MonitoringGetCellCounter2(
|
||||
return static_cast<TFE_MonitoringCounterCell*>(
|
||||
static_cast<void*>(counter->counter->GetCell(label1, label2)));
|
||||
}
|
||||
|
||||
void TFE_MonitoringIntGaugeCellSet(TFE_MonitoringIntGaugeCell* cell,
|
||||
int64_t value) {
|
||||
cell->cell.Set(value);
|
||||
}
|
||||
|
||||
int64_t TFE_MonitoringIntGaugeCellValue(TFE_MonitoringIntGaugeCell* cell) {
|
||||
return cell->cell.value();
|
||||
}
|
||||
|
||||
TFE_MonitoringIntGauge0* TFE_MonitoringNewIntGauge0(const char* name,
|
||||
TF_Status* status,
|
||||
const char* description) {
|
||||
auto* result = new TFE_MonitoringIntGauge0({name, description});
|
||||
Set_TF_Status_from_Status(status, result->gauge->GetStatus());
|
||||
if (!result->gauge->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteIntGauge0(TFE_MonitoringIntGauge0* gauge) {
|
||||
delete gauge;
|
||||
}
|
||||
|
||||
TFE_MonitoringIntGaugeCell* TFE_MonitoringGetCellIntGauge0(
|
||||
TFE_MonitoringIntGauge0* gauge) {
|
||||
return static_cast<TFE_MonitoringIntGaugeCell*>(
|
||||
static_cast<void*>(gauge->gauge->GetCell()));
|
||||
}
|
||||
|
||||
TFE_MonitoringIntGauge1* TFE_MonitoringNewIntGauge1(const char* name,
|
||||
TF_Status* status,
|
||||
const char* description,
|
||||
const char* label1) {
|
||||
auto* result = new TFE_MonitoringIntGauge1({name, description, label1});
|
||||
Set_TF_Status_from_Status(status, result->gauge->GetStatus());
|
||||
if (!result->gauge->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteIntGauge1(TFE_MonitoringIntGauge1* gauge) {
|
||||
delete gauge;
|
||||
}
|
||||
|
||||
TFE_MonitoringIntGaugeCell* TFE_MonitoringGetCellIntGauge1(
|
||||
TFE_MonitoringIntGauge1* gauge, const char* label1) {
|
||||
return static_cast<TFE_MonitoringIntGaugeCell*>(
|
||||
static_cast<void*>(gauge->gauge->GetCell(label1)));
|
||||
}
|
||||
|
||||
TFE_MonitoringIntGauge2* TFE_MonitoringNewIntGauge2(const char* name,
|
||||
TF_Status* status,
|
||||
const char* description,
|
||||
const char* label1,
|
||||
const char* label2) {
|
||||
auto* result =
|
||||
new TFE_MonitoringIntGauge2({name, description, label1, label2});
|
||||
Set_TF_Status_from_Status(status, result->gauge->GetStatus());
|
||||
if (!result->gauge->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteIntGauge2(TFE_MonitoringIntGauge2* gauge) {
|
||||
delete gauge;
|
||||
}
|
||||
|
||||
TFE_MonitoringIntGaugeCell* TFE_MonitoringGetCellIntGauge2(
|
||||
TFE_MonitoringIntGauge2* gauge, const char* label1, const char* label2) {
|
||||
return static_cast<TFE_MonitoringIntGaugeCell*>(
|
||||
static_cast<void*>(gauge->gauge->GetCell(label1, label2)));
|
||||
}
|
||||
|
||||
void TFE_MonitoringStringGaugeCellSet(TFE_MonitoringStringGaugeCell* cell,
|
||||
const char* value) {
|
||||
cell->cell.Set({value});
|
||||
}
|
||||
|
||||
const void TFE_MonitoringStringGaugeCellValue(
|
||||
TFE_MonitoringStringGaugeCell* cell, TF_Buffer* buf) {
|
||||
tensorflow::string value = cell->cell.value();
|
||||
void* data = tensorflow::port::Malloc(value.length());
|
||||
value.copy(static_cast<char*>(data), value.length(), 0);
|
||||
buf->data = data;
|
||||
buf->length = value.length();
|
||||
buf->data_deallocator = [](void* data, size_t length) {
|
||||
tensorflow::port::Free(data);
|
||||
};
|
||||
}
|
||||
|
||||
TFE_MonitoringStringGauge0* TFE_MonitoringNewStringGauge0(
|
||||
const char* name, TF_Status* status, const char* description) {
|
||||
auto* result = new TFE_MonitoringStringGauge0({name, description});
|
||||
Set_TF_Status_from_Status(status, result->gauge->GetStatus());
|
||||
if (!result->gauge->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteStringGauge0(TFE_MonitoringStringGauge0* gauge) {
|
||||
delete gauge;
|
||||
}
|
||||
|
||||
TFE_MonitoringStringGaugeCell* TFE_MonitoringGetCellStringGauge0(
|
||||
TFE_MonitoringStringGauge0* gauge) {
|
||||
return static_cast<TFE_MonitoringStringGaugeCell*>(
|
||||
static_cast<void*>(gauge->gauge->GetCell()));
|
||||
}
|
||||
|
||||
TFE_MonitoringStringGauge1* TFE_MonitoringNewStringGauge1(
|
||||
const char* name, TF_Status* status, const char* description,
|
||||
const char* label1) {
|
||||
auto* result = new TFE_MonitoringStringGauge1({name, description, label1});
|
||||
Set_TF_Status_from_Status(status, result->gauge->GetStatus());
|
||||
if (!result->gauge->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteStringGauge1(TFE_MonitoringStringGauge1* gauge) {
|
||||
delete gauge;
|
||||
}
|
||||
|
||||
TFE_MonitoringStringGaugeCell* TFE_MonitoringGetCellStringGauge1(
|
||||
TFE_MonitoringStringGauge1* gauge, const char* label1) {
|
||||
return static_cast<TFE_MonitoringStringGaugeCell*>(
|
||||
static_cast<void*>(gauge->gauge->GetCell(label1)));
|
||||
}
|
||||
|
||||
TFE_MonitoringStringGauge2* TFE_MonitoringNewStringGauge2(
|
||||
const char* name, TF_Status* status, const char* description,
|
||||
const char* label1, const char* label2) {
|
||||
auto* result =
|
||||
new TFE_MonitoringStringGauge2({name, description, label1, label2});
|
||||
Set_TF_Status_from_Status(status, result->gauge->GetStatus());
|
||||
if (!result->gauge->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteStringGauge2(TFE_MonitoringStringGauge2* gauge) {
|
||||
delete gauge;
|
||||
}
|
||||
|
||||
TFE_MonitoringStringGaugeCell* TFE_MonitoringGetCellStringGauge2(
|
||||
TFE_MonitoringStringGauge2* gauge, const char* label1, const char* label2) {
|
||||
return static_cast<TFE_MonitoringStringGaugeCell*>(
|
||||
static_cast<void*>(gauge->gauge->GetCell(label1, label2)));
|
||||
}
|
||||
|
||||
void TFE_MonitoringBoolGaugeCellSet(TFE_MonitoringBoolGaugeCell* cell,
|
||||
bool value) {
|
||||
cell->cell.Set(value);
|
||||
}
|
||||
|
||||
bool TFE_MonitoringBoolGaugeCellValue(TFE_MonitoringBoolGaugeCell* cell) {
|
||||
return cell->cell.value();
|
||||
}
|
||||
|
||||
TFE_MonitoringBoolGauge0* TFE_MonitoringNewBoolGauge0(const char* name,
|
||||
TF_Status* status,
|
||||
const char* description) {
|
||||
auto* result = new TFE_MonitoringBoolGauge0({name, description});
|
||||
Set_TF_Status_from_Status(status, result->gauge->GetStatus());
|
||||
if (!result->gauge->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteBoolGauge0(TFE_MonitoringBoolGauge0* gauge) {
|
||||
delete gauge;
|
||||
}
|
||||
|
||||
TFE_MonitoringBoolGaugeCell* TFE_MonitoringGetCellBoolGauge0(
|
||||
TFE_MonitoringBoolGauge0* gauge) {
|
||||
return static_cast<TFE_MonitoringBoolGaugeCell*>(
|
||||
static_cast<void*>(gauge->gauge->GetCell()));
|
||||
}
|
||||
|
||||
TFE_MonitoringBoolGauge1* TFE_MonitoringNewBoolGauge1(const char* name,
|
||||
TF_Status* status,
|
||||
const char* description,
|
||||
const char* label1) {
|
||||
auto* result = new TFE_MonitoringBoolGauge1({name, description, label1});
|
||||
Set_TF_Status_from_Status(status, result->gauge->GetStatus());
|
||||
if (!result->gauge->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteBoolGauge1(TFE_MonitoringBoolGauge1* gauge) {
|
||||
delete gauge;
|
||||
}
|
||||
|
||||
TFE_MonitoringBoolGaugeCell* TFE_MonitoringGetCellBoolGauge1(
|
||||
TFE_MonitoringBoolGauge1* gauge, const char* label1) {
|
||||
return static_cast<TFE_MonitoringBoolGaugeCell*>(
|
||||
static_cast<void*>(gauge->gauge->GetCell(label1)));
|
||||
}
|
||||
|
||||
TFE_MonitoringBoolGauge2* TFE_MonitoringNewBoolGauge2(const char* name,
|
||||
TF_Status* status,
|
||||
const char* description,
|
||||
const char* label1,
|
||||
const char* label2) {
|
||||
auto* result =
|
||||
new TFE_MonitoringBoolGauge2({name, description, label1, label2});
|
||||
Set_TF_Status_from_Status(status, result->gauge->GetStatus());
|
||||
if (!result->gauge->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteBoolGauge2(TFE_MonitoringBoolGauge2* gauge) {
|
||||
delete gauge;
|
||||
}
|
||||
|
||||
TFE_MonitoringBoolGaugeCell* TFE_MonitoringGetCellBoolGauge2(
|
||||
TFE_MonitoringBoolGauge2* gauge, const char* label1, const char* label2) {
|
||||
return static_cast<TFE_MonitoringBoolGaugeCell*>(
|
||||
static_cast<void*>(gauge->gauge->GetCell(label1, label2)));
|
||||
}
|
||||
|
||||
void TFE_MonitoringSamplerCellAdd(TFE_MonitoringSamplerCell* cell,
|
||||
double value) {
|
||||
cell->cell.Add(value);
|
||||
}
|
||||
|
||||
void TFE_MonitoringSamplerCellValue(TFE_MonitoringSamplerCell* cell,
|
||||
TF_Buffer* buf) {
|
||||
string content;
|
||||
cell->cell.value().SerializeToString(&content);
|
||||
void* data = tensorflow::port::Malloc(content.length());
|
||||
content.copy(static_cast<char*>(data), content.length(), 0);
|
||||
buf->data = data;
|
||||
buf->length = content.length();
|
||||
buf->data_deallocator = [](void* data, size_t length) {
|
||||
tensorflow::port::Free(data);
|
||||
};
|
||||
}
|
||||
|
||||
TFE_MonitoringBuckets* TFE_MonitoringNewExponentialBuckets(double scale,
|
||||
double growth_factor,
|
||||
int bucket_count) {
|
||||
return new TFE_MonitoringBuckets([scale, growth_factor, bucket_count]() {
|
||||
return tensorflow::monitoring::Buckets::Exponential(scale, growth_factor,
|
||||
bucket_count);
|
||||
});
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteBuckets(TFE_MonitoringBuckets* buckets) {
|
||||
delete buckets;
|
||||
}
|
||||
|
||||
TFE_MonitoringSampler0* TFE_MonitoringNewSampler0(
|
||||
const char* name, TFE_MonitoringBuckets* buckets, TF_Status* status,
|
||||
const char* description) {
|
||||
auto* result = new TFE_MonitoringSampler0(
|
||||
{name, buckets->create_buckets(), description});
|
||||
Set_TF_Status_from_Status(status, result->sampler->GetStatus());
|
||||
if (!result->sampler->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteSampler0(TFE_MonitoringSampler0* sampler) {
|
||||
delete sampler;
|
||||
}
|
||||
|
||||
TFE_MonitoringSamplerCell* TFE_MonitoringGetCellSampler0(
|
||||
TFE_MonitoringSampler0* sampler) {
|
||||
return static_cast<TFE_MonitoringSamplerCell*>(
|
||||
static_cast<void*>(sampler->sampler->GetCell()));
|
||||
}
|
||||
|
||||
TFE_MonitoringSampler1* TFE_MonitoringNewSampler1(
|
||||
const char* name, TFE_MonitoringBuckets* buckets, TF_Status* status,
|
||||
const char* description, const char* label1) {
|
||||
auto* result = new TFE_MonitoringSampler1(
|
||||
{name, buckets->create_buckets(), description, label1});
|
||||
Set_TF_Status_from_Status(status, result->sampler->GetStatus());
|
||||
if (!result->sampler->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteSampler1(TFE_MonitoringSampler1* sampler) {
|
||||
delete sampler;
|
||||
}
|
||||
|
||||
TFE_MonitoringSamplerCell* TFE_MonitoringGetCellSampler1(
|
||||
TFE_MonitoringSampler1* sampler, const char* label1) {
|
||||
return static_cast<TFE_MonitoringSamplerCell*>(
|
||||
static_cast<void*>(sampler->sampler->GetCell(label1)));
|
||||
}
|
||||
|
||||
TFE_MonitoringSampler2* TFE_MonitoringNewSampler2(
|
||||
const char* name, TFE_MonitoringBuckets* buckets, TF_Status* status,
|
||||
const char* description, const char* label1, const char* label2) {
|
||||
auto* result = new TFE_MonitoringSampler2(
|
||||
{name, buckets->create_buckets(), description, label1, label2});
|
||||
Set_TF_Status_from_Status(status, result->sampler->GetStatus());
|
||||
if (!result->sampler->GetStatus().ok()) {
|
||||
delete result;
|
||||
return nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void TFE_MonitoringDeleteSampler2(TFE_MonitoringSampler2* sampler) {
|
||||
delete sampler;
|
||||
}
|
||||
|
||||
TFE_MonitoringSamplerCell* TFE_MonitoringGetCellSampler2(
|
||||
TFE_MonitoringSampler2* sampler, const char* label1, const char* label2) {
|
||||
return static_cast<TFE_MonitoringSamplerCell*>(
|
||||
static_cast<void*>(sampler->sampler->GetCell(label1, label2)));
|
||||
}
|
||||
|
||||
@ -87,19 +87,7 @@ TF_CAPI_EXPORT extern bool TFE_ProfilerClientStartTracing(
|
||||
const char* service_addr, const char* logdir, const char* worker_list,
|
||||
bool include_dataset_ops, int duration_ms, int num_tracing_attempts);
|
||||
|
||||
// Set the value of a Gauge metric. If the metric with given name does not
|
||||
// exist, it will create a new Gauge metric. Right now it only supports type
|
||||
// int64, consider to add more type supports if needed.
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringSetGauge(const char* name,
|
||||
const char* label,
|
||||
int64_t value);
|
||||
|
||||
// Add the given value to a Sampler metric. If the metric with given name
|
||||
// does not exist, it will create a new Sampler metric.
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringAddSampler(const char* name,
|
||||
const char* label,
|
||||
double value);
|
||||
|
||||
// TODO(fishx): Move these monitoring APIs into a separate file.
|
||||
// -----------------------------------------------------------------------------
|
||||
// Monitoring Counter APIs.
|
||||
// These APIs de-templated monitoring Counter for swig.
|
||||
@ -149,6 +137,179 @@ TF_CAPI_EXPORT extern void TFE_MonitoringDeleteCounter2(
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringCounterCell* TFE_MonitoringGetCellCounter2(
|
||||
TFE_MonitoringCounter2* counter, const char* label1, const char* label2);
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Monitoring Gauge APIs.
|
||||
// These APIs de-templated monitoring Gauge for swig.
|
||||
|
||||
typedef struct TFE_MonitoringIntGaugeCell TFE_MonitoringIntGaugeCell;
|
||||
|
||||
// Atomically set the value of the cell.
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringIntGaugeCellSet(
|
||||
TFE_MonitoringIntGaugeCell* cell, int64_t value);
|
||||
|
||||
// Retrieves the current value of the cell.
|
||||
TF_CAPI_EXPORT extern int64_t TFE_MonitoringIntGaugeCellValue(
|
||||
TFE_MonitoringIntGaugeCell* cell);
|
||||
|
||||
// APIs for Int Gauge without label.
|
||||
typedef struct TFE_MonitoringIntGauge0 TFE_MonitoringIntGauge0;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringIntGauge0* TFE_MonitoringNewIntGauge0(
|
||||
const char* name, TF_Status* out_status, const char* description);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteIntGauge0(
|
||||
TFE_MonitoringIntGauge0* gauge);
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringIntGaugeCell*
|
||||
TFE_MonitoringGetCellIntGauge0(TFE_MonitoringIntGauge0* gauge);
|
||||
|
||||
// APIs for Int Gauge with 1 label.
|
||||
typedef struct TFE_MonitoringIntGauge1 TFE_MonitoringIntGauge1;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringIntGauge1* TFE_MonitoringNewIntGauge1(
|
||||
const char* name, TF_Status* out_status, const char* description,
|
||||
const char* label1);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteIntGauge1(
|
||||
TFE_MonitoringIntGauge1* gauge);
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringIntGaugeCell*
|
||||
TFE_MonitoringGetCellIntGauge1(TFE_MonitoringIntGauge1* gauge,
|
||||
const char* label1);
|
||||
|
||||
// APIs for Int Gauge with 2 label.
|
||||
typedef struct TFE_MonitoringIntGauge2 TFE_MonitoringIntGauge2;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringIntGauge2* TFE_MonitoringNewIntGauge2(
|
||||
const char* name, TF_Status* out_status, const char* description,
|
||||
const char* label1, const char* label2);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteIntGauge2(
|
||||
TFE_MonitoringIntGauge2* gauge);
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringIntGaugeCell*
|
||||
TFE_MonitoringGetCellIntGauge2(TFE_MonitoringIntGauge2* gauge,
|
||||
const char* label1, const char* label2);
|
||||
|
||||
typedef struct TFE_MonitoringStringGaugeCell TFE_MonitoringStringGaugeCell;
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringStringGaugeCellSet(
|
||||
TFE_MonitoringStringGaugeCell* cell, const char* value);
|
||||
// Retrieves the string value and saves it in buffer.
|
||||
TF_CAPI_EXPORT extern const void TFE_MonitoringStringGaugeCellValue(
|
||||
TFE_MonitoringStringGaugeCell* cell, TF_Buffer* buf);
|
||||
|
||||
// APIs for String Gauge without label.
|
||||
typedef struct TFE_MonitoringStringGauge0 TFE_MonitoringStringGauge0;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringStringGauge0* TFE_MonitoringNewStringGauge0(
|
||||
const char* name, TF_Status* out_status, const char* description);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteStringGauge0(
|
||||
TFE_MonitoringStringGauge0* gauge);
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringStringGaugeCell*
|
||||
TFE_MonitoringGetCellStringGauge0(TFE_MonitoringStringGauge0* gauge);
|
||||
|
||||
// APIs for String Gauge with 1 label.
|
||||
typedef struct TFE_MonitoringStringGauge1 TFE_MonitoringStringGauge1;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringStringGauge1* TFE_MonitoringNewStringGauge1(
|
||||
const char* name, TF_Status* out_status, const char* description,
|
||||
const char* label1);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteStringGauge1(
|
||||
TFE_MonitoringStringGauge1* gauge);
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringStringGaugeCell*
|
||||
TFE_MonitoringGetCellStringGauge1(TFE_MonitoringStringGauge1* gauge,
|
||||
const char* label1);
|
||||
|
||||
// APIs for String Gauge with 2 label.
|
||||
typedef struct TFE_MonitoringStringGauge2 TFE_MonitoringStringGauge2;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringStringGauge2* TFE_MonitoringNewStringGauge2(
|
||||
const char* name, TF_Status* out_status, const char* description,
|
||||
const char* label1, const char* label2);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteStringGauge2(
|
||||
TFE_MonitoringStringGauge2* gauge);
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringStringGaugeCell*
|
||||
TFE_MonitoringGetCellStringGauge2(TFE_MonitoringStringGauge2* gauge,
|
||||
const char* label1, const char* label2);
|
||||
|
||||
typedef struct TFE_MonitoringBoolGaugeCell TFE_MonitoringBoolGaugeCell;
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringBoolGaugeCellSet(
|
||||
TFE_MonitoringBoolGaugeCell* cell, bool value);
|
||||
TF_CAPI_EXPORT extern bool TFE_MonitoringBoolGaugeCellValue(
|
||||
TFE_MonitoringBoolGaugeCell* cell);
|
||||
|
||||
// APIs for Bool Gauge without label.
|
||||
typedef struct TFE_MonitoringBoolGauge0 TFE_MonitoringBoolGauge0;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringBoolGauge0* TFE_MonitoringNewBoolGauge0(
|
||||
const char* name, TF_Status* out_status, const char* description);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteBoolGauge0(
|
||||
TFE_MonitoringBoolGauge0* gauge);
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringBoolGaugeCell*
|
||||
TFE_MonitoringGetCellBoolGauge0(TFE_MonitoringBoolGauge0* gauge);
|
||||
|
||||
// APIs for Bool Gauge with 1 label.
|
||||
typedef struct TFE_MonitoringBoolGauge1 TFE_MonitoringBoolGauge1;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringBoolGauge1* TFE_MonitoringNewBoolGauge1(
|
||||
const char* name, TF_Status* out_status, const char* description,
|
||||
const char* label1);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteBoolGauge1(
|
||||
TFE_MonitoringBoolGauge1* gauge);
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringBoolGaugeCell*
|
||||
TFE_MonitoringGetCellBoolGauge1(TFE_MonitoringBoolGauge1* gauge,
|
||||
const char* label1);
|
||||
|
||||
// APIs for Bool Gauge with 2 label.
|
||||
typedef struct TFE_MonitoringBoolGauge2 TFE_MonitoringBoolGauge2;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringBoolGauge2* TFE_MonitoringNewBoolGauge2(
|
||||
const char* name, TF_Status* out_status, const char* description,
|
||||
const char* label1, const char* label2);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteBoolGauge2(
|
||||
TFE_MonitoringBoolGauge2* gauge);
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringBoolGaugeCell*
|
||||
TFE_MonitoringGetCellBoolGauge2(TFE_MonitoringBoolGauge2* gauge,
|
||||
const char* label1, const char* label2);
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Monitoring Sampler APIs.
|
||||
// These APIs de-templated monitoring Sampler for swig.
|
||||
|
||||
typedef struct TFE_MonitoringSamplerCell TFE_MonitoringSamplerCell;
|
||||
|
||||
// Atomically add the value of the cell.
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringSamplerCellAdd(
|
||||
TFE_MonitoringSamplerCell* cell, double value);
|
||||
|
||||
// Retrieves the current value of the cell. The return value is a HistogramProto
|
||||
// saved in buffer.
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringSamplerCellValue(
|
||||
TFE_MonitoringSamplerCell* cell, TF_Buffer* buf);
|
||||
|
||||
// APIs for sampler buckets
|
||||
typedef struct TFE_MonitoringBuckets TFE_MonitoringBuckets;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringBuckets*
|
||||
TFE_MonitoringNewExponentialBuckets(double scale, double growth_factor,
|
||||
int bucket_count);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteBuckets(
|
||||
TFE_MonitoringBuckets* buckets);
|
||||
|
||||
// APIs for Sampler without label.
|
||||
typedef struct TFE_MonitoringSampler0 TFE_MonitoringSampler0;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringSampler0* TFE_MonitoringNewSampler0(
|
||||
const char* name, TFE_MonitoringBuckets* buckets, TF_Status* out_status,
|
||||
const char* description);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteSampler0(
|
||||
TFE_MonitoringSampler0* sampler);
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringSamplerCell* TFE_MonitoringGetCellSampler0(
|
||||
TFE_MonitoringSampler0* sampler);
|
||||
|
||||
// APIs for Sampler with 1 label.
|
||||
typedef struct TFE_MonitoringSampler1 TFE_MonitoringSampler1;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringSampler1* TFE_MonitoringNewSampler1(
|
||||
const char* name, TFE_MonitoringBuckets* buckets, TF_Status* out_status,
|
||||
const char* description, const char* label1);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteSampler1(
|
||||
TFE_MonitoringSampler1* sampler);
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringSamplerCell* TFE_MonitoringGetCellSampler1(
|
||||
TFE_MonitoringSampler1* sampler, const char* label1);
|
||||
|
||||
// APIs for Sampler with 2 label.
|
||||
typedef struct TFE_MonitoringSampler2 TFE_MonitoringSampler2;
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringSampler2* TFE_MonitoringNewSampler2(
|
||||
const char* name, TFE_MonitoringBuckets* buckets, TF_Status* out_status,
|
||||
const char* description, const char* label1, const char* label2);
|
||||
TF_CAPI_EXPORT extern void TFE_MonitoringDeleteSampler2(
|
||||
TFE_MonitoringSampler2* sampler);
|
||||
TF_CAPI_EXPORT extern TFE_MonitoringSamplerCell* TFE_MonitoringGetCellSampler2(
|
||||
TFE_MonitoringSampler2* sampler, const char* label1, const char* label2);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* end extern "C" */
|
||||
#endif
|
||||
|
||||
@ -131,23 +131,6 @@ TEST(CAPI, MultipleProfilerSession) {
|
||||
TFE_DeleteProfilerContext(profiler_context);
|
||||
}
|
||||
|
||||
TEST(CAPI, MonitoringSetGauge) {
|
||||
TFE_MonitoringSetGauge("test/gauge", "label", 1);
|
||||
auto* collection_registry = monitoring::CollectionRegistry::Default();
|
||||
monitoring::CollectionRegistry::CollectMetricsOptions options;
|
||||
std::unique_ptr<monitoring::CollectedMetrics> metrics =
|
||||
collection_registry->CollectMetrics(options);
|
||||
|
||||
EXPECT_EQ("test/gauge", metrics->point_set_map.at("test/gauge")->metric_name);
|
||||
EXPECT_EQ(1,
|
||||
metrics->point_set_map.at("test/gauge")->points.at(0)->int64_value);
|
||||
|
||||
TFE_MonitoringSetGauge("test/gauge", "label", 5);
|
||||
metrics = collection_registry->CollectMetrics(options);
|
||||
EXPECT_EQ(5,
|
||||
metrics->point_set_map.at("test/gauge")->points.at(0)->int64_value);
|
||||
}
|
||||
|
||||
TEST(CAPI, MonitoringCounter0) {
|
||||
TF_Status* status = TF_NewStatus();
|
||||
auto* counter =
|
||||
@ -200,8 +183,59 @@ TEST(CAPI, MonitoringCounterMultiple) {
|
||||
TFE_MonitoringDeleteCounter2(counter2);
|
||||
}
|
||||
|
||||
TEST(CAPI, MonitoringAddSampler) {
|
||||
TFE_MonitoringAddSampler("test/sampler", "label", 1.0);
|
||||
TEST(CAPI, MonitoringGauge0) {
|
||||
TF_Status* status = TF_NewStatus();
|
||||
auto* gauge = TFE_MonitoringNewIntGauge0("test/gauge", status, "test");
|
||||
CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
|
||||
auto* cell = TFE_MonitoringGetCellIntGauge0(gauge);
|
||||
TFE_MonitoringIntGaugeCellSet(cell, 1);
|
||||
EXPECT_EQ(TFE_MonitoringIntGaugeCellValue(cell), 1);
|
||||
auto* collection_registry = monitoring::CollectionRegistry::Default();
|
||||
monitoring::CollectionRegistry::CollectMetricsOptions options;
|
||||
std::unique_ptr<monitoring::CollectedMetrics> metrics =
|
||||
collection_registry->CollectMetrics(options);
|
||||
|
||||
EXPECT_EQ("test/gauge", metrics->point_set_map.at("test/gauge")->metric_name);
|
||||
EXPECT_EQ(1,
|
||||
metrics->point_set_map.at("test/gauge")->points.at(0)->int64_value);
|
||||
|
||||
TFE_MonitoringIntGaugeCellSet(cell, 5);
|
||||
metrics = collection_registry->CollectMetrics(options);
|
||||
EXPECT_EQ(5,
|
||||
metrics->point_set_map.at("test/gauge")->points.at(0)->int64_value);
|
||||
TF_DeleteStatus(status);
|
||||
}
|
||||
|
||||
TEST(CAPI, MonitoringMultipleGauge) {
|
||||
TF_Status* status = TF_NewStatus();
|
||||
auto* gauge1 =
|
||||
TFE_MonitoringNewBoolGauge1("test/gauge1", status, "test", "label1");
|
||||
CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
|
||||
auto* cell1 = TFE_MonitoringGetCellBoolGauge1(gauge1, "foo");
|
||||
TFE_MonitoringBoolGaugeCellSet(cell1, true);
|
||||
EXPECT_TRUE(TFE_MonitoringBoolGaugeCellValue(cell1));
|
||||
|
||||
auto* gauge2 = TFE_MonitoringNewStringGauge2("test/gauge2", status, "test",
|
||||
"label1", "label2");
|
||||
CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
|
||||
auto* cell2 = TFE_MonitoringGetCellStringGauge2(gauge2, "foo", "bar");
|
||||
TFE_MonitoringStringGaugeCellSet(cell2, "str");
|
||||
auto* buf = new TF_Buffer;
|
||||
TFE_MonitoringStringGaugeCellValue(cell2, buf);
|
||||
string data(static_cast<const char*>(buf->data), buf->length);
|
||||
delete buf;
|
||||
EXPECT_EQ(data, "str");
|
||||
TF_DeleteStatus(status);
|
||||
}
|
||||
|
||||
TEST(CAPI, MonitoringSampler0) {
|
||||
TF_Status* status = TF_NewStatus();
|
||||
auto* buckets = TFE_MonitoringNewExponentialBuckets(1.0, 2.0, 2);
|
||||
auto* sampler =
|
||||
TFE_MonitoringNewSampler0("test/sampler", buckets, status, "test");
|
||||
CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
|
||||
auto* cell = TFE_MonitoringGetCellSampler0(sampler);
|
||||
TFE_MonitoringSamplerCellAdd(cell, 1.0);
|
||||
auto* collection_registry = monitoring::CollectionRegistry::Default();
|
||||
monitoring::CollectionRegistry::CollectMetricsOptions options;
|
||||
std::unique_ptr<monitoring::CollectedMetrics> metrics =
|
||||
@ -213,11 +247,48 @@ TEST(CAPI, MonitoringAddSampler) {
|
||||
->points.at(0)
|
||||
->histogram_value.sum());
|
||||
|
||||
TFE_MonitoringAddSampler("test/sampler", "label", 5.0);
|
||||
TFE_MonitoringSamplerCellAdd(cell, 5.0);
|
||||
metrics = collection_registry->CollectMetrics(options);
|
||||
EXPECT_EQ(6.0, metrics->point_set_map.at("test/sampler")
|
||||
->points.at(0)
|
||||
->histogram_value.sum());
|
||||
TFE_MonitoringDeleteBuckets(buckets);
|
||||
TF_DeleteStatus(status);
|
||||
}
|
||||
|
||||
TEST(CAPI, MonitoringMultipleSampler) {
|
||||
TF_Status* status = TF_NewStatus();
|
||||
auto* buckets = TFE_MonitoringNewExponentialBuckets(1.0, 2.0, 2);
|
||||
auto* sampler1 = TFE_MonitoringNewSampler1("test/sampler1", buckets, status,
|
||||
"test", "label1");
|
||||
CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
|
||||
auto* cell1 = TFE_MonitoringGetCellSampler1(sampler1, "foo");
|
||||
TFE_MonitoringSamplerCellAdd(cell1, 1.0);
|
||||
TFE_MonitoringSamplerCellAdd(cell1, 2.0);
|
||||
TF_Buffer* result1 = TF_NewBuffer();
|
||||
TFE_MonitoringSamplerCellValue(cell1, result1);
|
||||
tensorflow::HistogramProto hitogram1;
|
||||
EXPECT_TRUE(hitogram1.ParseFromString(
|
||||
{reinterpret_cast<const char*>(result1->data), result1->length}));
|
||||
EXPECT_EQ(hitogram1.sum(), 3.0);
|
||||
delete result1;
|
||||
|
||||
auto* sampler2 = TFE_MonitoringNewSampler2("test/sampler2", buckets, status,
|
||||
"test", "label1", "label2");
|
||||
CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
|
||||
auto* cell2 = TFE_MonitoringGetCellSampler2(sampler2, "foo", "bar");
|
||||
TFE_MonitoringSamplerCellAdd(cell2, 2.0);
|
||||
TFE_MonitoringSamplerCellAdd(cell2, 3.0);
|
||||
TF_Buffer* result2 = TF_NewBuffer();
|
||||
TFE_MonitoringSamplerCellValue(cell2, result2);
|
||||
tensorflow::HistogramProto hitogram2;
|
||||
EXPECT_TRUE(hitogram2.ParseFromString(
|
||||
{reinterpret_cast<const char*>(result2->data), result2->length}));
|
||||
EXPECT_EQ(hitogram2.sum(), 5.0);
|
||||
delete result2;
|
||||
|
||||
TFE_MonitoringDeleteBuckets(buckets);
|
||||
TF_DeleteStatus(status);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
@ -50,6 +50,8 @@ limitations under the License.
|
||||
#include "tensorflow/core/lib/gtl/map_util.h"
|
||||
#include "tensorflow/core/lib/gtl/stl_util.h"
|
||||
#include "tensorflow/core/lib/monitoring/counter.h"
|
||||
#include "tensorflow/core/lib/monitoring/gauge.h"
|
||||
#include "tensorflow/core/lib/monitoring/sampler.h"
|
||||
#include "tensorflow/core/platform/mutex.h"
|
||||
#include "tensorflow/core/platform/thread_annotations.h"
|
||||
#include "tensorflow/core/profiler/lib/profiler_session.h"
|
||||
@ -159,6 +161,98 @@ struct TFE_MonitoringCounter2 : TFE_MonitoringCounter<2> {
|
||||
using TFE_MonitoringCounter::TFE_MonitoringCounter;
|
||||
};
|
||||
|
||||
struct TFE_MonitoringIntGaugeCell {
|
||||
tensorflow::monitoring::GaugeCell<tensorflow::int64> cell;
|
||||
};
|
||||
struct TFE_MonitoringStringGaugeCell {
|
||||
tensorflow::monitoring::GaugeCell<tensorflow::string> cell;
|
||||
};
|
||||
struct TFE_MonitoringBoolGaugeCell {
|
||||
tensorflow::monitoring::GaugeCell<bool> cell;
|
||||
};
|
||||
|
||||
template <typename ValueType, int NumLabels>
|
||||
struct TFE_MonitoringGauge {
|
||||
template <typename... LabelDesc>
|
||||
TFE_MonitoringGauge(const char* name, const char* description,
|
||||
LabelDesc&&... label) {
|
||||
gauge = absl::WrapUnique(
|
||||
tensorflow::monitoring::Gauge<ValueType, NumLabels>::New(
|
||||
name, description, label...));
|
||||
}
|
||||
|
||||
std::unique_ptr<tensorflow::monitoring::Gauge<ValueType, NumLabels>> gauge;
|
||||
};
|
||||
|
||||
struct TFE_MonitoringIntGauge0 : TFE_MonitoringGauge<tensorflow::int64, 0> {
|
||||
using TFE_MonitoringGauge::TFE_MonitoringGauge;
|
||||
};
|
||||
struct TFE_MonitoringIntGauge1 : TFE_MonitoringGauge<tensorflow::int64, 1> {
|
||||
using TFE_MonitoringGauge::TFE_MonitoringGauge;
|
||||
};
|
||||
struct TFE_MonitoringIntGauge2 : TFE_MonitoringGauge<tensorflow::int64, 2> {
|
||||
using TFE_MonitoringGauge::TFE_MonitoringGauge;
|
||||
};
|
||||
|
||||
struct TFE_MonitoringStringGauge0 : TFE_MonitoringGauge<tensorflow::string, 0> {
|
||||
using TFE_MonitoringGauge::TFE_MonitoringGauge;
|
||||
};
|
||||
struct TFE_MonitoringStringGauge1 : TFE_MonitoringGauge<tensorflow::string, 1> {
|
||||
using TFE_MonitoringGauge::TFE_MonitoringGauge;
|
||||
};
|
||||
struct TFE_MonitoringStringGauge2 : TFE_MonitoringGauge<tensorflow::string, 2> {
|
||||
using TFE_MonitoringGauge::TFE_MonitoringGauge;
|
||||
};
|
||||
|
||||
struct TFE_MonitoringBoolGauge0 : TFE_MonitoringGauge<bool, 0> {
|
||||
using TFE_MonitoringGauge::TFE_MonitoringGauge;
|
||||
};
|
||||
struct TFE_MonitoringBoolGauge1 : TFE_MonitoringGauge<bool, 1> {
|
||||
using TFE_MonitoringGauge::TFE_MonitoringGauge;
|
||||
};
|
||||
struct TFE_MonitoringBoolGauge2 : TFE_MonitoringGauge<bool, 2> {
|
||||
using TFE_MonitoringGauge::TFE_MonitoringGauge;
|
||||
};
|
||||
|
||||
struct TFE_MonitoringBuckets {
|
||||
TFE_MonitoringBuckets(
|
||||
std::function<std::unique_ptr<tensorflow::monitoring::Buckets>(void)>
|
||||
fn) {
|
||||
create_buckets = fn;
|
||||
}
|
||||
|
||||
std::function<std::unique_ptr<tensorflow::monitoring::Buckets>(void)>
|
||||
create_buckets;
|
||||
};
|
||||
|
||||
struct TFE_MonitoringSamplerCell {
|
||||
tensorflow::monitoring::SamplerCell cell;
|
||||
};
|
||||
|
||||
template <int NumLabels>
|
||||
struct TFE_MonitoringSampler {
|
||||
template <typename... LabelDesc>
|
||||
TFE_MonitoringSampler(
|
||||
const char* name,
|
||||
std::unique_ptr<tensorflow::monitoring::Buckets> buckets,
|
||||
const char* description, LabelDesc&&... label) {
|
||||
sampler = absl::WrapUnique(tensorflow::monitoring::Sampler<NumLabels>::New(
|
||||
{name, description, label...}, std::move(buckets)));
|
||||
}
|
||||
|
||||
std::unique_ptr<tensorflow::monitoring::Sampler<NumLabels>> sampler;
|
||||
};
|
||||
|
||||
struct TFE_MonitoringSampler0 : TFE_MonitoringSampler<0> {
|
||||
using TFE_MonitoringSampler::TFE_MonitoringSampler;
|
||||
};
|
||||
struct TFE_MonitoringSampler1 : TFE_MonitoringSampler<1> {
|
||||
using TFE_MonitoringSampler::TFE_MonitoringSampler;
|
||||
};
|
||||
struct TFE_MonitoringSampler2 : TFE_MonitoringSampler<2> {
|
||||
using TFE_MonitoringSampler::TFE_MonitoringSampler;
|
||||
};
|
||||
|
||||
namespace tensorflow {
|
||||
// Set an AttrValue on the op. Doesn't handle the list types.
|
||||
void SetOpAttrValueScalar(TFE_Context* ctx, TFE_Op* op,
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
licenses(["notice"]) # Apache 2.0
|
||||
|
||||
load("//tensorflow:tensorflow.bzl", "tf_py_test", "tf_cc_binary")
|
||||
load("//tensorflow:tensorflow.bzl", "tf_py_test")
|
||||
load("//tensorflow:tensorflow.bzl", "cuda_py_test")
|
||||
load(
|
||||
"//tensorflow/tools/test:performance.bzl",
|
||||
@ -102,7 +102,9 @@ py_library(
|
||||
srcs_version = "PY2AND3",
|
||||
visibility = ["//tensorflow:internal"],
|
||||
deps = [
|
||||
"//tensorflow/python:c_api_util",
|
||||
"//tensorflow/python:pywrap_tensorflow",
|
||||
"//tensorflow/python:util",
|
||||
],
|
||||
)
|
||||
|
||||
|
||||
@ -20,7 +20,10 @@ from __future__ import print_function
|
||||
|
||||
import collections
|
||||
|
||||
from tensorflow.core.framework import summary_pb2
|
||||
from tensorflow.python import pywrap_tensorflow
|
||||
from tensorflow.python.framework import c_api_util
|
||||
from tensorflow.python.util import compat
|
||||
|
||||
_MetricMethod = collections.namedtuple('MetricMethod', 'create delete get_cell')
|
||||
_counter_methods = [
|
||||
@ -37,32 +40,62 @@ _counter_methods = [
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteCounter2,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellCounter2),
|
||||
]
|
||||
|
||||
|
||||
def gauge(name, label, value):
|
||||
"""Set the value of a Gauge metric.
|
||||
|
||||
If the metric with this name does not exist, it will create a new metric.
|
||||
|
||||
Args:
|
||||
name: metric name
|
||||
label: long label
|
||||
value: a int64 value
|
||||
"""
|
||||
pywrap_tensorflow.TFE_MonitoringSetGauge(name, label, value)
|
||||
|
||||
|
||||
def sampler(name, label, value):
|
||||
"""Add the value of a Sampler metric.
|
||||
|
||||
If the metric with this name does not exist, it will create a new metric.
|
||||
|
||||
Args:
|
||||
name: metric name
|
||||
label: metric label
|
||||
value: a double value
|
||||
"""
|
||||
pywrap_tensorflow.TFE_MonitoringAddSampler(name, label, value)
|
||||
_int_gauge_methods = [
|
||||
_MetricMethod(
|
||||
create=pywrap_tensorflow.TFE_MonitoringNewIntGauge0,
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteIntGauge0,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellIntGauge0),
|
||||
_MetricMethod(
|
||||
create=pywrap_tensorflow.TFE_MonitoringNewIntGauge1,
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteIntGauge1,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellIntGauge1),
|
||||
_MetricMethod(
|
||||
create=pywrap_tensorflow.TFE_MonitoringNewIntGauge2,
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteIntGauge2,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellIntGauge2),
|
||||
]
|
||||
_string_gauge_methods = [
|
||||
_MetricMethod(
|
||||
create=pywrap_tensorflow.TFE_MonitoringNewStringGauge0,
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteStringGauge0,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellStringGauge0),
|
||||
_MetricMethod(
|
||||
create=pywrap_tensorflow.TFE_MonitoringNewStringGauge1,
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteStringGauge1,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellStringGauge1),
|
||||
_MetricMethod(
|
||||
create=pywrap_tensorflow.TFE_MonitoringNewStringGauge2,
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteStringGauge2,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellStringGauge2),
|
||||
]
|
||||
_bool_gauge_methods = [
|
||||
_MetricMethod(
|
||||
create=pywrap_tensorflow.TFE_MonitoringNewBoolGauge0,
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteBoolGauge0,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellBoolGauge0),
|
||||
_MetricMethod(
|
||||
create=pywrap_tensorflow.TFE_MonitoringNewBoolGauge1,
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteBoolGauge1,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellBoolGauge1),
|
||||
_MetricMethod(
|
||||
create=pywrap_tensorflow.TFE_MonitoringNewBoolGauge2,
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteBoolGauge2,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellBoolGauge2),
|
||||
]
|
||||
_sampler_methods = [
|
||||
_MetricMethod(
|
||||
create=pywrap_tensorflow.TFE_MonitoringNewSampler0,
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteSampler0,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellSampler0),
|
||||
_MetricMethod(
|
||||
create=pywrap_tensorflow.TFE_MonitoringNewSampler1,
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteSampler1,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellSampler1),
|
||||
_MetricMethod(
|
||||
create=pywrap_tensorflow.TFE_MonitoringNewSampler2,
|
||||
delete=pywrap_tensorflow.TFE_MonitoringDeleteSampler2,
|
||||
get_cell=pywrap_tensorflow.TFE_MonitoringGetCellSampler2),
|
||||
]
|
||||
|
||||
|
||||
class Metric(object):
|
||||
@ -88,7 +121,8 @@ class Metric(object):
|
||||
self._metric = self._metric_methods[self._label_length].create(*args)
|
||||
|
||||
def __del__(self):
|
||||
self._metric_methods[self._label_length].delete(self._metric)
|
||||
if hasattr(self, '_metric'):
|
||||
self._metric_methods[self._label_length].delete(self._metric)
|
||||
|
||||
def get_cell(self, *labels):
|
||||
"""Retrieves the cell."""
|
||||
@ -124,7 +158,12 @@ class CounterCell(object):
|
||||
|
||||
|
||||
class Counter(Metric):
|
||||
"""A stateful class for updating a cumulative integer metric."""
|
||||
"""A stateful class for updating a cumulative integer metric.
|
||||
|
||||
This class encapsulates a set of values (or a single value for a label-less
|
||||
metric). Each value is identified by a tuple of labels. The class allows the
|
||||
user to increment each value.
|
||||
"""
|
||||
|
||||
def __init__(self, name, description, *labels):
|
||||
"""Creates a new Counter.
|
||||
@ -132,7 +171,7 @@ class Counter(Metric):
|
||||
Args:
|
||||
name: name of the new metric.
|
||||
description: description of the new metric.
|
||||
*labels: The label list of the new metrics
|
||||
*labels: The label list of the new metric.
|
||||
"""
|
||||
super(Counter, self).__init__('Counter', _counter_methods, len(labels),
|
||||
name, description, *labels)
|
||||
@ -140,3 +179,245 @@ class Counter(Metric):
|
||||
def get_cell(self, *labels):
|
||||
"""Retrieves the cell."""
|
||||
return CounterCell(super(Counter, self).get_cell(*labels))
|
||||
|
||||
|
||||
class IntGaugeCell(object):
|
||||
"""A single integer value stored in an `IntGauge`."""
|
||||
|
||||
def __init__(self, cell):
|
||||
"""Creates a new IntGaugeCell.
|
||||
|
||||
Args:
|
||||
cell: A c pointer of TFE_MonitoringIntGaugeCell.
|
||||
"""
|
||||
self._cell = cell
|
||||
|
||||
def set(self, value):
|
||||
"""Atomically set the value.
|
||||
|
||||
Args:
|
||||
value: integer value.
|
||||
"""
|
||||
pywrap_tensorflow.TFE_MonitoringIntGaugeCellSet(self._cell, value)
|
||||
|
||||
def value(self):
|
||||
"""Retrieves the current value."""
|
||||
return pywrap_tensorflow.TFE_MonitoringIntGaugeCellValue(self._cell)
|
||||
|
||||
|
||||
class IntGauge(Metric):
|
||||
"""A stateful class for updating a gauge-like integer metric.
|
||||
|
||||
This class encapsulates a set of integer values (or a single value for a
|
||||
label-less metric). Each value is identified by a tuple of labels. The class
|
||||
allows the user to set each value.
|
||||
"""
|
||||
|
||||
def __init__(self, name, description, *labels):
|
||||
"""Creates a new IntGauge.
|
||||
|
||||
Args:
|
||||
name: name of the new metric.
|
||||
description: description of the new metric.
|
||||
*labels: The label list of the new metric.
|
||||
"""
|
||||
super(IntGauge, self).__init__('IntGauge', _int_gauge_methods, len(labels),
|
||||
name, description, *labels)
|
||||
|
||||
def get_cell(self, *labels):
|
||||
"""Retrieves the cell."""
|
||||
return IntGaugeCell(super(IntGauge, self).get_cell(*labels))
|
||||
|
||||
|
||||
class StringGaugeCell(object):
|
||||
"""A single string value stored in an `StringGauge`."""
|
||||
|
||||
def __init__(self, cell):
|
||||
"""Creates a new StringGaugeCell.
|
||||
|
||||
Args:
|
||||
cell: A c pointer of TFE_MonitoringStringGaugeCell.
|
||||
"""
|
||||
self._cell = cell
|
||||
|
||||
def set(self, value):
|
||||
"""Atomically set the value.
|
||||
|
||||
Args:
|
||||
value: string value.
|
||||
"""
|
||||
pywrap_tensorflow.TFE_MonitoringStringGaugeCellSet(self._cell, value)
|
||||
|
||||
def value(self):
|
||||
"""Retrieves the current value."""
|
||||
with c_api_util.tf_buffer() as buffer_:
|
||||
pywrap_tensorflow.TFE_MonitoringStringGaugeCellValue(self._cell, buffer_)
|
||||
value = pywrap_tensorflow.TF_GetBuffer(buffer_).decode('utf-8')
|
||||
return value
|
||||
|
||||
|
||||
class StringGauge(Metric):
|
||||
"""A stateful class for updating a gauge-like string metric.
|
||||
|
||||
This class encapsulates a set of string values (or a single value for a
|
||||
label-less metric). Each value is identified by a tuple of labels. The class
|
||||
allows the user to set each value.
|
||||
"""
|
||||
|
||||
def __init__(self, name, description, *labels):
|
||||
"""Creates a new StringGauge.
|
||||
|
||||
Args:
|
||||
name: name of the new metric.
|
||||
description: description of the new metric.
|
||||
*labels: The label list of the new metric.
|
||||
"""
|
||||
super(StringGauge, self).__init__('StringGauge', _string_gauge_methods,
|
||||
len(labels), name, description, *labels)
|
||||
|
||||
def get_cell(self, *labels):
|
||||
"""Retrieves the cell."""
|
||||
return StringGaugeCell(super(StringGauge, self).get_cell(*labels))
|
||||
|
||||
|
||||
class BoolGaugeCell(object):
|
||||
"""A single boolean value stored in an `BoolGauge`."""
|
||||
|
||||
def __init__(self, cell):
|
||||
"""Creates a new BoolGaugeCell.
|
||||
|
||||
Args:
|
||||
cell: A c pointer of TFE_MonitoringBoolGaugeCell.
|
||||
"""
|
||||
self._cell = cell
|
||||
|
||||
def set(self, value):
|
||||
"""Atomically set the value.
|
||||
|
||||
Args:
|
||||
value: bool value.
|
||||
"""
|
||||
pywrap_tensorflow.TFE_MonitoringBoolGaugeCellSet(self._cell, value)
|
||||
|
||||
def value(self):
|
||||
"""Retrieves the current value."""
|
||||
return pywrap_tensorflow.TFE_MonitoringBoolGaugeCellValue(self._cell)
|
||||
|
||||
|
||||
class BoolGauge(Metric):
|
||||
"""A stateful class for updating a gauge-like bool metric.
|
||||
|
||||
This class encapsulates a set of boolean values (or a single value for a
|
||||
label-less metric). Each value is identified by a tuple of labels. The class
|
||||
allows the user to set each value.
|
||||
"""
|
||||
|
||||
def __init__(self, name, description, *labels):
|
||||
"""Creates a new BoolGauge.
|
||||
|
||||
Args:
|
||||
name: name of the new metric.
|
||||
description: description of the new metric.
|
||||
*labels: The label list of the new metric.
|
||||
"""
|
||||
super(BoolGauge, self).__init__('BoolGauge', _bool_gauge_methods,
|
||||
len(labels), name, description, *labels)
|
||||
|
||||
def get_cell(self, *labels):
|
||||
"""Retrieves the cell."""
|
||||
return BoolGaugeCell(super(BoolGauge, self).get_cell(*labels))
|
||||
|
||||
|
||||
class SamplerCell(object):
|
||||
"""SamplerCell stores each value of a Sampler."""
|
||||
|
||||
def __init__(self, cell):
|
||||
"""Creates a new SamplerCell.
|
||||
|
||||
Args:
|
||||
cell: A c pointer of TFE_MonitoringSamplerCell.
|
||||
"""
|
||||
self._cell = cell
|
||||
|
||||
def add(self, value):
|
||||
"""Atomically add a sample.
|
||||
|
||||
Args:
|
||||
value: float value.
|
||||
"""
|
||||
pywrap_tensorflow.TFE_MonitoringSamplerCellAdd(self._cell, value)
|
||||
|
||||
def value(self):
|
||||
"""Retrieves the current distribution of samples.
|
||||
|
||||
Returns:
|
||||
A HistogramProto describing the distribution of samples.
|
||||
"""
|
||||
with c_api_util.tf_buffer() as buffer_:
|
||||
pywrap_tensorflow.TFE_MonitoringSamplerCellValue(self._cell, buffer_)
|
||||
proto_data = pywrap_tensorflow.TF_GetBuffer(buffer_)
|
||||
histogram_proto = summary_pb2.HistogramProto()
|
||||
histogram_proto.ParseFromString(compat.as_bytes(proto_data))
|
||||
return histogram_proto
|
||||
|
||||
|
||||
class Buckets(object):
|
||||
"""Bucketing strategies for the samplers."""
|
||||
|
||||
def __init__(self, buckets):
|
||||
"""Creates a new Buckets.
|
||||
|
||||
Args:
|
||||
buckets: A c pointer of TFE_MonitoringBuckets.
|
||||
"""
|
||||
self.buckets = buckets
|
||||
|
||||
def __del__(self):
|
||||
pywrap_tensorflow.TFE_MonitoringDeleteBuckets(self.buckets)
|
||||
|
||||
|
||||
class ExponentialBuckets(Buckets):
|
||||
"""Exponential bucketing strategy.
|
||||
|
||||
Sets up buckets of the form:
|
||||
[-DBL_MAX, ..., scale * growth^i,
|
||||
scale * growth_factor^(i + 1), ..., DBL_MAX].
|
||||
"""
|
||||
|
||||
def __init__(self, scale, growth_factor, bucket_count):
|
||||
"""Creates a new exponential Buckets.
|
||||
|
||||
Args:
|
||||
scale: float
|
||||
growth_factor: float
|
||||
bucket_count: integer
|
||||
"""
|
||||
super(ExponentialBuckets, self).__init__(
|
||||
pywrap_tensorflow.TFE_MonitoringNewExponentialBuckets(
|
||||
scale, growth_factor, bucket_count))
|
||||
|
||||
|
||||
class Sampler(Metric):
|
||||
"""A stateful class for updating a cumulative histogram metric.
|
||||
|
||||
This class encapsulates a set of histograms (or a single histogram for a
|
||||
label-less metric) configured with a list of increasing bucket boundaries.
|
||||
Each histogram is identified by a tuple of labels. The class allows the
|
||||
user to add a sample to each histogram value.
|
||||
"""
|
||||
|
||||
def __init__(self, name, buckets, description, *labels):
|
||||
"""Creates a new Sampler.
|
||||
|
||||
Args:
|
||||
name: name of the new metric.
|
||||
buckets: bucketing strategy of the new metric.
|
||||
description: description of the new metric.
|
||||
*labels: The label list of the new metric.
|
||||
"""
|
||||
super(Sampler, self).__init__('Sampler', _sampler_methods, len(labels),
|
||||
name, buckets.buckets, description, *labels)
|
||||
|
||||
def get_cell(self, *labels):
|
||||
"""Retrieves the cell."""
|
||||
return SamplerCell(super(Sampler, self).get_cell(*labels))
|
||||
|
||||
@ -26,11 +26,6 @@ from tensorflow.python.framework import test_util
|
||||
|
||||
class MonitoringTest(test_util.TensorFlowTestCase):
|
||||
|
||||
def test_monitoring(self):
|
||||
# These methods should not throw any exception.
|
||||
monitoring.gauge('test/gauge', 'label', 1)
|
||||
monitoring.sampler('test/sampler', 'label', 1.0)
|
||||
|
||||
def test_counter(self):
|
||||
counter = monitoring.Counter('test/counter', 'test counter')
|
||||
counter.get_cell().increase_by(1)
|
||||
@ -52,6 +47,59 @@ class MonitoringTest(test_util.TensorFlowTestCase):
|
||||
with self.assertRaises(errors.AlreadyExistsError):
|
||||
counter2 = monitoring.Counter('test/same_counter', 'test counter') # pylint: disable=unused-variable
|
||||
|
||||
def test_int_gauge(self):
|
||||
gauge = monitoring.IntGauge('test/gauge', 'test gauge')
|
||||
gauge.get_cell().set(1)
|
||||
self.assertEqual(gauge.get_cell().value(), 1)
|
||||
gauge.get_cell().set(5)
|
||||
self.assertEqual(gauge.get_cell().value(), 5)
|
||||
|
||||
gauge1 = monitoring.IntGauge('test/gauge1', 'test gauge1', 'label1')
|
||||
gauge1.get_cell('foo').set(2)
|
||||
self.assertEqual(gauge1.get_cell('foo').value(), 2)
|
||||
|
||||
def test_string_gauge(self):
|
||||
gauge = monitoring.StringGauge('test/gauge', 'test gauge')
|
||||
gauge.get_cell().set('left')
|
||||
self.assertEqual(gauge.get_cell().value(), 'left')
|
||||
gauge.get_cell().set('right')
|
||||
self.assertEqual(gauge.get_cell().value(), 'right')
|
||||
|
||||
gauge1 = monitoring.StringGauge('test/gauge1', 'test gauge1', 'label1')
|
||||
gauge1.get_cell('foo').set('start')
|
||||
self.assertEqual(gauge1.get_cell('foo').value(), 'start')
|
||||
|
||||
def test_bool_gauge(self):
|
||||
gauge = monitoring.BoolGauge('test/gauge', 'test gauge')
|
||||
gauge.get_cell().set(True)
|
||||
self.assertTrue(gauge.get_cell().value())
|
||||
gauge.get_cell().set(False)
|
||||
self.assertFalse(gauge.get_cell().value())
|
||||
|
||||
gauge1 = monitoring.BoolGauge('test/gauge1', 'test gauge1', 'label1')
|
||||
gauge1.get_cell('foo').set(True)
|
||||
self.assertTrue(gauge1.get_cell('foo').value())
|
||||
|
||||
def test_sampler(self):
|
||||
buckets = monitoring.ExponentialBuckets(1.0, 2.0, 2)
|
||||
sampler = monitoring.Sampler('test/sampler', buckets, 'test sampler')
|
||||
sampler.get_cell().add(1.0)
|
||||
sampler.get_cell().add(5.0)
|
||||
histogram_proto = sampler.get_cell().value()
|
||||
self.assertEqual(histogram_proto.min, 1.0)
|
||||
self.assertEqual(histogram_proto.num, 2.0)
|
||||
self.assertEqual(histogram_proto.sum, 6.0)
|
||||
|
||||
sampler1 = monitoring.Sampler('test/sampler1', buckets, 'test sampler',
|
||||
'label1')
|
||||
sampler1.get_cell('foo').add(2.0)
|
||||
sampler1.get_cell('foo').add(4.0)
|
||||
sampler1.get_cell('bar').add(8.0)
|
||||
histogram_proto1 = sampler1.get_cell('foo').value()
|
||||
self.assertEqual(histogram_proto1.max, 4.0)
|
||||
self.assertEqual(histogram_proto1.num, 2.0)
|
||||
self.assertEqual(histogram_proto1.sum, 6.0)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
test.main()
|
||||
|
||||
@ -84,8 +84,6 @@ limitations under the License.
|
||||
%rename("%s") TFE_EnableCollectiveOps;
|
||||
%rename("%s") TF_ListPhysicalDevices;
|
||||
%rename("%s") TF_PickUnusedPortOrDie;
|
||||
%rename("%s") TFE_MonitoringSetGauge;
|
||||
%rename("%s") TFE_MonitoringAddSampler;
|
||||
%rename("%s") TFE_MonitoringCounterCellIncrementBy;
|
||||
%rename("%s") TFE_MonitoringCounterCellValue;
|
||||
%rename("%s") TFE_MonitoringNewCounter0;
|
||||
@ -97,6 +95,52 @@ limitations under the License.
|
||||
%rename("%s") TFE_MonitoringNewCounter2;
|
||||
%rename("%s") TFE_MonitoringDeleteCounter2;
|
||||
%rename("%s") TFE_MonitoringGetCellCounter2;
|
||||
%rename("%s") TFE_MonitoringIntGaugeCellSet;
|
||||
%rename("%s") TFE_MonitoringIntGaugeCellValue;
|
||||
%rename("%s") TFE_MonitoringNewIntGauge0;
|
||||
%rename("%s") TFE_MonitoringDeleteIntGauge0;
|
||||
%rename("%s") TFE_MonitoringGetCellIntGauge0;
|
||||
%rename("%s") TFE_MonitoringNewIntGauge1;
|
||||
%rename("%s") TFE_MonitoringDeleteIntGauge1;
|
||||
%rename("%s") TFE_MonitoringGetCellIntGauge1;
|
||||
%rename("%s") TFE_MonitoringNewIntGauge2;
|
||||
%rename("%s") TFE_MonitoringDeleteIntGauge2;
|
||||
%rename("%s") TFE_MonitoringGetCellIntGauge2;
|
||||
%rename("%s") TFE_MonitoringStringGaugeCellSet;
|
||||
%rename("%s") TFE_MonitoringStringGaugeCellValue;
|
||||
%rename("%s") TFE_MonitoringNewStringGauge0;
|
||||
%rename("%s") TFE_MonitoringDeleteStringGauge0;
|
||||
%rename("%s") TFE_MonitoringGetCellStringGauge0;
|
||||
%rename("%s") TFE_MonitoringNewStringGauge1;
|
||||
%rename("%s") TFE_MonitoringDeleteStringGauge1;
|
||||
%rename("%s") TFE_MonitoringGetCellStringGauge1;
|
||||
%rename("%s") TFE_MonitoringNewStringGauge2;
|
||||
%rename("%s") TFE_MonitoringDeleteStringGauge2;
|
||||
%rename("%s") TFE_MonitoringGetCellStringGauge2;
|
||||
%rename("%s") TFE_MonitoringBoolGaugeCellSet;
|
||||
%rename("%s") TFE_MonitoringBoolGaugeCellValue;
|
||||
%rename("%s") TFE_MonitoringNewBoolGauge0;
|
||||
%rename("%s") TFE_MonitoringDeleteBoolGauge0;
|
||||
%rename("%s") TFE_MonitoringGetCellBoolGauge0;
|
||||
%rename("%s") TFE_MonitoringNewBoolGauge1;
|
||||
%rename("%s") TFE_MonitoringDeleteBoolGauge1;
|
||||
%rename("%s") TFE_MonitoringGetCellBoolGauge1;
|
||||
%rename("%s") TFE_MonitoringNewBoolGauge2;
|
||||
%rename("%s") TFE_MonitoringDeleteBoolGauge2;
|
||||
%rename("%s") TFE_MonitoringGetCellBoolGauge2;
|
||||
%rename("%s") TFE_MonitoringSamplerCellAdd;
|
||||
%rename("%s") TFE_MonitoringSamplerCellValue;
|
||||
%rename("%s") TFE_MonitoringNewExponentialBuckets;
|
||||
%rename("%s") TFE_MonitoringDeleteBuckets;
|
||||
%rename("%s") TFE_MonitoringNewSampler0;
|
||||
%rename("%s") TFE_MonitoringDeleteSampler0;
|
||||
%rename("%s") TFE_MonitoringGetCellSampler0;
|
||||
%rename("%s") TFE_MonitoringNewSampler1;
|
||||
%rename("%s") TFE_MonitoringDeleteSampler1;
|
||||
%rename("%s") TFE_MonitoringGetCellSampler1;
|
||||
%rename("%s") TFE_MonitoringNewSampler2;
|
||||
%rename("%s") TFE_MonitoringDeleteSampler2;
|
||||
%rename("%s") TFE_MonitoringGetCellSampler2;
|
||||
|
||||
%{
|
||||
#include "tensorflow/python/eager/pywrap_tfe.h"
|
||||
|
||||
Loading…
Reference in New Issue
Block a user