Есть такие данные:
unsigned char numChar[6];

теперь их надо преобразовать в uint64. Сейчас это делается так:

uint64 tmp = num.lsnChar[0];
tmp <<= 8;
tmp += num.numChar[1];
tmp <<= 8;
tmp += num.numChar[2];
tmp <<= 8;
tmp += num.numChar[3];
tmp <<= 8;
tmp += num.numChar[4];
tmp <<= 8;
tmp += num.numChar[5];


А возможно ли как-нибудь ускорить процесс?

Здравствуйте, na1s, Вы писали:

N>Есть такие данные:
N>unsigned char numChar[6];

N>теперь их надо преобразовать в uint64. Сейчас это делается так:

N>uint64 tmp = num.lsnChar[0];
N>tmp <<= 8;
N>tmp += num.numChar[1];
N>tmp <<= 8;
N>tmp += num.numChar[2];
N>tmp <<= 8;
N>tmp += num.numChar[3];
N>tmp <<= 8;
N>tmp += num.numChar[4];
N>tmp <<= 8;
N>tmp += num.numChar[5];


N>А возможно ли как-нибудь ускорить процесс?

Можешь попробовать вот это:

uint64 tmp = *(uint64 *)(num.numChar);
tmp >> 16;

Здравствуйте, na1s, Вы писали:

N>Есть такие данные:
N>unsigned char numChar[6];

N>теперь их надо преобразовать в uint64. Сейчас это делается так:

N>uint64 tmp = num.lsnChar[0];
N>tmp <<= 8;
N>tmp += num.numChar[1];
N>tmp <<= 8;
N>tmp += num.numChar[2];
N>tmp <<= 8;
N>tmp += num.numChar[3];
N>tmp <<= 8;
N>tmp += num.numChar[4];
N>tmp <<= 8;
N>tmp += num.numChar[5];
N>А возможно ли как-нибудь ускорить процесс?
А что у тебя в каждом элементе массива?

Здравствуйте, na1s, Вы писали:

N>Есть такие данные:
N>unsigned char numChar[6];

N>теперь их надо преобразовать в uint64. Сейчас это делается так:

N>uint64 tmp = num.lsnChar[0];
N>tmp <<= 8;
N>tmp += num.numChar[1];
N>tmp <<= 8;
N>tmp += num.numChar[2];
N>tmp <<= 8;
N>tmp += num.numChar[3];
N>tmp <<= 8;
N>tmp += num.numChar[4];
N>tmp <<= 8;
N>tmp += num.numChar[5];


N>А возможно ли как-нибудь ускорить процесс?

А тебе именно в таком порядке надо? Если можно и в обратном (т.е. [0] в младшем разряде), то можно так: uint64 tmp = *(uint64 *)lsnChar & (uint64)0x0000ffffffffffff;

Здравствуйте, vadimcher, Вы писали:

V>Здравствуйте, na1s, Вы писали:

N>>Есть такие данные:
N>>unsigned char numChar[6];

N>>теперь их надо преобразовать в uint64. Сейчас это делается так:

N>>uint64 tmp = num.lsnChar[0];
N>>tmp <<= 8;
N>>tmp += num.numChar[1];
N>>tmp <<= 8;
N>>tmp += num.numChar[2];
N>>tmp <<= 8;
N>>tmp += num.numChar[3];
N>>tmp <<= 8;
N>>tmp += num.numChar[4];
N>>tmp <<= 8;
N>>tmp += num.numChar[5];


N>>А возможно ли как-нибудь ускорить процесс?

V>А тебе именно в таком порядке надо? Если можно и в обратном (т.е. [0] в младшем разряде), то можно так: uint64 tmp = *(uint64 *)lsnChar & (uint64)0x0000ffffffffffff;
В том то и дело, что в обратном. А то по времени долго работает предыдущий кусок кода, а как соптимизировать без понятия.

Здравствуйте, na1s, Вы писали:

V>>А тебе именно в таком порядке надо? Если можно и в обратном (т.е. [0] в младшем разряде), то можно так: uint64 tmp = *(uint64 *)lsnChar & (uint64)0x0000ffffffffffff;
N>В том то и дело, что в обратном. А то по времени долго работает предыдущий кусок кода, а как соптимизировать без понятия.

и сильно долго работает в релизной сборке?

Здравствуйте, труженик села, Вы писали:

ТС>Здравствуйте, na1s, Вы писали:

