// Provide ethernet devices with a semi-unique MAC address from the UUID void mbed_mac_address(char *mac) { uint16_t MAC[3]; // 3 16 bits words for the MAC uint32_t UID[4]; // get UID via ISP commands FLASHIAP_ReadUid(UID); // generate three CRC16's using different slices of the UUID MAC[0] = crcSlow((const uint8_t *)UID, 8); // most significant half-word MAC[1] = crcSlow((const uint8_t *)UID, 12); MAC[2] = crcSlow((const uint8_t *)UID, 16); // least significant half word // The network stack expects an array of 6 bytes // so we copy, and shift and copy from the half-word array to the byte array mac[0] = MAC[0] >> 8; mac[1] = MAC[0]; mac[2] = MAC[1] >> 8; mac[3] = MAC[1]; mac[4] = MAC[2] >> 8; mac[5] = MAC[2]; // We want to force bits [1:0] of the most significant byte [0] // to be "10" // http://en.wikipedia.org/wiki/MAC_address mac[0] |= 0x02; // force bit 1 to a "1" = "Locally Administered" mac[0] &= 0xFE; // force bit 0 to a "0" = Unicast }
static bool infoDecode(DeckInfo * info) { uint8_t crcHeader; uint8_t crcTlv; if (info->header != DECK_INFO_HEADER_ID) { DEBUG_PRINT("Memory error: wrong header ID\n"); return false; } crcHeader = crcSlow(info->raw, DECK_INFO_HEADER_SIZE); if(info->crc != crcHeader) { DEBUG_PRINT("Memory error: incorrect header CRC\n"); return false; } if(info->raw[DECK_INFO_TLV_VERSION_POS] != DECK_INFO_TLV_VERSION) { DEBUG_PRINT("Memory error: incorrect TLV version\n"); return false; } crcTlv = crcSlow(&info->raw[DECK_INFO_TLV_VERSION_POS], info->raw[DECK_INFO_TLV_LENGTH_POS]+2); if(crcTlv != info->raw[DECK_INFO_TLV_DATA_POS + info->raw[DECK_INFO_TLV_LENGTH_POS]]) { DEBUG_PRINT("Memory error: incorrect TLV CRC %x!=%x\n", (unsigned int)crcTlv, info->raw[DECK_INFO_TLV_DATA_POS + info->raw[DECK_INFO_TLV_LENGTH_POS]]); return false; } info->tlv.data = &info->raw[DECK_INFO_TLV_DATA_POS]; info->tlv.length = info->raw[DECK_INFO_TLV_LENGTH_POS]; return true; }
int cmd_module(int argc, char *argv[]) { struct module_info *header; header = (struct module_info *)pvPortMalloc(sizeof(struct module_info)); if (argc < 2) { cmd_print("\r\ni2c exists: %d",I2CEE_exists(SLAVE_ADDRESS_MODULE1)); } else { if(ustrncmp(argv[1],"write",5) == 0) { header->magic = 0x3A; header->vendor = 0x01; header->product = 0x01; header->version = 0x01; header->profile = ustrtoul(argv[2],NULL,16); header->modres = ustrtoul(argv[3],NULL,16); header->dummy2 = 0; header->crc = crcSlow((unsigned char *)header, sizeof(struct module_info)-sizeof(header->crc)); I2CEE_write(SLAVE_ADDRESS_MODULE1,(unsigned char *) header, sizeof(struct module_info), 0); vTaskDelay(100 / portTICK_RATE_MS); // there must be a delay after write or avoid I2CEE_read() } I2CEE_read(SLAVE_ADDRESS_MODULE1, (unsigned char *) header, sizeof(struct module_info), 0); cmd_print("\r\ni2c module magic: %X vendor: %X product: %X version: %X profile: %X modres: %X", header->magic, header->vendor, header->product, header->version, header->profile, header->modres); } vPortFree(header); return(0); }
void main(void) { unsigned char test[] = "123456789"; printf("Size of short is %i\n", sizeof(short)); printf("Size of int is %i\n", sizeof(int)); printf("Size of long is %i\n", sizeof(long)); /* * Print the check value for the selected CRC algorithm. */ printf("The check value for the %s standard is 0x%X\n", CRC_NAME, CHECK_VALUE); /* * Compute the CRC of the test message, slowly. */ printf("The crcSlow() of \"123456789\" is 0x%X\n", crcSlow(test, strlen(test))); /* * Compute the CRC of the test message, more efficiently. */ crcInit(); printf("The crcFast() of \"123456789\" is 0x%X\n", crcFast(test, strlen(test))); int testing = crcFast(test, strlen(test)); int *helping = &testing; printf("Test string with crc %s%c%c%c%c\n", test, helping[0],helping[1], helping[2],helping[3]); //How to add the characters to the packet /*packet[1020] = helping[0]; packet[1021] = helping[1]; packet[1022] = helping[2]; packet[1023] = helping[3];*/ } /* main() */
void logInit(void) { int i; if(isInit) return; logs = &_log_start; logsLen = &_log_stop - &_log_start; logsCrc = crcSlow(logs, logsLen); // Big lock that protects the log datastructures logLock = xSemaphoreCreateMutex(); for (i=0; i<logsLen; i++) { if(!(logs[i].type & LOG_GROUP)) logsCount++; } //Manually free all log blocks for(i=0; i<LOG_MAX_BLOCKS; i++) logBlocks[i].id = BLOCK_ID_FREE; //Init data structures and set the log subsystem in a known state logReset(); //Start the log task xTaskCreate(logTask, (const signed char * const)"log", configMINIMAL_STACK_SIZE, NULL, /*priority*/1, NULL); isInit = true; }
void logInit(void) { int i; rt_thread_t log_thread; if(isInit) return; logs = &_log_start; logsLen = &_log_stop - &_log_start; logsCrc = crcSlow(logs, logsLen); // Big lock that protects the log datastructures logLock = rt_mutex_create("log_lock",RT_IPC_FLAG_FIFO); for (i=0; i<logsLen; i++) { if(!(logs[i].type & LOG_GROUP)) logsCount++; } //Manually free all log blocks for(i=0; i<LOG_MAX_BLOCKS; i++) logBlocks[i].id = BLOCK_ID_FREE; //Init data structures and set the log subsystem in a known state logReset(); //Start the log task //xTaskCreate(logTask, (const signed char * const)"log", // configMINIMAL_STACK_SIZE, NULL, /*priority*/1, NULL); log_thread = rt_thread_create("log", logTask, RT_NULL, 512, 10, 5); isInit = RT_TRUE; }
void paramInit(void) { int i; if(isInit) return; #if defined(__CC_ARM) params = (struct param_s *)&Image$$PARAM$$Base; paramsLen = (int)&Image$$PARAM$$Length + (int)&Image$$PARAM$$ZI$$Length; #else params = &_param_start; paramsLen = &_param_stop - &_param_start; #endif paramsCrc = crcSlow(params, paramsLen); for (i=0; i<paramsLen; i++) { if(!(params[i].type & PARAM_GROUP)) paramsCount++; } //Start the param task xTaskCreate(paramTask, (const signed char * const)"PARAM", configMINIMAL_STACK_SIZE, NULL, /*priority*/1, NULL); //TODO: Handle stored parameters! isInit = true; }
void paramInit(void) { int i; if(isInit) return; params = &_param_start; paramsLen = &_param_stop - &_param_start; paramsCrc = crcSlow(params, paramsLen); for (i=0; i<paramsLen; i++) { if(!(params[i].type & PARAM_GROUP)) paramsCount++; } //Start the param task xTaskCreate(paramTask, (const signed char * const)PARAM_TASK_NAME, PARAM_TASK_STACKSIZE, NULL, PARAM_TASK_PRI, NULL); //TODO: Handle stored parameters! isInit = true; }
static void updateChecksum(SISControllerChecksum* csum, SISField* compressed) { uint8_t* compressedData = new uint8_t[compressed->HeaderDataLength()]; uint8_t* compressedPtr = compressedData; compressed->CopyHeaderData(compressedPtr); uint16_t ccsum = crcSlow(compressedData, compressed->HeaderDataLength()); delete [] compressedData; csum->iValue = ccsum; }
void paramInit(void) { int i; const char* group = NULL; int groupLength = 0; if(isInit) return; params = &_param_start; paramsLen = &_param_stop - &_param_start; // Calculate a hash of the toc by chaining description of each elements // Using the CRTP packet as temporary buffer paramsCrc = 0; for (int i=0; i<paramsLen; i++) { int len = 5; memcpy(&p.data[0], ¶msCrc, 4); p.data[4] = params[i].type; if (params[i].type & PARAM_GROUP) { if (params[i].type & PARAM_START) { group = params[i].name; groupLength = strlen(group); } } else { // CMD_GET_ITEM_V2 result's size is: 4 + strlen(params[i].name) + groupLength + 2 if (strlen(params[i].name) + groupLength + 2 > 26) { PARAM_ERROR("'%s.%s' too long\n", group, params[i].name); ASSERT_FAILED(); } } if (params[i].name) { memcpy(&p.data[5], params[i].name, strlen(params[i].name)); len += strlen(params[i].name); } paramsCrc = crcSlow(p.data, len); } for (i=0; i<paramsLen; i++) { if(!(params[i].type & PARAM_GROUP)) paramsCount++; } //Start the param task xTaskCreate(paramTask, PARAM_TASK_NAME, PARAM_TASK_STACKSIZE, NULL, PARAM_TASK_PRI, NULL); //TODO: Handle stored parameters! isInit = true; }
void Serializer(connection *conn, char *buffer) { char header[MAX_HEADER_SIZE]; char payload[MAX_PAYLOAD_SIZE]; char header_payload[MAX_HEADER_SIZE + MAX_PAYLOAD_SIZE]; char tailer[CRC32SIZE]; memset(&header, 0, sizeof(header)); memset(&payload, 0, sizeof(payload)); memset(&header_payload, 0, sizeof(header_payload)); memset(&tailer, 0, sizeof(tailer)); sprintf(payload, "%s|%s|%s|", conn->clientNickName, conn->serviceName, conn->messageText); sprintf(header, "%s|%s|%d|", conn->protoName, conn->protoVersion, (int)strlen(payload) + 8); sprintf(header_payload, "%s%s", header, payload); sprintf(tailer, "%X", (unsigned int)crcSlow((unsigned char *)header_payload, strlen(header_payload))); sprintf(buffer, "%s%s%s", header, payload, tailer); }
bool CryptoTest::Run() { CCrypto Crypto; Crypto.Initialize("Key.txt"); TCHAR szJuhang[] = _T("juhang"); Crypto.ProcessEncryption(szJuhang, sizeof(szJuhang)); Crypto.ProcessDecryption(szJuhang, sizeof(szJuhang)); /////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// unsigned char test[] = "123456789"; /* * Print the check value for the selected CRC algorithm. */ printf("The check value for the %s standard is 0x%X\n", CRC_NAME, CHECK_VALUE); /* * Compute the CRC of the test message, slowly. */ printf("The crcSlow() of \"123456789\" is 0x%X\n", crcSlow(test, 9)); /* * Compute the CRC of the test message, more efficiently. */ crcInit(); printf("The crcFast() of \"123456789\" is 0x%X\n", crcFast(test, 9)); /////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// Cmd5Capi md5Capi; std::wstring out, in; in = L"JUHANG"; out = md5Capi.Digest(in); return true; }
void main(void) { unsigned char test[] = "123456789"; /* * Print the check value for the selected CRC algorithm. */ printf("The check value for the %s standard is 0x%X\n", CRC_NAME, CHECK_VALUE); /* * Compute the CRC of the test message, slowly. */ printf("The crcSlow() of \"123456789\" is 0x%X\n", crcSlow(test, strlen(test))); /* * Compute the CRC of the test message, more efficiently. */ crcInit(); printf("The crcFast() of \"123456789\" is 0x%X\n", crcFast(test, strlen(test))); } /* main() */
static bool expbrdIsValid(ExpbrdData *data) { bool status = false; uint8_t crc; if (data->header == EXPBRD_ID) { crc = crcSlow(data, sizeof(ExpbrdData) - 1); if (crc == data->crc) { status = true; } else { DEBUG_PRINT("Wrong CRC:0x%X!=0x%X\n", crc, data->crc); } } else { DEBUG_PRINT("Wrong header id: 0x%X\n", data->header); } return status; }
int8_t vscp_sendUDPEvent( PVSCPMSG pmsg ) { int i; if ( UDPIsPutReady( vscp_udp_transmitsocket ) ) { pmsg->crc = crcSlow( (unsigned char *)pmsg, sizeof( vscpMsg ) - 2 ); UDPPut( pmsg->head ); UDPPut( ( pmsg->vscp_class >> 8 ) & 0xff ); UDPPut( pmsg->vscp_class & 0xff ); UDPPut( ( pmsg->vscp_type >> 8 ) & 0xff ); UDPPut( pmsg->vscp_type & 0xff ); for ( i=0; i<16; i++ ) { UDPPut( vscp_getGUID( i ) ); } UDPPut( ( pmsg->sizeData >> 8 ) & 0xff ); UDPPut( pmsg->sizeData & 0xff ); for ( i=0; i<pmsg->sizeData; i++ ) { UDPPut( pmsg->data[ i ] ); } UDPPut( ( pmsg->crc >> 8 ) & 0xff ); UDPPut( pmsg->crc & 0xff ); UDPFlush(); return TRUE; } return FALSE; }
//реализация функции конвертирования данных структуры в строку для пересылки по сети //аргументы: //connection - структура данных о клиенте и параметрах соединения //buffer - строка, в которую будет помещен результат void Serializer(connection *connection, char *buffer) { char tempString[BUFFERSIZE]; char messageLength[5]; memset(&tempString, 0, sizeof(tempString)); memset(&messageLength, 0, sizeof(messageLength)); strcat(buffer, connection->protoName); strcat(buffer, "|"); strcat(buffer, connection->protoVersion); strcat(buffer, "|"); strcat(tempString, connection->clientNickName); strcat(tempString, "|"); strcat(tempString, connection->serviceName); strcat(tempString, "|"); strcat(tempString, connection->messageText); strcat(tempString, "|"); sprintf(messageLength, "%d", (int)(strlen(buffer) + strlen(tempString) + 8 + 1)); sprintf(connection->length, "%d", (int)(atoi(messageLength) + strlen(messageLength))); strcat(buffer, connection->length); strcat(buffer, "|"); strcat(buffer, tempString); sprintf(connection->messageCRC32, "%X", (unsigned int)crcSlow((unsigned char *)buffer, strlen(buffer))); strcat(buffer, connection->messageCRC32); }
void sendCommand() { // while(1){ printf("Send command: \r\n"); printf("0 - NULL\r\n" "1 - Change can speed\r\n" "2 - Get can speed\r\n" "3 - Init can bus\r\n" "4 - Set can RX object\r\n" "5 - Get can RX object\r\n" "6 - Set can TX object\r\n" "7 - Get can TX object\r\n" "8 - Transmit CAN object\r\n" "9 - Get board temperature\r\n" "10 - Get board uptime\r\n" "11 - Set board LED\r\n" "12 - Get board LED\r\n" "13 - Init SD card\r\n" "14 - Open file\r\n" "15 - Close file\r\n" "16 - Write file\r\n" "17 - Write LCD command\r\n" "18 - Write LCD string\r\n"); scanf("%d",&input); switch(input) { case NULL_COMMAND: printf("NULL_COMMAND\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case CHANGE_CAN_SPEED: printf("CHANGE_CAN_SPEED\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case GET_CAN_SPEED: printf("GET_CAN_SPEED\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case INIT_CAN_BUS: printf("INIT_CAN_BUS\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case SET_CAN_RX_OBJ: printf("SET_CAN_RX_OBJ\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case GET_CAN_RX_OBJ: printf("GET_CAN_RX_OBJ\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case SETUP_CAN_TX_OBJ: printf("SETUP_CAN_TX_OBJ\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case GET_CAN_TX_OBJ: printf("GET_CAN_TX_OBJ\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case TRANSMIT_CAN_OBJ: printf("TRANSMIT_CAN_OBJ\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case GET_BOARD_TEMP: printf("GET_BOARD_TEMP\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case GET_BOARD_UPTIME: printf("GET_BOARD_UPTIME\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case SET_BOARD_LED: printf("SET_BOARD_LED\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case GET_BOARD_LED: printf("GET_BOARD_LED\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case INIT_SD_CARD: printf("INIT_SD_CARD\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case OPEN_FILE: printf("OPEN_FILE\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case CLOSE_FILE: printf("CLOSE_FILE\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case WRITE_FILE: printf("WRITE_FILE\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case READ_FILE: printf("READ_FILE\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case WRITE_LCD_CMD: printf("WRITE_LCD_CMD\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; case WRITE_LCD_STRING: printf("WRITE_LCD_STRING\r\n"); hdlc_frame->cmd = input; hdlc_frame->len = 0x00; break; default: printf("DEFAULT\r\n"); return; // } } hdlc_frame->sflag = HDLC_SFLAG; hdlc_frame->eflag = HDLC_EFLAG; hdlc_frame->crc = crcSlow((uint8_t*)hdlc_frame,3+hdlc_frame->len); //written = fwrite(hdlc_frame,1,3+hdlc_frame->len,can_board); written = write(can_board,hdlc_frame,3+hdlc_frame->len); printf("Written bytes: %d\r\n",written); return; }
void FILE_Processor::process_sdu( M_SDU &sdu ){ Transport_File file; DEBUG("%s", "Processing PDU:\n"); //for( int i = 0; i < sdu.length+1; i++ ){ // printf( "%X ", sdu.data[i] ); //} uint8_t flag = sdu.seq_flag; //printf("\n"); DEBUG( "\n%s","Checking sequence flag\n"); /* * Somehow putting the pdu.seq_flag directly in the switch caused a bus error on SPARC */ uint16_t sducrc; memcpy( &sducrc, sdu.data + sdu.length+1-2, 2 ); DEBUG("SDU crc = 0x%X\n", sducrc ); uint16_t calcedcrc = crcSlow( sdu.data, sdu.length+1-2 ); DEBUG("Calced crc = 0x%X\n", calcedcrc ); if( sducrc != calcedcrc ){ DEBUG("%s","CRC invalid, tossing packet\n"); return; } uint16_t apid = sdu.apid; switch( flag ){ case SEQ_COMPLETE_FILE:{ // complete file, don't bother adding to the list just output DEBUG("%s","We have a complete file\n"); fill_file_info( file, sdu ); file.tp_sdu = new unsigned char[file.length]; memcpy( file.tp_sdu, sdu.data+10, file.length-10 ); // now what? have a complete file, write to disk? this->save_file( file ); break; } case SEQ_FIRST_SEGMENT:{ DEBUG("%s","Got first SDU of a file\n" ); files_by_apid[apid].clear(); // clear out contents if there's an existing list, otherwise this makes a new one files_by_apid[apid].push_back( sdu ); break; } case SEQ_CONTINUATION:{ DEBUG("%s", "Got continuing SDU of a file\n" ); if( files_by_apid.count( apid ) == 1 ){ files_by_apid[apid].push_back( sdu ); }else{ DEBUG("%s", "But we haven't started this file yet, ignoring"); } break; } case SEQ_LAST_SEGMENT:{ if( files_by_apid.count( apid ) == 1 ){ files_by_apid[apid].push_back( sdu ); }else{ break; } files_by_apid[apid].push_back( sdu ); DEBUG("Got last SDU of a file, consisting of %d M_SDUs\n", files_by_apid[apid].size() ); // build file try{ list<M_SDU>::iterator _sdu = files_by_apid[apid].begin(); //from the first header, get the base file info fill_file_info( file, *_sdu ); // now build the file from all of the M_SDU packets file.tp_sdu = new unsigned char[file.length+1];//throw in the +1, in case of the filler portion memcpy(file.tp_sdu, _sdu->data+10, _sdu->length-10-2 ); // -10 this was the first M_SDU that's the transport header, -2 ignore the crc _sdu++; // note we need to check the sequence count before putting these together. we'll put zeros // in for missing packets, but we need to increase the byte count. size_t bytes_stored = _sdu->length-10-2; while( _sdu != files_by_apid[apid].end() && bytes_stored < _sdu->length ){ memcpy(file.tp_sdu+bytes_stored, _sdu->data, _sdu->length ); bytes_stored += _sdu->length; _sdu++; } this->save_file( file ); }catch(... ){ printf("Failed to Create file for apid: %d", apid ); } files_by_apid.erase(apid); break; } default:{ printf("%s:%d unknown packet type\n", __FILE__, __LINE__); break; } } DEBUG("%s", "End process sdu\n" ); }
static bool expbrdScan(void) { uint8_t i = 0; bool status = false; #if 1 if (owScan(&nBoards)) { DEBUG_PRINT("Found %d memories.\n", nBoards); } else { DEBUG_PRINT("Scan [FAILED].\n"); } #if 0 expbrdData[0].header = EXPBRD_ID; expbrdData[0].vid = EXPBRD_VID_BITCRAZE; expbrdData[0].pid = EXPBRD_PID_LEDRING; expbrdData[0].crc = crcSlow( (uint8_t *)&expbrdData[0], sizeof(ExpbrdData) - 1); status = owWrite(0, EXPBRD_OW_ADDR, sizeof(ExpbrdData), (uint8_t *)&expbrdData[0]); if( status == true ) { DEBUG_PRINT("owWrite LED Ring OK\n"); } else { DEBUG_PRINT("owWrite LED Ring Fail\n"); } #endif for (i = 0; i < nBoards; i++) { if (owRead(i, EXPBRD_OW_ADDR, sizeof(ExpbrdData), (uint8_t *)&expbrdData[i])) { if (expbrdIsValid(&expbrdData[i])) { DEBUG_PRINT("Info board %i:\n", i); expbrdPrintData(&expbrdData[i]); status = true; } } else { DEBUG_PRINT("Reading board nr:%d [FAILED].\n", i); } } #endif /* nBoards = 1; expbrdData[0].header = EXPBRD_ID; expbrdData[0].vid = EXPBRD_VID_BITCRAZE; expbrdData[0].pid = EXPBRD_PID_LEDRING; expbrdData[0].crc = crcSlow( (uint8_t *)&expbrdData[0], sizeof(ExpbrdData) - 1); */ owScan(&nBoards); return status; }
void main(void) { char* input_data = malloc(DATA_SIZE); FILE* input_file; input_file = fopen(INPUT_FILE, "r"); if(input_file == NULL){ fprintf(stderr, "Failed to open %s\n", INPUT_FILE); exit(1); } int i = 0; char buffer[BLOCK_SIZE]; while(fgets(buffer, BLOCK_SIZE, input_file)){ strcpy(input_data+i,buffer); i = i + BLOCK_SIZE - 1; } fclose(input_file); /*Replace the line field ascii with \0*/ input_data[strlen(input_data) - 1] = '\0'; struct stopwatch_t* sw = stopwatch_create(); /*--------------------------------------------------------------------------------------*/ stopwatch_init(); stopwatch_start(sw); printf("crcSlow() 0x%X ", crcSlow(input_data, strlen(input_data))); stopwatch_stop(sw); printf(" Time: %Lg\n", stopwatch_elapsed(sw)); /*--------------------------------------------------------------------------------------*/ stopwatch_start(sw); size_t input_data_len = strlen(input_data); int input_blocks = input_data_len / BLOCK_SIZE; int extra_blocks = 0; if(input_data_len % BLOCK_SIZE != 0) extra_blocks = 1; int total_blocks = input_blocks + extra_blocks; int *result = malloc(total_blocks * sizeof(int)); omp_set_num_threads(16); unsigned int ans = 0; char* block_data = malloc(input_blocks * (BLOCK_SIZE + 1)); char* block_addr; i = 0; #pragma omp parallel for default(none) shared(input_blocks, input_data, result, block_data) private (i, block_addr) for(i = 0; i < input_blocks; ++i){ block_addr = block_data + (BLOCK_SIZE + 1) * i; strncpy(block_addr, input_data + BLOCK_SIZE * i, BLOCK_SIZE); *(block_addr + BLOCK_SIZE) = '\0'; result[i] = CrcHash(block_addr, BLOCK_SIZE); } int rem = input_data_len % BLOCK_SIZE; char* last_block_data = malloc(rem + 1); if(extra_blocks == 1){ strncpy(last_block_data, input_data + BLOCK_SIZE * input_blocks, rem); *(last_block_data + rem) = '\0'; result[input_blocks] = CrcHash(last_block_data, rem); } i=0; for(i = 0; i < input_blocks; ++i){ ans = crc32_combine(ans, result[i], BLOCK_SIZE); } if(extra_blocks == 1) ans = crc32_combine(ans, result[i], rem); stopwatch_stop(sw); printf("Parallel() 0x%X Time: %Lg \n",ans, stopwatch_elapsed(sw)); /*--------------------------------------------------------------------------------------*/ crcInit(); stopwatch_start(sw); printf("crcFast() 0x%X ", crcFast(input_data, strlen(input_data))); stopwatch_stop(sw); printf(" Time: %Lg\n", stopwatch_elapsed(sw)); stopwatch_destroy(sw); /*--------------------------------------------------------------------------------------*/ stopwatch_start(sw); printf("crc_intel() 0x%X ", CrcHash((const void*)input_data, strlen(input_data))); stopwatch_stop(sw); printf(" Time: %Lg\n", stopwatch_elapsed(sw)); /*--------------------------------------------------------------------------------------*/ /*Cleanup*/ free(last_block_data); free(block_data); free(input_data); }