Чому memcpy () і memmove () швидші за збільшення покажчика?

Я копіюю N байт з pSrcдо pDest. Це можна зробити за один цикл:

for (int i = 0; i < N; i++)
    *pDest++ = *pSrc++

Чому це повільніше ніж memcpyабо memmove? Які трюки вони використовують, щоб пришвидшити це?

Оскільки memcpy використовує вказівники на слова замість байтових вказівників, також реалізації memcpy часто пишуться з інструкціями SIMD, що дозволяє перетасовувати 128 бітів за раз.

Інструкції SIMD - це інструкція по збірці, яка може виконувати одну і ту ж операцію над кожним елементом у векторі довжиною до 16 байт. Сюди входять інструкції щодо завантаження та зберігання.

Процедури копіювання пам'яті можуть бути набагато складнішими та швидшими, ніж прості копії пам'яті за допомогою покажчиків, таких як:

void simple_memory_copy(void* dst, void* src, unsigned int bytes)
{
  unsigned char* b_dst = (unsigned char*)dst;
  unsigned char* b_src = (unsigned char*)src;
  for (int i = 0; i < bytes; ++i)
    *b_dst++ = *b_src++;
}

Поліпшення

Перше вдосконалення, яке можна зробити, - це вирівняти один з покажчиків на межі слова (під словом я маю на увазі власний цілий розмір, як правило, 32 біти / 4 байти, але може бути 64 біт / 8 байт у новіших архітектурах) і використовувати переміщення розміру слова / копіювати інструкції. Для цього потрібно використовувати байт для копіювання байта, поки покажчик не вирівняється.

void aligned_memory_copy(void* dst, void* src, unsigned int bytes)
{
  unsigned char* b_dst = (unsigned char*)dst;
  unsigned char* b_src = (unsigned char*)src;

  // Copy bytes to align source pointer
  while ((b_src & 0x3) != 0)
  {
    *b_dst++ = *b_src++;
    bytes--;
  }

  unsigned int* w_dst = (unsigned int*)b_dst;
  unsigned int* w_src = (unsigned int*)b_src;
  while (bytes >= 4)
  {
    *w_dst++ = *w_src++;
    bytes -= 4;
  }

  // Copy trailing bytes
  if (bytes > 0)
  {
    b_dst = (unsigned char*)w_dst;
    b_src = (unsigned char*)w_src;
    while (bytes > 0)
    {
      *b_dst++ = *b_src++;
      bytes--;
    }
  }
}

Різні архітектури працюватимуть по-різному, залежно від того, якщо джерело або вказівник призначення відповідним чином вирівняні. Наприклад, на процесорі XScale я отримав кращу продуктивність, вирівнюючи цільовий покажчик, а не вихідний.

Для подальшого підвищення продуктивності можна здійснити деяку розгортання циклу, так що більшість регістрів процесора завантажуються даними, а це означає, що інструкції з завантаження / зберігання можуть бути переплетені та приховані затримки додатковими інструкціями (такими як підрахунок циклу тощо). Перевага, яку це приносить, дуже відрізняється від процесора, оскільки затримки інструкцій щодо завантаження / зберігання можуть бути зовсім різними.

На цьому етапі код закінчується написанням у збірці, а не на C (або C ++), оскільки вам потрібно вручну розмістити навантаження та зберегти інструкції, щоб отримати максимальну вигоду від приховування та пропускної здатності затримки.

Як правило, цілий рядок даних кешу повинен бути скопійований за одну ітерацію розкрученого циклу.

Що підводить мене до наступного вдосконалення, додавання попереднього вибору. Це спеціальні вказівки, які повідомляють кеш-систему процесора завантажувати певні частини пам'яті в свій кеш. Оскільки між видачею інструкції та заповненням рядка кеш-пам’яті є затримка, інструкції потрібно розміщувати таким чином, щоб дані були доступні тоді, коли їх потрібно скопіювати, а не раніше / пізніше.

