Распараллеливание вычислений с задействованием SymEngine

void compute_gradients(
    const size_t index_thread,
    const size_t index_start,
    const size_t index_finish,
    const std::vector<SE_Basic> &xs_names,
    const map_basic_basic &fun_loss_derivatives,
    const map_basic_basic &memory_values,
    std::vector<SE_Basic> &grad,
    std::mutex &mtx)
{
    std::cout << "Start compute_gradients() in "
              << index_thread << " thread\n";
    std::cout.flush();
    
    const size_t count = index_finish - index_start + 1;
    std::vector<SE_Basic> grad_temp(count);
    
    for (size_t i = index_start; i <= index_finish; ++i)
    {
        
        const SE_Basic &name = xs_names[i];
        
        const SE_Basic &der = fun_loss_derivatives.at(name);
        
        const std::string str = der->__str__();
        const size_t len = str.length();
        
        std::cout << index_thread << " der length: " << len << "\n";
        std::cout.flush();
        
        // const SE_Basic &der_value = der->subs(memory_values);
        
        // std::cout << index_thread << " der_value OK\n";
        // std::cout << der_value << "\n";
        // std::cout.flush();
        
        // grad_temp[i - index_start] = std::move(der_value);
    }
    
    // std::lock_guard<std::mutex> lock(mtx);
    // for (size_t j = index_start; j <= index_finish; ++j)
    // {
    //     grad[j] = grad_temp[j - index_start];
    // }
}
 
void train (/* args */)
{
    // ...
    
    // Threads
    std::mutex mtx;
    const size_t count_threads =
        std::thread::hardware_concurrency();
    std::cout << "count_threads: " << count_threads << "\n";
    std::cout.flush();
    threads = std::vector<std::unique_ptr<std::thread>>(count_threads);
 
    // Запуск потоков
    for (size_t t = 0u; t < count_threads; ++t)
    {
        const size_t start = t * (count_x / count_threads);
        const size_t end = (t == count_threads - 1) ?
            count_x - 1 : start + (count_x / count_threads);
        
        std::cout << start << " -> " << end << "\n";
        std::cout.flush();
        
        std::thread *ptr_thread = new std::thread(
            InSomnia::compute_gradients,
            t,
            start,
            end,
            std::cref(xs_names),
            std::cref(fun_loss_derivatives),
            std::cref(memory_values),
            std::ref(grad),
            std::ref(mtx));
                        
        threads[t] = std::unique_ptr<std::thread>(ptr_thread);
        
    }
 
    std::cout << "Start join\n";
    std::cout.flush();
 
    // Ожидание завершения всех потоков
    for (std::unique_ptr<std::thread> &t : threads)
    {
        t->join();
    }
 
    std::cout << "Finish join\n";
    
    // ...
    
}