V>>>А тебе именно в таком порядке надо? Если можно и в обратном (т.е. [0] в младшем разряде), то можно так: uint64 tmp = *(uint64 *)lsnChar & (uint64)0x0000ffffffffffff;
N>>В том то и дело, что в обратном. А то по времени долго работает предыдущий кусок кода, а как соптимизировать без понятия.

ТС>и сильно долго работает в релизной сборке?

Ну вызовов очень много это и дает такой результат

Здравствуйте, na1s, Вы писали:

N>Ну вызовов очень много это и дает такой результат

Если интерпретация данных как uint64 работает (с выравниванием и алиасингом проблем нет), просто даёт неправильный порядок, я бы попробовал интерпретировать их как два uint32 (или один uint64 на x64) и переставил бы в них байты через << >> и &, типа (i & 0xFF << 24) | (i& 0xFF00 << 8) | ...

Здравствуйте, na1s, Вы писали:

N>Есть такие данные:
N>unsigned char numChar[6];

N>теперь их надо преобразовать в uint64. Сейчас это делается так:

N>uint64 tmp = num.lsnChar[0];
N>tmp <<= 8;
N>tmp += num.numChar[1];
N>tmp <<= 8;
N>tmp += num.numChar[2];
N>tmp <<= 8;
N>tmp += num.numChar[3];
N>tmp <<= 8;
N>tmp += num.numChar[4];
N>tmp <<= 8;
N>tmp += num.numChar[5];

а зачем сдвиги и сложения? :

union Num {
  uint64_t val;
  uint8_t bytes[8];
};

Num tmp;
tmp.bytes[5] = num.lsnChar[0];
tmp.bytes[4] = num.numChar[1];
tmp.bytes[3] = num.numChar[2];
tmp.bytes[2] = num.numChar[3];
tmp.bytes[1] = num.numChar[4];
tmp.bytes[0] = num.numChar[5];

Здравствуйте, Zhendos, Вы писали:

Z>Здравствуйте, na1s, Вы писали:

N>>Есть такие данные:
N>>unsigned char numChar[6];

N>>теперь их надо преобразовать в uint64. Сейчас это делается так:

N>>uint64 tmp = num.lsnChar[0];
N>>tmp <<= 8;
N>>tmp += num.numChar[1];
N>>tmp <<= 8;
N>>tmp += num.numChar[2];
N>>tmp <<= 8;
N>>tmp += num.numChar[3];
N>>tmp <<= 8;
N>>tmp += num.numChar[4];
N>>tmp <<= 8;
N>>tmp += num.numChar[5];

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

Здравствуйте, Zhendos, Вы писали:

Z>можно еще htonl использовать, она должна быть оптимизирована максимально под подобную работу

Никому она не должна, да и т.к здесь копейки считают, то вызов тоже стоит.

мне кажется, оптимальнее всего будет на x64 следующее:

uint64 result = ((i << 56) & 0xff) | ((i << 48) & 0xff00) | ...

на 32 разрядном — сначала сделать 32 разрядные операции, затем объединить их результаты.

Здравствуйте, lowa, Вы писали:

L>Здравствуйте, na1s, Вы писали:

L>Можешь попробовать вот это:

L>

L>uint64 tmp = *(uint64 *)(num.numChar);
L>tmp >> 16;
L>

Это вариант и другие подобные не совсем корректен, так как захватывает чужие 2 байта, что может привести к SIGSEGV.

Имхо, ускорить тут можно только переписав на асме.

Здравствуйте, navrocky, Вы писали:

N>Здравствуйте, lowa, Вы писали:

L>>Здравствуйте, na1s, Вы писали:

L>>Можешь попробовать вот это:

L>>

L>>uint64 tmp = *(uint64 *)(num.numChar);
L>>tmp >> 16;
L>>

N>Это вариант и другие подобные не совсем корректен, так как захватывает чужие 2 байта, что может привести к SIGSEGV.

N>Имхо, ускорить тут можно только переписав на асме.

Если руки не кривые, а скорость очень нужна -- не приведет. Здесь проблема в другом, что порядок иной получается.

Здравствуйте, navrocky, Вы писали:

N>Это вариант и другие подобные не совсем корректен, так как захватывает чужие 2 байта, что может привести к SIGSEGV.

Возможная некорректность несколько шире.
К чтению байт со следующей страницы памяти не приведёт, если выравнивание num.numChar хотя бы 4.
А если этого выравнивания нет, то код может быть некорректен уже из-за выравнивания.
Ещё, uint64 может не являться корректным алиасом

Автор: McSeem2
Дата: 23.08.07