experiments/STT-tensorflow
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Qualify uses of std::string

Browse Source 
PiperOrigin-RevId: 324252304
Change-Id: I82a93ab00c2cba05ea0b7fe4fc3709f0bec30d93
This commit is contained in:
A. Unique TensorFlower 2020-07-31 11:49:28 -07:00 committed by TensorFlower Gardener
parent 7f3772b7b8
commit a697dbc604
21 changed files with 270 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tensorflow/core/framework/attr_value_util.h
View File

@ -36,7 +36,7 @@ class NameAttrList;
// A human-readable rendering of attr_value, that is more concise than a
// text-format proto.
string SummarizeAttrValue(const AttrValue& attr_value);
std::string SummarizeAttrValue(const AttrValue& attr_value);
// Generates an error if attr_value doesn't have the indicated attr type.
Status AttrValueHasType(const AttrValue& attr_value, StringPiece type);
@ -51,7 +51,7 @@ Status AttrValueHasType(const AttrValue& attr_value, StringPiece type);
bool ParseAttrValue(StringPiece type, StringPiece text, AttrValue* out);
// Sets *out based on the type of value.
void SetAttrValue(const string& value, AttrValue* out);
void SetAttrValue(const std::string& value, AttrValue* out);
void SetAttrValue(const tstring& value, AttrValue* out);
void SetAttrValue(const char* value, AttrValue* out);
void SetAttrValue(StringPiece value, AttrValue* out);

2
tensorflow/core/framework/device_base.h
View File

