-
Notifications
You must be signed in to change notification settings - Fork 2.5k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
-- a9ac6567c0933d786d68c10011e3f3ff9deedf89 by Greg Falcon <gfalcon@google.com>: Add absl::FunctionRef, a type analogous to the proposed C++23 std::function_ref. Like std::function, FunctionRef can be used to type-erase any callable (invokable) object. However, FunctionRef works by reference: it does not store a copy of the type-erased object. If the wrapped object is destroyed before the FunctionRef, the reference becomes dangling. FunctionRef relates to std::function in much the same way that string_view relates to std::string. Because of these limitations, FunctionRef is best used only as a function argument type, and only where the function will be invoked immediately (rather than saved for later use). When `const std::function<...>&` is used in this way, `absl::FunctionRef<...>` is a better-performing replacement. PiperOrigin-RevId: 275484044 -- 1f7c4df3760f8b93e5a5baf40b070eca1d3f4c98 by Abseil Team <absl-team@google.com>: Add FastHexToBufferZeroPad16() function for blazingly fast hex encoding of uint64_t. PiperOrigin-RevId: 275420901 -- 08d48ac004eba57cf2f1ada827181a2995f74807 by Abseil Team <absl-team@google.com>: Avoid applying the workaround for MSVC's static initialization problems when using clang-cl. PiperOrigin-RevId: 275366326 -- 40be82bd2b34670b5458c0a72a0475086153c2d6 by Abseil Team <absl-team@google.com>: Added comments to SimpleAtof()/SimpleAtod() that clarify that they always use the "C" locale, unlike the standard functions strtod() and strtof() referenced now in the comments. PiperOrigin-RevId: 275355815 -- 086779dacb3f6f2b3ab59947e94e79046bdb1fe1 by Jorg Brown <jorg@google.com>: Move the hex conversion table used by escaping.cc into numbers.h so that other parts of Abseil can more efficiently access it. PiperOrigin-RevId: 275331251 -- 3c4ed1b04e55d96a40cbe70fb70929ffbb0c0432 by Abseil Team <absl-team@google.com>: Avoid applying the workaround for MSVC's static initialization problems when using clang-cl. PiperOrigin-RevId: 275323858 -- 56ceb58ab688c3761978308609b09a1ac2739c9a by Derek Mauro <dmauro@google.com>: Add script for testing on Alpine Linux (for musl test coverage) PiperOrigin-RevId: 275321244 GitOrigin-RevId: a9ac6567c0933d786d68c10011e3f3ff9deedf89 Change-Id: I39799fa03768ddb44f3166200c860e1da4461807
- Loading branch information
Showing
15 changed files
with
887 additions
and
40 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,51 @@ | ||
load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test") | ||
load( | ||
"//absl:copts/configure_copts.bzl", | ||
"ABSL_DEFAULT_COPTS", | ||
"ABSL_DEFAULT_LINKOPTS", | ||
"ABSL_TEST_COPTS", | ||
) | ||
|
||
package(default_visibility = ["//visibility:public"]) | ||
|
||
licenses(["notice"]) # Apache 2.0 | ||
|
||
cc_library( | ||
name = "function_ref", | ||
srcs = ["internal/function_ref.h"], | ||
hdrs = ["function_ref.h"], | ||
copts = ABSL_DEFAULT_COPTS, | ||
linkopts = ABSL_DEFAULT_LINKOPTS, | ||
deps = [ | ||
"//absl/base:base_internal", | ||
"//absl/meta:type_traits", | ||
], | ||
) | ||
|
||
cc_test( | ||
name = "function_ref_test", | ||
size = "small", | ||
srcs = ["function_ref_test.cc"], | ||
copts = ABSL_TEST_COPTS, | ||
deps = [ | ||
":function_ref", | ||
"//absl/container:test_instance_tracker", | ||
"//absl/memory", | ||
"@com_google_googletest//:gtest_main", | ||
], | ||
) | ||
|
||
cc_test( | ||
name = "function_ref_benchmark", | ||
srcs = [ | ||
"function_ref_benchmark.cc", | ||
], | ||
copts = ABSL_TEST_COPTS, | ||
tags = ["benchmark"], | ||
visibility = ["//visibility:private"], | ||
deps = [ | ||
":function_ref", | ||
"//absl/base:core_headers", | ||
"@com_github_google_benchmark//:benchmark_main", | ||
], | ||
) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,137 @@ | ||
// Copyright 2019 The Abseil Authors. | ||
// | ||
// Licensed under the Apache License, Version 2.0 (the "License"); | ||
// you may not use this file except in compliance with the License. | ||
// You may obtain a copy of the License at | ||
// | ||
// https://www.apache.org/licenses/LICENSE-2.0 | ||
// | ||
// Unless required by applicable law or agreed to in writing, software | ||
// distributed under the License is distributed on an "AS IS" BASIS, | ||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
// See the License for the specific language governing permissions and | ||
// limitations under the License. | ||
// | ||
// ----------------------------------------------------------------------------- | ||
// File: function_ref.h | ||
// ----------------------------------------------------------------------------- | ||
// | ||
// This header file defines the `absl::FunctionRef` type for holding a | ||
// non-owning reference to an object of any invocable type. This function | ||
// reference is typically most useful as a type-erased argument type for | ||
// accepting function types that neither take ownership nor copy the type; using | ||
// the reference type in this case avoids a copy and an allocation. Best | ||
// practices of other non-owning reference-like objects (such as | ||
// `absl::string_view`) apply here. | ||
// | ||
// An `absl::FunctionRef` is similar in usage to a `std::function` but has the | ||
// following differences: | ||
// | ||
// * It doesn't own the underlying object. | ||
// * It doesn't have a null or empty state. | ||
// * It never performs deep copies or allocations. | ||
// * It's much faster and cheaper to construct. | ||
// * It's trivially copyable and destructable. | ||
// | ||
// Generally, `absl::FunctionRef` should not be used as a return value, data | ||
// member, or to initialize a `std::function`. Such usages will often lead to | ||
// problematic lifetime issues. Once you convert something to an | ||
// `absl::FunctionRef` you cannot make a deep copy later. | ||
// | ||
// This class is suitable for use wherever a "const std::function<>&" | ||
// would be used without making a copy. ForEach functions and other versions of | ||
// the visitor pattern are a good example of when this class should be used. | ||
// | ||
// This class is trivial to copy and should be passed by value. | ||
#ifndef ABSL_FUNCTIONAL_FUNCTION_REF_H_ | ||
#define ABSL_FUNCTIONAL_FUNCTION_REF_H_ | ||
|
||
#include <cassert> | ||
#include <functional> | ||
#include <type_traits> | ||
|
||
#include "absl/functional/internal/function_ref.h" | ||
#include "absl/meta/type_traits.h" | ||
|
||
namespace absl { | ||
|
||
// FunctionRef | ||
// | ||
// Dummy class declaration to allow the partial specialization based on function | ||
// types below. | ||
template <typename T> | ||
class FunctionRef; | ||
|
||
// FunctionRef | ||
// | ||
// An `absl::FunctionRef` is a lightweight wrapper to any invokable object with | ||
// a compatible signature. Generally, an `absl::FunctionRef` should only be used | ||
// as an argument type and should be preferred as an argument over a const | ||
// reference to a `std::function`. | ||
// | ||
// Example: | ||
// | ||
// // The following function takes a function callback by const reference | ||
// bool Visitor(const std::function<void(my_proto&, | ||
// absl::string_view)>& callback); | ||
// | ||
// // Assuming that the function is not stored or otherwise copied, it can be | ||
// // replaced by an `absl::FunctionRef`: | ||
// bool Visitor(absl::FunctionRef<void(my_proto&, absl::string_view)> | ||
// callback); | ||
// | ||
// Note: the assignment operator within an `absl::FunctionRef` is intentionally | ||
// deleted to prevent misuse; because the `absl::FunctionRef` does not own the | ||
// underlying type, assignment likely indicates misuse. | ||
template <typename R, typename... Args> | ||
class FunctionRef<R(Args...)> { | ||
private: | ||
// Used to disable constructors for objects that are not compatible with the | ||
// signature of this FunctionRef. | ||
template <typename F, | ||
typename FR = absl::base_internal::InvokeT<F, Args&&...>> | ||
using EnableIfCompatible = | ||
typename std::enable_if<std::is_void<R>::value || | ||
std::is_convertible<FR, R>::value>::type; | ||
|
||
public: | ||
// Constructs a FunctionRef from any invokable type. | ||
template <typename F, typename = EnableIfCompatible<const F&>> | ||
FunctionRef(const F& f) // NOLINT(runtime/explicit) | ||
: invoker_(&absl::functional_internal::InvokeObject<F, R, Args...>) { | ||
absl::functional_internal::AssertNonNull(f); | ||
ptr_.obj = &f; | ||
} | ||
|
||
// Overload for function pointers. This eliminates a level of indirection that | ||
// would happen if the above overload was used (it lets us store the pointer | ||
// instead of a pointer to a pointer). | ||
// | ||
// This overload is also used for references to functions, since references to | ||
// functions can decay to function pointers implicitly. | ||
template < | ||
typename F, typename = EnableIfCompatible<F*>, | ||
absl::functional_internal::EnableIf<absl::is_function<F>::value> = 0> | ||
FunctionRef(F* f) // NOLINT(runtime/explicit) | ||
: invoker_(&absl::functional_internal::InvokeFunction<F*, R, Args...>) { | ||
assert(f != nullptr); | ||
ptr_.fun = reinterpret_cast<decltype(ptr_.fun)>(f); | ||
} | ||
|
||
// To help prevent subtle lifetime bugs, FunctionRef is not assignable. | ||
// Typically, it should only be used as an argument type. | ||
FunctionRef& operator=(const FunctionRef& rhs) = delete; | ||
|
||
// Call the underlying object. | ||
R operator()(Args... args) const { | ||
return invoker_(ptr_, std::forward<Args>(args)...); | ||
} | ||
|
||
private: | ||
absl::functional_internal::VoidPtr ptr_; | ||
absl::functional_internal::Invoker<R, Args...> invoker_; | ||
}; | ||
|
||
} // namespace absl | ||
|
||
#endif // ABSL_FUNCTIONAL_FUNCTION_REF_H_ |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,140 @@ | ||
// Copyright 2019 The Abseil Authors. | ||
// | ||
// Licensed under the Apache License, Version 2.0 (the "License"); | ||
// you may not use this file except in compliance with the License. | ||
// You may obtain a copy of the License at | ||
// | ||
// https://www.apache.org/licenses/LICENSE-2.0 | ||
// | ||
// Unless required by applicable law or agreed to in writing, software | ||
// distributed under the License is distributed on an "AS IS" BASIS, | ||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
// See the License for the specific language governing permissions and | ||
// limitations under the License. | ||
|
||
#include "absl/functional/function_ref.h" | ||
|
||
#include <memory> | ||
|
||
#include "benchmark/benchmark.h" | ||
#include "absl/base/attributes.h" | ||
|
||
namespace absl { | ||
namespace { | ||
|
||
int dummy = 0; | ||
|
||
void FreeFunction() { benchmark::DoNotOptimize(dummy); } | ||
|
||
struct TrivialFunctor { | ||
void operator()() const { benchmark::DoNotOptimize(dummy); } | ||
}; | ||
|
||
struct LargeFunctor { | ||
void operator()() const { benchmark::DoNotOptimize(this); } | ||
std::string a, b, c; | ||
}; | ||
|
||
template <typename Function, typename... Args> | ||
void ABSL_ATTRIBUTE_NOINLINE CallFunction(Function f, Args&&... args) { | ||
f(std::forward<Args>(args)...); | ||
} | ||
|
||
template <typename Function, typename Callable, typename... Args> | ||
void ConstructAndCallFunctionBenchmark(benchmark::State& state, | ||
const Callable& c, Args&&... args) { | ||
for (auto _ : state) { | ||
CallFunction<Function>(c, std::forward<Args>(args)...); | ||
} | ||
} | ||
|
||
void BM_TrivialStdFunction(benchmark::State& state) { | ||
ConstructAndCallFunctionBenchmark<std::function<void()>>(state, | ||
TrivialFunctor{}); | ||
} | ||
BENCHMARK(BM_TrivialStdFunction); | ||
|
||
void BM_TrivialFunctionRef(benchmark::State& state) { | ||
ConstructAndCallFunctionBenchmark<FunctionRef<void()>>(state, | ||
TrivialFunctor{}); | ||
} | ||
BENCHMARK(BM_TrivialFunctionRef); | ||
|
||
void BM_LargeStdFunction(benchmark::State& state) { | ||
ConstructAndCallFunctionBenchmark<std::function<void()>>(state, | ||
LargeFunctor{}); | ||
} | ||
BENCHMARK(BM_LargeStdFunction); | ||
|
||
void BM_LargeFunctionRef(benchmark::State& state) { | ||
ConstructAndCallFunctionBenchmark<FunctionRef<void()>>(state, LargeFunctor{}); | ||
} | ||
BENCHMARK(BM_LargeFunctionRef); | ||
|
||
void BM_FunPtrStdFunction(benchmark::State& state) { | ||
ConstructAndCallFunctionBenchmark<std::function<void()>>(state, FreeFunction); | ||
} | ||
BENCHMARK(BM_FunPtrStdFunction); | ||
|
||
void BM_FunPtrFunctionRef(benchmark::State& state) { | ||
ConstructAndCallFunctionBenchmark<FunctionRef<void()>>(state, FreeFunction); | ||
} | ||
BENCHMARK(BM_FunPtrFunctionRef); | ||
|
||
// Doesn't include construction or copy overhead in the loop. | ||
template <typename Function, typename Callable, typename... Args> | ||
void CallFunctionBenchmark(benchmark::State& state, const Callable& c, | ||
Args... args) { | ||
Function f = c; | ||
for (auto _ : state) { | ||
benchmark::DoNotOptimize(&f); | ||
f(args...); | ||
} | ||
} | ||
|
||
struct FunctorWithTrivialArgs { | ||
void operator()(int a, int b, int c) const { | ||
benchmark::DoNotOptimize(a); | ||
benchmark::DoNotOptimize(b); | ||
benchmark::DoNotOptimize(c); | ||
} | ||
}; | ||
|
||
void BM_TrivialArgsStdFunction(benchmark::State& state) { | ||
CallFunctionBenchmark<std::function<void(int, int, int)>>( | ||
state, FunctorWithTrivialArgs{}, 1, 2, 3); | ||
} | ||
BENCHMARK(BM_TrivialArgsStdFunction); | ||
|
||
void BM_TrivialArgsFunctionRef(benchmark::State& state) { | ||
CallFunctionBenchmark<FunctionRef<void(int, int, int)>>( | ||
state, FunctorWithTrivialArgs{}, 1, 2, 3); | ||
} | ||
BENCHMARK(BM_TrivialArgsFunctionRef); | ||
|
||
struct FunctorWithNonTrivialArgs { | ||
void operator()(std::string a, std::string b, std::string c) const { | ||
benchmark::DoNotOptimize(&a); | ||
benchmark::DoNotOptimize(&b); | ||
benchmark::DoNotOptimize(&c); | ||
} | ||
}; | ||
|
||
void BM_NonTrivialArgsStdFunction(benchmark::State& state) { | ||
std::string a, b, c; | ||
CallFunctionBenchmark< | ||
std::function<void(std::string, std::string, std::string)>>( | ||
state, FunctorWithNonTrivialArgs{}, a, b, c); | ||
} | ||
BENCHMARK(BM_NonTrivialArgsStdFunction); | ||
|
||
void BM_NonTrivialArgsFunctionRef(benchmark::State& state) { | ||
std::string a, b, c; | ||
CallFunctionBenchmark< | ||
FunctionRef<void(std::string, std::string, std::string)>>( | ||
state, FunctorWithNonTrivialArgs{}, a, b, c); | ||
} | ||
BENCHMARK(BM_NonTrivialArgsFunctionRef); | ||
|
||
} // namespace | ||
} // namespace absl |
Oops, something went wrong.