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

Change std::call_once to absl::call_once

Browse Source 
absl::call_once is faster and supports fibers.
PiperOrigin-RevId: 292148213
Change-Id: I66e96d735b722a2642508a7e7a1e73de254234d7
This commit is contained in:
George Karpenkov 2020-01-29 08:37:15 -08:00 committed by TensorFlower Gardener
parent b1171f57ad
commit 9b544af08d
38 changed files with 114 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
tensorflow/compiler/aot/BUILD
View File

@ -33,6 +33,7 @@ cc_library(
deps = [
":aot_only_var_handle_op",
":embedded_protocol_buffers",
"@com_google_absl//absl/base",
"@com_google_absl//absl/memory",
"@com_google_absl//absl/strings",
"@com_google_absl//absl/types:span",

5
tensorflow/compiler/aot/compile.cc
View File

@ -20,6 +20,7 @@ limitations under the License.
#include <utility>
#include <vector>
#include "absl/base/call_once.h"
#include "llvm-c/Target.h"
#include "tensorflow/compiler/aot/codegen.h"
#include "tensorflow/compiler/aot/flags.h"
@ -142,7 +143,7 @@ static Status ReadProtoFile(const string& fname, protobuf::Message* proto) {
}
}
static std::once_flag targets_init;
static absl::once_flag targets_init;
static void InitializeTargets() {
// Initialize all LLVM targets so we can cross compile.
@ -167,7 +168,7 @@ static void InitializeTargets() {
}
Status Main(const MainFlags& flags) {
std::call_once(targets_init, &InitializeTargets);
absl::call_once(targets_init, &InitializeTargets);
// Process config.
tf2xla::Config config;

2
tensorflow/compiler/jit/BUILD
View File

@ -261,6 +261,7 @@ cc_library(
"//tensorflow/compiler/xla:parse_flags_from_env",
"//tensorflow/core:framework_internal",
"//tensorflow/core:lib",
"@com_google_absl//absl/base",
"@com_google_absl//absl/strings",
],
)
@ -642,6 +643,7 @@ cc_library(
"//tensorflow/core:protos_all_cc",
"//tensorflow/stream_executor/lib",
"@com_google_absl//absl/algorithm:container",
"@com_google_absl//absl/base",
"@com_google_absl//absl/container:flat_hash_map",
"@com_google_absl//absl/container:flat_hash_set",
"@com_google_absl//absl/container:inlined_vector",

17
tensorflow/compiler/jit/flags.cc
View File

@ -17,6 +17,7 @@ limitations under the License.
#include <mutex> // NOLINT
#include "absl/base/call_once.h"
#include "absl/strings/numbers.h"
#include "absl/strings/str_split.h"
#include "absl/strings/strip.h"
@ -34,7 +35,7 @@ XlaOpsCommonFlags* ops_flags;
IntroduceFloatingPointJitterPassFlags* jitter_flags;
std::vector<Flag>* flag_list;
std::once_flag flags_init;
absl::once_flag flags_init;
bool SetterForXlaAutoJitFlag(const string& value) {
int32 opt_level;
@ -215,38 +216,38 @@ void AllocateAndParseFlags() {
} // namespace
bool SetXlaAutoJitFlagFromFlagString(const string& value) {
std::call_once(flags_init, &AllocateAndParseFlags);
absl::call_once(flags_init, &AllocateAndParseFlags);
return SetterForXlaAutoJitFlag(value);
}
BuildXlaOpsPassFlags* GetBuildXlaOpsPassFlags() {
std::call_once(flags_init, &AllocateAndParseFlags);
absl::call_once(flags_init, &AllocateAndParseFlags);
return build_ops_flags;
}
MarkForCompilationPassFlags* GetMarkForCompilationPassFlags() {
std::call_once(flags_init, &AllocateAndParseFlags);
absl::call_once(flags_init, &AllocateAndParseFlags);
return mark_for_compilation_flags;
}
XlaDeviceFlags* GetXlaDeviceFlags() {
std::call_once(flags_init, &AllocateAndParseFlags);
absl::call_once(flags_init, &AllocateAndParseFlags);
return device_flags;
}
const XlaOpsCommonFlags& GetXlaOpsCommonFlags() {
std::call_once(flags_init, &AllocateAndParseFlags);
absl::call_once(flags_init, &AllocateAndParseFlags);
return *ops_flags;
}
const IntroduceFloatingPointJitterPassFlags&
GetIntroduceFloatingPointJitterPassFlags() {
std::call_once(flags_init, &AllocateAndParseFlags);
absl::call_once(flags_init, &AllocateAndParseFlags);
return *jitter_flags;
}
void AppendMarkForCompilationPassFlags(std::vector<Flag>* flag_list) {
std::call_once(flags_init, &AllocateAndParseFlags);
absl::call_once(flags_init, &AllocateAndParseFlags);
AppendMarkForCompilationPassFlagsInternal(flag_list);
}

5
tensorflow/compiler/jit/mark_for_compilation_pass.cc
View File

@ -21,6 +21,7 @@ limitations under the License.
#include <unordered_map>
#include <unordered_set>
#include "absl/base/call_once.h"
#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "absl/strings/str_join.h"
@ -1616,8 +1617,8 @@ StatusOr<bool> MarkForCompilationPassImpl::ShouldCompileClusterImpl(
if (!should_compile && global_jit_level_ != OptimizerOptions::OFF &&
device_type.type_string() == DEVICE_CPU) {
static std::once_flag once;
std::call_once(once, [] {
static absl::once_flag once;
absl::call_once(once, [] {
LOG(WARNING)
<< "(One-time warning): Not using XLA:CPU for cluster because envvar "
"TF_XLA_FLAGS=--tf_xla_cpu_global_jit was not set. If you want "

1
tensorflow/compiler/xla/BUILD
View File

@ -881,6 +881,7 @@ cc_library(
":xla_proto_cc",
"//tensorflow/core:framework_internal",
"//tensorflow/core:lib",
"@com_google_absl//absl/base",
"@com_google_absl//absl/container:flat_hash_map",
"@com_google_absl//absl/container:node_hash_map",
"@com_google_absl//absl/strings",

16
tensorflow/compiler/xla/debug_options_flags.cc
View File

@ -15,9 +15,9 @@ limitations under the License.
#include "tensorflow/compiler/xla/debug_options_flags.h"
#include <mutex> // NOLINT(build/c++11): only using std::call_once, not mutex.
#include <vector>
#include "absl/base/call_once.h"
#include "absl/container/flat_hash_map.h"
#include "absl/container/node_hash_map.h"
#include "absl/strings/str_format.h"
@ -64,7 +64,7 @@ DebugOptions DefaultDebugOptionsIgnoringFlags() {
return opts;
}
static std::once_flag flags_init;
static absl::once_flag flags_init;
static DebugOptions* flag_values;
static std::vector<tensorflow::Flag>* flag_objects;
@ -207,8 +207,8 @@ static void AllocateFlags() {
// warning if a pass was specified but never consumed any fuel, on the
// theory that this is may be a typo.
if (!initial_fuel->empty()) {
static std::once_flag register_atexit_once;
std::call_once(
static absl::once_flag register_atexit_once;
absl::call_once(
register_atexit_once,
+[] { std::atexit(WarnIfFuelWasNeverConsumed); });
}
@ -527,18 +527,18 @@ static void AllocateFlags() {
}
void AppendDebugOptionsFlags(std::vector<tensorflow::Flag>* flag_list) {
std::call_once(flags_init, &AllocateFlags);
absl::call_once(flags_init, &AllocateFlags);
flag_list->insert(flag_list->end(), flag_objects->begin(),
flag_objects->end());
}
xla::DebugOptions GetDebugOptionsFromFlags() {
std::call_once(flags_init, &AllocateFlags);
absl::call_once(flags_init, &AllocateFlags);
return *flag_values;
}
void ResetThreadLocalFuel() {
std::call_once(flags_init, &AllocateFlags);
absl::call_once(flags_init, &AllocateFlags);
thread_fuel.reset(new absl::node_hash_map<string, std::atomic<int64>>());
CHECK(initial_fuel != nullptr);
@ -548,7 +548,7 @@ void ResetThreadLocalFuel() {
}
bool ConsumeFuel(absl::string_view pass, bool* just_ran_out) {
std::call_once(flags_init, &AllocateFlags);
absl::call_once(flags_init, &AllocateFlags);
if (just_ran_out != nullptr) {
*just_ran_out = false;
}

1
tensorflow/compiler/xla/service/BUILD
View File

@ -4473,6 +4473,7 @@ cc_library(
"//tensorflow/compiler/xla:types",
"//tensorflow/core:lib",
"@com_google_absl//absl/algorithm:container",
"@com_google_absl//absl/base",
"@com_google_absl//absl/base:core_headers",
"@com_google_absl//absl/memory",
"@com_google_absl//absl/synchronization",

1
tensorflow/compiler/xla/service/cpu/BUILD
View File

@ -88,6 +88,7 @@ cc_library(
"@com_google_absl//absl/memory",
"@com_google_absl//absl/strings",
":target_machine_features",
"@com_google_absl//absl/base",
"@com_google_absl//absl/types:span",
"//tensorflow/compiler/xla/service:copy_insertion",
"//tensorflow/compiler/xla/service:hlo_casting_utils",

14
tensorflow/compiler/xla/service/cpu/cpu_compiler.cc
View File

@ -19,7 +19,6 @@ limitations under the License.
#include <string.h>
#include <map>
#include <mutex> // NOLINT(build/c++11): only using std::call_once, not mutex.
#include <string>
#include <unordered_map>
#include <utility>
@ -27,6 +26,7 @@ limitations under the License.
// IWYU pragma: no_include "llvm/Config/Disassemblers.def.inc"
// IWYU pragma: no_include "llvm/Config/Targets.def.inc"
#include "absl/base/call_once.h"
#include "absl/memory/memory.h"
#include "absl/strings/str_cat.h"
#include "llvm/ADT/StringRef.h"
@ -166,7 +166,7 @@ namespace {
// multiple invocations of the LLVM compilation pipeline with a different set of
// flags. Therefore, we only pass command-line flags to LLVM once, before the
// first module is compiled.
std::once_flag llvm_command_line_options_initialized;
absl::once_flag llvm_command_line_options_initialized;
// This visitor records which HLO instructions should have profiling information
// recorded.
@ -565,8 +565,8 @@ StatusOr<std::unique_ptr<Executable>> CpuCompiler::RunBackend(
auto slow_compile_alarm = SlowCompilationAlarm();
TF_RET_CHECK(stream_exec != nullptr);
std::call_once(llvm_command_line_options_initialized,
&llvm_ir::InitializeLLVMCommandLineOptions, module->config());
absl::call_once(llvm_command_line_options_initialized,
&llvm_ir::InitializeLLVMCommandLineOptions, module->config());
ModuleHook pre_optimization_ir_hook;
ModuleHook post_optimization_ir_hook;
@ -702,9 +702,9 @@ CpuCompiler::CompileAheadOfTime(std::unique_ptr<HloModuleGroup> module_group,
std::vector<std::unique_ptr<HloModule>> modules =
module_group->ConsumeModules();
std::call_once(llvm_command_line_options_initialized,
&llvm_ir::InitializeLLVMCommandLineOptions,
modules[0]->config());
absl::call_once(llvm_command_line_options_initialized,
&llvm_ir::InitializeLLVMCommandLineOptions,
modules[0]->config());
// We can pass just one llvm::TargetOptions when we compile the LLVM module,
// so we bail if the configs have conflicting flags. At the moment, the only

2
tensorflow/compiler/xla/service/gpu/BUILD
View File

@ -1235,6 +1235,7 @@ cc_library(
"//tensorflow/stream_executor:stream_executor_headers",
"//tensorflow/stream_executor/cuda:cuda_diagnostics",
"//tensorflow/stream_executor/gpu:asm_compiler",
"@com_google_absl//absl/base",
"@com_google_absl//absl/container:node_hash_map",
"@com_google_absl//absl/types:optional",
],
@ -1465,6 +1466,7 @@ cc_library(
"//tensorflow/compiler/xla/service:hlo_module_config",
"//tensorflow/core:stream_executor_no_cuda",
"//tensorflow/stream_executor:stream_executor_headers",
"@com_google_absl//absl/base",
"@com_google_absl//absl/strings",
],
)

5
tensorflow/compiler/xla/service/gpu/buffer_comparator.cc
View File

@ -18,6 +18,7 @@ limitations under the License.
#include <algorithm>
#include <cmath>
#include "absl/base/call_once.h"
#include "absl/strings/str_replace.h"
#include "tensorflow/compiler/xla/service/gpu/partition_assignment.h"
#include "tensorflow/compiler/xla/service/gpu/stream_executor_util.h"
@ -585,8 +586,8 @@ static StatusOr<bool> DeviceCompare(se::Stream* stream,
if (compiled_ptx_or.ok()) {
compiled_ptx = compiled_ptx_or.ConsumeValueOrDie();
} else {
static std::once_flag ptxas_not_found_logged;
std::call_once(ptxas_not_found_logged, [&]() {
static absl::once_flag ptxas_not_found_logged;
absl::call_once(ptxas_not_found_logged, [&]() {
LOG(WARNING)
<< compiled_ptx_or.status().ToString()
<< "\nRelying on driver to perform ptx compilation. "

1
tensorflow/compiler/xla/service/gpu/gpu_compiler.cc
View File

@ -19,7 +19,6 @@ limitations under the License.
#include <atomic>
#include <functional>
#include <mutex> // NOLINT(build/c++11): only using std::call_once, not mutex.
#include <utility>
#include "absl/memory/memory.h"

1
tensorflow/compiler/xla/service/gpu/llvm_gpu_backend/BUILD
View File

@ -35,6 +35,7 @@ cc_library(
"//tensorflow/core:lib",
"//tensorflow/core:lib_internal",
"//tensorflow/core/profiler/lib:traceme",
"@com_google_absl//absl/base",
"@com_google_absl//absl/memory",
"@com_google_absl//absl/strings",
"@com_google_absl//absl/strings:str_format",

9
tensorflow/compiler/xla/service/gpu/llvm_gpu_backend/gpu_backend_lib.cc
View File

@ -21,6 +21,7 @@ limitations under the License.
#include <string>
#include <utility>
#include "absl/base/call_once.h"
#include "absl/memory/memory.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
@ -492,8 +493,8 @@ namespace nvptx {
StatusOr<string> CompileToPtx(llvm::Module* module, GpuVersion gpu_version,
const HloModuleConfig& hlo_module_config,
const string& libdevice_dir_path) {
static std::once_flag backend_init_flag;
std::call_once(backend_init_flag, NVPTXBackendInit, hlo_module_config);
static absl::once_flag backend_init_flag;
absl::call_once(backend_init_flag, NVPTXBackendInit, hlo_module_config);
string ptx;
std::unique_ptr<llvm::TargetMachine> target_machine;
@ -712,8 +713,8 @@ namespace amdgpu {
StatusOr<std::vector<uint8>> CompileToHsaco(
llvm::Module* module, GpuVersion gpu_version,
const HloModuleConfig& hlo_module_config, const string& rocdl_dir_path) {
static std::once_flag backend_init_flag;
std::call_once(backend_init_flag, AMDGPUBackendInit, hlo_module_config);
static absl::once_flag backend_init_flag;
absl::call_once(backend_init_flag, AMDGPUBackendInit, hlo_module_config);
std::vector<uint8> hsaco;
std::unique_ptr<llvm::TargetMachine> target_machine;

5
tensorflow/compiler/xla/service/gpu/nvptx_compiler.cc
View File

@ -19,6 +19,7 @@ limitations under the License.
#include <fstream>
#include "absl/base/call_once.h"
#include "tensorflow/compiler/xla/service/algebraic_simplifier.h"
#include "tensorflow/compiler/xla/service/dump.h"
#include "tensorflow/compiler/xla/service/gpu/cublas_gemm_pad_for_tensor_cores.h"
@ -247,8 +248,8 @@ absl::optional<bool> CanShareBufferHint(const HloInstruction* user,
//
// Only prints a warning the first time it's called.
void WarnIfBadDriverJITVersion() {
static std::once_flag run_once;
std::call_once(run_once, [] {
static absl::once_flag run_once;
absl::call_once(run_once, [] {
auto version_or_status = se::cuda::Diagnostician::FindKernelDriverVersion();
if (!version_or_status.ok()) {
LOG(WARNING) << "Couldn't read CUDA driver version.";

6
tensorflow/compiler/xla/service/slow_operation_alarm.cc
View File

@ -16,9 +16,9 @@ limitations under the License.
#include "tensorflow/compiler/xla/service/slow_operation_alarm.h"
#include <list>
#include <mutex> // NOLINT (for std::call_once, not std::mutex)
#include "absl/algorithm/container.h"
#include "absl/base/call_once.h"
#include "absl/base/thread_annotations.h"
#include "absl/memory/memory.h"
#include "absl/synchronization/mutex.h"
@ -29,7 +29,7 @@ namespace {
absl::Mutex mu(absl::kConstInit);
absl::CondVar* ready;
std::once_flag init_flag;
absl::once_flag init_flag;
std::list<SlowOperationAlarm*>* outstanding_alarms ABSL_PT_GUARDED_BY(mu) =
nullptr;
@ -73,7 +73,7 @@ void AlarmLoop() {
}
void ScheduleAlarm(SlowOperationAlarm* alarm) {
std::call_once(init_flag, [] {
absl::call_once(init_flag, [] {
ready = new absl::CondVar();
outstanding_alarms = new std::list<SlowOperationAlarm*>();
(void)tensorflow::Env::Default()->StartThread(

1
tensorflow/core/BUILD
View File

@ -2578,6 +2578,7 @@ tf_cuda_library(
":lib",
":lib_internal",
":protos_all_cc",
"@com_google_absl//absl/base",
"@com_google_absl//absl/algorithm:container",
"@com_google_absl//absl/memory",
"@com_google_absl//absl/strings",

5
tensorflow/core/common_runtime/process_state.cc
View File

@ -18,6 +18,7 @@ limitations under the License.
#include <cstring>
#include <vector>
#include "absl/base/call_once.h"
#include "tensorflow/core/common_runtime/bfc_allocator.h"
#include "tensorflow/core/common_runtime/pool_allocator.h"
#include "tensorflow/core/framework/allocator.h"
@ -33,8 +34,8 @@ namespace tensorflow {
/*static*/ ProcessState* ProcessState::singleton() {
static ProcessState* instance = new ProcessState;
static std::once_flag f;
std::call_once(f, []() {
static absl::once_flag f;
absl::call_once(f, []() {
AllocatorFactoryRegistry::singleton()->process_state_ = instance;
});

5
tensorflow/core/framework/op_kernel.cc
View File

@ -23,6 +23,7 @@ limitations under the License.
#include <utility>
#include <vector>
#include "absl/base/call_once.h"
#include "tensorflow/core/framework/allocation_description.pb.h"
#include "tensorflow/core/framework/attr_value_util.h"
#include "tensorflow/core/framework/device_attributes.pb.h"
@ -1226,8 +1227,8 @@ void LoadDynamicKernelsInternal() {
void LoadDynamicKernels() {
// TODO(gunan): As more features are available, add intelligent kernel
// selection, and dropping unsuitable kernel logic here.
static std::once_flag dll_loader_flag;
std::call_once(dll_loader_flag, LoadDynamicKernelsInternal);
static absl::once_flag dll_loader_flag;
absl::call_once(dll_loader_flag, LoadDynamicKernelsInternal);
}
void* GlobalKernelRegistry() {

8
tensorflow/core/kernels/BUILD
View File

@ -536,6 +536,7 @@ tf_cuda_library(
"//tensorflow/stream_executor/gpu:asm_compiler",
"//tensorflow/stream_executor/gpu:redzone_allocator",
"@com_google_absl//absl/algorithm:container",
"@com_google_absl//absl/base",
"@com_google_absl//absl/types:span",
],
)
@ -782,7 +783,7 @@ cc_library(
deps = select({
":no_mkldnn_contraction_kernel": [":eigen_contraction_kernel_no_mkl"],
"//conditions:default": [":eigen_contraction_kernel_with_mkl"],
}),
}) + ["@com_google_absl//absl/base"],
)
cc_library(
@ -801,6 +802,7 @@ cc_library(
],
}),
deps = [
"@com_google_absl//absl/base",
"//third_party/eigen3",
"//tensorflow/core/platform:dynamic_annotations",
] + select({
@ -820,6 +822,7 @@ cc_library(
deps = [
"//tensorflow/core/platform:dynamic_annotations",
"//third_party/eigen3",
"@com_google_absl//absl/base",
],
)
@ -1888,6 +1891,7 @@ tf_cc_test(
"//tensorflow/core:test",
"//tensorflow/core:test_main",
"//tensorflow/core:testlib",
"@com_google_absl//absl/base",
],
)
@ -4978,6 +4982,7 @@ cc_library(
)
PARSING_DEPS = [
"@com_google_absl//absl/base",
"//tensorflow/core:core_cpu_internal",
"//tensorflow/core:framework",
"//tensorflow/core:lib",
@ -6868,6 +6873,7 @@ cc_library(
"//tensorflow/core:protos_all_cc_impl",
"//third_party/eigen3",
"//third_party/fft2d:fft2d_headers",
"@com_google_absl//absl/base",
"@com_google_protobuf//:protobuf",
"@fft2d",
"@gemmlowp",

1
tensorflow/core/kernels/conv_ops.cc
View File

@ -28,7 +28,6 @@ limitations under the License.
#include <atomic>
#include <map>
#include <mutex> // NOLINT(build/c++11): only using std::call_once, not mutex.
#include <vector>
#include "tensorflow/core/framework/allocator.h"

6
tensorflow/core/kernels/eigen_contraction_kernel.cc
View File

@ -17,6 +17,8 @@ limitations under the License.
#include <mutex> // NOLINT(build/c++11)
#include "absl/base/call_once.h"
// We need a pair of compile time and runtime flags to disable compilation of
// custom contraction kernels for unsupported architectures (e.g. Android,
// iOS, ARM and PPC CPUs, etc...), and to be able to fallback on default Eigen
@ -42,8 +44,8 @@ EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE bool UseCustomContractionKernels() {
// This subroutine should not be used in GPU. In case it is, a custom kernel
// should always be used
#if !defined __NVCC__ && !defined __HIP_DEVICE_COMPILE__
static std::once_flag initialized;
std::call_once(initialized, [&] {
static absl::once_flag initialized;
absl::call_once(initialized, [&] {
char* flag = std::getenv("TENSORFLOW_USE_CUSTOM_CONTRACTION_KERNEL");
if (flag && (strcmp(flag, "false") == 0 || strcmp(flag, "0") == 0)) {
use_custom_contraction_kernel = false;

13
tensorflow/core/kernels/example_parsing_ops.cc
View File

@ -19,6 +19,7 @@ limitations under the License.
#include <unordered_set>
#include <vector>
#include "absl/base/call_once.h"
#include "tensorflow/core/common_runtime/metrics.h"
#include "tensorflow/core/example/example.pb.h"
#include "tensorflow/core/example/feature.pb.h"
@ -70,7 +71,7 @@ class ParseExampleOp : public OpKernel {
OP_REQUIRES_OK(ctx, GetInputListKeys(ctx, "dense_keys", &dense_keys_t));
OP_REQUIRES_OK(ctx, GetInputListKeys(ctx, "sparse_keys", &sparse_keys_t));
}
std::call_once(flag_, [&dense_keys_t, &sparse_keys_t, &ragged_keys_t]() {
absl::call_once(flag_, [&dense_keys_t, &sparse_keys_t, &ragged_keys_t]() {
metrics::RecordParseDenseFeature(dense_keys_t.size());
metrics::RecordParseSparseFeature(sparse_keys_t.size());
metrics::RecordParseRaggedFeature(ragged_keys_t.size());
@ -284,7 +285,7 @@ class ParseExampleOp : public OpKernel {
ParseExampleAttrs attrs_;
int op_version_;
std::once_flag flag_;
absl::once_flag flag_;
};
REGISTER_KERNEL_BUILDER(Name("ParseExample").Device(DEVICE_CPU),
@ -434,7 +435,7 @@ class ParseSequenceExampleOp : public OpKernel {
&feature_list_sparse_keys));
OP_REQUIRES_OK(ctx, ctx->input("feature_list_ragged_keys",
&feature_list_ragged_keys));
std::call_once(flag_, [&]() {
absl::call_once(flag_, [&]() {
metrics::RecordParseDenseFeature(
context_dense_keys->NumElements() +
feature_list_dense_keys->NumElements());
@ -707,7 +708,7 @@ class ParseSequenceExampleOp : public OpKernel {
ParseSequenceExampleAttrs attrs_;
int op_version_;
std::once_flag flag_;
absl::once_flag flag_;
};
REGISTER_KERNEL_BUILDER(Name("ParseSequenceExample").Device(DEVICE_CPU),
@ -753,7 +754,7 @@ class ParseSingleSequenceExampleOp : public OpKernel {
attrs_.num_feature_list_dense);
std::vector<string> feature_list_sparse_keys_t(
attrs_.num_feature_list_sparse);
std::call_once(
absl::call_once(
flag_, [&context_dense_keys_t, &context_sparse_keys_t,
&feature_list_dense_keys_t, &feature_list_sparse_keys_t]() {
metrics::RecordParseDenseFeature(context_dense_keys_t.size() +
@ -1129,7 +1130,7 @@ class ParseSingleSequenceExampleOp : public OpKernel {
protected:
ParseSingleSequenceExampleAttrs attrs_;
std::once_flag flag_;
absl::once_flag flag_;
};
REGISTER_KERNEL_BUILDER(Name("ParseSingleSequenceExample").Device(DEVICE_CPU),

7
tensorflow/core/kernels/example_parsing_ops_test.cc
View File

@ -15,6 +15,7 @@ limitations under the License.
#include <unordered_map>
#include "absl/base/call_once.h"
#include "tensorflow/core/common_runtime/kernel_benchmark_testlib.h"
#include "tensorflow/core/example/example.pb.h"
#include "tensorflow/core/example/feature.pb.h"
@ -82,11 +83,11 @@ template <typename T>
struct ExampleStore {
private:
static ExampleTensorMap serialized_example;
static std::once_flag flags_init;
static absl::once_flag flags_init;
public:
static ExampleTensorMap& GetSerializedExample() {
std::call_once(flags_init, [] {
absl::call_once(flags_init, [] {
AddExample(&serialized_example, 10, 1, 1);
AddExample(&serialized_example, 100, 1, 1);
AddExample(&serialized_example, 1000, 1, 1);
@ -133,7 +134,7 @@ struct ExampleStore {
template <typename T>
ExampleTensorMap ExampleStore<T>::serialized_example;
template <typename T>
std::once_flag ExampleStore<T>::flags_init;
absl::once_flag ExampleStore<T>::flags_init;
template struct ExampleStore<BytesFiller>;
template struct ExampleStore<Int64Filler>;

9
tensorflow/core/kernels/gpu_utils.cc
View File

@ -21,6 +21,7 @@ limitations under the License.
#include "google/protobuf/any.pb.h"
#include "absl/algorithm/container.h"
#include "absl/base/call_once.h"
#include "tensorflow/core/platform/logger.h"
#include "tensorflow/core/protobuf/autotuning.pb.h"
#include "tensorflow/core/protobuf/conv_autotuning.pb.h"
@ -42,8 +43,8 @@ se::DeviceMemoryBase WrapRedzoneBestEffort(se::RedzoneAllocator* rz_allocator,
}
auto output_rz_or = rz_allocator->AllocateBytes(buffer.size());
if (!output_rz_or.ok()) {
static std::once_flag rz_allocation_failure_logged;
std::call_once(rz_allocation_failure_logged, []() {
static absl::once_flag rz_allocation_failure_logged;
absl::call_once(rz_allocation_failure_logged, []() {
LOG(WARNING) << "Failed to allocate memory for convolution redzone "
<< "checking; skipping this check. This is benign and only "
<< "means that we won't check cudnn for out-of-bounds reads "
@ -62,8 +63,8 @@ void CheckRedzones(const se::RedzoneAllocator& rz_allocator,
se::port::StatusOr<se::RedzoneAllocator::RedzoneCheckStatus> rz_status =
rz_allocator.CheckRedzones();
if (!rz_status.ok()) {
static std::once_flag failure_logged;
std::call_once(failure_logged, [&]() {
static absl::once_flag failure_logged;
absl::call_once(failure_logged, [&]() {
LOG(WARNING) << "Failed to check cudnn convolutions for out-of-bounds "
<< "reads and writes with an error message: '"
<< rz_status.status().error_message()

1
tensorflow/core/nccl/BUILD
View File

@ -35,6 +35,7 @@ cc_library(
"@local_config_rocm//rocm:rccl",
"//tensorflow/core:gpu_runtime",
]) + if_cuda_or_rocm([
"@com_google_absl//absl/base",
"@com_google_absl//absl/container:flat_hash_map",
"@com_google_absl//absl/memory",
"//tensorflow/core:core_cpu",

5
tensorflow/core/nccl/nccl_manager.cc
View File

@ -18,6 +18,7 @@ limitations under the License.
#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
#include "absl/base/call_once.h"
#include "tensorflow/core/lib/core/refcount.h"
#include "tensorflow/core/lib/core/threadpool.h"
#include "tensorflow/core/platform/env.h"
@ -237,8 +238,8 @@ NcclManager* NcclManager::instance() {
#if TENSORFLOW_USE_ROCM
// singleton does not count against total instances
// see comment above in Collective constructor concerning ROCm platform
static std::once_flag once;
std::call_once(once, [] { --NcclManager::instance_count; });
static absl::once_flag once;
absl::call_once(once, [] { --NcclManager::instance_count; });
#endif
return instance;
}

1
tensorflow/core/platform/BUILD
View File

@ -164,6 +164,7 @@ cc_library(
":byte_order",
":logging",
":platform_port",
"@com_google_absl//absl/base",
],
)

5
tensorflow/core/platform/cpu_feature_guard.cc
View File

@ -18,6 +18,7 @@ limitations under the License.
#include <mutex>
#include <string>
#include "absl/base/call_once.h"
#include "tensorflow/core/platform/byte_order.h"
#include "tensorflow/core/platform/cpu_info.h"
#include "tensorflow/core/platform/logging.h"
@ -91,12 +92,12 @@ class CPUFeatureGuard {
CPUFeatureGuard g_cpu_feature_guard_singleton;
std::once_flag g_cpu_feature_guard_warn_once_flag;
absl::once_flag g_cpu_feature_guard_warn_once_flag;
} // namespace
void InfoAboutUnusedCPUFeatures() {
std::call_once(g_cpu_feature_guard_warn_once_flag, [] {
absl::call_once(g_cpu_feature_guard_warn_once_flag, [] {
string missing_instructions;
#if defined(_MSC_VER) && !defined(__clang__)

6
tensorflow/core/platform/cpu_info.cc
View File

@ -14,6 +14,8 @@ limitations under the License.
==============================================================================*/
#include "tensorflow/core/platform/cpu_info.h"
#include "absl/base/call_once.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/platform.h"
#include "tensorflow/core/platform/types.h"
@ -297,12 +299,12 @@ class CPUIDInfo {
int model_num_;
};
std::once_flag cpuid_once_flag;
absl::once_flag cpuid_once_flag;
void InitCPUIDInfo() {
// This ensures that CPUIDInfo::Initialize() is called exactly
// once regardless of how many threads concurrently call us
std::call_once(cpuid_once_flag, CPUIDInfo::Initialize);
absl::call_once(cpuid_once_flag, CPUIDInfo::Initialize);
}
#endif // PLATFORM_IS_X86

5
tensorflow/core/platform/profile_utils/cpu_utils.cc
View File

@ -23,6 +23,7 @@ limitations under the License.
#include <windows.h>
#endif
#include "absl/base/call_once.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/profile_utils/android_armv7a_cpu_utils_helper.h"
@ -134,8 +135,8 @@ static ICpuUtilsHelper* cpu_utils_helper_instance_ = nullptr;
}
/* static */ ICpuUtilsHelper& CpuUtils::GetCpuUtilsHelperSingletonInstance() {
static std::once_flag flag;
std::call_once(flag, []() {
static absl::once_flag flag;
absl::call_once(flag, []() {
if (cpu_utils_helper_instance_ != nullptr) {
LOG(FATAL) << "cpu_utils_helper_instance_ is already instantiated.";
}

1
tensorflow/stream_executor/cuda/BUILD
View File

@ -63,6 +63,7 @@ cc_library(
"//tensorflow/stream_executor/platform",
],
) + tf_additional_cuda_platform_deps() + [
"@com_google_absl//absl/base",
"@com_google_absl//absl/base:core_headers",
"@com_google_absl//absl/memory",
"@com_google_absl//absl/strings",

5
tensorflow/stream_executor/cuda/cuda_platform.cc
View File

@ -15,6 +15,7 @@ limitations under the License.
#include "tensorflow/stream_executor/cuda/cuda_platform.h"
#include "absl/base/call_once.h"
#include "absl/base/const_init.h"
#include "absl/memory/memory.h"
#include "absl/strings/str_cat.h"
@ -76,8 +77,8 @@ CudaPlatform::~CudaPlatform() {}
void CudaPlatform::InspectNumaNodes() {
// To get NUMA node information, we need to create all executors, so we can
// examine their device descriptions to see their bus assignments.
static std::once_flag once;
std::call_once(once, [&] {
static absl::once_flag once;
absl::call_once(once, [&] {
StreamExecutorConfig config;
for (int i = 0; i < VisibleDeviceCount(); i++) {
config.ordinal = i;

1
tensorflow/stream_executor/gpu/BUILD
View File

@ -237,6 +237,7 @@ cc_library(
],
deps = if_gpu_is_configured([
"asm_compiler",
"@com_google_absl//absl/base",
"@com_google_absl//absl/container:fixed_array",
"@com_google_absl//absl/strings:str_format",
"@com_google_absl//absl/types:optional",

5
tensorflow/stream_executor/gpu/redzone_allocator.cc
View File

@ -15,6 +15,7 @@ limitations under the License.
#include "tensorflow/stream_executor/gpu/redzone_allocator.h"
#include "absl/base/call_once.h"
#include "absl/container/fixed_array.h"
#include "absl/strings/str_format.h"
#include "absl/types/optional.h"
@ -307,8 +308,8 @@ port::StatusOr<RedzoneCheckStatus> RedzoneAllocator::CheckRedzones() const {
if (compiled_ptx_or.ok()) {
compiled_ptx = compiled_ptx_or.ValueOrDie();
} else {
static std::once_flag ptxas_not_found_logged;
std::call_once(ptxas_not_found_logged, [&]() {
static absl::once_flag ptxas_not_found_logged;
absl::call_once(ptxas_not_found_logged, [&]() {
LOG(WARNING) << compiled_ptx_or.status().ToString()
<< "\nRelying on driver to perform ptx compilation. "
<< "\nModify $PATH to customize ptxas location."

1
tensorflow/stream_executor/rocm/BUILD
View File

@ -136,6 +136,7 @@ cc_library(
":rocm_driver",
":rocm_gpu_executor",
":rocm_platform_id",
"@com_google_absl//absl/base",
"@com_google_absl//absl/memory",
"//tensorflow/stream_executor", # buildcleaner: keep
"//tensorflow/stream_executor:executor_cache",

5
tensorflow/stream_executor/rocm/rocm_platform.cc
View File

@ -15,6 +15,7 @@ limitations under the License.
#include "tensorflow/stream_executor/rocm/rocm_platform.h"
#include "absl/base/call_once.h"
#include "absl/memory/memory.h"
#include "absl/strings/str_format.h"
#include "tensorflow/stream_executor/gpu/gpu_driver.h"
@ -38,8 +39,8 @@ ROCmPlatform::~ROCmPlatform() {}
void ROCmPlatform::InspectNumaNodes() {
// To get NUMA node information, we need to create all executors, so we can
// examine their device descriptions to see their bus assignments.
std::once_flag once;
std::call_once(once, [&] {
absl::once_flag once;
absl::call_once(once, [&] {
StreamExecutorConfig config;
for (int i = 0; i < VisibleDeviceCount(); i++) {
config.ordinal = i;