@ -237,7 +237,7 @@ class DeviceBase {
// Unimplemented by default
virtual const DeviceAttributes& attributes() const;
virtual int NumaNode() const { return attributes().locality().numa_node(); }
virtual const string& name() const;
virtual const std::string& name() const;
// Materializes the given TensorProto into 'tensor' stored in Device
// memory. Most devices will want to override this.

96
tensorflow/core/framework/function.h
View File

@ -114,9 +114,9 @@ class FunctionDefHelper {
// Constructs an AttrValue.func given the "name" and "attrs".
static AttrValueWrapper FunctionRef(
const string& name,
const std::string& name,
gtl::ArraySlice<std::pair<string, AttrValueWrapper>> attrs);
static AttrValueWrapper FunctionRef(const string& name) {
static AttrValueWrapper FunctionRef(const std::string& name) {
return FunctionRef(name, {});
}
@ -127,11 +127,11 @@ class FunctionDefHelper {
// When constructing a NodeDef, the first entry in ret is used as
// the node name, the remaining values are ignored.
std::vector<string> ret;
string op;
std::string op;
std::vector<string> arg;
std::vector<std::pair<string, AttrValueWrapper>> attr;
std::vector<string> dep;
string device;
std::string device;
NodeDef ToNodeDef() const;
};
@ -143,7 +143,7 @@ class FunctionDefHelper {
// - `control_ret_def` holds a mapping from the function control
// output names to the nodes from `node_def`.
static FunctionDef Create(
const string& function_name, gtl::ArraySlice<string> in_def,
const std::string& function_name, gtl::ArraySlice<string> in_def,
gtl::ArraySlice<string> out_def, gtl::ArraySlice<string> attr_def,
gtl::ArraySlice<Node> node_def,
gtl::ArraySlice<std::pair<string, string>> ret_def,
@ -153,7 +153,7 @@ class FunctionDefHelper {
// function encoding (node_name:output_name[:output_index]).
// - `ret_def` holds a mapping from the function output names from `out_def`
// to the node outputs from `node_def`.
static FunctionDef Create(const string& function_name,
static FunctionDef Create(const std::string& function_name,
gtl::ArraySlice<string> in_def,
gtl::ArraySlice<string> out_def,
gtl::ArraySlice<string> attr_def,
@ -161,7 +161,7 @@ class FunctionDefHelper {
gtl::ArraySlice<std::pair<string, string>> ret_def);
// TODO(josh11b): Get rid of these and transition to the one above.
static FunctionDef Define(const string& function_name,
static FunctionDef Define(const std::string& function_name,
gtl::ArraySlice<string> arg_def,
gtl::ArraySlice<string> ret_def,
gtl::ArraySlice<string> attr_def,
@ -175,7 +175,7 @@ class FunctionDefHelper {
// Helpers to construct a constant scalar.
template <typename T>
static Node Const(const string& name, const T& val) {
static Node Const(const std::string& name, const T& val) {
Node n = {{name}, "Const"};
const DataType dtype = DataTypeToEnum<T>::value;
n.attr.push_back({"dtype", dtype});
@ -186,7 +186,7 @@ class FunctionDefHelper {
}
template <typename T>
static Node Const(const string& name, gtl::ArraySlice<T> vals) {
static Node Const(const std::string& name, gtl::ArraySlice<T> vals) {
Node n = {{name}, "Const"};
const DataType dtype = DataTypeToEnum<T>::value;
n.attr.push_back({"dtype", dtype});
@ -207,7 +207,7 @@ inline FunctionDefHelper::AttrValueWrapper::AttrValueWrapper(const char* val) {
template <>
inline FunctionDefHelper::AttrValueWrapper::AttrValueWrapper(
const string& val) {
const std::string& val) {
InitFromString(val);
}
@ -251,13 +251,13 @@ Status InstantiateFunction(const FunctionDef& fdef, AttrSlice attr_values,
// Particularly, it may not include all information presented in
// "func_def" (e.g., comments, description of the function arguments,
// etc.)
string DebugString(const FunctionDef& func_def);
string DebugString(const GraphDef& instantiated_func_def);
string DebugString(gtl::ArraySlice<NodeDef> instantiated_func_nodes);
std::string DebugString(const FunctionDef& func_def);
std::string DebugString(const GraphDef& instantiated_func_def);
std::string DebugString(gtl::ArraySlice<NodeDef> instantiated_func_nodes);
// Returns a debug string for a top level graph (the main program and
// its supporting functions defined in its library).
string DebugStringWhole(const GraphDef& gdef);
std::string DebugStringWhole(const GraphDef& gdef);
// Returns true if f1 == f2. Compares all fields, including descriptions. Order
// of NodeDefs doesn't matter.
@ -360,14 +360,14 @@ class FunctionLibraryDefinition : public OpRegistryInterface {
delete;
// Returns True if the library contains `func`, False otherwise.
bool Contains(const string& func) const;
bool Contains(const std::string& func) const;
// Returns nullptr if "func" is not defined in "lib_def". Otherwise,
// returns its definition proto.
//
// NB: This function returns a borrowed pointer, which can be invalidated by a
// subsequent call to `ReplaceFunction()` with the given name.
const FunctionDef* Find(const string& func) const TF_LOCKS_EXCLUDED(mu_);
const FunctionDef* Find(const std::string& func) const TF_LOCKS_EXCLUDED(mu_);
// Adds function definition 'fdef' to this function library.
// Returns status 'ok' on success, or error otherwise. This is a no-op if
@ -388,7 +388,7 @@ class FunctionLibraryDefinition : public OpRegistryInterface {
// a non-OK status if "func" was not found in the library, OK otherwise.
// Please be careful when replacing function: make sure all previous pointers
// returned by `Find()` are no longer in use.
Status ReplaceFunction(const string& func, const FunctionDef& fdef)
Status ReplaceFunction(const std::string& func, const FunctionDef& fdef)
TF_LOCKS_EXCLUDED(mu_);
// Replaces the gradient corresponding to `grad.function_name()`. Returns
@ -401,7 +401,7 @@ class FunctionLibraryDefinition : public OpRegistryInterface {
// Please be careful when removing function: make sure there are no other
// nodes using the function, and all previous pointers returned by `Find()`
// are no longer in use.
Status RemoveFunction(const string& func) TF_LOCKS_EXCLUDED(mu_);
Status RemoveFunction(const std::string& func) TF_LOCKS_EXCLUDED(mu_);
// Adds the functions and gradients in 'other' to this function library.
// Duplicate functions and gradients are ignored.
@ -417,7 +417,8 @@ class FunctionLibraryDefinition : public OpRegistryInterface {
// If the gradient function for 'func' is specified explicitly in
// the library, returns the gradient function name. Otherwise,
// returns an empty string.
string FindGradient(const string& func) const TF_LOCKS_EXCLUDED(mu_);
std::string FindGradient(const std::string& func) const
TF_LOCKS_EXCLUDED(mu_);
// OpRegistryInterface method. Useful for constructing a Graph.
//
@ -427,26 +428,27 @@ class FunctionLibraryDefinition : public OpRegistryInterface {
//
// NB: This function outputs a borrowed pointer, which can be invalidated by a
// subsequent call to `ReplaceFunction()` with the given name.
Status LookUp(const string& op_type_name,
Status LookUp(const std::string& op_type_name,
const OpRegistrationData** op_reg_data) const override
TF_LOCKS_EXCLUDED(mu_);
// Generates new function name with the specified prefix that is unique
// across this library.
string UniqueFunctionName(StringPiece prefix) const TF_LOCKS_EXCLUDED(mu_);
std::string UniqueFunctionName(StringPiece prefix) const
TF_LOCKS_EXCLUDED(mu_);
// Given a node def 'ndef', inspects attributes of the callee
// function to derive the attribute 'value' for 'attr'. Returns OK
// iff the attribute is given by the function's definition.
// TODO(irving): Remove; keep only the const Node& version.
template <typename T>
Status GetAttr(const NodeDef& ndef, const string& attr, T* value) const;
Status GetAttr(const NodeDef& ndef, const std::string& attr, T* value) const;
// Given a node, inspects attributes of the callee function to derive the
// attribute 'value' for 'attr'. Returns OK iff the attribute is given by the
// function's definition.
template <typename T>
Status GetAttr(const Node& node, const string& attr, T* value) const;
Status GetAttr(const Node& node, const std::string& attr, T* value) const;
// Returns a proto representation of the state of this function library.
FunctionDefLibrary ToProto() const TF_LOCKS_EXCLUDED(mu_);
@ -475,7 +477,7 @@ class FunctionLibraryDefinition : public OpRegistryInterface {
// name `func` already exists in this function library, and has the same
// implementation as in `other`. If the implementations conflict, an invalid
// argument error is returned.
Status CopyFunctionDefFrom(const string& func,
Status CopyFunctionDefFrom(const std::string& func,
const FunctionLibraryDefinition& other)
TF_LOCKS_EXCLUDED(mu_);
@ -491,7 +493,7 @@ class FunctionLibraryDefinition : public OpRegistryInterface {
std::shared_ptr<FunctionDefAndOpRegistration> FindHelper(
const string& func) const TF_SHARED_LOCKS_REQUIRED(mu_);
string FindGradientHelper(const string& func) const
std::string FindGradientHelper(const std::string& func) const
TF_SHARED_LOCKS_REQUIRED(mu_);
Status AddHelper(std::shared_ptr<FunctionDefAndOpRegistration> registration,
@ -518,12 +520,13 @@ class FunctionLibraryDefinition : public OpRegistryInterface {
// Remove `func` from the library. Returns non-OK Status unless `func` is in
// the library. This should only be called when there is a guarantee that the
// function being removed hasn't been retrieved with `Find`.
Status RemoveFunctionHelper(const string& func)
Status RemoveFunctionHelper(const std::string& func)
TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
// Remove gradient of function `func` from the library. Returns non-OK Status
// unless `func` has a gradient.
Status RemoveGradient(const string& func) TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
Status RemoveGradient(const std::string& func)
TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
mutable mutex mu_;
const OpRegistryInterface* const default_registry_;
@ -566,7 +569,7 @@ class FunctionLibraryRuntime {
// The canonical device name of the device on which the function
// should be instantiated. If empty, the function will be
// instantiated on the local device.
string target;
std::string target;
// Should the function be instantiated as a multi-device function?
bool is_multi_device_function = false;
@ -640,13 +643,13 @@ class FunctionLibraryRuntime {
// `state_handle` will have the same handle and share the same
// state (in stateful kernels); and two functions with different
// values for `state_handle` will have independent state.
string state_handle;
std::string state_handle;
// This interface is EXPERIMENTAL and subject to change.
//
// Instantiates the function using an executor of the given type. If empty,
// the default TensorFlow executor will be used.
string executor_type;
std::string executor_type;
// If true, the runtime will attempt to create kernels for the function at
// instantiation time, rather than on the first run. This can be used to
@ -680,10 +683,10 @@ class FunctionLibraryRuntime {
bool include_optimized_graph_in_debug_string = false;
};
typedef uint64 Handle;
virtual Status Instantiate(const string& function_name, AttrSlice attrs,
virtual Status Instantiate(const std::string& function_name, AttrSlice attrs,
const InstantiateOptions& options,
Handle* handle) = 0;
Status Instantiate(const string& function_name, AttrSlice attrs,
Status Instantiate(const std::string& function_name, AttrSlice attrs,
Handle* handle) {
auto opts = absl::make_unique<InstantiateOptions>();
return Instantiate(function_name, attrs, *opts, handle);
@ -738,7 +741,7 @@ class FunctionLibraryRuntime {
// Parameters for remote function execution.
bool remote_execution = false;
string source_device = ""; // Fully specified device name.
std::string source_device = ""; // Fully specified device name.
// Allocator attributes specifying where the args are / rets should be put.
// These should either be {} or match the length of args / retvals. If {},
@ -758,7 +761,7 @@ class FunctionLibraryRuntime {
bool run_all_kernels_inline = false;
// Returns a human readable representation of this.
string DebugString() const;
std::string DebugString() const;
};
typedef std::function<void(const Status&)> DoneCallback;
virtual void Run(const Options& opts, Handle handle,
@ -786,7 +789,7 @@ class FunctionLibraryRuntime {
// NOTE(mrry): This method assumes that the runtime is associated with a
// default function library, and looks up `function_name` in that library.
// It does not support overriding the function library.
virtual bool IsStateful(const string& function_name) const = 0;
virtual bool IsStateful(const std::string& function_name) const = 0;
// Returns the device on which the function executes.
virtual Device* device() = 0;
@ -817,7 +820,7 @@ class FunctionLibraryRuntime {
// Returns a debug string showing the definition of the function of
// 'handle'.
virtual string DebugString(Handle handle) = 0;
virtual std::string DebugString(Handle handle) = 0;
// Returns the graph version number.
virtual int graph_def_version() const = 0;
@ -847,13 +850,13 @@ class FunctionLibraryRuntime {
// `ExecutorFactory::GetFactory()`) that will be used based on the given
// dynamic `options` and static `attrs`. If none is specified, this method
// will return an empty string, which leaves the decision up to the runtime.
static string ExecutorType(const InstantiateOptions& options,
AttrSlice attrs);
static std::string ExecutorType(const InstantiateOptions& options,
AttrSlice attrs);
};
// Returns the device of the `arg_index`-th function input. Update
// `composite_devices` if the input device is a composite device.
string GetFunctionResourceInputDevice(
std::string GetFunctionResourceInputDevice(
const Tensor& input, const int arg_index, const FunctionDef& function_def,
absl::flat_hash_map<string, std::vector<string>>* composite_devices);
@ -864,9 +867,10 @@ string GetFunctionResourceInputDevice(
// space. But it may be change as the implementation
// evolves. Therefore, it should not be persisted or compared across
// address spaces.
string Canonicalize(const string& funcname, AttrSlice attrs,
const FunctionLibraryRuntime::InstantiateOptions& options);
string Canonicalize(const string& funcname, AttrSlice attrs);
std::string Canonicalize(
const std::string& funcname, AttrSlice attrs,
const FunctionLibraryRuntime::InstantiateOptions& options);
std::string Canonicalize(const std::string& funcname, AttrSlice attrs);
const FunctionLibraryRuntime::Handle kInvalidHandle = -1;
const FunctionLibraryRuntime::LocalHandle kInvalidLocalHandle = -1;
@ -907,8 +911,8 @@ class DistributedFunctionLibraryRuntime {
// local `handle` is filled for the instantiated function data and can be used
// for subsequent run function calls on the remote target.
virtual void Instantiate(
const string& function_name, const FunctionLibraryDefinition& lib_def,
AttrSlice attrs,
const std::string& function_name,
const FunctionLibraryDefinition& lib_def, AttrSlice attrs,
const FunctionLibraryRuntime::InstantiateOptions& options,
FunctionLibraryRuntime::LocalHandle* handle,
FunctionLibraryRuntime::DoneCallback done) = 0;
@ -1022,11 +1026,11 @@ Status ArgNumType(AttrSlice attrs, const OpDef::ArgDef& arg_def,
namespace gradient {
// Register a gradient creator for the "op".
typedef std::function<Status(const AttrSlice& attrs, FunctionDef*)> Creator;
bool RegisterOp(const string& op, Creator func);
bool RegisterOp(const std::string& op, Creator func);
// Returns OK the gradient creator for the "op" is found (may be
// nullptr if REGISTER_OP_NO_GRADIENT is used.
Status GetOpGradientCreator(const string& op, Creator* creator);
Status GetOpGradientCreator(const std::string& op, Creator* creator);
}; // namespace gradient
// Declare explicit instantiations of GetAttr

16
tensorflow/core/framework/log_memory.h
View File

@ -52,14 +52,14 @@ class LogMemory {
UNKNOWN_STEP_ID = -6,
};
static const string kLogMemoryLabel;
static const std::string kLogMemoryLabel;
// Test to see if memory logging is enabled. For now, logging is
// enabled whenever VLOG_IS_ON(1) for the log_memory module.
static bool IsEnabled();
// Log the beginning of a step.
static void RecordStep(int64 step_id, const string& handle);
static void RecordStep(int64 step_id, const std::string& handle);
// Log a tensor buffer allocation. The name indicates which kernel
// made the allocation. If the allocation is made through an
@ -67,8 +67,8 @@ class LogMemory {
// otherwise step_id is one of the SpecialStepIds defined in
// op_kernel.h, e.g. Op Kernel construction or an optimization pass
// such as constant folding.
static void RecordTensorAllocation(const string& kernel_name, int64 step_id,
const Tensor& tensor);
static void RecordTensorAllocation(const std::string& kernel_name,
int64 step_id, const Tensor& tensor);
// Log a tensor buffer deallocation. The deallocation is triggered
// when the buffer's refcount falls to zero, and the tracking
@ -77,10 +77,10 @@ class LogMemory {
// corresponding tensor previously passed in to
// RecordTensorAllocation.
static void RecordTensorDeallocation(int64 allocation_id,
const string& allocator_name);
const std::string& allocator_name);
// Log the use of a tensor as an output from a kernel.
static void RecordTensorOutput(const string& kernel_name, int64 step_id,
static void RecordTensorOutput(const std::string& kernel_name, int64 step_id,
int index, const Tensor& tensor);
// Log a "raw" allocation, which is just a buffer sized in
@ -92,7 +92,7 @@ class LogMemory {
// is executing, otherwise step_id is one of the SpecialStepIds
// defined in op_kernel.h, e.g. Op Kernel construction or an
// optimization pass such as constant folding.
static void RecordRawAllocation(const string& operation, int64 step_id,
static void RecordRawAllocation(const std::string& operation, int64 step_id,
size_t num_bytes, void* ptr,
Allocator* allocator);
@ -101,7 +101,7 @@ class LogMemory {
// enqueued using the buffer. A deferred deallocation should always
// be followed by a matching non-deferred deallocation when the
// buffer is actually returned and can be reused.
static void RecordRawDeallocation(const string& operation, int64 step_id,
static void RecordRawDeallocation(const std::string& operation, int64 step_id,
void* ptr, Allocator* allocator,
bool deferred);
};

29
tensorflow/core/framework/node_def_util.h
View File

@ -62,16 +62,16 @@ extern const char* const kColocationGroupPrefix;
// The parameter `max_inputs_in_summary` specifies how many inputs at most to
// serialize in the output (in order not to get a string which is overly large).
// The value `-1` specifies that all inputs will be shown.
string SummarizeNodeDef(const NodeDef& node_def,
int max_inputs_in_summary = -1);
string SummarizeAttrs(const NodeDef& node_def);
string SummarizeAttrsHelper(AttrSlice attrs, StringPiece device);
std::string SummarizeNodeDef(const NodeDef& node_def,
int max_inputs_in_summary = -1);
std::string SummarizeAttrs(const NodeDef& node_def);
std::string SummarizeAttrsHelper(AttrSlice attrs, StringPiece device);
// Produces a formatted string pattern from the node which can uniquely identify
// this node upstream to produce an informative error message. The pattern
// followed is: {{node <node_name>}}
string FormatNodeDefForError(const NodeDef& node_def);
string FormatNodeDefForError(
std::string FormatNodeDefForError(const NodeDef& node_def);
std::string FormatNodeDefForError(
StringPiece node_name, bool has_experimental_debug_info,
const NodeDef_ExperimentalDebugInfo& experimental_debug_info);
@ -148,7 +148,7 @@ class AttrSlice {
// Returns the attr with attr_name if found. Otherwise, returns
// nullptr.
const AttrValue* Find(StringPiece attr_name) const;
const AttrValue* FindByString(const string& attr_name) const;
const AttrValue* FindByString(const std::string& attr_name) const;
// Returns the attr_value for attr_name if found. Otherwise, returns a
// NotFound status.
@ -157,8 +157,8 @@ class AttrSlice {
// Helper class to avoid allocations in EqualAttrs.
// TODO(irving): Will go away once NodeInfo is used.
struct Scratch {
string a;
string b;
std::string a;
std::string b;
};
// Check if all attrs and attr values match. Does not take defaults into
@ -175,13 +175,13 @@ class AttrSlice {
// If this AttrSlice has an attached NodeDef, summarize it. This is for
// error messages only: we intentionally do not provide direct access to the
// NodeDef, since it is not always there.
string SummarizeNode() const;
std::string SummarizeNode() const;
// Iteration over all attrs
AttrValueMap::const_iterator begin() const { return attrs_->begin(); }
AttrValueMap::const_iterator end() const { return attrs_->end(); }
string DebugString() const;
std::string DebugString() const;
private:
const NodeDef* ndef_;
@ -195,7 +195,7 @@ bool HasNodeAttr(const NodeDef& node_def, StringPiece attr_name);
// attr with attr_name is found in node_def, or the attr does not have
// a matching type, a non-ok status will be returned.
Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
string* value); // type: "string"
std::string* value); // type: "string"
Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
tstring* value); // type: "tstring"
Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
@ -266,7 +266,7 @@ Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
// attr with attr_name is found in node_def, or the attr does not have
// a matching type, false is returned.
bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
string* value); // type: "string"
std::string* value); // type: "string"
bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
int64* value); // type: "int"
bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
@ -309,7 +309,8 @@ bool TryGetNodeAttr(
// If no attr with attr_name is found in node_def, or the attr does not have
// a matching type, a reference to an empty string is returned.
// REQUIRES: Must not use the returned value beyond the lifetime of node_def.
const string& GetNodeAttrString(const AttrSlice& attrs, StringPiece attr_name);
const std::string& GetNodeAttrString(const AttrSlice& attrs,
StringPiece attr_name);
// Specialization to parse an attribute directly into a Padding enum.
Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,

27
tensorflow/core/framework/op.h
View File

@ -45,11 +45,12 @@ class OpRegistryInterface {
// Returns an error status and sets *op_reg_data to nullptr if no OpDef is
// registered under that name, otherwise returns the registered OpDef.
// Caller must not delete the returned pointer.
virtual Status LookUp(const string& op_type_name,
virtual Status LookUp(const std::string& op_type_name,
const OpRegistrationData** op_reg_data) const = 0;
// Shorthand for calling LookUp to get the OpDef.
Status LookUpOpDef(const string& op_type_name, const OpDef** op_def) const;
Status LookUpOpDef(const std::string& op_type_name,
const OpDef** op_def) const;
};
// The standard implementation of OpRegistryInterface, along with a
@ -71,11 +72,11 @@ class OpRegistry : public OpRegistryInterface {
void Register(const OpRegistrationDataFactory& op_data_factory);
Status LookUp(const string& op_type_name,
Status LookUp(const std::string& op_type_name,
const OpRegistrationData** op_reg_data) const override;
// Returns OpRegistrationData* of registered op type, else returns nullptr.
const OpRegistrationData* LookUp(const string& op_type_name) const;
const OpRegistrationData* LookUp(const std::string& op_type_name) const;
// Fills *ops with all registered OpDefs (except those with names
// starting with '_' if include_internal == false) sorted in
@ -84,7 +85,7 @@ class OpRegistry : public OpRegistryInterface {
// Returns ASCII-format OpList for all registered OpDefs (except
// those with names starting with '_' if include_internal == false).
string DebugString(bool include_internal) const;
std::string DebugString(bool include_internal) const;
// A singleton available at startup.
static OpRegistry* Global();
@ -153,7 +154,7 @@ class OpRegistry : public OpRegistryInterface {
Status RegisterAlreadyLocked(const OpRegistrationDataFactory& op_data_factory)
const TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
const OpRegistrationData* LookUpSlow(const string& op_type_name) const;
const OpRegistrationData* LookUpSlow(const std::string& op_type_name) const;
mutable mutex mu_;
// Functions in deferred_ may only be called with mu_ held.
@ -179,11 +180,11 @@ class OpListOpRegistry : public OpRegistryInterface {
// Does not take ownership of op_list, *op_list must outlive *this.
explicit OpListOpRegistry(const OpList* op_list);
~OpListOpRegistry() override;
Status LookUp(const string& op_type_name,
Status LookUp(const std::string& op_type_name,
const OpRegistrationData** op_reg_data) const override;
// Returns OpRegistrationData* of op type in list, else returns nullptr.
const OpRegistrationData* LookUp(const string& op_type_name) const;
const OpRegistrationData* LookUp(const std::string& op_type_name) const;
private:
// Values are owned.
@ -225,15 +226,15 @@ template <>
class OpDefBuilderWrapper<true> {
public:
explicit OpDefBuilderWrapper(const char name[]) : builder_(name) {}
OpDefBuilderWrapper<true>& Attr(string spec) {
OpDefBuilderWrapper<true>& Attr(std::string spec) {
builder_.Attr(std::move(spec));
return *this;
}
OpDefBuilderWrapper<true>& Input(string spec) {
OpDefBuilderWrapper<true>& Input(std::string spec) {
builder_.Input(std::move(spec));
return *this;
}
OpDefBuilderWrapper<true>& Output(string spec) {
OpDefBuilderWrapper<true>& Output(std::string spec) {
builder_.Output(std::move(spec));
return *this;
}
@ -259,11 +260,11 @@ class OpDefBuilderWrapper<true> {
builder_.SetAllowsUninitializedInput();
return *this;
}
OpDefBuilderWrapper<true>& Deprecated(int version, string explanation) {
OpDefBuilderWrapper<true>& Deprecated(int version, std::string explanation) {
builder_.Deprecated(version, std::move(explanation));
return *this;
}
OpDefBuilderWrapper<true>& Doc(string text) {
OpDefBuilderWrapper<true>& Doc(std::string text) {
builder_.Doc(std::move(text));
return *this;
}

16
tensorflow/core/framework/op_def_builder.h
View File

@ -53,7 +53,7 @@ struct OpRegistrationData {
class OpDefBuilder {
public:
// Constructs an OpDef with just the name field set.
explicit OpDefBuilder(string op_name);
explicit OpDefBuilder(std::string op_name);
// Adds an attr to this OpDefBuilder (and returns *this). The spec has
// format "<name>:<type>" or "<name>:<type>=<default>"
@ -86,7 +86,7 @@ class OpDefBuilder {
// * Ability to restrict the type of the tensor like the existing
// restrictions for type attrs.
// Perhaps by linking the type of the tensor to a type attr?
OpDefBuilder& Attr(string spec);
OpDefBuilder& Attr(std::string spec);
// Adds an input or output to this OpDefBuilder (and returns *this).
// The spec has form "<name>:<type-expr>" or "<name>:Ref(<type-expr>)"
@ -103,8 +103,8 @@ class OpDefBuilder {
// in the spec?
// TODO(josh11b): SparseInput() and SparseOutput() matching the Python
// handling?
OpDefBuilder& Input(string spec);
OpDefBuilder& Output(string spec);
OpDefBuilder& Input(std::string spec);
OpDefBuilder& Output(std::string spec);
// Turns on the indicated boolean flag in this OpDefBuilder (and
// returns *this).
@ -114,7 +114,7 @@ class OpDefBuilder {
OpDefBuilder& SetAllowsUninitializedInput();
// Deprecate the op at a certain GraphDef version.
OpDefBuilder& Deprecated(int version, string explanation);
OpDefBuilder& Deprecated(int version, std::string explanation);
// Adds docs to this OpDefBuilder (and returns *this).
// Docs have the format:
@ -130,7 +130,7 @@ class OpDefBuilder {
// to suppress the automatically-generated type documentation in
// generated output.
#ifndef TF_LEAN_BINARY
OpDefBuilder& Doc(string text);
OpDefBuilder& Doc(std::string text);
#else
OpDefBuilder& Doc(string text) { return *this; }
#endif
@ -157,7 +157,7 @@ class OpDefBuilder {
// Adds control output to this OpDefBuilder (and returns *this).
// The <name> must be a valid node name (matches regexp
// [a-zA-Z][a-zA-Z0-9_]*). Named control output can only exist for functions.
OpDefBuilder& ControlOutput(string name);
OpDefBuilder& ControlOutput(std::string name);
OpDef* op_def() { return &op_reg_data_.op_def; }
@ -166,7 +166,7 @@ class OpDefBuilder {
std::vector<string> inputs_;
std::vector<string> outputs_;
std::vector<string> control_outputs_;
string doc_;
std::string doc_;
std::vector<string> errors_;
};

2
tensorflow/core/framework/op_def_util.h
View File

@ -54,7 +54,7 @@ const ApiDef::Arg* FindInputArg(StringPiece name, const ApiDef& api_def);
// Produce a human-readable version of an op_def that is more concise
// than a text-format proto. Excludes descriptions.
string SummarizeOpDef(const OpDef& op_def);
std::string SummarizeOpDef(const OpDef& op_def);
// Returns an error if new_op is not backwards-compatible with (more
// accepting than) old_op.

29
tensorflow/core/framework/op_kernel.h
View File

@ -145,14 +145,16 @@ class OpKernel {
// Accessors.
const NodeDef& def() const { return props_->node_def; }
const string& name() const { return props_->node_def.name(); }
const std::string& name() const { return props_->node_def.name(); }
absl::string_view name_view() const { return name_view_; }
const string& type_string() const { return props_->node_def.op(); }
const std::string& type_string() const { return props_->node_def.op(); }
absl::string_view type_string_view() const { return type_string_view_; }
const string& requested_input(int i) const {
const std::string& requested_input(int i) const {
return props_->node_def.input(i);
}
const string& requested_device() const { return props_->node_def.device(); }
const std::string& requested_device() const {
return props_->node_def.device();
}
int num_inputs() const { return props_->input_types.size(); }
DataType input_type(int i) const { return props_->input_types[i]; }
@ -177,10 +179,11 @@ class OpKernel {
// Returns a trace string for current computation, op name/type and input
// tensor shape/dtype are encoded for profiler cost analysis. Most OpKernel
// should use the default implementation.
virtual string TraceString(const OpKernelContext& ctx, bool verbose) const;
virtual std::string TraceString(const OpKernelContext& ctx,
bool verbose) const;
protected:
string ShapeTraceString(const OpKernelContext& ctx) const;
std::string ShapeTraceString(const OpKernelContext& ctx) const;
private:
const std::shared_ptr<const NodeProperties> props_;
@ -652,7 +655,7 @@ class OpKernelContext {
SessionState* session_state = nullptr;
// Unique session identifier. Can be empty.
string session_handle;
std::string session_handle;
// Metadata about the session. Can be nullptr.
const SessionMetadata* session_metadata = nullptr;
@ -684,7 +687,7 @@ class OpKernelContext {
StepStatsCollectorInterface* stats_collector = nullptr;
GraphCollector* graph_collector = nullptr;
bool run_all_kernels_inline = false;
const string* executor_type = nullptr;
const std::string* executor_type = nullptr;
// TensorSliceReaderCache support.
checkpoint::TensorSliceReaderCacheWrapper* slice_reader_cache = nullptr;
@ -826,7 +829,7 @@ class OpKernelContext {
// Returns the registered name for the executor type that is executing the
// current kernel. If empty, the default executor is used.
const string& executor_type() const;
const std::string& executor_type() const;
// Input to output forwarding.
@ -1100,7 +1103,7 @@ class OpKernelContext {
SessionState* session_state() const { return params_->session_state; }
// Unique identifier of the session it belongs to. Can be empty.
string session_handle() const { return params_->session_handle; }
std::string session_handle() const { return params_->session_handle; }
// Metadata about the session. Can be nullptr.
const SessionMetadata* session_metadata() const {
@ -1405,7 +1408,7 @@ Status SupportedDeviceTypesForNode(
// Returns a message with a description of the kernels registered for op
// `op_name`.
string KernelsRegisteredForOp(StringPiece op_name);
std::string KernelsRegisteredForOp(StringPiece op_name);
// Call once after Op registration has completed.
Status ValidateKernelRegistrations(const OpRegistryInterface& op_registry);
@ -1497,13 +1500,13 @@ Status FindKernelDef(
bool has_experimental_debug_info,
const NodeDef_ExperimentalDebugInfo& experimental_debug_info,
StringPiece node_op, StringPiece node_device, AttrSlice node_attrs,
const KernelDef** def, string* kernel_class_name);
const KernelDef** def, std::string* kernel_class_name);
// If node_def has a corresponding kernel registered on device_type,
// returns OK and fill in the kernel def and kernel_class_name. <def> and
// <kernel_class_name> may be null.
Status FindKernelDef(const DeviceType& device_type, const NodeDef& node_def,
const KernelDef** def, string* kernel_class_name);
const KernelDef** def, std::string* kernel_class_name);
// Writes a list of all registered kernels to LOG(INFO), to help users debug
// missing kernel errors.

11
tensorflow/core/framework/op_segment.h
View File

@ -46,8 +46,8 @@ class OpSegment {
// A hold can be placed on a session, preventing all its kernels
// from being deleted.
void AddHold(const string& session_handle);
void RemoveHold(const string& session_handle);
void AddHold(const std::string& session_handle);
void RemoveHold(const std::string& session_handle);
// If the kernel for "node_name" has been created in the
// "session_handle", returns the existing op kernel in "*kernel".
@ -57,12 +57,13 @@ class OpSegment {
//
// OpSegment keeps the ownership of the returned "*kernel".
typedef std::function<Status(OpKernel**)> CreateKernelFn;
Status FindOrCreate(const string& session_handle, const string& node_name,
OpKernel** kernel, CreateKernelFn create_fn);
Status FindOrCreate(const std::string& session_handle,
const std::string& node_name, OpKernel** kernel,
CreateKernelFn create_fn);
// Returns true if OpSegment should own the kernel.
static bool ShouldOwnKernel(FunctionLibraryRuntime* lib,
const string& node_op);
const std::string& node_op);
private:
// op name -> OpKernel

2
tensorflow/core/framework/ops_util.h
View File

@ -81,7 +81,7 @@ bool IsDim0SliceAligned(const TensorShape& s, int64 start, int64 end_or_size) {
}
// Returns <suffix> sanitized to have only [a-zA-Z0-9-_].
string SanitizeThreadSuffix(string suffix);
std::string SanitizeThreadSuffix(std::string suffix);
// Helper to compute 'strides' given a tensor 'shape'. I.e.,
// strides[i] = prod(shape.dim_size[(i+1):])

10
tensorflow/core/framework/rendezvous.h
View File

@ -74,7 +74,7 @@ class RendezvousInterface {
friend class Rendezvous;
friend class SendOp;
friend class RecvOp;
string buf_;
std::string buf_;
};
// The caller is a tensor producer and it sends a message (a tensor
@ -169,9 +169,11 @@ class Rendezvous : public RendezvousInterface, public core::RefCounted {
// Constructs a rendezvous key for the tensor of "name" sent from
// "src_device" to "dst_device". The tensor is generated in the frame
// and iteration specified by "frame_iter".
static string CreateKey(const string& src_device, uint64 src_incarnation,
const string& dst_device, const string& name,
const FrameAndIter& frame_iter);
static std::string CreateKey(const std::string& src_device,
uint64 src_incarnation,
const std::string& dst_device,
const std::string& name,
const FrameAndIter& frame_iter);
static Status ParseKey(StringPiece key, ParsedKey* out);
};

126
tensorflow/core/framework/resource_mgr.h
View File

@ -79,7 +79,7 @@ namespace tensorflow {
class ResourceBase : public core::RefCounted {
public:
// Returns a debug string for *this.
virtual string DebugString() const = 0;
virtual std::string DebugString() const = 0;
// Returns memory used by this resource.
virtual int64 MemoryUsed() const { return 0; }
@ -100,7 +100,7 @@ class ScopedStepContainer {
ScopedStepContainer(const int64 step_id,
std::function<void(const string&)> cleanup,
const string& prefix)
const std::string& prefix)
: container_(strings::StrCat("__", prefix, "_per_step_", step_id)),
cleanup_(cleanup),
dirty_(false) {}
@ -125,25 +125,25 @@ class ScopedStepContainer {
// Pass through to MakeResourceHandle with the container name
template <typename T>
ResourceHandle MakeResourceHandle(
const string& name, const DeviceBase& device) TF_MUST_USE_RESULT;
const std::string& name, const DeviceBase& device) TF_MUST_USE_RESULT;
// Pass through to ResourceMgr::Create with the container name
template <typename T>
Status Create(ResourceMgr* rm, const string& name,
Status Create(ResourceMgr* rm, const std::string& name,
T* resource) TF_MUST_USE_RESULT;
// Pass through to ResourceMgr::Delete with the container name
template <typename T>
Status Delete(ResourceMgr* rm, const string& name) TF_MUST_USE_RESULT;
Status Delete(ResourceMgr* rm, const std::string& name) TF_MUST_USE_RESULT;
// Pass through to ResourceMgr::Lookup with the container name
template <typename T>
Status Lookup(ResourceMgr* rm, const string& name,
Status Lookup(ResourceMgr* rm, const std::string& name,
T** resource) const TF_MUST_USE_RESULT;
// Pass through to ResourceMgr::LookupOrCreate with the container name
template <typename T>
Status LookupOrCreate(ResourceMgr* rm, const string& name, T** resource,
Status LookupOrCreate(ResourceMgr* rm, const std::string& name, T** resource,
std::function<Status(T**)> creator) TF_MUST_USE_RESULT;
private:
const string container_;
const std::string container_;
const std::function<void(const string&)> cleanup_;
mutex mu_;
mutable std::atomic<bool> dirty_ TF_GUARDED_BY(mu_);
@ -152,11 +152,11 @@ class ScopedStepContainer {
class ResourceMgr {
public:
ResourceMgr();
explicit ResourceMgr(const string& default_container);
explicit ResourceMgr(const std::string& default_container);
~ResourceMgr();
// Returns the default container name for *this.
const string& default_container() const { return default_container_; }
const std::string& default_container() const { return default_container_; }
// Creates a resource "name" in the "container". The caller transfers
// the ownership of one ref on "resource" to *this, regardless of whether this
@ -165,7 +165,7 @@ class ResourceMgr {
// REQUIRES: std::is_base_of<ResourceBase, T>
// REQUIRES: resource != nullptr.
template <typename T>
Status Create(const string& container, const string& name,
Status Create(const std::string& container, const std::string& name,
T* resource) TF_MUST_USE_RESULT;
// If "container" has a resource "name", returns it in "*resource" and
@ -174,7 +174,7 @@ class ResourceMgr {
// REQUIRES: std::is_base_of<ResourceBase, T>
// REQUIRES: resource != nullptr
template <typename T, bool use_dynamic_cast = false>
Status Lookup(const string& container, const string& name,
Status Lookup(const std::string& container, const std::string& name,
T** resource) const TF_MUST_USE_RESULT;
// Similar to Lookup, but looks up multiple resources at once, with only a
@ -197,7 +197,7 @@ class ResourceMgr {
// REQUIRES: std::is_base_of<ResourceBase, T>
// REQUIRES: resource != nullptr
template <typename T, bool use_dynamic_cast = false>
Status LookupOrCreate(const string& container, const string& name,
Status LookupOrCreate(const std::string& container, const std::string& name,
T** resource,
std::function<Status(T**)> creator) TF_MUST_USE_RESULT;
@ -205,19 +205,20 @@ class ResourceMgr {
//
// REQUIRES: std::is_base_of<ResourceBase, T>
template <typename T>
Status Delete(const string& container, const string& name) TF_MUST_USE_RESULT;
Status Delete(const std::string& container,
const std::string& name) TF_MUST_USE_RESULT;
// Deletes the resource pointed by "handle".
Status Delete(const ResourceHandle& handle) TF_MUST_USE_RESULT;
// Deletes all resources from the "container" and removes the container.
Status Cleanup(const string& container) TF_MUST_USE_RESULT;
Status Cleanup(const std::string& container) TF_MUST_USE_RESULT;
// Deletes all resources in all containers.
void Clear();
// Returns a text description for all resources.
string DebugString() const;
std::string DebugString() const;
private:
typedef std::pair<uint64, StringPiece> Key;
@ -236,7 +237,7 @@ class ResourceMgr {
std::unique_ptr<string> name;
ResourceAndName();
ResourceAndName(ResourceBase* resource, string name);
ResourceAndName(ResourceBase* resource, std::string name);
ResourceAndName(ResourceAndName&& other) noexcept;
~ResourceAndName();
@ -247,31 +248,31 @@ class ResourceMgr {
};
typedef std::unordered_map<Key, ResourceAndName, KeyHash, KeyEqual> Container;
const string default_container_;
const std::string default_container_;
mutable mutex mu_;
std::unordered_map<string, Container*> containers_ TF_GUARDED_BY(mu_);
template <typename T, bool use_dynamic_cast = false>
Status LookupInternal(const string& container, const string& name,
Status LookupInternal(const std::string& container, const std::string& name,
T** resource) const
TF_SHARED_LOCKS_REQUIRED(mu_) TF_MUST_USE_RESULT;
Status DoCreate(const string& container, TypeIndex type, const string& name,
ResourceBase* resource)
Status DoCreate(const std::string& container, TypeIndex type,
const std::string& name, ResourceBase* resource)
TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) TF_MUST_USE_RESULT;
Status DoLookup(const string& container, TypeIndex type, const string& name,
ResourceBase** resource) const
Status DoLookup(const std::string& container, TypeIndex type,
const std::string& name, ResourceBase** resource) const
TF_SHARED_LOCKS_REQUIRED(mu_) TF_MUST_USE_RESULT;
Status DoDelete(const string& container, uint64 type_hash_code,
const string& resource_name,
const string& type_name) TF_MUST_USE_RESULT;
Status DoDelete(const string& container, TypeIndex type,
const string& resource_name) TF_MUST_USE_RESULT;
Status DoDelete(const std::string& container, uint64 type_hash_code,
const std::string& resource_name,
const std::string& type_name) TF_MUST_USE_RESULT;
Status DoDelete(const std::string& container, TypeIndex type,
const std::string& resource_name) TF_MUST_USE_RESULT;
// Inserts the type name for 'hash_code' into the hash_code to type name map.
Status InsertDebugTypeName(uint64 hash_code, const string& type_name)
Status InsertDebugTypeName(uint64 hash_code, const std::string& type_name)
TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) TF_MUST_USE_RESULT;
// Returns the type name for the 'hash_code'.
@ -289,14 +290,14 @@ class ResourceMgr {
// Makes a resource handle with the specified type for a given container /
// name.
ResourceHandle MakeResourceHandle(
const string& container, const string& name, const DeviceBase& device,
const TypeIndex& type_index,
const std::string& container, const std::string& name,
const DeviceBase& device, const TypeIndex& type_index,
const std::vector<DtypeAndPartialTensorShape>& dtypes_and_shapes = {})
TF_MUST_USE_RESULT;
template <typename T>
ResourceHandle MakeResourceHandle(
OpKernelContext* ctx, const string& container, const string& name,
OpKernelContext* ctx, const std::string& container, const std::string& name,
const std::vector<DtypeAndPartialTensorShape>& dtypes_and_shapes = {}) {
return MakeResourceHandle(
container.empty() ? ctx->resource_manager()->default_container()
@ -306,7 +307,8 @@ ResourceHandle MakeResourceHandle(
template <typename T>
ResourceHandle MakeResourceHandle(
OpKernelConstruction* ctx, const string& container, const string& name,
OpKernelConstruction* ctx, const std::string& container,
const std::string& name,
const std::vector<DtypeAndPartialTensorShape>& dtypes_and_shapes = {}) {
return MakeResourceHandle(
container.empty() ? ctx->resource_manager()->default_container()
@ -315,7 +317,8 @@ ResourceHandle MakeResourceHandle(
}
Status MakeResourceHandleToOutput(OpKernelContext* context, int output_index,
const string& container, const string& name,
const std::string& container,
const std::string& name,
const TypeIndex& type_index);
// Returns a resource handle from a numbered op input.
@ -409,19 +412,19 @@ class ContainerInfo {
// name is name(). If resource_is_private_to_kernel() is true, the
// kernel should delete the resource when the kernel is deleted.
ResourceMgr* resource_manager() const { return rmgr_; }
const string& container() const { return container_; }
const string& name() const { return name_; }
const std::string& container() const { return container_; }
const std::string& name() const { return name_; }
bool resource_is_private_to_kernel() const {
return resource_is_private_to_kernel_;
}
// Returns a readable string for *this.
string DebugString() const;
std::string DebugString() const;
private:
ResourceMgr* rmgr_ = nullptr;
string container_;
string name_;
std::string container_;
std::string name_;
bool resource_is_private_to_kernel_ = false;
};
@ -435,8 +438,8 @@ class ContainerInfo {
// Returns OK if the resource is found and transfers one ref of
// *resource to the caller. Otherwise, returns an error.
template <typename T>
Status GetResourceFromContext(OpKernelContext* ctx, const string& input_name,
T** resource);
Status GetResourceFromContext(OpKernelContext* ctx,
const std::string& input_name, T** resource);
// Utility op kernel to check if a handle to resource type T is initialized.
template <typename T>
@ -470,8 +473,8 @@ class ResourceHandleOp : public OpKernel {
bool IsExpensive() override { return false; }
private:
string container_;
string name_;
std::string container_;
std::string name_;
mutex mutex_;
Tensor resource_;
std::atomic<bool> initialized_{false};
@ -584,8 +587,8 @@ void CheckDeriveFromResourceBase() {
}
template <typename T>
Status ResourceMgr::Create(const string& container, const string& name,
T* resource) {
Status ResourceMgr::Create(const std::string& container,
const std::string& name, T* resource) {
CheckDeriveFromResourceBase<T>();
CHECK(resource != nullptr);
mutex_lock l(mu_);
@ -593,8 +596,8 @@ Status ResourceMgr::Create(const string& container, const string& name,
}
template <typename T, bool use_dynamic_cast>
Status ResourceMgr::Lookup(const string& container, const string& name,
T** resource) const {
Status ResourceMgr::Lookup(const std::string& container,
const std::string& name, T** resource) const {
CheckDeriveFromResourceBase<T>();
tf_shared_lock l(mu_);
return LookupInternal<T, use_dynamic_cast>(container, name, resource);
@ -632,7 +635,8 @@ struct TypeCastFunctor<T, true> {
};
template <typename T, bool use_dynamic_cast>
Status ResourceMgr::LookupInternal(const string& container, const string& name,
Status ResourceMgr::LookupInternal(const std::string& container,
const std::string& name,
T** resource) const {
ResourceBase* found = nullptr;
Status s = DoLookup(container, TypeIndex::Make<T>(), name, &found);
@ -645,8 +649,8 @@ Status ResourceMgr::LookupInternal(const string& container, const string& name,
}
template <typename T, bool use_dynamic_cast>
Status ResourceMgr::LookupOrCreate(const string& container, const string& name,
T** resource,
Status ResourceMgr::LookupOrCreate(const std::string& container,
const std::string& name, T** resource,
std::function<Status(T**)> creator) {
CheckDeriveFromResourceBase<T>();
*resource = nullptr;
@ -669,14 +673,15 @@ Status ResourceMgr::LookupOrCreate(const string& container, const string& name,
}
template <typename T>
Status ResourceMgr::Delete(const string& container, const string& name) {
Status ResourceMgr::Delete(const std::string& container,
const std::string& name) {
CheckDeriveFromResourceBase<T>();
return DoDelete(container, TypeIndex::Make<T>(), name);
}
template <typename T>
Status GetResourceFromContext(OpKernelContext* ctx, const string& input_name,
T** resource) {
Status GetResourceFromContext(OpKernelContext* ctx,
const std::string& input_name, T** resource) {
DataType dtype;
TF_RETURN_IF_ERROR(ctx->input_dtype(input_name, &dtype));
if (dtype == DT_RESOURCE) {
@ -684,8 +689,8 @@ Status GetResourceFromContext(OpKernelContext* ctx, const string& input_name,
TF_RETURN_IF_ERROR(ctx->input(input_name, &handle));
return LookupResource(ctx, handle->scalar<ResourceHandle>()(), resource);
}
string container;
string shared_name;
std::string container;
std::string shared_name;
{
mutex* mu;
TF_RETURN_IF_ERROR(ctx->input_ref_mutex(input_name, &mu));
@ -879,7 +884,7 @@ void ResourceHandlesOp<T>::Compute(OpKernelContext* ctx) {
template <typename T>
ResourceHandle ScopedStepContainer::MakeResourceHandle(
const string& name, const DeviceBase& device) {
const std::string& name, const DeviceBase& device) {
mutex_lock ml(mu_);
dirty_ = true;
return tensorflow::MakeResourceHandle(container_, name, device,
@ -887,13 +892,14 @@ ResourceHandle ScopedStepContainer::MakeResourceHandle(
}
template <typename T>
Status ScopedStepContainer::Lookup(ResourceMgr* rm, const string& name,
Status ScopedStepContainer::Lookup(ResourceMgr* rm, const std::string& name,
T** resource) const {
return rm->Lookup<T>(container_, name, resource);
}
template <typename T>
Status ScopedStepContainer::LookupOrCreate(ResourceMgr* rm, const string& name,
Status ScopedStepContainer::LookupOrCreate(ResourceMgr* rm,
const std::string& name,
T** resource,
std::function<Status(T**)> creator) {
mutex_lock ml(mu_);
@ -902,7 +908,7 @@ Status ScopedStepContainer::LookupOrCreate(ResourceMgr* rm, const string& name,
}
template <typename T>
Status ScopedStepContainer::Create(ResourceMgr* rm, const string& name,
Status ScopedStepContainer::Create(ResourceMgr* rm, const std::string& name,
T* resource) {
mutex_lock ml(mu_);
dirty_ = true;
@ -910,7 +916,7 @@ Status ScopedStepContainer::Create(ResourceMgr* rm, const string& name,
}
template <typename T>
Status ScopedStepContainer::Delete(ResourceMgr* rm, const string& name) {
Status ScopedStepContainer::Delete(ResourceMgr* rm, const std::string& name) {
return rm->Delete<T>(container_, name);
}

2
tensorflow/core/framework/resource_var.h
View File

@ -67,7 +67,7 @@ class Var : public ResourceBase {
mutex* mu() { return &mu_; }
Tensor* tensor() { return &tensor_; }
string DebugString() const override {
std::string DebugString() const override {
return strings::StrCat(DataTypeString(tensor_.dtype()), "/",
tensor_.shape().DebugString());
}

12
tensorflow/core/framework/session_state.h
View File

@ -31,13 +31,13 @@ namespace tensorflow {
class SessionState {
public:
// Get a tensor from the session state.
Status GetTensor(const string& handle, Tensor* tensor);
Status GetTensor(const std::string& handle, Tensor* tensor);
// Store a tensor in the session state.
Status AddTensor(const string& handle, const Tensor& tensor);
Status AddTensor(const std::string& handle, const Tensor& tensor);
// Delete a tensor from the session state.
Status DeleteTensor(const string& handle);
Status DeleteTensor(const std::string& handle);
int64 GetNewId();
@ -60,15 +60,15 @@ class TensorStore {
struct TensorAndKey {
Tensor tensor;
int64 id;
string device_name;
std::string device_name;
string GetHandle(const string& tensor_name) {
std::string GetHandle(const std::string& tensor_name) {
return strings::StrCat(tensor_name, ";", id, ";", device_name);
}
};
// Add the named tensor to the tensor store for this run.
Status AddTensor(const string& name, const TensorAndKey& tk);
Status AddTensor(const std::string& name, const TensorAndKey& tk);
// Save the tensors in the tensor store of this run to the session.
Status SaveTensors(const std::vector<string>& output_names,

10
tensorflow/core/framework/shape_inference.h
View File

@ -344,13 +344,13 @@ class InferenceContext {
// incomplete shape.
DimensionHandle NumElements(ShapeHandle s);
string DebugString(ShapeHandle s);
string DebugString(DimensionHandle d);
string DebugString(const ShapeAndType& shape_and_type);
string DebugString(gtl::ArraySlice<ShapeAndType> shape_and_types);
std::string DebugString(ShapeHandle s);
std::string DebugString(DimensionHandle d);
std::string DebugString(const ShapeAndType& shape_and_type);
std::string DebugString(gtl::ArraySlice<ShapeAndType> shape_and_types);
// Describes the whole context, for debugging purposes.
string DebugString() const;
std::string DebugString() const;
// If <shape> has rank <rank>, or its rank is unknown, return OK and return
// the shape with asserted rank in <*out>. Otherwise return an error.

2
tensorflow/core/framework/tracking_allocator.h
View File

@ -54,7 +54,7 @@ struct AllocRecord {
class TrackingAllocator : public Allocator {
public:
explicit TrackingAllocator(Allocator* allocator, bool track_ids);
string Name() override { return allocator_->Name(); }
std::string Name() override { return allocator_->Name(); }
void* AllocateRaw(size_t alignment, size_t num_bytes) override {
return AllocateRaw(alignment, num_bytes, AllocationAttributes());
}

32
tensorflow/core/framework/variant.h
View File

@ -32,10 +32,10 @@ limitations under the License.
namespace tensorflow {
template <typename T>
string TypeNameVariant(const T& value);
std::string TypeNameVariant(const T& value);
template <typename T>
string DebugStringVariant(const T& value);
std::string DebugStringVariant(const T& value);
// Allows for specializations of Variant Decoding. `data` may be modified in
// the process of decoding to `value`.
@ -43,13 +43,13 @@ template <typename T>
bool DecodeVariant(VariantTensorData* data, T* value);
template <typename T>
bool DecodeVariant(string* buf, T* value);
bool DecodeVariant(std::string* buf, T* value);
template <typename T>
void EncodeVariant(const T& value, VariantTensorData* data);
template <typename T>
void EncodeVariant(const T& value, string* buf);
void EncodeVariant(const T& value, std::string* buf);
// This is an implementation of a type-erased container that can store an
// object of any type. The implementation is very similar to std::any, but has
@ -234,7 +234,7 @@ class Variant {
return GetValue()->TypeId();
}
string DebugString() const {
std::string DebugString() const {
return strings::StrCat(
"Variant<type: ", TypeName(),
" value: ", is_empty() ? "[empty]" : GetValue()->DebugString(), ">");
@ -264,7 +264,7 @@ class Variant {
// In the special case that a serialized Variant is stored (value
// is a VariantTensorDataProto), returns value.TypeName(), the
// TypeName field stored in the VariantTensorDataProto buffer.
string TypeName() const {
std::string TypeName() const {
if (is_empty()) {
return "";
}
@ -282,12 +282,12 @@ class Variant {
bool Decode(VariantTensorData data);
// Helper methods to directly serialize/deserialize from strings.
void Encode(string* buf) const {
void Encode(std::string* buf) const {
if (!is_empty()) {
GetValue()->Encode(buf);
}
}
bool Decode(string buf) {
bool Decode(std::string buf) {
if (!is_empty()) {
return GetValue()->Decode(std::move(buf));
}
@ -313,12 +313,12 @@ class Variant {
virtual void CloneInto(ValueInterface* memory) const = 0;
virtual void MoveAssign(ValueInterface* memory) = 0;
virtual void MoveInto(ValueInterface* memory) = 0;
virtual string TypeName() const = 0;
virtual string DebugString() const = 0;
virtual std::string TypeName() const = 0;
virtual std::string DebugString() const = 0;
virtual void Encode(VariantTensorData* data) const = 0;
virtual bool Decode(VariantTensorData data) = 0;
virtual void Encode(string* buf) const = 0;
virtual bool Decode(string data) = 0;
virtual void Encode(std::string* buf) const = 0;
virtual bool Decode(std::string data) = 0;
};
template <typename T>
@ -359,9 +359,9 @@ class Variant {
new (memory) Value(InPlace(), std::move(value));
}
string TypeName() const final { return TypeNameVariant(value); }
std::string TypeName() const final { return TypeNameVariant(value); }
string DebugString() const final { return DebugStringVariant(value); }
std::string DebugString() const final { return DebugStringVariant(value); }
void Encode(VariantTensorData* data) const final {
EncodeVariant(value, data);
@ -371,9 +371,9 @@ class Variant {
return DecodeVariant(&data, &value);
}
void Encode(string* buf) const final { EncodeVariant(value, buf); }
void Encode(std::string* buf) const final { EncodeVariant(value, buf); }
bool Decode(string buf) final { return DecodeVariant(&buf, &value); }
bool Decode(std::string buf) final { return DecodeVariant(&buf, &value); }
T value;
};

32
tensorflow/core/framework/variant_encode_decode.h
View File

@ -105,7 +105,7 @@ bool DecodeVariantImpl(VariantTensorData data,
TypeResolver<T, false /* is_pod */, false /* Tensor */,
true /* protobuf */>,
T* value) {
string metadata;
std::string metadata;
data.get_metadata(&metadata);
return value->ParseFromString(std::move(metadata));
}
@ -136,27 +136,27 @@ template <typename T, bool = has_type_name<typename std::decay<T>::type>::value,
struct TypeNameResolver {};
template <typename T>
string TypeNameVariantImpl(const T& value,
TypeNameResolver<T, true /* has_type_name */>) {
std::string TypeNameVariantImpl(const T& value,
TypeNameResolver<T, true /* has_type_name */>) {
return value.TypeName();
}
template <typename T>
string TypeNameVariantImpl(
std::string TypeNameVariantImpl(
const T& value,
TypeNameResolver<T, false /* has_type_name */, true /* Tensor */>) {
return "tensorflow::Tensor";
}
template <typename T>
string TypeNameVariantImpl(
std::string TypeNameVariantImpl(
const T& value, TypeNameResolver<T, false /* has_type_name */,
false /* Tensor */, true /* protobuf */>) {
return value.GetTypeName();
}
template <typename T>
string TypeNameVariantImpl(
std::string TypeNameVariantImpl(
const T& value,
TypeNameResolver<T, false /* has_type_name */, false /* Tensor */,
false /* protobuf */>) {
@ -164,7 +164,7 @@ string TypeNameVariantImpl(
}
template <typename T>
string TypeNameVariant(const T& value) {
std::string TypeNameVariant(const T& value) {
return TypeNameVariantImpl(value, TypeNameResolver<T>());
}
@ -194,27 +194,27 @@ struct DebugStringResolver {};
// TODO(ebrevdo): Expand DebugStringResolver to return TypeString if
// there is no StrCat<T>() constructor.
template <typename T>
string DebugStringVariantImpl(
std::string DebugStringVariantImpl(
const T& value, DebugStringResolver<T, true /* has_debug_string */>) {
return value.DebugString();
}
template <typename T>
string DebugStringVariantImpl(
std::string DebugStringVariantImpl(
const T& value, DebugStringResolver<T, false /* has_debug_string */,
true /* can_strcat */>) {
return strings::StrCat(value);
}
template <typename T>
string DebugStringVariantImpl(
std::string DebugStringVariantImpl(
const T& value, DebugStringResolver<T, false /* has_debug_string */,
false /* can_strcat */>) {
return "?";
}
template <typename T>
string DebugStringVariant(const T& value) {
std::string DebugStringVariant(const T& value) {
return DebugStringVariantImpl(value, DebugStringResolver<T>());
}
@ -230,7 +230,7 @@ bool DecodeVariant(VariantTensorData* data, T* value) {
}
template <typename T>
void EncodeVariant(const T& value, string* buf) {
void EncodeVariant(const T& value, std::string* buf) {
VariantTensorData data;
EncodeVariantImpl(value, TypeResolver<T>(), &data);
data.set_type_name(TypeNameVariant(value));
@ -239,7 +239,7 @@ void EncodeVariant(const T& value, string* buf) {
}
template <typename T>
bool DecodeVariant(string* buf, T* value) {
bool DecodeVariant(std::string* buf, T* value) {
VariantTensorData data;
if (!data.ParseFromString(*buf)) return false;
if (!DecodeVariantImpl(std::move(data), TypeResolver<T>(), value)) {
@ -250,7 +250,7 @@ bool DecodeVariant(string* buf, T* value) {
// Specializations for VariantTensorDataProto
template <>
string TypeNameVariant(const VariantTensorDataProto& value);
std::string TypeNameVariant(const VariantTensorDataProto& value);
template <>
void EncodeVariant(const VariantTensorDataProto& value,
@ -260,10 +260,10 @@ template <>
bool DecodeVariant(VariantTensorData* data, VariantTensorDataProto* value);
template <>
void EncodeVariant(const VariantTensorDataProto& value, string* buf);
void EncodeVariant(const VariantTensorDataProto& value, std::string* buf);
template <>
bool DecodeVariant(string* buf, VariantTensorDataProto* value);
bool DecodeVariant(std::string* buf, VariantTensorDataProto* value);
// Encodes an array of Variant objects in to the given StringListEncoder.
// `variant_array` is assumed to point to an array of `n` Variant objects.

28
tensorflow/core/framework/variant_op_registry.h
View File

@ -93,7 +93,7 @@ class UnaryVariantOpRegistry {
AsyncVariantDeviceCopyFn;
// Add a decode function to the registry.
void RegisterDecodeFn(const string& type_name,
void RegisterDecodeFn(const std::string& type_name,
const VariantDecodeFn& decode_fn);
// Returns nullptr if no decode function was found for the given TypeName.
@ -124,7 +124,7 @@ class UnaryVariantOpRegistry {
}
// Add a unary op function to the registry.
void RegisterUnaryOpFn(VariantUnaryOp op, const string& device,
void RegisterUnaryOpFn(VariantUnaryOp op, const std::string& device,
const TypeIndex& type_index,
const VariantUnaryOpFn& unary_op_fn) {
VariantUnaryOpFn* existing = GetUnaryOpFn(op, device, type_index);
@ -146,7 +146,7 @@ class UnaryVariantOpRegistry {
}
// Add a binary op function to the registry.
void RegisterBinaryOpFn(VariantBinaryOp op, const string& device,
void RegisterBinaryOpFn(VariantBinaryOp op, const std::string& device,
const TypeIndex& type_index,
const VariantBinaryOpFn& add_fn) {
VariantBinaryOpFn* existing = GetBinaryOpFn(op, device, type_index);
@ -252,7 +252,7 @@ class UnaryVariantOpRegistry {
// Find or insert a string into a persistent string storage
// container; return the StringPiece pointing to the permanent string
// location.
static StringPiece GetPersistentStringPiece(const string& str) {
static StringPiece GetPersistentStringPiece(const std::string& str) {
const auto string_storage = PersistentStringStorage();
auto found = string_storage->find(str);
if (found == string_storage->end()) {
@ -307,7 +307,7 @@ Status VariantDeviceCopy(
template <typename Device>
Status UnaryOpVariant(OpKernelContext* ctx, VariantUnaryOp op, const Variant& v,
Variant* v_out) {
const string& device = DeviceName<Device>::value;
const std::string& device = DeviceName<Device>::value;
UnaryVariantOpRegistry::VariantUnaryOpFn* unary_op_fn =
UnaryVariantOpRegistry::Global()->GetUnaryOpFn(op, device, v.TypeId());
if (unary_op_fn == nullptr) {
@ -336,7 +336,7 @@ Status BinaryOpVariants(OpKernelContext* ctx, VariantBinaryOp op,
"type ids. Type names: '",
a.TypeName(), "' vs. '", b.TypeName(), "'");
}
const string& device = DeviceName<Device>::value;
const std::string& device = DeviceName<Device>::value;
UnaryVariantOpRegistry::VariantBinaryOpFn* binary_op_fn =
UnaryVariantOpRegistry::Global()->GetBinaryOpFn(op, device, a.TypeId());
if (binary_op_fn == nullptr) {
@ -354,7 +354,7 @@ namespace variant_op_registry_fn_registration {
template <typename T>
class UnaryVariantDecodeRegistration {
public:
UnaryVariantDecodeRegistration(const string& type_name) {
UnaryVariantDecodeRegistration(const std::string& type_name) {
// The Variant is passed by pointer because it should be
// mutable: get below may Decode the variant, which
// is a self-mutating behavior. The variant is not modified in
@ -386,7 +386,8 @@ class UnaryVariantDeviceCopyRegistration {
UnaryVariantDeviceCopyRegistration(
const VariantDeviceCopyDirection direction, const TypeIndex& type_index,
const LocalVariantDeviceCopyFn& device_copy_fn) {
const string type_index_name = port::MaybeAbiDemangle(type_index.name());
const std::string type_index_name =
port::MaybeAbiDemangle(type_index.name());
UnaryVariantOpRegistry::Global()->RegisterDeviceCopyFn(
direction, type_index,
[type_index_name, device_copy_fn](
@ -413,10 +414,11 @@ class UnaryVariantUnaryOpRegistration {
LocalVariantUnaryOpFn;
public:
UnaryVariantUnaryOpRegistration(VariantUnaryOp op, const string& device,
UnaryVariantUnaryOpRegistration(VariantUnaryOp op, const std::string& device,
const TypeIndex& type_index,
const LocalVariantUnaryOpFn& unary_op_fn) {
const string type_index_name = port::MaybeAbiDemangle(type_index.name());
const std::string type_index_name =
port::MaybeAbiDemangle(type_index.name());
UnaryVariantOpRegistry::Global()->RegisterUnaryOpFn(
op, device, type_index,
[type_index_name, unary_op_fn](OpKernelContext* ctx, const Variant& v,
@ -442,10 +444,12 @@ class UnaryVariantBinaryOpRegistration {
LocalVariantBinaryOpFn;
public:
UnaryVariantBinaryOpRegistration(VariantBinaryOp op, const string& device,
UnaryVariantBinaryOpRegistration(VariantBinaryOp op,
const std::string& device,
const TypeIndex& type_index,
const LocalVariantBinaryOpFn& binary_op_fn) {
const string type_index_name = port::MaybeAbiDemangle(type_index.name());
const std::string type_index_name =
port::MaybeAbiDemangle(type_index.name());
UnaryVariantOpRegistry::Global()->RegisterBinaryOpFn(
op, device, type_index,
[type_index_name, binary_op_fn](OpKernelContext* ctx, const Variant& a,

28
tensorflow/core/framework/variant_tensor_data.h
View File

@ -44,8 +44,8 @@ class VariantTensorData {
VariantTensorData(VariantTensorDataProto proto);
// Name of the type of objects being serialized.
const string& type_name() const { return type_name_; }
void set_type_name(const string& type_name) { type_name_ = type_name; }
const std::string& type_name() const { return type_name_; }
void set_type_name(const std::string& type_name) { type_name_ = type_name; }
template <typename T, bool = std::is_pod<typename std::decay<T>::type>::value>
struct PODResolver {};
@ -62,9 +62,9 @@ class VariantTensorData {
return GetMetadata<T>(value, PODResolver<T>());
}
string& metadata_string() { return metadata_; }
std::string& metadata_string() { return metadata_; }
const string& metadata_string() const { return metadata_; }
const std::string& metadata_string() const { return metadata_; }
// Tensors contained within objects being serialized.
int tensors_size() const;
@ -84,25 +84,27 @@ class VariantTensorData {
bool FromConstProto(const VariantTensorDataProto& proto);
// Serialization via VariantTensorDataProto
string SerializeAsString() const;
bool SerializeToString(string* buf);
bool ParseFromString(string s);
std::string SerializeAsString() const;
bool SerializeToString(std::string* buf);
bool ParseFromString(std::string s);
string DebugString() const;
std::string DebugString() const;
public:
string type_name_;
string metadata_;
std::string type_name_;
std::string metadata_;
std::vector<Tensor> tensors_;
private:
template <typename T>
void SetMetadata(const string& value, PODResolver<T, false /* is_pod */>) {
void SetMetadata(const std::string& value,
PODResolver<T, false /* is_pod */>) {
metadata_ = value;
}
template <typename T>
bool GetMetadata(string* value, PODResolver<T, false /* is_pod */>) const {
bool GetMetadata(std::string* value,
PODResolver<T, false /* is_pod */>) const {
*value = metadata_;
return true;
}
@ -121,7 +123,7 @@ class VariantTensorData {
};
// For backwards compatibility for when this was a proto
string ProtoDebugString(const VariantTensorData& object);
std::string ProtoDebugString(const VariantTensorData& object);
} // namespace tensorflow