#include "source/common/thread_local/thread_local_impl.h"

#include <algorithm>

#include <atomic>

#include <cstdint>

#include <list>

#include "envoy/event/dispatcher.h"

#include "source/common/common/assert.h"

#include "source/common/common/stl_helpers.h"

#include "source/common/runtime/runtime_features.h"

namespace Envoy {

namespace ThreadLocal {

thread_local InstanceImpl::ThreadLocalData InstanceImpl::thread_local_data_;

InstanceImpl::SlotImpl::SlotImpl(InstanceImpl& parent, uint32_t index)

  // Do nothing if the parent is already shutdown. Return early here to avoid accessing the main

  // thread dispatcher because it may have been destroyed.

  // Main thread dispatcher may be nullptr if the slot is being created and destroyed during

  // server initialization.

    // If the slot is being destroyed on the main thread, we can remove it immediately.

    // If the slot is being destroyed on a worker thread, we need to post the removal to the

    // main thread. There are two possible cases here:

    // 1. The removal is executed on the main thread as expected if the main dispatcher is still

    //    active. This is the common case and the clean up will be done as expected because the

    //    the worker dispatchers must be active before the main dispatcher is exited.

    // 2. The removal is not executed if the main dispatcher has already exited. This is fine

    //    because the removal has no side effect and will be ignored. The shutdown process will

    //    clean up all the slots anyway.

  // See the header file comments for still_alive_guard_ for the purpose of this capture and the

  // expired check below.

  //

  // Note also that this logic is duplicated below and dataCallback(), rather

  // than incurring another lambda redirection.

  // See the header file comments for still_alive_guard_ for why we capture index_.

    // This duplicates logic in wrapCallback() (above). Using wrapCallback also

    // works, but incurs another indirection of lambda at runtime. As the

    // duplicated logic is only an if-statement and a bool function, it doesn't

    // seem worth factoring that out to a helper function.

void InstanceImpl::SlotImpl::runOnAllThreads(const UpdateCb& cb,

    // See the header file comments for still_alive_guard_ for why we capture index_.

  // Handle main thread.

  // When shutting down, we do not post slot removals to other threads. This is because the other

  // threads have already shut down and the dispatcher is no longer alive. There is also no reason

  // to do removal, because no allocations happen during shutdown and shutdownThread() will clean

  // things up on the other thread.

    // This runs on each thread and clears the slot, making it available for a new allocations.

    // This is safe even if a new allocation comes in, because everything happens with post() and

    // will be sequenced after this removal. It is also safe if there are callbacks pending on

    // other threads because they will run first.

  // Handle main thread.

void InstanceImpl::runOnAllThreads(std::function<void()> cb,

  // Handle main thread first so that when the last worker thread wins, we could just call the

  // all_threads_complete_cb method. Parallelism of main thread execution is being traded off

  // for programming simplicity here.

  // Destruction of slots is done in *reverse* order. This is so that filters and higher layer

  // things that are built on top of the cluster manager, stats, etc. will be destroyed before

  // more base layer things. The reason reverse ordering is done is to deal with the case that leaf

  // objects depend in some way on "persistent" objects (particularly the cluster manager) that are

  // created very early on with a known slot number and never destroyed until shutdown. For example,

  // if we chose to create persistent per-thread gRPC clients we would potentially run into shutdown

  // issues if that thing got destroyed after the cluster manager. This happens in practice

  // currently when a redis connection pool is destroyed and removes its member update callback from

  // the backing cluster. Examples of things with TLS that are created early on and are never

  // destroyed until server shutdown are stats, runtime, and the cluster manager (see server.cc).

  //

  // It's possible this might need to become more complicated later but it's OK for now. Note that

  // this is always safe to do because:

  // 1) All slot updates come in via post().

  // 2) No updates or removals will come in during shutdown().

  //

  // TODO(mattklein123): Deletion should really be in reverse *allocation* order. This could be

  //                     implemented relatively easily by keeping a parallel list of slot #s. This

  //                     would fix the case where something allocates two slots, but is interleaved

  //                     with a deletion, such that the second allocation is actually a lower slot

  //                     number than the first. This is an edge case that does not exist anywhere

  //                     in the code today, but we can keep this in mind if things become more

  //                     complicated in the future.

} // namespace ThreadLocal

} // namespace Envoy