0
цикл короче != быстрее
У Вас что-то с мировоззрением. Разжёвываю, чем меньше команд выполняется в цикле, тем быстрее он заканчивается, и это постулат, который и ежу понятен.
Я вот не поленился и посчитал при дефолтных настройках компилятора у Вас цикл в 17 команд(вызовы учёл)
41          uint32_t CRC_CalcCRC(uint32_t Data)
     42          {
   \                     _Z11CRC_CalcCRCj:
   \   00000000   0x0001             MOVS     R1,R0
     43            CRC->DR = Data;
   \   00000002   0x....             LDR.N    R0,??DataTable3_1  ;; 0x40023000
   \   00000004   0x6001             STR      R1,[R0, #+0]
     44            
     45            return (CRC->DR);
   \   00000006   0x....             LDR.N    R0,??DataTable3_1  ;; 0x40023000
   \   00000008   0x6800             LDR      R0,[R0, #+0]
   \   0000000A   0x4770             BX       LR               ;; return
     46          }
...
53          uint32_t reverse_32(uint32_t data)
     54          {
     55                  asm("rbit r0,r0");
   \                     _Z10reverse_32j:
   \   00000000   0xFA90 0xF0A0      rbit r0,r0
     56                  return data;
   \   00000004   0x4770             BX       LR               ;; return
     57          };
65                          while(len >= 4) {
   \                     ??crc32_ether_2:
   \   0000001A   0xF1B9 0x0F04      CMP      R9,#+4
   \   0000001E   0xDB12             BLT.N    ??crc32_ether_3
     66                                  crc_reg = CRC_CalcCRC(reverse_32(*p++));
   \   00000020   0xF8D8 0x0000      LDR      R0,[R8, #+0]
   \   00000024   0x.... 0x....      BL       _Z10reverse_32j
   \   00000028   0xF118 0x0804      ADDS     R8,R8,#+4
   \   0000002C   0x.... 0x....      BL       _Z11CRC_CalcCRCj
   \   00000030   0x0007             MOVS     R7,R0
     67                                  len -= 4;
   \   00000032   0xF1B9 0x0904      SUBS     R9,R9,#+4
   \   00000036   0xE7F0             B.N      ??crc32_ether_2
     68                          }
, а у меня 10
15          	while (count32--) {
   \                     ??HW_CRC32_0:
   \   0000001A   0x0028             MOVS     R0,R5
   \   0000001C   0x1E45             SUBS     R5,R0,#+1
   \   0000001E   0x2800             CMP      R0,#+0
   \   00000020   0xD006             BEQ.N    ??HW_CRC32_1
     16          		CRC->DR = __RBIT(*p32++);
   \   00000022   0x6820             LDR      R0,[R4, #+0]
   \   00000024   0xFA90 0xF0A0      RBIT     R0,R0
   \   00000028   0x1D24             ADDS     R4,R4,#+4
   \   0000002A   0x....             LDR.N    R7,??DataTable3_1  ;; 0x40023000
   \   0000002C   0x6038             STR      R0,[R7, #+0]
   \   0000002E   0xE7F4             B.N      ??HW_CRC32_0
     17          	}
Предлагаю закончить холивар, всё-равно никому он не интересен.
  • avatar
  • vildi
  • 27 апреля 2016, 11:55
+1
Во-первых, ясное дело, что компилятор оперирует регистрами и прочими низкоуровневыми сущностями.
Во-вторых, я избавился от вызова функции
reverse_32
применив
__RBIT
.
В третьих, imho,
CRC_CalcCRC
делает лишние телодвижения, которые компилятор не будет игнорировать, а эта функция у Вас в цикле вызывается.
В четвёртых, счётчик цикла у меня изменяется простым декрементом.
В пятых, цикл у меня короче, а значит и быстрее.
Вывод, на компилятор надейся, а сам не плошай.
  • avatar
  • vildi
  • 26 апреля 2016, 11:17
0
Запускал, и даже переделал с претензией на большую скорость
uint32_t HW_CRC32(const uint8_t* pData, size_t count, uint32_t init) {
	uint32_t crc;
	uint32_t *p32 = (uint32_t*) pData;
	size_t count32 = count >> 2;
	if (0xFFFFFFFF == init)
		CRC->CR |= CRC_CR_RESET;

	while (count32--) {
		CRC->DR = __RBIT(*p32++);
	}

	crc = __RBIT(CRC->DR);
	count = count % 4;
	if (count) {
		CRC->DR = __RBIT(crc);
		switch (count) {
		case 1:
			CRC->DR = __RBIT((*p32 & 0x000000FF) ^ crc) >> 24;
			crc = (crc >> 8) ^ __RBIT(CRC->DR);
			break;
		case 2:
			CRC->DR = (__RBIT((*p32 & 0x0000FFFF) ^ crc) >> 16);
			crc = (crc >> 16) ^ __RBIT(CRC->DR);
			break;
		case 3:
			CRC->DR = __RBIT((*p32 & 0x00FFFFFF) ^ crc) >> 8;
			crc = (crc >> 24) ^ __RBIT(CRC->DR);
			break;
		}
	}
	return ~crc;
}
Сброс делается при
init = 0xFFFFFFFF
для совместимости с софтовой версией
  • avatar
  • vildi
  • 19 апреля 2016, 13:00
0
А вот
crc_reg
не определён при
len < 4
и результат непредсказуем. Вы хоть тестировали код?
  • avatar
  • vildi
  • 08 апреля 2016, 11:27