Summary:
When SingleProducer is disabled, AsyncPipe's method becomes thread-safe
and can be called by multiple threads simultaneously. This is useful
in a use case where a long running operation is being executed by
multiple threads that all want to post status updates to the same
AsyncPipe instance.

Reviewed By: iahs

Differential Revision: D25494695

fbshipit-source-id: 1d0a74ec69dc8f64c171e21be612d211919cda4b

Summary: All changes were automated

Reviewed By: Orvid

Differential Revision: D25507592

fbshipit-source-id: 3ce36732a2d1c691087fbd95c3e87f554f4d8d98

Summary:
During tsan test, sometimes annotationGuard() is called after kAnnotationMutexes is already destroyed which throws exception.
This change fix the issue by uses Indestructible for kAnnotationMutexes, so that it is not destroyed.

Reviewed By: yfeldblum

Differential Revision: D25443571

fbshipit-source-id: 69411a7edc4f96ba8c7d08bd29f87ab7b2ff78ae

Summary:
This includes several enhancements to folly::small_vector:

Eliminate overhead accessing vector elements by making heap_ points to element 0 of the vector.  To get start address only dispatch is required as shown below:

     value_type* data () {
       // Dispatch between heap_ or internalStorage,
       return isExtern() ? heap_ : &internalStorage_;
     }

Reorganize the implementation by recording if capacity is stored internally or on the heap in "size". As a result the maximum vector size is half smaller. This is the only visible behavior change of this PR. Assuming size is 64 bits then
  - bit63 determines if vector elements are stored in internalStorage_ or externally in the heap
  - bit62 determines if vector capacity is stored internally or on the heap
  - bit61..bit0 contain the size of the vector.

Reduce the overhead of updating size buy adding incrementSize functions.

Tune emplace_back function and vector initialization.

Reviewed By: yfeldblum

Differential Revision: D24413105

fbshipit-source-id: b447704832af9c734be51aa6d23b8cb4be69a8bf

Summary:
The initialization of `folly::MicroLock` *looks* correct. MSAN instrumentation probably needs to be disabled in its implementation.

Regardless, the main point of using `folly::MicroLock` was its low memory usage (1 byte). I'm now changing it to `folly::SharedMutex` (4 bytes) which will be the same size due to alignment. Although `folly::SharedMutex` is not ideal for write-only locks, we don't care too much about write performance here.

Differential Revision: D25487925

fbshipit-source-id: 4c30650cf22dafbdaa9fea0c2252d29caf477d54

Summary: folly/Traits.h defines a `void_t` alias in the `folly::` namespace. Just use that instead of specifying the one in `std::`.

Reviewed By: ispeters

Differential Revision: D25483712

fbshipit-source-id: 6be0435dfec600690cc90bc15fd3d2af17826173

Reviewed By: prshreshtha

Differential Revision: D25387330

fbshipit-source-id: 027e04024e01d1eab938d67a2d1dfc93c9322b15

Summary: The call-once logic in getFiberManager was unnecessarily complex. getFiberManager should only be called on main context, so use a static var initialization to implement the call-once logic (using executor.cpp as an example).

Reviewed By: yfeldblum

Differential Revision: D25467655

fbshipit-source-id: c880b1740edf28944e772c9310f3e45f5612396d

Summary:
With the current constructor setup, overwriting multiple request datas involves chaining together multiple ShallowCopyScopeGuard. This is quite inefficient as it involves copying the requests-data/callbacks maps multiple times.

This diff introduces a new variadic constructor that accepts RequestDataItems (named pair of token and data)

Reviewed By: A5he

Differential Revision: D25317291

fbshipit-source-id: 8a9cb00a615ecf802f22727189e4dc5a0c056c73

Summary: Adding a new ReleasableDestructor and use it in `folly::AsyncSocket::UniquePtr`.

Reviewed By: yfeldblum

Differential Revision: D25352913

fbshipit-source-id: b85204688706cb82a323e37063c9a6a390ec2ee8

Summary: This simplifies generic code.

