tf
This commit is contained in:
1 parent
eb1b42a5e8
commit
458eb2aef1
1283 files changed
+323373
No files matched your search
@@ -0,0 +1,43 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_ARRAY_SLICE_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_ARRAY_SLICE_H_
|
||||
|
||||
#include "absl/types/span.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
template <typename T>
|
||||
using ArraySlice = absl::Span<const T>;
|
||||
template <typename T>
|
||||
using MutableArraySlice = absl::Span<T>;
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
namespace perftools {
|
||||
namespace gputools {
|
||||
|
||||
// Temporarily pull stream_executor into perftools::gputools while we migrate
|
||||
// code to the new namespace. TODO(b/77980417): Remove this once we've
|
||||
// completed the migration.
|
||||
using namespace stream_executor; // NOLINT[build/namespaces]
|
||||
|
||||
} // namespace gputools
|
||||
} // namespace perftools
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_ARRAY_SLICE_H_
|
||||
@@ -0,0 +1,100 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
// IWYU pragma: private, include "third_party/tensorflow/stream_executor/stream_executor.h"
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_CASTS_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_CASTS_H_
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
// port::bit_cast<Dest,Source> is a template function that implements the
|
||||
// equivalent of "*reinterpret_cast<Dest*>(&source)". We need this in
|
||||
// very low-level functions like the protobuf library and fast math
|
||||
// support.
|
||||
//
|
||||
// float f = 3.14159265358979;
|
||||
// int i = port::bit_cast<int32>(f);
|
||||
// // i = 0x40490fdb
|
||||
//
|
||||
// The classical address-casting method is:
|
||||
//
|
||||
// // WRONG
|
||||
// float f = 3.14159265358979; // WRONG
|
||||
// int i = * reinterpret_cast<int*>(&f); // WRONG
|
||||
//
|
||||
// The address-casting method actually produces undefined behavior
|
||||
// according to ISO C++ specification section 3.10 -15 -. Roughly, this
|
||||
// section says: if an object in memory has one type, and a program
|
||||
// accesses it with a different type, then the result is undefined
|
||||
// behavior for most values of "different type".
|
||||
//
|
||||
// This is true for any cast syntax, either *(int*)&f or
|
||||
// *reinterpret_cast<int*>(&f). And it is particularly true for
|
||||
// conversions between integral lvalues and floating-point lvalues.
|
||||
//
|
||||
// The purpose of 3.10 -15- is to allow optimizing compilers to assume
|
||||
// that expressions with different types refer to different memory. gcc
|
||||
// 4.0.1 has an optimizer that takes advantage of this. So a
|
||||
// non-conforming program quietly produces wildly incorrect output.
|
||||
//
|
||||
// The problem is not the use of reinterpret_cast. The problem is type
|
||||
// punning: holding an object in memory of one type and reading its bits
|
||||
// back using a different type.
|
||||
//
|
||||
// The C++ standard is more subtle and complex than this, but that
|
||||
// is the basic idea.
|
||||
//
|
||||
// Anyways ...
|
||||
//
|
||||
// port::bit_cast<> calls memcpy() which is blessed by the standard,
|
||||
// especially by the example in section 3.9 . Also, of course,
|
||||
// port::bit_cast<> wraps up the nasty logic in one place.
|
||||
//
|
||||
// Fortunately memcpy() is very fast. In optimized mode, with a
|
||||
// constant size, gcc 2.95.3, gcc 4.0.1, and msvc 7.1 produce inline
|
||||
// code with the minimal amount of data movement. On a 32-bit system,
|
||||
// memcpy(d,s,4) compiles to one load and one store, and memcpy(d,s,8)
|
||||
// compiles to two loads and two stores.
|
||||
//
|
||||
// I tested this code with gcc 2.95.3, gcc 4.0.1, icc 8.1, and msvc 7.1.
|
||||
//
|
||||
// WARNING: if Dest or Source is a non-POD type, the result of the memcpy
|
||||
// is likely to surprise you.
|
||||
//
|
||||
// Props to Bill Gibbons for the compile time assertion technique and
|
||||
// Art Komninos and Igor Tandetnik for the msvc experiments.
|
||||
//
|
||||
// -- mec 2005-10-17
|
||||
|
||||
template <class Dest, class Source>
|
||||
inline Dest bit_cast(const Source& source) {
|
||||
// Compile time assertion: sizeof(Dest) == sizeof(Source)
|
||||
// A compile error here means your Dest and Source have different sizes.
|
||||
static_assert(sizeof(Dest) == sizeof(Source),
|
||||
"src and dst types must have equal sizes");
|
||||
|
||||
Dest dest;
|
||||
memcpy(&dest, &source, sizeof(dest));
|
||||
return dest;
|
||||
}
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_CASTS_H_
|
||||
@@ -0,0 +1,29 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_DEMANGLE_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_DEMANGLE_H_
|
||||
|
||||
#include "tensorflow/stream_executor/platform/port.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
string Demangle(const char* mangled);
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_DEMANGLE_H_
|
||||
@@ -0,0 +1,41 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_ENV_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_ENV_H_
|
||||
|
||||
#include "tensorflow/core/platform/env.h"
|
||||
#include "tensorflow/stream_executor/lib/status.h"
|
||||
#include "tensorflow/stream_executor/lib/stringpiece.h"
|
||||
#include "tensorflow/stream_executor/platform/port.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
using tensorflow::Env;
|
||||
using tensorflow::Thread;
|
||||
|
||||
inline Status FileExists(const string& filename) {
|
||||
return Env::Default()->FileExists(filename);
|
||||
}
|
||||
|
||||
inline Status FileExists(const port::StringPiece& filename) {
|
||||
return Env::Default()->FileExists(string(filename));
|
||||
}
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_ENV_H_
|
||||
@@ -0,0 +1,31 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
// IWYU pragma: private, include "third_party/tensorflow/stream_executor/stream_executor.h"
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_ERROR_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_ERROR_H_
|
||||
|
||||
#include "tensorflow/core/lib/core/error_codes.pb.h" // IWYU pragma: export
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
namespace error = tensorflow::error;
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_ERROR_H_
|
||||
@@ -0,0 +1,71 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_HUMAN_READABLE_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_HUMAN_READABLE_H_
|
||||
|
||||
#include <assert.h>
|
||||
#include <limits>
|
||||
|
||||
#include "tensorflow/stream_executor/lib/stringprintf.h"
|
||||
#include "tensorflow/stream_executor/platform/port.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
class HumanReadableNumBytes {
|
||||
public:
|
||||
static string ToString(int64 num_bytes) {
|
||||
if (num_bytes == std::numeric_limits<int64>::min()) {
|
||||
// Special case for number with not representable nagation.
|
||||
return "-8E";
|
||||
}
|
||||
|
||||
const char* neg_str = GetNegStr(&num_bytes);
|
||||
|
||||
// Special case for bytes.
|
||||
if (num_bytes < 1024LL) {
|
||||
// No fractions for bytes.
|
||||
return port::Printf("%s%lldB", neg_str, num_bytes);
|
||||
}
|
||||
|
||||
static const char units[] = "KMGTPE"; // int64 only goes up to E.
|
||||
const char* unit = units;
|
||||
while (num_bytes >= (1024LL) * (1024LL)) {
|
||||
num_bytes /= (1024LL);
|
||||
++unit;
|
||||
assert(unit < units + sizeof(units));
|
||||
}
|
||||
|
||||
return port::Printf(((*unit == 'K') ? "%s%.1f%c" : "%s%.2f%c"), neg_str,
|
||||
num_bytes / 1024.0, *unit);
|
||||
}
|
||||
|
||||
private:
|
||||
template <typename T>
|
||||
static const char* GetNegStr(T* value) {
|
||||
if (*value < 0) {
|
||||
*value = -(*value);
|
||||
return "-";
|
||||
} else {
|
||||
return "";
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_HUMAN_READABLE_H_
|
||||
@@ -0,0 +1,70 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_INITIALIZE_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_INITIALIZE_H_
|
||||
|
||||
#include "tensorflow/stream_executor/platform/port.h"
|
||||
|
||||
#if defined(PLATFORM_GOOGLE)
|
||||
#include "tensorflow/stream_executor/platform/google/initialize.h"
|
||||
#else
|
||||
|
||||
#undef REGISTER_MODULE_INITIALIZER
|
||||
#undef DECLARE_MODULE_INITIALIZER
|
||||
#undef REGISTER_MODULE_INITIALIZER_SEQUENCE
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
class Initializer {
|
||||
public:
|
||||
typedef void (*InitializerFunc)();
|
||||
explicit Initializer(InitializerFunc func) { func(); }
|
||||
|
||||
struct Dependency {
|
||||
Dependency(const char *n, Initializer *i) : name(n), initializer(i) {}
|
||||
const char *const name;
|
||||
Initializer *const initializer;
|
||||
};
|
||||
|
||||
struct DependencyRegisterer {
|
||||
DependencyRegisterer(const char *type, const char *name,
|
||||
Initializer *initializer,
|
||||
const Dependency &dependency);
|
||||
};
|
||||
};
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#define REGISTER_INITIALIZER(type, name, body) \
|
||||
static void google_init_##type##_##name() { body; } \
|
||||
::stream_executor::port::Initializer google_initializer_##type##_##name( \
|
||||
google_init_##type##_##name)
|
||||
|
||||
#define REGISTER_MODULE_INITIALIZER(name, body) \
|
||||
REGISTER_INITIALIZER(module, name, body)
|
||||
|
||||
#define DECLARE_INITIALIZER(type, name) \
|
||||
extern ::stream_executor::port::Initializer google_initializer_##type##_##name
|
||||
|
||||
#define DECLARE_MODULE_INITIALIZER(name) DECLARE_INITIALIZER(module, name)
|
||||
|
||||
#define REGISTER_MODULE_INITIALIZER_SEQUENCE(name1, name2)
|
||||
|
||||
#endif // !defined(PLATFORM_GOOGLE)
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_INITIALIZE_H_
|
||||
@@ -0,0 +1,29 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_INLINED_VECTOR_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_INLINED_VECTOR_H_
|
||||
|
||||
#include "absl/container/inlined_vector.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
using absl::InlinedVector;
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_INLINED_VECTOR_H_
|
||||
@@ -0,0 +1,101 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_MATHUTIL_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_MATHUTIL_H_
|
||||
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <limits>
|
||||
#include <type_traits>
|
||||
#include <vector>
|
||||
|
||||
#include "tensorflow/stream_executor/platform/logging.h"
|
||||
#include "tensorflow/stream_executor/platform/port.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
class MathUtil {
|
||||
public:
|
||||
template <typename IntegralType>
|
||||
static IntegralType CeilOfRatio(IntegralType numerator,
|
||||
IntegralType denominator) {
|
||||
return CeilOrFloorOfRatio<IntegralType, true>(numerator, denominator);
|
||||
}
|
||||
template <typename IntegralType>
|
||||
static IntegralType FloorOfRatio(IntegralType numerator,
|
||||
IntegralType denominator) {
|
||||
return CeilOrFloorOfRatio<IntegralType, false>(numerator, denominator);
|
||||
}
|
||||
template <typename IntegralType, bool ceil>
|
||||
static IntegralType CeilOrFloorOfRatio(IntegralType numerator,
|
||||
IntegralType denominator);
|
||||
};
|
||||
|
||||
// ---- CeilOrFloorOfRatio ----
|
||||
// This is a branching-free, cast-to-double-free implementation.
|
||||
//
|
||||
// Casting to double is in general incorrect because of loss of precision
|
||||
// when casting an int64 into a double.
|
||||
//
|
||||
// There's a bunch of 'recipes' to compute a integer ceil (or floor) on the web,
|
||||
// and most of them are incorrect.
|
||||
template<typename IntegralType, bool ceil>
|
||||
IntegralType MathUtil::CeilOrFloorOfRatio(IntegralType numerator,
|
||||
IntegralType denominator) {
|
||||
static_assert(std::is_integral<IntegralType>::value,
|
||||
"CeilOfRatio_is_only_defined_for_integral_types");
|
||||
assert(denominator != 0);
|
||||
// Dividing the smallest signed integer by -1 is not supported: it would
|
||||
// SIGFPE
|
||||
assert(!std::is_signed<IntegralType>::value ||
|
||||
numerator != std::numeric_limits<IntegralType>::min() ||
|
||||
denominator != -1);
|
||||
|
||||
const IntegralType rounded_toward_zero = numerator / denominator;
|
||||
const IntegralType intermediate_product = rounded_toward_zero * denominator;
|
||||
|
||||
if (ceil) { // Compile-time condition: not an actual branching
|
||||
// When rounded_toward_zero is negative, then an adjustment is never needed:
|
||||
// the real ratio is negative, and so rounded toward zero is the ceil.
|
||||
// When rounded_toward_zero is non-negative, an adjustment is needed if the
|
||||
// sign of the difference numerator - intermediate_product is the same as
|
||||
// the sign of the denominator.
|
||||
//
|
||||
// Using a bool and then a static_cast to IntegralType is not strictly
|
||||
// necessary, but it makes the code clear, and anyway the compiler should
|
||||
// get rid of it.
|
||||
const bool needs_adjustment = (rounded_toward_zero >= 0) &&
|
||||
((denominator > 0 && numerator > intermediate_product) ||
|
||||
(denominator < 0 && numerator < intermediate_product));
|
||||
const IntegralType adjustment = static_cast<IntegralType>(needs_adjustment);
|
||||
const IntegralType ceil_of_ratio = rounded_toward_zero + adjustment;
|
||||
return ceil_of_ratio;
|
||||
} else {
|
||||
// Floor case: symmetrical to the previous one
|
||||
const bool needs_adjustment = (rounded_toward_zero <= 0) &&
|
||||
((denominator > 0 && numerator < intermediate_product) ||
|
||||
(denominator < 0 && numerator > intermediate_product));
|
||||
const IntegralType adjustment = static_cast<IntegralType>(needs_adjustment);
|
||||
const IntegralType floor_of_ratio = rounded_toward_zero - adjustment;
|
||||
return floor_of_ratio;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_MATHUTIL_H_
|
||||
@@ -0,0 +1,29 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_NOTIFICATION_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_NOTIFICATION_H_
|
||||
|
||||
#include "tensorflow/core/platform/notification.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
using tensorflow::Notification;
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_NOTIFICATION_H_
|
||||
@@ -0,0 +1,32 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_NUMBERS_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_NUMBERS_H_
|
||||
|
||||
#include "tensorflow/stream_executor/platform/port.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
// Convert strings to floating point values.
|
||||
// Leading and trailing spaces are allowed.
|
||||
// Values may be rounded on over- and underflow.
|
||||
bool safe_strto32(const string& str, int32* value);
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_NUMBERS_H_
|
||||
@@ -0,0 +1,60 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_PATH_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_PATH_H_
|
||||
|
||||
#include "tensorflow/core/lib/io/path.h"
|
||||
#include "tensorflow/stream_executor/lib/stringpiece.h"
|
||||
#include "tensorflow/stream_executor/platform/port.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
using tensorflow::io::Dirname;
|
||||
|
||||
namespace internal {
|
||||
// TODO(rspringer): Move to cc/implementation file.
|
||||
// Not part of the public API.
|
||||
string JoinPathImpl(std::initializer_list<port::StringPiece> paths);
|
||||
} // namespace internal
|
||||
|
||||
// Join multiple paths together.
|
||||
// JoinPath unconditionally joins all paths together. For example:
|
||||
//
|
||||
// Arguments | JoinPath
|
||||
// ---------------------------+---------------------
|
||||
// '/foo', 'bar' | /foo/bar
|
||||
// '/foo/', 'bar' | /foo/bar
|
||||
// '/foo', '/bar' | /foo/bar
|
||||
// '/foo', '/bar', '/baz' | /foo/bar/baz
|
||||
//
|
||||
// All paths will be treated as relative paths, regardless of whether or not
|
||||
// they start with a leading '/'. That is, all paths will be concatenated
|
||||
// together, with the appropriate path separator inserted in between.
|
||||
// Arguments must be convertible to port::StringPiece.
|
||||
//
|
||||
// Usage:
|
||||
// string path = file::JoinPath("/var/log", dirname, filename);
|
||||
// string path = file::JoinPath(FLAGS_test_srcdir, filename);
|
||||
template <typename... T>
|
||||
inline string JoinPath(const T&... args) {
|
||||
return internal::JoinPathImpl({args...});
|
||||
}
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_PATH_H_
|
||||
@@ -0,0 +1,30 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_PROCESS_STATE_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_PROCESS_STATE_H_
|
||||
|
||||
#include "tensorflow/stream_executor/platform/port.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
string Hostname();
|
||||
bool GetCurrentDirectory(string* dir);
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_PROCESS_STATE_H_
|
||||
@@ -0,0 +1,38 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_PTR_UTIL_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_PTR_UTIL_H_
|
||||
|
||||
#include <memory>
|
||||
#include "tensorflow/core/util/ptr_util.h"
|
||||
|
||||
namespace stream_executor {
|
||||
using tensorflow::MakeUnique;
|
||||
using tensorflow::WrapUnique;
|
||||
} // namespace stream_executor
|
||||
|
||||
namespace perftools {
|
||||
namespace gputools {
|
||||
|
||||
// Temporarily pull stream_executor into perftools::gputools while we migrate
|
||||
// code to the new namespace. TODO(jlebar): Remove this once we've completed
|
||||
// the migration.
|
||||
using namespace stream_executor; // NOLINT[build/namespaces]
|
||||
|
||||
} // namespace gputools
|
||||
} // namespace perftools
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_PTR_UTIL_H_
|
||||
@@ -0,0 +1,30 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_STACKTRACE_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_STACKTRACE_H_
|
||||
|
||||
#include "tensorflow/core/platform/stacktrace.h"
|
||||
#include "tensorflow/stream_executor/platform/port.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
using tensorflow::CurrentStackTrace;
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_STACKTRACE_H_
|
||||
@@ -0,0 +1,46 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_STATIC_THREADLOCAL_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_STATIC_THREADLOCAL_H_
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define __thread __declspec(thread)
|
||||
#endif
|
||||
|
||||
// For POD types in TLS mode, s_obj_VAR is the thread-local variable.
|
||||
#define SE_STATIC_THREAD_LOCAL_POD(_Type_, _var_) \
|
||||
static __thread _Type_ s_obj_##_var_; \
|
||||
namespace { \
|
||||
class ThreadLocal_##_var_ { \
|
||||
public: \
|
||||
ThreadLocal_##_var_() {} \
|
||||
void Init() {} \
|
||||
inline _Type_ *pointer() const { \
|
||||
return &s_obj_##_var_; \
|
||||
} \
|
||||
inline _Type_ *safe_pointer() const { \
|
||||
return &s_obj_##_var_; \
|
||||
} \
|
||||
_Type_ &get() const { \
|
||||
return s_obj_##_var_; \
|
||||
} \
|
||||
bool is_native_tls() const { return true; } \
|
||||
private: \
|
||||
SE_DISALLOW_COPY_AND_ASSIGN(ThreadLocal_##_var_); \
|
||||
} _var_; \
|
||||
}
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_STATIC_THREADLOCAL_H_
|
||||
@@ -0,0 +1,60 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
// IWYU pragma: private, include "third_party/tensorflow/stream_executor/stream_executor.h"
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_STATUS_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_STATUS_H_
|
||||
|
||||
#include "tensorflow/core/lib/core/status.h"
|
||||
#include "tensorflow/stream_executor/lib/error.h" // IWYU pragma: export
|
||||
#include "tensorflow/stream_executor/lib/stringpiece.h"
|
||||
#include "tensorflow/stream_executor/platform/logging.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
using Status = tensorflow::Status;
|
||||
|
||||
#define SE_CHECK_OK(val) TF_CHECK_OK(val)
|
||||
#define SE_ASSERT_OK(val) \
|
||||
ASSERT_EQ(::stream_executor::port::Status::OK(), (val))
|
||||
|
||||
// Define some canonical error helpers.
|
||||
inline Status UnimplementedError(StringPiece message) {
|
||||
return Status(error::UNIMPLEMENTED, message);
|
||||
}
|
||||
inline Status InternalError(StringPiece message) {
|
||||
return Status(error::INTERNAL, message);
|
||||
}
|
||||
inline Status FailedPreconditionError(StringPiece message) {
|
||||
return Status(error::FAILED_PRECONDITION, message);
|
||||
}
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
namespace perftools {
|
||||
namespace gputools {
|
||||
|
||||
// Temporarily pull stream_executor into perftools::gputools while we migrate
|
||||
// code to the new namespace. TODO(b/77980417): Remove this once we've
|
||||
// completed the migration.
|
||||
using namespace stream_executor; // NOLINT[build/namespaces]
|
||||
|
||||
} // namespace gputools
|
||||
} // namespace perftools
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_STATUS_H_
|
||||
@@ -0,0 +1,53 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
// Helper macros for dealing with the port::Status datatype.
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_STATUS_MACROS_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_STATUS_MACROS_H_
|
||||
|
||||
// Early-returns the status if it is in error; otherwise, proceeds.
|
||||
//
|
||||
// The argument expression is guaranteed to be evaluated exactly once.
|
||||
#define SE_RETURN_IF_ERROR(__status) \
|
||||
do { \
|
||||
auto status = __status; \
|
||||
if (!status.ok()) { \
|
||||
return status; \
|
||||
} \
|
||||
} while (false)
|
||||
|
||||
// Identifier concatenation helper macros.
|
||||
#define SE_MACRO_CONCAT_INNER(__x, __y) __x##__y
|
||||
#define SE_MACRO_CONCAT(__x, __y) SE_MACRO_CONCAT_INNER(__x, __y)
|
||||
|
||||
// Implementation of SE_ASSIGN_OR_RETURN that uses a unique temporary identifier
|
||||
// for avoiding collision in the enclosing scope.
|
||||
#define SE_ASSIGN_OR_RETURN_IMPL(__lhs, __rhs, __name) \
|
||||
auto __name = (__rhs); \
|
||||
if (!__name.ok()) { \
|
||||
return __name.status(); \
|
||||
} \
|
||||
__lhs = std::move(__name.ValueOrDie());
|
||||
|
||||
// Early-returns the status if it is in error; otherwise, assigns the
|
||||
// right-hand-side expression to the left-hand-side expression.
|
||||
//
|
||||
// The right-hand-side expression is guaranteed to be evaluated exactly once.
|
||||
#define SE_ASSIGN_OR_RETURN(__lhs, __rhs) \
|
||||
SE_ASSIGN_OR_RETURN_IMPL(__lhs, __rhs, \
|
||||
SE_MACRO_CONCAT(__status_or_value, __COUNTER__))
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_STATUS_MACROS_H_
|
||||
@@ -0,0 +1,311 @@
|
||||
/* Copyright 2017 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.
|
||||
==============================================================================*/
|
||||
|
||||
// StatusOr<T> is the union of a Status object and a T object. StatusOr models
|
||||
// the concept of an object that is either a value, or an error Status
|
||||
// explaining why such a value is not present. To this end, StatusOr<T> does not
|
||||
// allow its Status value to be Status::OK.
|
||||
//
|
||||
// The primary use-case for StatusOr<T> is as the return value of a
|
||||
// function which may fail.
|
||||
//
|
||||
// Example client usage for a StatusOr<T>, where T is not a pointer:
|
||||
//
|
||||
// StatusOr<float> result = DoBigCalculationThatCouldFail();
|
||||
// if (result.ok()) {
|
||||
// float answer = result.ValueOrDie();
|
||||
// printf("Big calculation yielded: %f", answer);
|
||||
// } else {
|
||||
// LOG(ERROR) << result.status();
|
||||
// }
|
||||
//
|
||||
// Example client usage for a StatusOr<T*>:
|
||||
//
|
||||
// StatusOr<Foo*> result = FooFactory::MakeNewFoo(arg);
|
||||
// if (result.ok()) {
|
||||
// std::unique_ptr<Foo> foo(result.ValueOrDie());
|
||||
// foo->DoSomethingCool();
|
||||
// } else {
|
||||
// LOG(ERROR) << result.status();
|
||||
// }
|
||||
//
|
||||
// Example client usage for a StatusOr<std::unique_ptr<T>>:
|
||||
//
|
||||
// StatusOr<std::unique_ptr<Foo>> result = FooFactory::MakeNewFoo(arg);
|
||||
// if (result.ok()) {
|
||||
// std::unique_ptr<Foo> foo = std::move(result.ValueOrDie());
|
||||
// foo->DoSomethingCool();
|
||||
// } else {
|
||||
// LOG(ERROR) << result.status();
|
||||
// }
|
||||
//
|
||||
// Example factory implementation returning StatusOr<T*>:
|
||||
//
|
||||
// StatusOr<Foo*> FooFactory::MakeNewFoo(int arg) {
|
||||
// if (arg <= 0) {
|
||||
// return tensorflow::InvalidArgument("Arg must be positive");
|
||||
// } else {
|
||||
// return new Foo(arg);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// Note that the assignment operators require that destroying the currently
|
||||
// stored value cannot invalidate the argument; in other words, the argument
|
||||
// cannot be an alias for the current value, or anything owned by the current
|
||||
// value.
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_STATUSOR_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_STATUSOR_H_
|
||||
|
||||
#include "tensorflow/core/platform/macros.h"
|
||||
#include "tensorflow/stream_executor/lib/status.h"
|
||||
#include "tensorflow/stream_executor/lib/statusor_internals.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
#if defined(__clang__)
|
||||
// Only clang supports warn_unused_result as a type annotation.
|
||||
template <typename T>
|
||||
class TF_MUST_USE_RESULT StatusOr;
|
||||
#endif
|
||||
|
||||
template <typename T>
|
||||
class StatusOr : private internal_statusor::StatusOrData<T>,
|
||||
private internal_statusor::TraitsBase<
|
||||
std::is_copy_constructible<T>::value,
|
||||
std::is_move_constructible<T>::value> {
|
||||
template <typename U>
|
||||
friend class StatusOr;
|
||||
|
||||
typedef internal_statusor::StatusOrData<T> Base;
|
||||
|
||||
public:
|
||||
typedef T element_type;
|
||||
|
||||
// Constructs a new StatusOr with Status::UNKNOWN status. This is marked
|
||||
// 'explicit' to try to catch cases like 'return {};', where people think
|
||||
// StatusOr<std::vector<int>> will be initialized with an empty vector,
|
||||
// instead of a Status::UNKNOWN status.
|
||||
explicit StatusOr();
|
||||
|
||||
// StatusOr<T> will be copy constructible/assignable if T is copy
|
||||
// constructible.
|
||||
StatusOr(const StatusOr&) = default;
|
||||
StatusOr& operator=(const StatusOr&) = default;
|
||||
|
||||
// StatusOr<T> will be move constructible/assignable if T is move
|
||||
// constructible.
|
||||
StatusOr(StatusOr&&) = default;
|
||||
StatusOr& operator=(StatusOr&&) = default;
|
||||
|
||||
// Conversion copy/move constructor, T must be convertible from U.
|
||||
template <typename U, typename std::enable_if<
|
||||
std::is_convertible<U, T>::value>::type* = nullptr>
|
||||
StatusOr(const StatusOr<U>& other);
|
||||
template <typename U, typename std::enable_if<
|
||||
std::is_convertible<U, T>::value>::type* = nullptr>
|
||||
StatusOr(StatusOr<U>&& other);
|
||||
|
||||
// Conversion copy/move assignment operator, T must be convertible from U.
|
||||
template <typename U, typename std::enable_if<
|
||||
std::is_convertible<U, T>::value>::type* = nullptr>
|
||||
StatusOr& operator=(const StatusOr<U>& other);
|
||||
template <typename U, typename std::enable_if<
|
||||
std::is_convertible<U, T>::value>::type* = nullptr>
|
||||
StatusOr& operator=(StatusOr<U>&& other);
|
||||
|
||||
// Constructs a new StatusOr with the given value. After calling this
|
||||
// constructor, calls to ValueOrDie() will succeed, and calls to status() will
|
||||
// return OK.
|
||||
//
|
||||
// NOTE: Not explicit - we want to use StatusOr<T> as a return type
|
||||
// so it is convenient and sensible to be able to do 'return T()'
|
||||
// when the return type is StatusOr<T>.
|
||||
//
|
||||
// REQUIRES: T is copy constructible.
|
||||
StatusOr(const T& value);
|
||||
|
||||
// Constructs a new StatusOr with the given non-ok status. After calling
|
||||
// this constructor, calls to ValueOrDie() will CHECK-fail.
|
||||
//
|
||||
// NOTE: Not explicit - we want to use StatusOr<T> as a return
|
||||
// value, so it is convenient and sensible to be able to do 'return
|
||||
// Status()' when the return type is StatusOr<T>.
|
||||
//
|
||||
// REQUIRES: !status.ok(). This requirement is DCHECKed.
|
||||
// In optimized builds, passing Status::OK() here will have the effect
|
||||
// of passing tensorflow::error::INTERNAL as a fallback.
|
||||
StatusOr(const Status& status);
|
||||
StatusOr& operator=(const Status& status);
|
||||
|
||||
// TODO(b/62186997): Add operator=(T) overloads.
|
||||
|
||||
// Similar to the `const T&` overload.
|
||||
//
|
||||
// REQUIRES: T is move constructible.
|
||||
StatusOr(T&& value);
|
||||
|
||||
// RValue versions of the operations declared above.
|
||||
StatusOr(Status&& status);
|
||||
StatusOr& operator=(Status&& status);
|
||||
|
||||
// Returns this->status().ok()
|
||||
bool ok() const { return this->status_.ok(); }
|
||||
|
||||
// Returns a reference to our status. If this contains a T, then
|
||||
// returns Status::OK().
|
||||
const Status& status() const &;
|
||||
Status status() &&;
|
||||
|
||||
// Returns a reference to our current value, or CHECK-fails if !this->ok().
|
||||
//
|
||||
// Note: for value types that are cheap to copy, prefer simple code:
|
||||
//
|
||||
// T value = statusor.ValueOrDie();
|
||||
//
|
||||
// Otherwise, if the value type is expensive to copy, but can be left
|
||||
// in the StatusOr, simply assign to a reference:
|
||||
//
|
||||
// T& value = statusor.ValueOrDie(); // or `const T&`
|
||||
//
|
||||
// Otherwise, if the value type supports an efficient move, it can be
|
||||
// used as follows:
|
||||
//
|
||||
// T value = std::move(statusor).ValueOrDie();
|
||||
//
|
||||
// The std::move on statusor instead of on the whole expression enables
|
||||
// warnings about possible uses of the statusor object after the move.
|
||||
// C++ style guide waiver for ref-qualified overloads granted in cl/143176389
|
||||
// See go/ref-qualifiers for more details on such overloads.
|
||||
const T& ValueOrDie() const &;
|
||||
T& ValueOrDie() &;
|
||||
const T&& ValueOrDie() const &&;
|
||||
T&& ValueOrDie() &&;
|
||||
|
||||
T ConsumeValueOrDie() { return std::move(ValueOrDie()); }
|
||||
|
||||
// Ignores any errors. This method does nothing except potentially suppress
|
||||
// complaints from any tools that are checking that errors are not dropped on
|
||||
// the floor.
|
||||
void IgnoreError() const;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Implementation details for StatusOr<T>
|
||||
|
||||
template <typename T>
|
||||
StatusOr<T>::StatusOr() : Base(Status(tensorflow::error::UNKNOWN, "")) {}
|
||||
|
||||
template <typename T>
|
||||
StatusOr<T>::StatusOr(const T& value) : Base(value) {}
|
||||
|
||||
template <typename T>
|
||||
StatusOr<T>::StatusOr(const Status& status) : Base(status) {}
|
||||
|
||||
template <typename T>
|
||||
StatusOr<T>& StatusOr<T>::operator=(const Status& status) {
|
||||
this->Assign(status);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
StatusOr<T>::StatusOr(T&& value) : Base(std::move(value)) {}
|
||||
|
||||
template <typename T>
|
||||
StatusOr<T>::StatusOr(Status&& status) : Base(std::move(status)) {}
|
||||
|
||||
template <typename T>
|
||||
StatusOr<T>& StatusOr<T>::operator=(Status&& status) {
|
||||
this->Assign(std::move(status));
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
template <typename U,
|
||||
typename std::enable_if<std::is_convertible<U, T>::value>::type*>
|
||||
inline StatusOr<T>::StatusOr(const StatusOr<U>& other)
|
||||
: Base(static_cast<const typename StatusOr<U>::Base&>(other)) {}
|
||||
|
||||
template <typename T>
|
||||
template <typename U,
|
||||
typename std::enable_if<std::is_convertible<U, T>::value>::type*>
|
||||
inline StatusOr<T>& StatusOr<T>::operator=(const StatusOr<U>& other) {
|
||||
if (other.ok())
|
||||
this->Assign(other.ValueOrDie());
|
||||
else
|
||||
this->Assign(other.status());
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
template <typename U,
|
||||
typename std::enable_if<std::is_convertible<U, T>::value>::type*>
|
||||
inline StatusOr<T>::StatusOr(StatusOr<U>&& other)
|
||||
: Base(static_cast<typename StatusOr<U>::Base&&>(other)) {}
|
||||
|
||||
template <typename T>
|
||||
template <typename U,
|
||||
typename std::enable_if<std::is_convertible<U, T>::value>::type*>
|
||||
inline StatusOr<T>& StatusOr<T>::operator=(StatusOr<U>&& other) {
|
||||
if (other.ok()) {
|
||||
this->Assign(std::move(other).ValueOrDie());
|
||||
} else {
|
||||
this->Assign(std::move(other).status());
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
const Status& StatusOr<T>::status() const & {
|
||||
return this->status_;
|
||||
}
|
||||
template <typename T>
|
||||
Status StatusOr<T>::status() && {
|
||||
return ok() ? Status::OK() : std::move(this->status_);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
const T& StatusOr<T>::ValueOrDie() const & {
|
||||
this->EnsureOk();
|
||||
return this->data_;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
T& StatusOr<T>::ValueOrDie() & {
|
||||
this->EnsureOk();
|
||||
return this->data_;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
const T&& StatusOr<T>::ValueOrDie() const && {
|
||||
this->EnsureOk();
|
||||
return std::move(this->data_);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
T&& StatusOr<T>::ValueOrDie() && {
|
||||
this->EnsureOk();
|
||||
return std::move(this->data_);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void StatusOr<T>::IgnoreError() const {
|
||||
// no-op
|
||||
}
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_STATUSOR_H_
|
||||
@@ -0,0 +1,247 @@
|
||||
/* Copyright 2017 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_STATUSOR_INTERNALS_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_STATUSOR_INTERNALS_H_
|
||||
|
||||
#include "tensorflow/core/platform/macros.h"
|
||||
#include "tensorflow/stream_executor/lib/status.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
namespace internal_statusor {
|
||||
|
||||
class Helper {
|
||||
public:
|
||||
// Move type-agnostic error handling to the .cc.
|
||||
static void HandleInvalidStatusCtorArg(Status*);
|
||||
TF_ATTRIBUTE_NORETURN static void Crash(const Status& status);
|
||||
};
|
||||
|
||||
// Construct an instance of T in `p` through placement new, passing Args... to
|
||||
// the constructor.
|
||||
// This abstraction is here mostly for the gcc performance fix.
|
||||
template <typename T, typename... Args>
|
||||
void PlacementNew(void* p, Args&&... args) {
|
||||
#if defined(__GNUC__) && !defined(__clang__)
|
||||
// Teach gcc that 'p' cannot be null, fixing code size issues.
|
||||
if (p == nullptr) __builtin_unreachable();
|
||||
#endif
|
||||
new (p) T(std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
// Helper base class to hold the data and all operations.
|
||||
// We move all this to a base class to allow mixing with the appropriate
|
||||
// TraitsBase specialization.
|
||||
template <typename T>
|
||||
class StatusOrData {
|
||||
template <typename U>
|
||||
friend class StatusOrData;
|
||||
|
||||
public:
|
||||
StatusOrData() = delete;
|
||||
|
||||
StatusOrData(const StatusOrData& other) {
|
||||
if (other.ok()) {
|
||||
MakeValue(other.data_);
|
||||
MakeStatus();
|
||||
} else {
|
||||
MakeStatus(other.status_);
|
||||
}
|
||||
}
|
||||
|
||||
StatusOrData(StatusOrData&& other) noexcept {
|
||||
if (other.ok()) {
|
||||
MakeValue(std::move(other.data_));
|
||||
MakeStatus();
|
||||
} else {
|
||||
MakeStatus(std::move(other.status_));
|
||||
}
|
||||
}
|
||||
|
||||
template <typename U>
|
||||
StatusOrData(const StatusOrData<U>& other) {
|
||||
if (other.ok()) {
|
||||
MakeValue(other.data_);
|
||||
MakeStatus();
|
||||
} else {
|
||||
MakeStatus(other.status_);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename U>
|
||||
StatusOrData(StatusOrData<U>&& other) {
|
||||
if (other.ok()) {
|
||||
MakeValue(std::move(other.data_));
|
||||
MakeStatus();
|
||||
} else {
|
||||
MakeStatus(std::move(other.status_));
|
||||
}
|
||||
}
|
||||
|
||||
explicit StatusOrData(const T& value) : data_(value) { MakeStatus(); }
|
||||
explicit StatusOrData(T&& value) : data_(std::move(value)) { MakeStatus(); }
|
||||
|
||||
explicit StatusOrData(const Status& status) : status_(status) {
|
||||
EnsureNotOk();
|
||||
}
|
||||
explicit StatusOrData(Status&& status) : status_(std::move(status)) {
|
||||
EnsureNotOk();
|
||||
}
|
||||
|
||||
StatusOrData& operator=(const StatusOrData& other) {
|
||||
if (this == &other) return *this;
|
||||
if (other.ok())
|
||||
Assign(other.data_);
|
||||
else
|
||||
Assign(other.status_);
|
||||
return *this;
|
||||
}
|
||||
|
||||
StatusOrData& operator=(StatusOrData&& other) {
|
||||
if (this == &other) return *this;
|
||||
if (other.ok())
|
||||
Assign(std::move(other.data_));
|
||||
else
|
||||
Assign(std::move(other.status_));
|
||||
return *this;
|
||||
}
|
||||
|
||||
~StatusOrData() {
|
||||
if (ok()) {
|
||||
status_.~Status();
|
||||
data_.~T();
|
||||
} else {
|
||||
status_.~Status();
|
||||
}
|
||||
}
|
||||
|
||||
void Assign(const T& value) {
|
||||
if (ok()) {
|
||||
data_.~T();
|
||||
MakeValue(value);
|
||||
} else {
|
||||
MakeValue(value);
|
||||
status_ = Status::OK();
|
||||
}
|
||||
}
|
||||
|
||||
void Assign(T&& value) {
|
||||
if (ok()) {
|
||||
data_.~T();
|
||||
MakeValue(std::move(value));
|
||||
} else {
|
||||
MakeValue(std::move(value));
|
||||
status_ = Status::OK();
|
||||
}
|
||||
}
|
||||
|
||||
void Assign(const Status& status) {
|
||||
Clear();
|
||||
status_ = status;
|
||||
EnsureNotOk();
|
||||
}
|
||||
|
||||
void Assign(Status&& status) {
|
||||
Clear();
|
||||
status_ = std::move(status);
|
||||
EnsureNotOk();
|
||||
}
|
||||
|
||||
bool ok() const { return status_.ok(); }
|
||||
|
||||
protected:
|
||||
// status_ will always be active after the constructor.
|
||||
// We make it a union to be able to initialize exactly how we need without
|
||||
// waste.
|
||||
// Eg. in the copy constructor we use the default constructor of Status in
|
||||
// the ok() path to avoid an extra Ref call.
|
||||
union {
|
||||
Status status_;
|
||||
};
|
||||
|
||||
// data_ is active iff status_.ok()==true
|
||||
struct Dummy {};
|
||||
union {
|
||||
// When T is const, we need some non-const object we can cast to void* for
|
||||
// the placement new. dummy_ is that object.
|
||||
Dummy dummy_;
|
||||
T data_;
|
||||
};
|
||||
|
||||
void Clear() {
|
||||
if (ok()) data_.~T();
|
||||
}
|
||||
|
||||
void EnsureOk() const {
|
||||
if (!ok()) Helper::Crash(status_);
|
||||
}
|
||||
|
||||
void EnsureNotOk() {
|
||||
if (ok()) Helper::HandleInvalidStatusCtorArg(&status_);
|
||||
}
|
||||
|
||||
// Construct the value (ie. data_) through placement new with the passed
|
||||
// argument.
|
||||
template <typename Arg>
|
||||
void MakeValue(Arg&& arg) {
|
||||
internal_statusor::PlacementNew<T>(&dummy_, std::forward<Arg>(arg));
|
||||
}
|
||||
|
||||
// Construct the status (ie. status_) through placement new with the passed
|
||||
// argument.
|
||||
template <typename... Args>
|
||||
void MakeStatus(Args&&... args) {
|
||||
internal_statusor::PlacementNew<Status>(&status_,
|
||||
std::forward<Args>(args)...);
|
||||
}
|
||||
};
|
||||
|
||||
// Helper base class to allow implicitly deleted constructors and assignment
|
||||
// operations in StatusOr.
|
||||
// TraitsBase will explicitly delete what it can't support and StatusOr will
|
||||
// inherit that behavior implicitly.
|
||||
template <bool Copy, bool Move>
|
||||
struct TraitsBase {
|
||||
TraitsBase() = default;
|
||||
TraitsBase(const TraitsBase&) = default;
|
||||
TraitsBase(TraitsBase&&) = default;
|
||||
TraitsBase& operator=(const TraitsBase&) = default;
|
||||
TraitsBase& operator=(TraitsBase&&) = default;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct TraitsBase<false, true> {
|
||||
TraitsBase() = default;
|
||||
TraitsBase(const TraitsBase&) = delete;
|
||||
TraitsBase(TraitsBase&&) = default;
|
||||
TraitsBase& operator=(const TraitsBase&) = delete;
|
||||
TraitsBase& operator=(TraitsBase&&) = default;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct TraitsBase<false, false> {
|
||||
TraitsBase() = default;
|
||||
TraitsBase(const TraitsBase&) = delete;
|
||||
TraitsBase(TraitsBase&&) = delete;
|
||||
TraitsBase& operator=(const TraitsBase&) = delete;
|
||||
TraitsBase& operator=(TraitsBase&&) = delete;
|
||||
};
|
||||
|
||||
} // namespace internal_statusor
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_STATUSOR_INTERNALS_H_
|
||||
@@ -0,0 +1,42 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_STR_UTIL_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_STR_UTIL_H_
|
||||
|
||||
#include "tensorflow/core/lib/strings/str_util.h"
|
||||
#include "tensorflow/stream_executor/lib/stringpiece.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
using tensorflow::str_util::Join;
|
||||
using tensorflow::str_util::Split;
|
||||
|
||||
// Returns a copy of the input string 'str' with the given 'suffix'
|
||||
// removed. If the suffix doesn't match, returns a copy of the original string.
|
||||
inline string StripSuffixString(port::StringPiece str, port::StringPiece suffix) {
|
||||
if (tensorflow::str_util::EndsWith(str, suffix)) {
|
||||
str.remove_suffix(suffix.size());
|
||||
}
|
||||
return string(str);
|
||||
}
|
||||
|
||||
using tensorflow::str_util::Lowercase;
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_STR_UTIL_H_
|
||||
@@ -0,0 +1,32 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
// IWYU pragma: private, include "third_party/tensorflow/stream_executor/stream_executor.h"
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_STRCAT_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_STRCAT_H_
|
||||
|
||||
#include "absl/strings/str_cat.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
using absl::StrAppend;
|
||||
using absl::StrCat;
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_STRCAT_H_
|
||||
@@ -0,0 +1,29 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_STRINGPIECE_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_STRINGPIECE_H_
|
||||
|
||||
#include "absl/strings/string_view.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
using StringPiece = absl::string_view;
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_STRINGPIECE_H_
|
||||
@@ -0,0 +1,30 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_STRINGPRINTF_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_STRINGPRINTF_H_
|
||||
|
||||
#include "tensorflow/core/lib/strings/stringprintf.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
using tensorflow::strings::Printf;
|
||||
using tensorflow::strings::Appendf;
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_STRINGPRINTF_H_
|
||||
@@ -0,0 +1,29 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_THREAD_OPTIONS_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_THREAD_OPTIONS_H_
|
||||
|
||||
#include "tensorflow/core/platform/env.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
using tensorflow::ThreadOptions;
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_THREAD_OPTIONS_H_
|
||||
@@ -0,0 +1,32 @@
|
||||
/* Copyright 2015 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.
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef TENSORFLOW_STREAM_EXECUTOR_LIB_THREADPOOL_H_
|
||||
#define TENSORFLOW_STREAM_EXECUTOR_LIB_THREADPOOL_H_
|
||||
|
||||
#include "tensorflow/core/lib/core/threadpool.h"
|
||||
#include "tensorflow/stream_executor/lib/env.h"
|
||||
#include "tensorflow/stream_executor/lib/notification.h"
|
||||
#include "tensorflow/stream_executor/lib/thread_options.h"
|
||||
|
||||
namespace stream_executor {
|
||||
namespace port {
|
||||
|
||||
using tensorflow::thread::ThreadPool;
|
||||
|
||||
} // namespace port
|
||||
} // namespace stream_executor
|
||||
|
||||
#endif // TENSORFLOW_STREAM_EXECUTOR_LIB_THREADPOOL_H_
|
||||
Reference in new issue
Block a user