Це означає розміщувати вказівки щодо попереднього вибору на початку функції, а також всередині основного циклу копіювання. За допомогою інструкцій попередньої вибірки в середині циклу копіювання отримують дані, які будуть скопійовані за кілька ітерацій.

Я не можу згадати, але, можливо, також буде корисно попередньо встановити цільові адреси, а також вихідні.

Фактори

Основними факторами, що впливають на швидкість копіювання пам'яті, є:

• Затримка між процесором, його кешами та основною пам'яттю.
• Розмір і структура рядків кешу процесора.
• Інструкції щодо переміщення / копіювання пам'яті процесора (затримка, пропускна здатність, розмір реєстру тощо).

Отже, якщо ви хочете написати ефективний і швидкий режим роботи з пам'яттю, вам доведеться знати досить багато про процесор та архітектуру, для якої ви пишете. Досить сказати, що якщо ви не пишете на якійсь вбудованій платформі, було б набагато простіше просто використовувати вбудовану процедуру копіювання пам’яті.

memcpyможе скопіювати більше одного байта одночасно, залежно від архітектури комп'ютера. Більшість сучасних комп'ютерів можуть працювати з 32 і більше бітами в одній інструкції процесора.

З одного прикладу реалізації :

    00026 * Для швидкого копіювання оптимізуйте загальний випадок, коли обидва вказівники
    00027 * і довжина вирівняні за словом, а замість цього скопіюйте слово за раз
    00028 * байт за раз. В іншому випадку скопіюйте в байти.

Ви можете реалізувати, memcpy()використовуючи будь-який з наведених нижче методів, деякі з яких залежать від вашої архітектури для підвищення продуктивності, і всі вони будуть набагато швидшими, ніж ваш код:

1. Використовуйте великі одиниці, наприклад, 32-бітні слова замість байтів. Ви також можете (або, можливо, доведеться) вирішувати вирівнювання і тут. Ви не можете читати / писати 32-бітне слово в непарне місце для пам'яті, наприклад, на деяких платформах, а на інших платформах ви сплачуєте величезний штраф за продуктивність. Щоб це виправити, адреса повинна бути одиницею, що ділиться на 4. Ви можете взяти це до 64-біт для 64-бітних процесорів або навіть вище, використовуючи інструкції SIMD (одна інструкція, кілька даних) ( MMX , SSE тощо)

2. Ви можете використовувати спеціальні інструкції процесора, які ваш компілятор не зможе оптимізувати з C. Наприклад, на 80386 ви можете використовувати інструкцію префікса "rep" + інструкцію "movsb" для переміщення N байтів, продиктованих розміщенням N у підрахунку реєструвати. Хороші компілятори просто зроблять це за вас, але ви, можливо, знаходитесь на платформі, якій не вистачає хорошого компілятора. Зауважте, що цей приклад, як правило, є поганою демонстрацією швидкості, але в поєднанні з вирівнюванням + більш великі інструкції одиниці може бути швидшим, ніж переважно все інше на певних процесорах.

3. Розгортання циклу - гілки можуть бути досить дорогими для деяких процесорів, тому розгортання циклів може зменшити кількість гілок. Це також хороша методика поєднання із інструкціями SIMD та дуже великими розмірами одиниць.

Наприклад, http://www.agner.org/optimize/#asmlib має memcpyреалізацію, яка перевершує найбільше (дуже незначна сума). Якщо ви прочитаєте вихідний код, він буде повний безліч вбудованого коду збірки, який виконує всі вищезазначені три техніки, вибираючи, який із цих методів виходячи з того, на якому процесорі ви працюєте.

Зверніть увагу, що існують подібні оптимізації для пошуку байтів у буфері. strchr()а друзі часто швидше, ніж ваш еквівалент рукою. Особливо це стосується .NET та Java . Наприклад, у .NET вбудований String.IndexOf()набагато швидше, ніж навіть пошук рядків Боєра – Мура , оскільки він використовує вищезазначені методи оптимізації.