Reviewed By: andriigrynenko

Differential Revision: D25164246

fbshipit-source-id: 4f42a2360f7ce32978360ddad63d1ca9512e6135

Summary: Even though `SimpleObservable<T>::getObserver` lazily creates the observer, it has no side-effects and so it can be `const`.

Differential Revision: D25146628

fbshipit-source-id: f7d850aed5748a81c7cf083d489ca0d2c58be72c

Summary: `AsyncServerSocket::getQueueTimeout` also returns an `Observer` now.

Reviewed By: andriigrynenko

Differential Revision: D25146630

fbshipit-source-id: 106ffc744eb6a3c09625897e72484054e0330247

Summary:
`FOLLY_TLS` is explicitly disabled for 32-bit iOS. Perhaps because old iOS versions did not support `__thread`.

`thread_local` is standard C++11, appears to be supported by the iOS 32-bit build, and is also used in multiple places around folly already.

Differential Revision: D25287484

fbshipit-source-id: 2e81e275e0f1cba7bcf5239fe34d4b5eb8add6d0

Summary:
An `AtomicObserver` is a read-optimized cache for an `Observer` value using `std::atomic`. This avoids creating a `shared_ptr` on every read (atomic increment/decrement on control block). The functionality is similar to that of `TLObserver` but uses significantly less memory if `std::atomic<T>` is valid.

The read path involves 2 atomic loads and a cache staleness check. A lock is used when the cache needs to be updated.

Reviewed By: zhxchen17

Differential Revision: D25254487

fbshipit-source-id: cfaf7c328c075f9f06c5c9d2d7bb2e1987285616

Summary:
Add API to allow clients to advertise support for psk_ke (non-DHE) resumption. Unfortunately, OpenSSL has no option to allow servers to support psk_ke resumption.

SSL_OP_ALLOW_NO_DHE_KEX option was added in OpenSSL 1.1.1, so add the appropriate guard.

Reviewed By: mingtaoy

Differential Revision: D24546720

fbshipit-source-id: fd7c5b3a9f4c572876f9b421ee8f74ba7d5e252c

Summary:
EventBaseAtomicNotificationQueue is now what used to be just AtomicNotificationQueue.
In the future, this allows reusing AtomicNotificationQueue with other types of executors.

(Note: this ignores all push blocking failures!)

Reviewed By: andriigrynenko

Differential Revision: D24878180

fbshipit-source-id: d719e31c7194cb2dd6d57a103814581b802a9250

Summary: These are similar enough that implicit conversion to make the migration boundary easy to manage seems justified

Reviewed By: WillerZ

Differential Revision: D25384005

fbshipit-source-id: 4602d9016919860ff0626de4fa4ae5442fca094a

Summary: Add support for Openssl's TLS 1.3 ciphersuites API. SSL_CTX_set_ciphersuites was added in OpenSSL 1.1.1, so guard it with a prereq.

Reviewed By: yfeldblum, mingtaoy

Differential Revision: D24542765

fbshipit-source-id: d281bb2262cd456823da1896c0c77c3ba4ab78ce

Summary:
Older standard libraries provide a `std::enable_shared_from_this` that doesn't have a `weak_from_this()` member, even when compiling in C++17 mode. Change the preprocessor conditional to account for this, and select the custom Folly implementation when the `std::` one is non-conforming.

This change makes special accommodation for older MSVC versions, which fails to define the `__cpp_lib_enable_shared_from_this` feature test macro, but that provides a conforming `std::enable_shared_from_this` when compiling as C++17.

Reviewed By: yfeldblum, ispeters

Differential Revision: D25402425

fbshipit-source-id: c53b9fcebbf93c54342824dd56fd11eaa681abd1

Summary: Make futures::retrying return a SemiFuture and safely constrain where the work runs to avoid accidental inline execution.

Reviewed By: yfeldblum

Differential Revision: D24490957

fbshipit-source-id: 9b8c0f369084f2d26bbb4764abde6866fb09b4d9

