Summary:
folly::AsyncSocket: propagate finishFail ex

(Note: this ignores all push blocking failures!)

Reviewed By: yfeldblum

Differential Revision: D25479314

fbshipit-source-id: 683e1e118ace2ea983bde78d8afddb84dab69f6f

Summary:
AsyncUDPSocket: multi release pacing for UDP GSO

(Note: this ignores all push blocking failures!)

Reviewed By: mjoras

Differential Revision: D25451694

fbshipit-source-id: 3550a3744b407cbc40efebe759f472ee9f40a5b8

Summary:
The `StringPiece` overloads of comparisons operators are inefficient to compile, as they get in the overload set of every comparison and then get ruled out by SFINAE (which require trait instantiations).

Move them instead to friend inlines, where they enjoy the expected implicit conversion rules.

(Note: this ignores all push blocking failures!)

Reviewed By: yfeldblum

Differential Revision: D25549986

fbshipit-source-id: fd323e2e8cbf4f3dd29508b8aff1cfaba2784f4f

Summary:
Previously theFOLLY_HAVE_LIBUNWIND macro would evaluate to false even if LibUnwind was available.

Pull Request resolved: https://github.com/facebook/folly/pull/1501

Reviewed By: yfeldblum

Differential Revision: D25583562

Pulled By: Orvid

fbshipit-source-id: 7dac5afa1f0f24747f4accf2e08b804ab12e416f

Summary:
Motivation: we sometimes need to add concept of lower priorities on top of executors which provide custom scheduling via custom APIs such `EDFThreadPoolExecutor`.

This adapter wraps an arbitrary executor, and adds an additional queue. Tasks from this queue will be fetched and placed on the wrapped executor's queue in a metered fashion - in particular we only allow up to "maxReadAtOnce" tasks to be placed onto the main executors queue.

Once work is added to metered queue, the adapter schedules callback into the wrapped executor. When callback is executed it:
1) fetches head task from the queue
2) fetches up to maxReadAtOnce - 1, and reschedules those onto the main executor.
3) reschedules itself onto the main executor
4) executes the task fetched at stage 1.

While in theory this algorithm does not provide strong priority guarantees, in practice lower priority tasks are almost always yielding to the higher priority tasks.

This primitive also allows interesting compositions to be built:
1. multiple priorities scheduling can be achieved by chaining metered adapters.
2. Fair queue scheduling (e.g. round robin consumption from N queues) can be achieved by creating N metered adapters wrapping the same executor.

(Note: this ignores all push blocking failures!)

Reviewed By: prshreshtha

Differential Revision: D24983861

fbshipit-source-id: 1a4ce61fc7cc706889da9724de71822bfaab440b

Summary:
So it may be easier to use in Python code.

A lot of Python code will check the type with this:
```
if isinstance(obj, (bytes, memoryview)):
  ...
```

Currently, the `IOBuf.__iter__` returns a `cython.view.memoryview` c-type (which can be only "cimport" in cython but not able to "import), and to make it useable in scenarios like above, we have to explicitly cast it to builtin `memoryview`.

With this change, the use of the iterator is more natural.

Reviewed By: fried

Differential Revision: D25577842

fbshipit-source-id: 6b22028d06bba639fca32f7de3a063e1fb1baa15

Summary:
Benchmarks are great, but are missing parts that allows them to be run outside of raw binary, like in mobile context, where we generally want to showcase the list of results, instead of pretty printing them to stdout.
To allow for that - adding a new public API, and restructuring few things, to code dedupe and still maintain the same functionality.

Reviewed By: Orvid

Differential Revision: D25552087

fbshipit-source-id: 946a9fbcac3faff0a69f3d86d20f3621649c7e5a

Summary:
This new API has a few benefits:
1. It allows `getSSLSession` to support TLS 1.3 session resumption by returning a mutable session wrapper as opposed to the immutable `SSL_SESSION*` object.
2. OpenSSL `SSL_SESSION*` objects require the caller to keep accurate reference counts. Failure to do so can result in memory leaks or use-after-free errors.
3. This design abstracts away OpenSSL internals, which are unnecessary for the caller to perform session resumption.

Reviewed By: mingtaoy

Differential Revision: D24239802

fbshipit-source-id: cd3e90217717394f32dc6a2281e7a40c805990b2

Summary:
In most cases, `folly::observer::waitForAllUpdates` should not be needed. However, the asynchronous nature of observers break some basic assumptions that most users expect. Such as:
```
thing.set(value);
EXPECT_EQ(thing.get(), value);
```
If `thing` is using `folly::observer` underneath the hood, the asynchrony is passed on to the user which is very easy to overlook, leading to bugs. The API of `thing` might want to enforce that when `thing.set` returns, all observed values will have been updated.
Blocking is a perfectly okay solution in cases we don't expect an observer to be updated frequently.

Differential Revision: D25542376

fbshipit-source-id: c83909807fbf36e0311a45b667da94c43751a1da

Summary: Mirrors Task. One behavioral difference is that yielding an empty Try from a Task converts into a UsingUninitializedTry exception, while for AsyncGenerator it converts into a return. This is for consistency with Thrift's ClientBufferedStream to avoid confusing users, but there is also an argument for converting to UsingUninitializedTry instead.

Reviewed By: yfeldblum

Differential Revision: D25379361

fbshipit-source-id: 2a2878185696566b29345c99fee7ba74bef4ae8a

Summary:
This diff introduces a generic abstraction to convert a python error (set by a C-API call) into an informative C++ exception.

The main motivation for this is to improve the error handling behavior when dealing with failed cython api module imports.

This diff adds one callsite to the new abstraction in fiber.cpp  to demonstrate its usage.

Reviewed By: yfeldblum

Differential Revision: D25469594

fbshipit-source-id: e9f83c06460f35fa76030ceae9726297276db850

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