Коротка відповідь:

• кеш-заливка
• де можливо, переклади слів замість байтів
• SIMD магія

Я не знаю, чи він насправді використовується в реальних реалізаціях memcpy, але я думаю , що пристрій Даффа заслуговує на згадування тут.

З Вікіпедії :

send(to, from, count)
register short *to, *from;
register count;
{
        register n = (count + 7) / 8;
        switch(count % 8) {
        case 0:      do {     *to = *from++;
        case 7:              *to = *from++;
        case 6:              *to = *from++;
        case 5:              *to = *from++;
        case 4:              *to = *from++;
        case 3:              *to = *from++;
        case 2:              *to = *from++;
        case 1:              *to = *from++;
                } while(--n > 0);
        }
}

Зауважте, що вищезгадане не є тим, що memcpyвоно навмисно не збільшує toпокажчик. Він реалізує дещо іншу операцію: запис у регістр, нанесений на пам'ять. Детальніше дивіться у статті Вікіпедії.

Як кажуть інші, мемпі-копії розміром більше 1-байтних фрагментів. Копіювання фрагментами розміру слова відбувається набагато швидше. Однак більшість реалізацій роблять це на крок далі і виконують кілька інструкцій MOV (word) перед циклом. Перевага копіювання у скажімо, 8 словоблоків на цикл полягає в тому, що цикл сам по собі дорогий. Ця методика зменшує кількість умовних гілок в 8 разів, оптимізуючи копію для гігантських блоків.

Відповіді великов, але якщо ви все ще хочете здійснити швидкі memcpyсебе, є цікавий блог про швидке тетсре, Fast тетсра в C .

void *memcpy(void* dest, const void* src, size_t count)
{
    char* dst8 = (char*)dest;
    char* src8 = (char*)src;

    if (count & 1) {
        dst8[0] = src8[0];
        dst8 += 1;
        src8 += 1;
    }

    count /= 2;
    while (count--) {
        dst8[0] = src8[0];
        dst8[1] = src8[1];

        dst8 += 2;
        src8 += 2;
    }
    return dest;
}

Навіть це може бути краще за рахунок оптимізації доступу до пам'яті.

Оскільки, як і багато інших бібліотечних процедур, вона була оптимізована для архітектури, на якій ви працюєте. Інші опублікували різні техніки, які можна використовувати.

Зважаючи на вибір, скористайтеся бібліотечними процедурами, а не прокручуйте власні. Це варіація СУХОГО, яку я називаю DRO (Не повторюйте інші). Крім того, бібліотечні процедури рідше помилкові, ніж ваша власна реалізація.

Я бачив, як перевіряючі доступ до пам'яті скаржаться на позачергові зчитування в буферах пам'яті або рядків, які не кратні розміру слова. Це результат оптимізації, яка використовується.

Ви можете подивитися реалізацію memset, memcpy та memmove в MacOS.

Під час завантаження ОС визначає, на якому процесорі він працює. Він вбудував спеціально оптимізований код для кожного підтримуваного процесора і під час завантаження зберігає інструкцію jmp до потрібного коду у фіксованому місці / лише для читання.

Реалізації мемсету C, memcpy та memmove - це лише стрибок до цього фіксованого місця.

Реалізації використовують різний код в залежності від вирівнювання джерела та місця призначення для memcpy та memmove. Вони, очевидно, використовують усі наявні векторні можливості. Вони також використовують варіанти, що не кешуються, коли ви копіюєте великі обсяги даних, і мають інструкції, щоб мінімізувати очікування таблиць сторінок. Це не просто асемблерний код, це асемблерний код, написаний кимось, хто надзвичайно добре знає архітектуру кожного процесора.

Intel також додала інструкції асемблера, які можуть робити швидкі операції швидше. Наприклад, з інструкцією для підтримки strstr, яка виконує порівняння 256 байт за один цикл.