Summary:
The null-deleter test case showcases not_null's handling of null deleters. It also tries to demonstrate that std::unique_ptr does not handle null deleters properly (e.g. by segfaulting). The latter is really "check what kind of undefined behavior we encounter", and this doesn't always work. Surprise! Specifically, the undefined behavior encountered when supplying a null deleter into std::unique_ptr when using tsan is an infinite hang, which breaks the test suite.

Fortunately, testing std::unique_ptr's handling of null deleters is irrelevant to the correctness of not_null_unique_ptr, so we can remove this code.

After this diff, the following test does not hang:
  buck test mode/dev-tsan //folly/memory/test:not_null_test -- 'nn\.null_deleter' --run-disabled

Reviewed By: yfeldblum

Differential Revision: D24662902

fbshipit-source-id: 230187890b29e1d1a5c8284958c9b798c891c7f7

Summary: Fix heap use after free test issue

Reviewed By: danobi

Differential Revision: D24656212

fbshipit-source-id: 03ab1ee563f56e55a7b793155355c43bdfa11fdf

Reviewed By: yfeldblum

Differential Revision: D24660041

fbshipit-source-id: fe31b99206d5bf5b643d8e8111b25c570fe7c0d8

Summary:
This test inexplicably aborts when ran under TSAN.  TSAN reports a read-write
race where the exception is freed by the lock-holder / combiner thread and read
concurrently by the thread that requested the combine operation.

TSAN reports a similar read-write race for this code as well
https://gist.github.com/aary/a14ae8d008e1d48a0f2d61582209f217 (copied below).
Which is easier to verify as being correct.  Though this does not conclusively
prove that this test and implementation are race-free, the above repro combined
with error-free stress runs of this test under other modes (optimized builds
with and without both ASAN and UBSAN) give us a high signal at TSAN's error
being a false-negative.

So disabling it for now until some point in the future where TSAN stops
reporting this as a false-negative

```
namespace {
struct Storage {
  std::atomic<std::uint64_t> futex_{0};
  std::atomic<std::uint64_t> next_;
  std::aligned_storage_t<48, 8> storage_;
};

template <typename Waiter>
void transferCurrentException(Waiter* waiter) {
  assert(std::current_exception());
  new (&waiter->storage_) std::exception_ptr{std::current_exception()};
  waiter->futex_.store(1, std::memory_order_release);
}

template <template <typename> class Atom = std::atomic>
void concurrentExceptionPropagationStress(
    int,
    std::chrono::milliseconds) {
  auto exceptions = std::vector<std::unique_ptr<Storage>>{};
  exceptions.resize(1000000);
  for (auto i = std::size_t{0}; i < exceptions.size(); ++i) {
    exceptions[i] = std::make_unique<Storage>();
  }
  auto throwing = std::function<void(std::uint64_t)>{[&](auto counter) {
    if (counter % 2) {
      throw std::runtime_error{folly::to<std::string>(counter)};
    }
  }};

  std::cout << "Started test" << std::endl;
  auto writer = std::thread{[&]() {
    for (auto i = std::size_t{0}; i < exceptions.size(); ++i) {
      try {
        std::this_thread::yield();
        throwing(i);
      } catch (...) {
        transferCurrentException(exceptions.at(i).get());
        continue;
      }

      exceptions.at(i)->futex_.store(2, std::memory_order_release);
    }
  }};

  auto reader = std::thread{[&]() {
    for (auto i = std::size_t{0}; i < exceptions.size(); ++i) {
      auto value = std::uint64_t{};
      while (!(value = exceptions.at(i)->futex_.load(std::memory_order_acquire))) {}

      if (value == 1) {
        try {
          auto buf = reinterpret_cast<std::exception_ptr*>(&exceptions.at(i)->storage_);
          auto ex = folly::launder(buf);
          auto copy = std::move(*ex);
          ex->exception_ptr::~exception_ptr();
          std::rethrow_exception(std::move(copy));
        } catch (std::exception& exc) {
          assert(folly::to<std::uint64_t>(exc.what()) == i);
        }
      }
    }
  }};

  reader.join();
  writer.join();
}
} // namespace
```

Reviewed By: yfeldblum

Differential Revision: D24653383

fbshipit-source-id: 3ce166766eb42b22ec7b8cfaf8d31ca53580ff9e

Summary:
Fixes compilation of `co_await co_awaitTry(someTask.scheduleOn(ex))` when
awaited within other `Task` coroutines by adding the `await_resume_try()`
method to ViaIfAsyncAwaiter.

Also added some unit-tests for this case.

