How to store thread-specific data in C++ globally?

I need to store some data in each thread, but since I'm going to access it in multiple places, I can't just use extern thread_local. I was wondering if there is an approach to somehow store some data in the current thread, something like this:

auto data = std:this_thread::my_data;

I know this is not a standard C++ API and this_thread does not have any field to store custom data. But I need something similar to that.

(For those who wondering why I need this, in summary, I am designing a scheduler around LibTorch (PyTorch's C++ API), and I need to know in specific parts of LibTorch's API which CUDA Context I have assigned to that specific thread since I have multiple threads running in parallel each using a different CUA Context. I'm currently using cuCtxGetCurrent() but the problem is that it adds not that negligible overhead and also causes some synchronization problems when called from multiple threads.)

UPDATE:
Since there is a misunderstanding, let me explain in more detail why I can't use thread_local. As I mentioned, I'm designing a scheduler for LibTorch. Imagine this simple example:

CUcontext ctx;
cuCtxCreate(ctx, 0, 0);
cuCtxSetCurrent(ctx);
auto stream = at::cuda::getStreamFromPool(false, 0);
at::cuda::setCurrentCUDAStream(stream);

Tensor output = mod->forward(input);

Now, forward is a function implemented in the LibTorch backend and already compiled. And there are tons of inner PyTorch functions called inside forward. Somewhere in the backend, I want to know which CUDA Context and Stream I have selected but using thread_local I can't do it. It might be possible, but not that easy and straightforward. So, as mentioned earlier, I need something like std:this_thread::my_daya to have global access anywhere.

std::thread constructor expected a callable: thread( Function&& f, Args&&... args );. There are many approaches how to share thread's my_data between other threads. A canonical approach is passing my_data by reference in args:

int my_data = 0;
std::thread thread([](int& my_data){ my_data = 1; }, std::ref(my_data));
thread.join();
std::cout << my_data << "\n";

Another approach is using a callable object:

struct my_thread {
  int my_data = 0;
  void operator()() { my_data = 1; }
};

my_thread this_thread;
std::thread thread(std::ref(this_thread));
thread.join();
std::cout << this_thread.my_data << "\n";

You define a data somewhere and pass it by ref to your thread constructor. Do whatever you'd like your thread worker to perform and you can use it again and again in other places.