lockless | Collection of lockfree doodads | Caching library

I wish to create a lockless queue using std::atomic.
Here's my probably not so good first attempt at trying to do so:

I am making my own channel implementation, but std::task::Context doesn't make it clear how the waker was generated.

My fake code:

In my C++ game engine, I have a job system which utilizes worker threads to do various tasks. Threads are affinitized to each available core. Recently, I have been trying to optimize some of my system pipelines by maximizing CPU utilization. Here is some example pseudo-ish code. It isn't an exact replica but the situation is similar.

I am creating a very fast multi-threaded discrete event simulation framework. The core of the framework uses atomics and lockless programming techniques to achieve very fast execution across many threads. This requires me to align some variables to cache lines and pad the remaining cache line space so that I don't have cache line contention. Here is how I do it:

I am trying to implement a thread-safe lockless container, analogous to std::vector, according to this https://software.intel.com/en-us/blogs/2008/07/24/tbbconcurrent_vector-secrets-of-memory-organization

From what I understood, to prevent re-allocations and invalidating all iterators on all threads, instead of a single contiguous array, they add new contiguous blocks.
Each block they add is with a size of increasing powers of 2, so they can use log(index) to find the proper segment where an item at [index] is supposed to be.

From what I gather, they have a static array of pointers to segments, so they can quickly access them, however they don't know how many segments the user wants, so they made a small initial one and if the amount of segments exceeds the current count, they allocate a huge one and switch to using that one.

The problem is, adding a new segment can't be done in a lockless thread safe manner or at least I haven't figured out how. I can atomically increment the current size, but only that.
And also switching from the small to the large array of segment pointers involves a big allocation and memory copies, so I can't understand how they are doing it.

They have some code posted online, but all the important functions are without available source code, they are in their Thread Building Blocks DLL. Here is some code that demonstrates the issue:

In kfifo.h kfifo_get calls kfifo_is_empty which checks if __kfifo->in == __kfifo_out. Meanwhile kfifo_put does __kfifo->in++ after adding data. Since this is a lockless implementation of circular buffer with 1 reader and writer what prevents the writer from corrupting the data while kfifo_is_empty is reading the value of __kfifo->in?

I have a thread pool that should accept any std::packaged_task and give a future.

I am trying to select a class template based on a given enum template parameter (store_type). Now I instantiate a class that uses this, but it seems to always try to instantiate the basic_store for this class.

I want to use C++17 parallel capabilities to divide every element of a std::vector by some constant and store the result in another std::vector of same length and (!!) order.

E.g.