Reviewed By: andriigrynenko

Differential Revision: D24650827

fbshipit-source-id: 687717d9f73f1fdcfb1f2ff17e4ddca46c16b189

Summary: Fix async socket test (stack-use-after-scope)

Reviewed By: andriigrynenko

Differential Revision: D24650836

fbshipit-source-id: 795fb71770612a409195d93216c7c5e129bea605

Summary: Avoid dereferencing a nullptr socket_

Reviewed By: danobi

Differential Revision: D24652875

fbshipit-source-id: 63a9535226c8ff58fd5348f3c38f5c6c498d9527

Summary: It's useful to be able to use the v4-mapped addresses sometimes.

Reviewed By: avasylev

Differential Revision: D24371807

fbshipit-source-id: 74fe13fa4bef9c77cc51a18137559facda9bdbeb

Summary:
This adds support for applying the co_awaitTry() algorithm to a
TaskWithExecutor type.

This required a bit of a refactor of the `co_awaitTry()` implementtion
to not require that it's passed a SemiAwaitable but and to allow
Awaitable objects to also be passed to `co_awaitTry()`.

Renamed TaskWithExecutor::InlineAwaiter to InlineTryAwaitable and make
it private to better reflect its purpose.

No longer implement `Task::Awaiter::await_resume()` in terms of the
`await_resume_try()` method. This should avoid a call to the Try<T>
move-constructor by extracting the T result directly from the Try<T>
stored in the promise.

Reviewed By: andriigrynenko

Differential Revision: D24602729

fbshipit-source-id: d352e717877769502cc55a01731eb165ddad9ad8

Summary: This allows migrating projects that were creating custom NotificationQueues.

Differential Revision: D24580356

fbshipit-source-id: ce9a15c408224b8a471246fde2bd121eab4ae329

Summary:
AsyncUDPSocket zerocopy support

(Note: this ignores all push blocking failures!)

Reviewed By: mjoras

Differential Revision: D24553259

fbshipit-source-id: 8c2385a2a336f3c84c76e4e29f42596a5af657e7

Summary:
Context: we don't yet support uint8_t/uint16_t as SkipValueType due to integral promotion errors. Once we do (something like D22249713, D24571536), consider the below test case

```
using ValueType = uint64_t;
using SkipValueType = uint8_t;
Encode<ValueType, SkipValueType, ...>({0, std::numeric_limits<ValueType>::max() -1});
```

This would check fail at
```
CHECK_LT(upperBound >> numLowerBits, std::numeric_limits<SkipValueType>::max());
```

(255 vs 255)

In fact, I think CHECK_LE is a more correct check.

Also made another check fail to print nicer results for uint8 values.

Reviewed By: ot, philippv

Differential Revision: D24605502

fbshipit-source-id: e422ed1f959ff8ef63dfe99149340637a3741b2a

Summary:
Replace the Travis build status badge in README.md with 3 separate badges
for the newer Linux, Mac, and Windows builds performed via Github Actions.

Reviewed By: yfeldblum, vitaut

Differential Revision: D24610866

fbshipit-source-id: 6581387989fb15213519db7810a4430cfb04e2ea

Summary:
evb_ can be updated by start/stopConsuming, so it's not safe to access it in the assertion (given that size() is thread safe).

(Note: this ignores all push blocking failures!)

Differential Revision: D24559287

fbshipit-source-id: b5886ce13fa54fb59361c1de110ec8bb02a06a12

Summary:
The current `pauseAccepting` and `resumeAccepting` will direct operate on the underlying udp socket to pause/resume read any packet. However this makes it hard to make similar behavior as TCP, which stop/pause the listening socket but still serving the accepted socket.
As for UDP the bookkeeping is usually done at upper layer. this change will allowed the `AsyncUDPServerSocket` inform its callback that pause/resume new peer "connection".

Reviewed By: yfeldblum

Differential Revision: D24483859

fbshipit-source-id: ed10eaf3e9ef140112002303e37a73eff7d40943

Summary:
Avoid duplicate code for UDP CMSG processing

(Note: this ignores all push blocking failures!)

Reviewed By: yfeldblum

Differential Revision: D24394694

fbshipit-source-id: 80664109154e78ec4d6ee8d33cf9a5269f60195e

Summary:
Rather than conditionally calling either popAsyncStackFrameCallee()
or deactivateAsyncStackFrame() depending on whether there is a
parent frame, we now extend popAsyncStackFrameCallee() to handle
the null parent case.

Reviewed By: andriigrynenko

Differential Revision: D24554471

