Есть шанс, что ошибся форумом, но более правильное место сходу не придумал. Только-только начал смотреть на эту штуку, потому вопросы тупые.

Предположим, что есть функция примерно такая (не реальный код, пример!):

__kernel void calc(int a, int b, int c, int d, __global int* output)
{
    int v1 = a+b;
    int v2 = b+c;
    int v3 = c-d;
    
    int v4 = v1 * v2;
    int v5 = v2-v3;
    
    *output = v4 - v5;
}

Насколько я понимаю, эта функция будет выполнена на каждом ядре (не знаю как назвать, аппаратном потоке?) в видеокарте.

Правильно ли я понимаю, что все действия тут будут выполнены последовательно? Т.е. да, в зависимости от настроек, сама функция вызовется одновременно в куче потоков, но в каждом потоке эти вычисления будут идти по очереди, как написано в коде? Или там есть что-то типа pairing для обычных процессоров, когда независимые инструкции выполняются одновременно на одном ядре?

И второй вопрос — имеет ли смысл разносить эти вычисления на разные потоки как-то так —

__global int v1,v2,v3,v4,v5;

__kernel void calc(int a, int b, int c, int d, __global int* output)
{
    int id = get_global_id();
    
    if( 0 == id % 3)
        v1 = a+b;
    if( 1 == id %3)
        v2 = b+c;
    if( 2 == id %3)
        v3 = c-d;
    
    // тут не знаю как функция называется - ждем завершения 
    if(0 == id % 3)
    {
        wait_for_thread(1);
        v4 = v1 * v2;
    }
    
    if(1 == id % 3)
    {
        wait_for_thread(2);
        v5 = v2-v3;
    }

    if(0 == id % 3)
    {
        wait_for_thread(1);
        *output = v4 - v5;
    }
}

т.е. распараллелить самому независимые вычисления? Если да, то начиная примерно с какого количества операций это будет иметь смысл?


Спасибо,
Илья