/* =============================================================================
* main
* =============================================================================
*/
MAIN(argc, argv)
{
GOTO_REAL();
/*
* Initialization
*/
parseArgs(argc, (char** const)argv);
long numThread = global_params[PARAM_THREAD];
SIM_GET_NUM_CPU(numThread);
TM_STARTUP(numThread);
P_MEMORY_STARTUP(numThread);
thread_startup(numThread);
long percentAttack = global_params[PARAM_ATTACK];
long maxDataLength = global_params[PARAM_LENGTH];
long numFlow = global_params[PARAM_NUM];
long randomSeed = global_params[PARAM_SEED];
printf("Percent attack = %li\n", percentAttack);
printf("Max data length = %li\n", maxDataLength);
printf("Num flow = %li\n", numFlow);
printf("Random seed = %li\n", randomSeed);
dictionary_t* dictionaryPtr = dictionary_alloc();
assert(dictionaryPtr);
stream_t* streamPtr = stream_alloc(percentAttack);
assert(streamPtr);
long numAttack = stream_generate(streamPtr,
dictionaryPtr,
numFlow,
randomSeed,
maxDataLength);
printf("Num attack = %li\n", numAttack);
decoder_t* decoderPtr = decoder_alloc();
assert(decoderPtr);
vector_t** errorVectors = (vector_t**)malloc(numThread * sizeof(vector_t*));
assert(errorVectors);
long i;
for (i = 0; i < numThread; i++) {
vector_t* errorVectorPtr = vector_alloc(numFlow);
assert(errorVectorPtr);
errorVectors[i] = errorVectorPtr;
}
arg_t arg;
arg.streamPtr = streamPtr;
arg.decoderPtr = decoderPtr;
arg.errorVectors = errorVectors;
/*
* Run transactions
*/
TIMER_T startTime;
TIMER_READ(startTime);
GOTO_SIM();
#ifdef OTM
#pragma omp parallel
{
processPackets((void*)&arg);
}
#else
thread_start(processPackets, (void*)&arg);
#endif
GOTO_REAL();
TIMER_T stopTime;
TIMER_READ(stopTime);
printf("\nTime = %lf\n", TIMER_DIFF_SECONDS(startTime, stopTime));
/*
* Check solution
*/
/*long numFound = 0;
for (i = 0; i < numThread; i++) {
vector_t* errorVectorPtr = errorVectors[i];
long e;
long numError = vector_getSize(errorVectorPtr);
numFound += numError;
for (e = 0; e < numError; e++) {
long flowId = (long)vector_at(errorVectorPtr, e);
bool_t status = stream_isAttack(streamPtr, flowId);
assert(status);
}
}*/
/*printf("Num found = %li\n", numFound);
assert(numFound == numAttack);*/
/*
* Clean up
*/
for (i = 0; i < numThread; i++) {
vector_free(errorVectors[i]);
}
free(errorVectors);
decoder_free(decoderPtr);
stream_free(streamPtr);
dictionary_free(dictionaryPtr);
TM_SHUTDOWN();
P_MEMORY_SHUTDOWN();
GOTO_SIM();
thread_shutdown();
MAIN_RETURN(0);
}
int
main ()
{
decoder_t* decoderPtr;
puts("Starting...");
decoderPtr = decoder_alloc();
assert(decoderPtr);
long numDataByte = 3;
long numPacketByte = PACKET_HEADER_LENGTH + numDataByte;
char* abcBytes = (char*)SEQ_MALLOC(numPacketByte);
assert(abcBytes);
packet_t* abcPacketPtr;
abcPacketPtr = (packet_t*)abcBytes;
abcPacketPtr->flowId = 1;
abcPacketPtr->fragmentId = 0;
abcPacketPtr->numFragment = 2;
abcPacketPtr->length = numDataByte;
abcPacketPtr->data[0] = 'a';
abcPacketPtr->data[1] = 'b';
abcPacketPtr->data[2] = 'c';
char* defBytes = (char*)SEQ_MALLOC(numPacketByte);
assert(defBytes);
packet_t* defPacketPtr;
defPacketPtr = (packet_t*)defBytes;
defPacketPtr->flowId = 1;
defPacketPtr->fragmentId = 1;
defPacketPtr->numFragment = 2;
defPacketPtr->length = numDataByte;
defPacketPtr->data[0] = 'd';
defPacketPtr->data[1] = 'e';
defPacketPtr->data[2] = 'f';
assert(decoder_process(decoderPtr, abcBytes, numDataByte) == ERROR_SHORT);
abcPacketPtr->flowId = -1;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_FLOWID);
abcPacketPtr->flowId = 1;
abcPacketPtr->fragmentId = -1;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_FRAGMENTID);
abcPacketPtr->fragmentId = 0;
abcPacketPtr->fragmentId = 2;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_FRAGMENTID);
abcPacketPtr->fragmentId = 0;
abcPacketPtr->fragmentId = 2;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_FRAGMENTID);
abcPacketPtr->fragmentId = 0;
abcPacketPtr->length = -1;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_LENGTH);
abcPacketPtr->length = numDataByte;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_NONE);
defPacketPtr->numFragment = 3;
assert(decoder_process(decoderPtr, defBytes, numPacketByte) == ERROR_NUMFRAGMENT);
defPacketPtr->numFragment = 2;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_NONE);
defPacketPtr->fragmentId = 0;
assert(decoder_process(decoderPtr, defBytes, numPacketByte) == ERROR_INCOMPLETE);
defPacketPtr->fragmentId = 1;
long flowId;
assert(decoder_process(decoderPtr, defBytes, numPacketByte) == ERROR_NONE);
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_NONE);
char* str = decoder_getComplete(decoderPtr, &flowId);
assert(strcmp(str, "abcdef") == 0);
SEQ_FREE(str);
assert(flowId == 1);
abcPacketPtr->numFragment = 1;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_NONE);
str = decoder_getComplete(decoderPtr, &flowId);
assert(strcmp(str, "abc") == 0);
SEQ_FREE(str);
abcPacketPtr->numFragment = 2;
assert(flowId == 1);
str = decoder_getComplete(decoderPtr, &flowId);
assert(str == NULL);
assert(flowId == -1);
decoder_free(decoderPtr);
SEQ_FREE(abcBytes);
SEQ_FREE(defBytes);
puts("All tests passed.");
return 0;
}
/* =============================================================================
* main
* =============================================================================
*/
MAIN(argc, argv)
{
GOTO_REAL();
/*
* Initialization
*/
SETUP_NUMBER_TASKS(3);
parseArgs(argc, (char** const)argv);
long numThread = global_params[PARAM_THREAD];
SETUP_NUMBER_THREADS(numThread);
SIM_GET_NUM_CPU(numThread);
TM_STARTUP(numThread, 0);
P_MEMORY_STARTUP(numThread);
thread_startup(numThread);
long percentAttack = global_params[PARAM_ATTACK];
long maxDataLength = global_params[PARAM_LENGTH];
long numFlow = global_params[PARAM_NUM];
long randomSeed = global_params[PARAM_SEED];
/* printf("Percent attack = %li\n", percentAttack);
printf("Max data length = %li\n", maxDataLength);
printf("Num flow = %li\n", numFlow);
printf("Random seed = %li\n", randomSeed); */
double time_total = 0.0;
int repeats = global_params[PARAM_REPEAT];
for (; repeats > 0; --repeats) {
dictionary_t* dictionaryPtr = dictionary_alloc();
assert(dictionaryPtr);
stream_t* streamPtr = stream_alloc(percentAttack);
assert(streamPtr);
long numAttack = stream_generate(streamPtr,
dictionaryPtr,
numFlow,
randomSeed,
maxDataLength);
// printf("Num attack = %li\n", numAttack);
decoder_t* decoderPtr = decoder_alloc();
assert(decoderPtr);
vector_t** errorVectors = (vector_t**)malloc(numThread * sizeof(vector_t*));
assert(errorVectors);
long i;
for (i = 0; i < numThread; i++) {
vector_t* errorVectorPtr = vector_alloc(numFlow);
assert(errorVectorPtr);
errorVectors[i] = errorVectorPtr;
}
arg_t arg;
arg.streamPtr = streamPtr;
arg.decoderPtr = decoderPtr;
arg.errorVectors = errorVectors;
/*
* Run transactions
*/
TIMER_T startTime;
TIMER_READ(startTime);
tm_time_t start_clock=TM_TIMER_READ();
GOTO_SIM();
thread_start(processPackets, (void*)&arg);
GOTO_REAL();
TIMER_T stopTime;
tm_time_t end_clock=TM_TIMER_READ();
TIMER_READ(stopTime);
double time_tmp = TIMER_DIFF_SECONDS(startTime, stopTime);
time_total += time_tmp;
PRINT_STATS();
PRINT_CLOCK_THROUGHPUT(end_clock-start_clock);
/*
* Check solution
*/
long numFound = 0;
for (i = 0; i < numThread; i++) {
vector_t* errorVectorPtr = errorVectors[i];
long e;
long numError = vector_getSize(errorVectorPtr);
numFound += numError;
for (e = 0; e < numError; e++) {
long flowId = (long)vector_at(errorVectorPtr, e);
bool_t status = stream_isAttack(streamPtr, flowId);
assert(status);
}
}
// printf("Num found = %li\n", numFound);
assert(numFound == numAttack);
/*
* Clean up
*/
for (i = 0; i < numThread; i++) {
vector_free(errorVectors[i]);
}
free(errorVectors);
decoder_free(decoderPtr);
stream_free(streamPtr);
dictionary_free(dictionaryPtr);
}
printf("Time = %f\n", time_total);
TM_SHUTDOWN();
P_MEMORY_SHUTDOWN();
GOTO_SIM();
thread_shutdown();
MAIN_RETURN(0);
}