fbshipit-source-id: 7f7ce64da63db1fa726d9fb23669fe49d03c2d6c

Summary:
Removes the symmetricTransferMaybeReschedule() helper functions as
the workarounds are no longer required now that clang fixes have been
merged.

Reviewed By: andriigrynenko

Differential Revision: D24554145

fbshipit-source-id: ce3a6b6a8ead63b98e605c21d6555950b3b55c9a

Summary: Merely a terminology thing. An object returned by `co_await` is an awaiter, not an awaitable.

Reviewed By: yfeldblum, lewissbaker

Differential Revision: D24524929

fbshipit-source-id: ee9b7c8807972e78fff97f055d498977048d0c48

Summary:
Allocation of InlineTaskDetached coroutines now call through to the
folly_coro_async_malloc() and folly_coro_async_free() functions so that
their allocations can be correctly accounted for as coroutine allocations.

Reviewed By: yfeldblum

Differential Revision: D24574568

fbshipit-source-id: 9bece3f8e6f6d221bca021a50fe02e1eed88f07b

Summary:
The previous implementation was calculating an address within the
detached_task() function by just adding the constant +2 to the
function-pointer. This was causing some issues with some of the
tools used to optimise binaries.

Reworked this implementation to instead actually return a true
return-address obtained from the compiler builtin so that it's
hopefully less problematic for those tools.

Reviewed By: maksfb

Differential Revision: D24506346

fbshipit-source-id: c41bd55ab09ebc70d040d355556ed4992243c14f

