Как прочитать 5 байтов в значимом uint64_t в C?

Когда вы говорите «быстрее»… как часто выполняется этот код? 5 раз <<8 плюс |, вероятно, стоит менее 100 нс. Таким образом, если этот код выполняется 10 000 раз, это в сумме составляет 1 (одну) секунду.

Если код выполняется меньше раз и вам нужно более 1 секунды для реализации решения с порядком байтов, вы тратите время всех.

Тем не менее, решение для определения endianess простое:

int a = 1;
char * ptr = (char*)&a;
bool littleEndian = *ptr == 1;

Теперь все, что вам нужно, это машина с обратным порядком байтов и пара тестов, чтобы убедиться, что ваше memcpy решение работает. Обратите внимание, что вам нужно вызвать memcpy пять раз в одном из двух случаев, чтобы изменить порядок байтов.

Или вы могли бы просто сдвинуть и или пять раз...

EDIT Думаю, я немного неправильно понял ваш вопрос. Вы говорите, что хотите использовать младшие 5 байтов (= 40 бит) uint64_t в качестве счетчика, да?

Таким образом, операция будет выполняться много-много раз. Опять же, memcpy совершенно бесполезен. Возьмем число 0x12345678 (32 бита). В памяти это выглядит так:

0x12 0x34 0x56 0x78    big endian
0x78 0x56 0x34 0x12    little endian

Как видите, байты поменялись местами. Таким образом, для преобразования между ними вы должны использовать битовый сдвиг или обмен байтами. memcpy не работает.

Но на самом деле это не имеет значения, поскольку ЦП будет выполнять декодирование за вас. Все, что вам нужно сделать, это переместить биты в нужном месте.

 key = item & 0x1FFFFF
 count = (item >>> 21)

читать и

 item = count << 21 | key

написать. Теперь вам просто нужно построить ключ из пяти байтов, и все готово:

 key = (((hash[0] << 8) | (hash[1]<<8)) | ....

ИЗМЕНИТЬ 2

Кажется, у вас есть массив 40-битных целых чисел, и вы хотите прочитать/записать этот массив.

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

Другое решение — использовать два массива:

int lower[];
unit8_t upper[]

то есть: Сохраните биты 33–40 в массиве second. Для чтения/записи значений необходим один Shift+or.

Если вы относитесь к числам как к числам, а не к массиву байтов, ваш код не будет зависеть от порядка следования байтов. Следовательно, я бы выбрал решение shift и или.

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

Ну, я просто обнаружил, что заголовки ядра идут с <asm/byteorder.h>.

встроенный memcpy в while(i<x+3){++*i=++*j} может быть еще медленнее, так как работа с кешем медленнее, чем с регистрами.

другой способ для memcpy:

union dat {
 uint64_t a;
 char b[8];
} d;