Summary:
Watchman's GitHub Action has been failing because of the use of `set-env` is deprecated due to security issues. See https://github.blog/changelog/2020-10-01-github-actions-deprecating-set-env-and-add-path-commands/ for details.

See https://github.com/facebook/watchman/runs/1520165260?check_suite_focus=true for example of failures.

To fix it we just need to write to the special environment file.

Reviewed By: chadaustin

Differential Revision: D25412442

fbshipit-source-id: d31ef025189c8aebfa08d434d9373f5da7d4690e

Summary:
The async stack-trace for a coroutine call-stack that was launched
by calling Task<T>::semi() to create a SemiFuture would have as its
first few frames:
- detached_task
- folly::coro::Task::semi::{lambda#1}::operator()
- <the coroutine being launched>

This isn't particularly useful as it doesn't tell you where the coroutine was launched from. The more interesting information here
is the callsite of .semi() rather than the internals of .semi().

This reworks the implementation of .semi() to capture the return-address
of the call to .semi() and then later inject this as the return-address
of the async-frame when the coroutine is eventually launched.

Note: This also now launches the coroutine inline inside the SemiFuture by calling .startInlineImpl(). This should avoid an
extra executor reschedule.

Reviewed By: yfeldblum

Differential Revision: D25415029

fbshipit-source-id: ab24e86b871c78e2c3a9af843e24e2dab3254273

Summary:
IoUringBackend rework

(Note: this ignores all push blocking failures!)

Reviewed By: kevin-vigor

Differential Revision: D25287276

fbshipit-source-id: b69cc715e8bf5da2e493a742e71a62795a62f955

Summary: folly::ConcurrentHashMap::reserve() - avoid setting count to 0

Reviewed By: magedm

Differential Revision: D25398175

fbshipit-source-id: fc61b27d145f0d800cba9d35c942c0a5c8b53e2a

Summary:
This diff adds heterogeneous mutation support to ConcurrentHashMap.
The gating of the allowed key types are done in `EnableHeterogeneousInsert`.

`CHM::insert()` does not destructure `pair` arguments and `CHM::emplace()` does
not yet attempt to identify a usable key, leaving those as future follow-ups.

Reviewed By: yfeldblum

Differential Revision: D25255528

fbshipit-source-id: e056db05c96d3bd29c8cbce562ecd2221884cd5f

Summary:
This diff adds heterogeneous lookup handling for `ConcurrentHashMap` (`find()`
and `at()`), which allows lookups on keys that the hasher and key equal
functors accept but are not exactly the same as the `KeyType` of the map.
Common usage of the feature include looking up with a `std::string_view` key in
a `map<string, X>`, thereby avoiding creating an unnecessary temporary string
object.

Reviewed By: yfeldblum

Differential Revision: D25250409

fbshipit-source-id: 78dad163d623794b179c1691180b54cf109784ee

Summary: Title, per the comments in D24542765

Reviewed By: mingtaoy

Differential Revision: D25339949

fbshipit-source-id: a203dcd9ee4d2f3282d9d0f8706f8af9f084551c

Summary:
On Windows, MSVC rightfully complains about conversion from uint64_t to uint8_t
and uint32_t. In both cases, the narrowing is acceptable, so let's do that.

Reviewed By: yfeldblum

Differential Revision: D25352231

fbshipit-source-id: aa900fc14a666f1a99bfaa45b1afac02e7209fa3

Summary: This change introduces CO_* versions of the main GTest ASSERT_* macros that we use in test validation. These are needed as calling ASSERT_* in a coroutine does not work. ASSERT_* embeds a `return` statement, while coroutines need a `co_return` statement.

Reviewed By: ispeters

Differential Revision: D25369376

fbshipit-source-id: dbd95e8c21e28581f93202af4d6fea9245238f5d

folly: utf8ToCodePoint: enforce max valid code point is U+10FFFF - return U+FFFD / throw for well-formed UTF-8 encoded values that are larger than the max code point

Summary:
UTF-8 can encode large numbers, but Unicode code points are only defined up to `U+10FFFF`.

For example:
- the 4B UTF-8 encoding `"\xF6\x8D\x9B\ xBC"` (bits: `11110110 10001101 10011011 10111100`) is a valid UTF-8 encoding
- but the encoded value is `U+18D6 (https://github.com/facebook/folly/commit/d40182262d41679cab28f6be7366cc5ff901683b)FC` which is larger than `U+10FFFF`

With `opts.skip_invalid_utf8 = true;` `json::serialize` should have returned `"\ufffd"` since it the input is invalid, but due to a bug in `utf8ToCodePoint` it returned the incorrect `"\"\xF6\x8D\x9B\xBC\""`.

Update `utf8ToCodePoint` to also reject 4 byte UTF-8 encoded values larger than the max Unicode code point (`U+10FFFF`).

Reviewed By: luciang

Differential Revision: D25275722

fbshipit-source-id: e7daeea834a0c5323923a5451a2565ceff5e4734

Differential Revision: D25307854

fbshipit-source-id: 11b1282659b1b2c20b04e848f0c9824813af5b21

Summary: This change introduces a specialization for string-to-float (32-bit) conversion. It improves fidelity to the numeric value represented by the input string.

Reviewed By: vitaut

Differential Revision: D25239226

fbshipit-source-id: 531aa33aa74aaeeb98d9803bcd10bd7f31654988

Summary: Fix the WriteOptions gso default value - it should be disabled

Reviewed By: danobi

Differential Revision: D25313187

fbshipit-source-id: 581f41d9da48405092eef303630aaa88b18d1da0

Summary:
Today, a continuation of coro or semifuture application handlers will always execute on NORMAL priority thread pool. This is because the effective executor for the task is the `ThreadManager::Impl` and its `add()` implementation does not preserver tasks' priority (which we map into thread pool).

In this change, we wrap each priority/source in a separate keepalive. Generated code is routing either coro or semifuture onto the corresponding keepalive, which is preserved across tasks that do not explicitly specify a target executor.

Reviewed By: andriigrynenko

Differential Revision: D25105971

fbshipit-source-id: 9adaea654b3a099ff4de048026a67bdb588a3c2a

Summary: `makeStaticObserver` is a helper method that returns an observer that never changes in value.

Reviewed By: andriigrynenko

Differential Revision: D25254488

fbshipit-source-id: 1336d0088aff1e5abfa8160bd76e4f61b68eaed8

Summary:
This diff enables aggregation of point-in-time snapshots of the `TDigest`s that represents the state of `BasicQuantileStat`

We capture a `Snapshot` of `TDigest` and `SlidingWindow<TDigest>`.

The diff exposes `TDigest` and `SlidingWindow<TDigest>` to `QuantileStats`.

These objects are wrapped by the structs, `Snapshot` and `SnapshotEntry`, in `BasicQuantileStat` and `BasicQuantileStatMap`, respectively .

Reviewed By: yfeldblum

Differential Revision: D25170883

fbshipit-source-id: 0201a05cc4020851b652ed3a7b602d5b22aa63be

Summary:
Clean up tombstones when copying from a full map.
Equal capacity maps are copied with tombstones for speed but that optimization should not be used if it results in a full map.

Add guarantee that a copy from a map with tombstones will have at least one empty element.

Reviewed By: A5he

Differential Revision: D25230678

fbshipit-source-id: 900b734cc526be8da8be4e70137d19645f994f19

Summary: It took me a while to find that I'd `co_await`'d the same `Task<>` twice when working in a loop. This would've made it easier to find.

Reviewed By: andriigrynenko

Differential Revision: D24718615

fbshipit-source-id: 263c0aae208eab37ab198f875dc72a03287785c1

Summary: If timed_wait is called with an awaitable that has a non-copyable return value then we must std::move the result.

Reviewed By: iahs

Differential Revision: D25222893

fbshipit-source-id: bd3c0ca19d182a464ad4b430f1792dcfff54ffdf