wanna | Wan na is an implementation of a 21st-century to-do list | User Interface library

Starting with your second question, you can find all the specifications here.

Summarizing, thread local variables are defined in .tdata / .tbss. Those are somewhat similar to .data, however accessing those is different. These sections are replicated per thread. The actual variable offset is computed at the runtime.

A variable is identified by an offset in .tdata. Speaking of x86_64 it will use the FS segment register to find the TCB (Thread control block), using the data structures stored there it will locate the thread local storage where the variable is located. Note that all allocations are done lazily if possible.

Now, regarding your first question - I am not aware of a way to just list all the thread local variables from another thread, and I doubt it is available.

However, a thread can take a pointer to thread variable, and pass it to another thread. So what you probably need is some registration mechanism.

Each new thread will register itself to some main store, then unregister on termination. Registration and deregistration are on your responsibility.

Schematically, it would look like this:

Without having the full code to test outputs this is harder to do, but it seems that there are some redundant processes that you are adding elements to a list of lists only to flatten that list and add that to a dictionary as a set. You can increase some of the speed and memory by removing that and instead just adding it to the dictionary right away.

There are some other tweaks that can be done such as using f-strings instead of string concatenation, using list comprehension, and removing having to do the same math in the loop (time_range * gamma) and instead just reference it by memory.

But these are all minor tweaks compared to your step one process which looks to be the largest time sink (approx N^4 in time complexity). I am unsure if it is larger as I don't see the functions that you use inside that for loop, but tweaking that to reduce the number of calculations would provide the largest benefit to time savings.

It seems that GLUE 3.0 image has some issues with SSL. A workaround for working locally is to disable SSL (you also have to change the script paths as documentation is not updated).

This crate does not seem to account for field reordering. It appears the compiler reordered the struct to have upper first:

For your first question try the following

You can use

I have followed a lazy, not-best-efficient, yet useful, strategy. Since dealing with docx is less flexible than html, I converted the markdown md to html first, then moved from html to docx like this:

You need to rework your function.

Python isn’t smart enough to know which part of the code you need multiprocessed.

Most likely it’s the for loop right, you want to encrypt the files in parallel. So you can try something like this.

Define the function which needs to be run for each loop, then, create the for loop outside. Then use multiprocessing like this.

m is not a dependent name.

You can only have dependent names inside of a template, if they depend on the template parameters of the enclosing templates.

Example: