Summary: Windows has it, but some things aren't there, and some have different names.

Reviewed By: yfeldblum

Differential Revision: D2990475

fb-gh-sync-id: 3f30e084eb7789c13b3981ec0fbf5b7b642c3367
fbshipit-source-id: 3f30e084eb7789c13b3981ec0fbf5b7b642c3367

Summary: Portabilty.h is just a mashup of everything that was needed up-to now, however, with the Windows port significantly expanding the scope of portability in Folly, it no longer needs to be a massive mashup, so start things by splitting out the asm stubs.

Reviewed By: yfeldblum

Differential Revision: D3007018

fb-gh-sync-id: f32913f74660aaa8889a553ae5d6f7182a4f5789
fbshipit-source-id: f32913f74660aaa8889a553ae5d6f7182a4f5789

Summary:event_base_new does not change the global current_base so no need to
call it with the mutex held.

Reviewed By: chadparry

Differential Revision: D3055963

fb-gh-sync-id: df420b189ef0d7d56eda5ad6c32e03b195804e6b
fbshipit-source-id: df420b189ef0d7d56eda5ad6c32e03b195804e6b

Summary:Treat any return type as convertible to void:

As of C++17, std::function<void(Args...)> can be set to callables
returning non-void types when called with parameters Args....
This diff adds that capability to folly::Function. It also adds
unit tests, not only for ignoring return types, but also for
correctly converting between the return type of the embedded
callabled and the return type of the encapsulating folly::Function.

Allow conversion of one folly::Function type to another one which
declares a return type the original one can be converted to:

E.g. allow to construct a Function<double()> from a
Function<int()> or a Function<Base*()> from a
Function<Derived*()>.

Reviewed By: yfeldblum

Differential Revision: D3095583

fb-gh-sync-id: 6d924dc6e97f759d8109db4200e1cb9333a98d31
fbshipit-source-id: 6d924dc6e97f759d8109db4200e1cb9333a98d31

Summary: It needs stdint to define uint8_t

Reviewed By: yfeldblum, mzlee

Differential Revision: D3101140

fb-gh-sync-id: 308507af1ccd81e2eb389a400376556a6cc597b2
fbshipit-source-id: 308507af1ccd81e2eb389a400376556a6cc597b2

Summary:On Android, clang 3.8 + libstdc++ doesn't support the full
range of atomic operations.  This diff fixes up the ones we
ran into when building fb4a.

Reviewed By: mzlee

Differential Revision: D3092352

fb-gh-sync-id: 7fea8513e23425fc37050ad14d82aabaceb00352
shipit-source-id: 7fea8513e23425fc37050ad14d82aabaceb00352

Summary:[Folly] Fix Build: `folly` after replacing `FOLLY_NORETURN`.

Problem 1:
* Clang does not treat `[[noreturn]]` and `__attribute__((__noreturn__))` as the same attribute. When a function is declared twice with the noreturn attribute, both declarations must use either the one syntax or the other; Clang fails if the two declarations mix-and-match. When both `folly/detail/FunctionalExcept.h` and gcc49's `bits/functexcept.h` are both included from the same source, they (now) mix-and-match the attribute syntaxes and Clang emits an error.
* `folly/detail/FunctionalExcept.h` should be included only when `bits/functexcept.h` is unavailable - somehow, both headers were being included.

We fix the latter problem and keep our `[[noreturn]]` syntax.

Found from WDT build failures in Travis CI.

Reviewed By: ldemailly

Differential Revision: D3089987

fb-gh-sync-id: 705a087fc2a9629739d6cedd8315d56111204e6d
shipit-source-id: 705a087fc2a9629739d6cedd8315d56111204e6d

Summary:Use C++'s standardized `[[noreturn]]` attribute.

All supported compilers (and some unsupported compilers) also support the standardized syntax.

GCC >= 4.8, Clang >= 3.0, and MSVC >= 2015 have direct support for the C++'s standardized way of writing the attribute.

