C array = массив быстрее, чем memcpy ()

Я использую значения в b, чтобы определить новые значения для a. Он проходит через цикл while, проверяющий сходимость данных.

В этом случае вы сможете избежать любого копирования, если переключите массивы вперед и назад, что-то вроде этого (что не соответствует тому, что вы написали; при необходимости отрегулируйте):

double array1[SIZE], array2[SIZE];
double* a = array1, double* b = array2;
generate_initial_values(array1);

for (;;)
{
    // do either 
    memcpy(b, a, sizeof array1); // sizeof either array will do; *don't* use sizeof a or b, which is only the size of the pointer, not of the array
    update_values_in_b(b);

    // or, better:
    produce_modified_values_in_b_from_a(a, b);

    if (converged(a, b)) break;
    // switch arrays
    double* temp_ptr = a;
    a = b;
    b = temp_ptr;
}

Второй способ будет быстрее, если он вам подходит. Если вам необходим memcpy, вы можете попробовать все это в Очень быстрый memcpy для обработки изображений?, но, вероятно, лучше всего использовать memcpy и установить максимально высокий уровень оптимизации компилятора. Убедитесь, что вы #include <string.h> и что аргумент размера для memcpy является константой времени компиляции (она указана выше), и посмотрите на сгенерированный код сборки, чтобы убедиться, что компилятор встраивает копию.

Изменить: подождите, вот еще одна мысль, которая даже не требует переключения массивов:

double a[SIZE], b[SIZE];
generate_initial_values(a);

for (;;)
{
    produce_modified_values_in_second_array_from_first(a, b);
    if (converged(a, b)) break;
    produce_modified_values_in_second_array_from_first(b, a);
    if (converged(b, a)) break;
}

Когда вы выходите из цикла, вы не знаете, какой массив имеет последние значения, но если они сошлись, вам, вероятно, все равно. если вы это сделаете, вы можете установить указатель на последние значения или использовать функцию:

void calling_function(void)
{
    ...
    double a[SIZE], b[SIZE];
    generate_initial_values(a);
    double* great_values = get_great_values(a, b); // returns either a or b
    ...
}

double* get_great_values(double* a1, double* a2)
{
    for (;;)
    {
        produce_modified_values_in_second_array_from_first(a1, a2);
        if (converged(a1, a2)) return a2;
        produce_modified_values_in_second_array_from_first(a2, a1);
        if (converged(a2, a1)) return a1;
    }
}

Если memcpy() не работает, вы застряли. Функция memcpy() для больших операндов привязана к памяти, поэтому ее невозможно ^* превзойти. Единственный вариант - переработать вашу программу, чтобы не нужно было копировать массивы.

(Привязка к памяти означает, что memcpy() ограничена скоростью вашей оперативной памяти или контроллера памяти. Функции могут быть привязаны к ЦП, памяти, ввода-вывода и т. Д.)

На большинстве платформ memcpy() написан на настроенном вручную ассемблере и сильно оптимизирован для использования преимуществ различных функций процессора (таких как SSE). Попытка использовать несколько ядер не сработает, потому что, даже если вы распределяете работу по большему количеству ядер, вы не распределяете работу по большему количеству ОЗУ или большему количеству контроллеров памяти.

Сноски

^* Некоторые платформы или наборы инструментов могут иметь плохо оптимизированный memcpy().