Summary:
D24542292 fixed a problem introduced by D24505812 (https://github.com/facebook/folly/commit/af8630489dc8318f72d18358591bc3fa0be304ff) with gcc version 6.

Unfortunately this broke some python code generation.

I didn't fully root cause the issue but it appears that the macro expansion of FMT_BEGIN_NAMESPACE is inconsistent.

The original diff D24505812 (https://github.com/facebook/folly/commit/af8630489dc8318f72d18358591bc3fa0be304ff) hardcoded the fmt namespace I changed it to what the fmt lib used when declaring the formatter template.

Reverting the change to use the macro back to hardcoding the fmt namespace fixes the test and still works around the gcc 6 compler problem.

Reviewed By: vitaut

Differential Revision: D24542292

fbshipit-source-id: cfaecf8bb94f3c6fc084ebae79886ad3e2b58539

Summary:
The TaskTests::FutureRoundtrip and TaskTests::StartInlineUnsafe tests were
incorrectly using stateful lambdas in a way that leads to the coroutines
having a dangling reference to a destructed temporary lambda. This was causing
ASAN failures.

This changes those usages to instead use stateless lambdas.

Reviewed By: lxfind

Differential Revision: D24542508

fbshipit-source-id: 034d397b79e0553094a14d2cb6d00fe3816b4b92

Summary:
The document titles should be explicitly passed, otherwise pandoc generates a warning and tries to guess

Before:
```
folly/folly/docs on  master
❯ make Format.html
/usr/bin/pandoc -s -H style.css -f markdown -t html --toc -o Format.html Format.md
[WARNING] This document format requires a nonempty <title> element.
  Defaulting to 'Format' as the title.
  To specify a title, use 'title' in metadata or --metadata title="...".

folly/folly/docs on  master
❯ make index.html
/usr/bin/pandoc -s -H style.css -f markdown -t html --toc -o index.html *.md
[WARNING] This document format requires a nonempty <title> element.
  Defaulting to 'AtomicHashMap' as the title.
  To specify a title, use 'title' in metadata or --metadata title="...".
```

After:
```
folly/folly/docs on  fix-docs [!]
❯ make Format.html
/usr/bin/pandoc -s -H style.css -f markdown -t html --toc -o Format.html Format.md --metadata title="folly/Format.h"

folly/folly/docs on  fix-docs [!]
❯ make index.html
/usr/bin/pandoc -s -H style.css -f markdown -t html --toc -o index.html *.md --metadata title="Folly API Documentation"
```

Reviewed By: danobi

Differential Revision: D24546374

fbshipit-source-id: 818e6ce39f361695a5f94c7662953062ea2f2868

Summary: Using the FunctionScheduler with PoissonDistribution will not work if we supply an interval of 36min+. This is around 2^31 so looks like it's hitting some integer limit. Also, there is no failure message and the behavior is that the function scheduler just never executes the function even for the first time after startup interval. Fixing this by using the proper type in the disribution.

Reviewed By: yfeldblum

Differential Revision: D24505727

fbshipit-source-id: ad050cf82bcf5a39383ffc601b52ad05d3d54f44

Summary: Original commit changeset: 578dd8981922

Reviewed By: jalopezsilva, pdubovitsky

Differential Revision: D24531203

fbshipit-source-id: 573ccd55a4d8f3b6841cc533e25c84b18fe24d4d

Summary:
Some llvm toolsets mis-parse the function-like C-style casts in ConstexprMath.h as function declarations, resulting in strange compiler errors. Prefer `static_cast` to eliminate the ambiguity.

Note: We cannot use brace-initialization syntax, because that would error on narrowing conversions.

Reviewed By: ispeters, Mizuchi

Differential Revision: D24463342

fbshipit-source-id: 5d5aabb08cd20e91a1a5f5460cc4505cafb3cdfc

Summary: This is a quick and dirty hack that works around a wasm dependency issue. The issue manifests itself in a compile error when including fmt headers during a wasm build.

Reviewed By: shodoco

Differential Revision: D24516599

fbshipit-source-id: 578dd8981922a97702992a8c30b88b47fef1706e

Summary: gcc versions 5 & 6 do not support template specializations outside the original namespace of the template even if the namespace is explicitly included in the template specialization.

Differential Revision: D24505812

fbshipit-source-id: 693e93de5bc5074866fdea713436a06d35762cb7

Summary:
taskExecuteCount_ can be incremented from a single thread, but reading it from another thread is still technically a data race. Mark it as atomic to make TSAN happy.
Also make sure we never return < 0 when called from a non-consumer thread (since we only have the synchronization guarantee on the consumer thread).

Differential Revision: D24523284

fbshipit-source-id: 6185125e132d71a83a3f29c909b7e4eab09e6e79

Summary:
Glog v0.4.0 when configured with Debug build type adds a 'd' suffix to
the library file. This results in FindGlog.cmake failing to locate it.

Update FindGlog.cmake to use check for 'glogd', and use
select_library_configurations() to set GLOG_LIBRARY to the correct
found filename.

(Note: this has no effect if a non-Debug type is used.)

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

Reviewed By: yfeldblum

Differential Revision: D24503510

Pulled By: Orvid

fbshipit-source-id: 705df05a4a3d7df2df8af3bb66c319fb044adbce

Summary: This also splits queue size counter into two to make sure we do fewer atomic operations on the consumer thread.

Differential Revision: D24490151

fbshipit-source-id: 69297a2fd0c5fddcd7355a28fe600b72320e81cd

Summary: Following up on some comments on the initial diff.

Differential Revision: D24489715

fbshipit-source-id: baea66c7b811ebabf4476d7fd6a1136ab9ec2282

Differential Revision: D24414496

fbshipit-source-id: ad552d3dd58b6c351c99e5f8c9056c5829c4c095

Summary: Add an {fmt} formatter for `StringPiece`. This is much faster than going through ostream `operator<<` which we fallback to otherwise.

Reviewed By: yfeldblum

Differential Revision: D24337424

fbshipit-source-id: c6f1775cf83cfa6bcaa25cb4f6b665a76672e7c3

Summary:
A lot of these imports with specialization is not necessary. Clean up them to use generic functions instead.

(Note: this ignores all push blocking failures!)

Reviewed By: yfeldblum

Differential Revision: D24236181

fbshipit-source-id: fe6e6c41f680561c625b263bc6adeba738ddb252

Summary: Inform LifecycleObservers when an EventBase is attached or detached from an AsyncSocket.

Reviewed By: bschlinker

Differential Revision: D24294292

fbshipit-source-id: 652ec438d0b6213a78742b8a8ef0d24d55ac9816

Summary: Implement a thread local Observer that optimizes on the shared_ptr copy by using ReadMostlySharedPtr

Reviewed By: andriigrynenko

Differential Revision: D24439652

fbshipit-source-id: 9174be7f3f2fc34bdc79bd83eab571972b0c057d

Summary: Construction of ReadMostlyMainPtr is much slower than shared_ptr

Reviewed By: yfeldblum

Differential Revision: D24350176

fbshipit-source-id: 55730192f79288e7ad848b4cec6483bc0c1711b6

Summary:
This is a lock-free replacement for NotificationQueue. Unlike notification queue it supports only one consumer, which allows simplifying the internal structure a lot and avoiding any use of spin locks.
Another improvement comparing to NotificationQueue is the use of epoll edge-triggered events. This allows completely eliminating read syscals, since we don't need to drain eventfd to stop it from waking up the epoll loop.

Differential Revision: D24297158

fbshipit-source-id: 1f418d861210f6dcad52b4d663f49eb2e8f3ae8c