Clang - http://goo.gl/ftJGVM
GCC 4.8.2 - http://goo.gl/ORCVOD
ICC 13.0.1 - http://goo.gl/I5tn5I
MSVC 2015 - https://msdn.microsoft.com/en-us/library/hh567368.aspx

(Regardling Clang, earlier versions may support it. 3.0 was the earliest Clang version listed at godbolt.com, so that's as far back as I went.)

Therefore, we no longer need to use the compiler-specific syntaxes, or use preprocessor macros with per-compiler definitions:

    __attribute__((__noreturn__))
    __attribute__((noreturn))
    __declspec(noreturn)

Reviewed By: Orvid

Differential Revision: D3073621

fb-gh-sync-id: 32d4771d1bf1974693b8574fa2d39c9559872945
shipit-source-id: 32d4771d1bf1974693b8574fa2d39c9559872945

Summary: Because things belong places.

Reviewed By: mzlee

Differential Revision: D3077737

fb-gh-sync-id: 966f37df722ae737481d776ff1c9b0d5132b7a58
shipit-source-id: 966f37df722ae737481d776ff1c9b0d5132b7a58

Summary: And use that to guard the use of posix_memalign.

Reviewed By: benyl

Differential Revision: D3081743

fb-gh-sync-id: 2c71d9cbeeaeb59d1600d486cccfc2109699ba6b
shipit-source-id: 2c71d9cbeeaeb59d1600d486cccfc2109699ba6b

Summary:std::function is copy-constructible and requires that the callable that it wraps
is copy-constructible as well, which is a constraint that is often inconvenient.
In most cases when using a std::function we don't make use of its
copy-constructibility.

This diff introduces a templated type called folly::Function that is very
similar to a std::function, except it is not copy-constructible and doesn't
require the callable to be either.

Like std::function, Function is a templated type with template parameters
for return type and argument types of the callable, but not the callable's
specific type. It can store function pointers, static member function pointers,
std::function objects, std::reference_wrapper objects and arbitrary callable
types (functors) with matching return and argument types.

Much like std::function, Function will store small callables in-place, so
that no additional memory allocation is necessary. For larger callables,
Function will allocate memory on the heap.

Function has two more template parameters: firstly, an enum parameter of
type folly::FunctionMoveCtor, which defaults to NO_THROW and determines
whether no-except-movability should be guaranteed. If set to NO_THROW,
callables that are not no-except-movable will be stored on the heap, even
if they would fit into the storage area within Function.

Secondly, a size_t parameter (EmbedFunctorSize), which determines the size of
the internal callable storage. If you know the specific type of the callable you
want to store, you can set EmbedFunctorSize to sizeof(CallableType).

The original motivation of this diff was to allow to pass lambdas to
folly::Future::then that are not copy-constructible because they capture
non-copyable types, such as a promise or a unique pointer.

Another diff will shortly follow that changes folly::Future to use
folly::Function instead of std::function for callbacks, thus allowing to
pass non-copyable lambdas to folly::Future::then.

Reviewed By: fugalh

Differential Revision: D2844587

fb-gh-sync-id: 3bee2af75ef8a4eca4409aaa679cc13762cae0d0
shipit-source-id: 3bee2af75ef8a4eca4409aaa679cc13762cae0d0

Summary: The guards already look for __APPLE__, but __ANDROID__ needs this as well.

Reviewed By: yfeldblum

Differential Revision: D3053976

fb-gh-sync-id: a9ba7a612d29502d4a7e691c6741837d4a8b42f0
shipit-source-id: a9ba7a612d29502d4a7e691c6741837d4a8b42f0

This reverts commit bb733f43.

Summary:Since SSLContextManager sets SSL_OP_CIPHER_SERVER_PREFERENCE on the SSL_CTX
when it creates contexts, we may be unable to accommodate any clients who
prefer a different ciphersuite. Having differently weighted cipher preference
lists allows SSLContext to set a list with a different most-preferred cipher
for some fraction of new handshakes.

Note: resumption will work with the previously negotiated ciphersuite even if
the server doesn't explicitly prefer/support it anymore, provided the cipher is
supported in OpenSSL.

Reviewed By: knekritz

Differential Revision: D3050496

fb-gh-sync-id: 1c3b77ce3af87f939f8b8c6fe72b6a64eeaeeeb4
shipit-source-id: 1c3b77ce3af87f939f8b8c6fe72b6a64eeaeeeb4

Summary: This helps account for 32-bit vs. 64-bit compilation targets.

Reviewed By: benyl

Differential Revision: D3076523

fb-gh-sync-id: 56f49daaf55d242ac48f8b8d38a40c6d6230818b
shipit-source-id: 56f49daaf55d242ac48f8b8d38a40c6d6230818b

Summary: A more compact hex representation of ciphers in ClientHello can be useful, e.g., for logging.

Reviewed By: knekritz

Differential Revision: D3052308

fb-gh-sync-id: beaf6fcd4705d4d7fae652d8d8b95b52ca9e07a9
shipit-source-id: beaf6fcd4705d4d7fae652d8d8b95b52ca9e07a9

Summary: This adds Windows support to portability/Memory.h and also does some refactoring to be more correct about when to use posix_memalign, and also changes it to fall back to memalign rather than posix_memalign.

Reviewed By: mzlee

Differential Revision: D3069990

fb-gh-sync-id: 88861583c6028e9fb02a3e3804bd6d476956c555
shipit-source-id: 88861583c6028e9fb02a3e3804bd6d476956c555

Summary:Instead of relying on `push_back()` to guarantee exponential growth,
delegate to `expand_noinit`. This removes the duplication of logic
between the two functions, and significantly speeds up short appends.

```
$ _bin/folly/test/fbstring_benchmark_using_jemalloc --bm_min_usec=100000
                                                          Before:             After:
============================================================================ ===================
./folly/test/FBStringTestBenchmarks.cpp.h       relative  time/iter  iters/s  time/iter  iters/s
============================================================================ ===================
...
BM_push_back_fbstring(1)                                     7.51ns  133.20M     6.87ns  145.49M
BM_push_back_fbstring(23)                                  175.08ns    5.71M   173.92ns    5.75M
BM_push_back_fbstring(127)                                 586.02ns    1.71M   585.70ns    1.71M
BM_push_back_fbstring(1024)                                  3.30us  302.81K     3.41us  293.13K
BM_short_append_fbstring(23)                               367.01ns    2.72M   179.45ns    5.57M
BM_short_append_fbstring(1024)                               9.33us  107.20K     5.72us  174.95K
...
============================================================================ ===================
```

Reviewed By: philippv

Differential Revision: D3075249

fb-gh-sync-id: 497775ba3fc707bf50821a3cf10fb9d247b9352d
shipit-source-id: 497775ba3fc707bf50821a3cf10fb9d247b9352d

Summary: It is perfectly reasonable to need to feature macros when checking configuration, and the configuration is needed to know if features.h exists, so put it in the same file.

Reviewed By: yfeldblum

Differential Revision: D3072255

fb-gh-sync-id: 0f253dd1fa2f4a95adb11f11c45e6b86ef9c25bc
shipit-source-id: 0f253dd1fa2f4a95adb11f11c45e6b86ef9c25bc

Summary: This is needed to avoid a circular dependency.

Reviewed By: yfeldblum

Differential Revision: D3072037

fb-gh-sync-id: 546a46fd68f25f0c5b027d4d938335b2711d8fdd
shipit-source-id: 546a46fd68f25f0c5b027d4d938335b2711d8fdd

Reviewed By: pritamdamania

Differential Revision: D3068807

fb-gh-sync-id: 0b45ab678e2ec5565eb379540576527cf8b1d308
shipit-source-id: 0b45ab678e2ec5565eb379540576527cf8b1d308

Summary:Upgrade UncaughtExceptionCounter to use std::uncaught_exceptions on Visual Studio 2015 Update 1
Closes https://github.com/facebook/folly/pull/358

Reviewed By: yfeldblum

Differential Revision: D3066005

Pulled By: Orvid

fb-gh-sync-id: 6bc7129aa794257b1f6e7a084139d8a3a52fa4a8
shipit-source-id: 6bc7129aa794257b1f6e7a084139d8a3a52fa4a8

Summary: Something that Windows very definitely lacks. This is a fun one.

Reviewed By: yfeldblum

Differential Revision: D2979661

fb-gh-sync-id: e23c1db0cb8655b22308b874bd421a7cc1e4759e
shipit-source-id: e23c1db0cb8655b22308b874bd421a7cc1e4759e

Summary:[Folly] Remove `pthread_yield` support.

* It is not actually part of POSIX - rather, `sched_yield` is.
* In C++, we should be using `std::this_thread::yield` anyway.

Reviewed By: Gownta

Differential Revision: D3056221

fb-gh-sync-id: 2fea55dd7b715149327987d61e5a573ad0455330
shipit-source-id: 2fea55dd7b715149327987d61e5a573ad0455330

Summary:We currently set the session context to the
default of common name, this allows session
context to be set to a different value
for different applications

Reviewed By: ngoyal

Differential Revision: D3059769

fb-gh-sync-id: 185afeb487c2c62dcf44f96076bd05871692c7ab
shipit-source-id: 185afeb487c2c62dcf44f96076bd05871692c7ab

Summary:ASAN needs to know about the stack extents. Currently it has no knowledge of
fibers and so it can give false positives, particularly in cases of no-return
(think exceptions).

See: https://github.com/google/sanitizers/issues/189

This change along with a related ASAN diff fixes that, and I've verified it
fixes false positive test failures I'm seeing when throws happen from fibers.

Also rips out some hacks that attempted to work around the limitations of
ASAN these changes should fix.

This change depends on:
D3017630
D2952854
D3017619

And will also depend on rollout of libasan.so to /usr/local/fbcode platform dirs on all machines.

Reviewed By: andriigrynenko

Differential Revision: D2952899

fb-gh-sync-id: 19da779227c6c0f30c5755806325aa4cba364cfe
shipit-source-id: 19da779227c6c0f30c5755806325aa4cba364cfe

Summary: Because including the root portability header just to get a couple of defines to be able to enable things is a waste. In addition, it would be nice if the config defines are never needed outside of the portability headers.

Reviewed By: yfeldblum

Differential Revision: D3059651

fb-gh-sync-id: 1cb9910d850ea015616a598808556b4815b3fb74
shipit-source-id: 1cb9910d850ea015616a598808556b4815b3fb74

Summary: Fix folly/test:thread_local_test in the shared library scenario by moving onThreadExit into libfolly_thread_local.so, avoiding the crash when a user's .so is dlclosed.

Reviewed By: andriigrynenko

Differential Revision: D2919287

fb-gh-sync-id: ecc4220fd40203289366eb1a6391b8b6d971e65f
shipit-source-id: ecc4220fd40203289366eb1a6391b8b6d971e65f

Summary: Older compilers do not have have `std::make_unique`. We have `folly::make_unique` which does the same job, and because we already have `using namespace folly` in this file it suffices to erase the `using std::make_unique` line.

Reviewed By: eduardosuarez

Differential Revision: D3058089

fb-gh-sync-id: a5a5eb54e2bc0ba7ef0880f2b5680a79d1f41d37
shipit-source-id: a5a5eb54e2bc0ba7ef0880f2b5680a79d1f41d37

Summary: [Folly] Remove an outdated/inapplicable comment from `folly/Portability.h`.

Reviewed By: Gownta

Differential Revision: D3055909

fb-gh-sync-id: c17fdcc7de13fe5a9bb38bb4498a006ec71a61e2
shipit-source-id: c17fdcc7de13fe5a9bb38bb4498a006ec71a61e2

Summary: We don't have it on Windows :(

Reviewed By: yfeldblum

Differential Revision: D2978397

fb-gh-sync-id: 388bc450ce269559825ebfb78e3646533c2e1153
shipit-source-id: 388bc450ce269559825ebfb78e3646533c2e1153

Summary:easy:
`options.parentDeathSignal_` is `int`, and second argument of `prctl` is `unsigned long`. Adding explicit cast.

hard:
this change is fixing a real problem when building folly with Clang 3.9.0. The [[ https://github.com/llvm-mirror/clang/commit/f4ddf94ecbd9899a497151621f3871545e24e93b | new alignment implementation ]] in `-O3` generates code that breaks folly's `ParentDeathSubprocessTest.ParentDeathSignal`.
For the following snipped of code:
```lang=cpp
  if (options.parentDeathSignal_ != 0) {
    if (prctl(PR_SET_PDEATHSIG, options.parentDeathSignal_, 0, 0, 0) == -1) {
      return errno;
    }
  }
```
LLVM generates the following assembly:
```lang=asm
   0x000000000040a77b <+347>:   mov    0x28(%r14),%rsi
   0x000000000040a77f <+351>:   test   %esi,%esi
   0x000000000040a781 <+353>:   je     0x40a7a1 <folly::Subprocess::prepareChild(folly::Subprocess::Options const&, __sigset_t const*, char const*) const+385>
   0x000000000040a783 <+355>:   mov    $0x1,%edi
   0x000000000040a788 <+360>:   xor    %edx,%edx
   0x000000000040a78a <+362>:   xor    %ecx,%ecx
   0x000000000040a78c <+364>:   xor    %r8d,%r8d
   0x000000000040a78f <+367>:   xor    %eax,%eax
   0x000000000040a791 <+369>:   callq  0x405ad0 <prctl@plt>
```
`%rsi` is a 64-bit register, on the line 1 value of `0x28(%r14)` is loaded to this register. That address points to `options.parentDeathSignal_`, which is a 32-bit value, set to 10 somewhere in a test. After that load:
```
rsi            0x7f000000000a
```
Notice it is not 10 (0xa), there is some garbage value in the upper part of the register. On the line 2, the lower part of this register is checked if it is zero, which corresponds to the first if statement. Then lines 4-8 prepare for `prctl` call. The value of the second argument is passed via `%rsi`, but the upper 32 bits were not cleared. This makes the function call generate `Invalid argument` error.
With the added explicit cast, notice a call `movslq %eax,%rsi`, which moves a signed 32-bit value of `%eax` (which contains `options.parentDeathSignal_`) to unsigned 64-bin `%rsi`:
```
   0x000000000040a77b <+347>:   mov    0x28(%r14),%rax
   0x000000000040a77f <+351>:   test   %eax,%eax
   0x000000000040a781 <+353>:   je     0x40a7a4 <folly::Subprocess::prepareChild(folly::Subprocess::Options const&, __sigset_t const*, char const*) const+388>
   0x000000000040a783 <+355>:   movslq %eax,%rsi
   0x000000000040a786 <+358>:   mov    $0x1,%edi
   0x000000000040a78b <+363>:   xor    %edx,%edx
   0x000000000040a78d <+365>:   xor    %ecx,%ecx
   0x000000000040a78f <+367>:   xor    %r8d,%r8d
   0x000000000040a792 <+370>:   xor    %eax,%eax
   0x000000000040a794 <+372>:   callq  0x405ad0 <prctl@plt>
```

Reviewed By: yfeldblum

Differential Revision: D3051611

fb-gh-sync-id: fc0f809bc4be0eed79dc5a701717efa27fedc022
shipit-source-id: fc0f809bc4be0eed79dc5a701717efa27fedc022

Summary:Add a new method to MPMCQueue:
```
template <class Clock, typename... Args>
  bool tryWriteUntil(const std::chrono::time_point<Clock>& when,
                     Args&&... args) noexcept
```
This allows you to write producers which terminate reliably in the absence of consumers.

Returns `true` if `args` was enqueued, `false` otherwise.

`Clock` must be one of the types supported by the underlying call to `folly::detail::Futex::futexWaitUntil`; at time of writing these are `std::chrono::steady_clock` and `std::chrono::system_clock`.

Reviewed By: nbronson

Differential Revision: D2895574

fb-gh-sync-id: bdfabcd043191c149f1271e30ffc28476cc8a36e
shipit-source-id: bdfabcd043191c149f1271e30ffc28476cc8a36e

Summary:Allow HTTPSession to have a movable read
callback independent of the openssl check.

This allows other downstream transports to
deliver app data more efficiently.

Reviewed By: w-o-o, knekritz

Differential Revision: D3023517

fb-gh-sync-id: ff27c0e14f7364ad7d7b0028ef740b2678dbcb4c
shipit-source-id: ff27c0e14f7364ad7d7b0028ef740b2678dbcb4c

Summary:defined(FOLLY_TLS) is guarded once in the test, so we should
guard for it throughout.  Also a missing header for some platforms.

Reviewed By: yfeldblum

Differential Revision: D3049797

fb-gh-sync-id: 5d66c71dda94c57a2e50aee96d55be1c574bf921
shipit-source-id: 5d66c71dda94c57a2e50aee96d55be1c574bf921

Summary:This commit fixes compiler errors when Constexpr.h was included
on gcc before cstring (or string.h) was included. Also, qualify
the call to strlen with the std namespace.

Reviewed By: yfeldblum

Differential Revision: D3047417

fb-gh-sync-id: 7a50dac2e9449b149062896f34fa5e864f767943
shipit-source-id: 7a50dac2e9449b149062896f34fa5e864f767943

Summary: Also, add error checking back in, and remove the empty WIN32 implementation.

Reviewed By: francis-ma

Differential Revision: D3047494

fb-gh-sync-id: 5a2a18cd1ca675a081ad2a9252c765ab56527b6b
shipit-source-id: 5a2a18cd1ca675a081ad2a9252c765ab56527b6b

Summary:Adding support for resetting a specified function's timer.

"Resetting a function's timer" effectively means "canceling whatever next runs it would have had, and treating it as though it were just added".
When `resetFunctionTimer` is called, the specified function's interval (timer) will be reset, and it will execute after its initially-specified `startDelay`. If the `startDelay` is zero, the function will execute immediately, and then be scheduled as before - once every `interval` milliseconds.

Motivation: batch processing of updates, where both a size and time limit are in play. If the size limit is reached, it makes sense to reset the timer for the scheduled function.

Differential Revision: D3045868

fb-gh-sync-id: a5ceb0069c04a77fdab16b61679987ee55484e89
shipit-source-id: a5ceb0069c04a77fdab16b61679987ee55484e89

Summary:The `init()` function uses the previous value of `lock_`, but that is
uninitialized and the compiler can issue a warning about it. It is
also potentially undefined behavior because it is not guaranteed that
the address of `lock_` is taken before `init()` (in which case the it
would be just an indeterminate value).

Since it is not very useful to initialize only one slot and leave the
others uninitialized, we can just have a single `init()` that
zero-initializes all the slots.

Reviewed By: dcolascione

Differential Revision: D3042629

fb-gh-sync-id: de1633b02eb1c891e310f2d5d2cfc5376cd41d5f
shipit-source-id: de1633b02eb1c891e310f2d5d2cfc5376cd41d5f

Reviewed By: ot

Differential Revision: D3045850

fb-gh-sync-id: ee19b146c43410d8d8804c9bfe79c3811394b10e
shipit-source-id: ee19b146c43410d8d8804c9bfe79c3811394b10e