int main () { random_t* random1Ptr; random_t* random2Ptr; random_t* random3Ptr; long i; puts("Starting..."); random1Ptr = random_alloc(); random2Ptr = random_alloc(); random3Ptr = random_alloc(); random_seed(random2Ptr, (RANDOM_DEFAULT_SEED + 1)); random_seed(random3Ptr, (RANDOM_DEFAULT_SEED + 1)); for (i = 0; i < NUM_ITERATIONS; i++) { unsigned long rand1 = random_generate(random1Ptr); unsigned long rand2 = random_generate(random2Ptr); unsigned long rand3 = random_generate(random3Ptr); printf("i = %2li, rand1 = %12lu, rand2 = %12lu, rand2 = %12lu\n", i, rand1, rand2, rand3); assert(rand1 != rand2); assert(rand2 == rand3); } random_free(random1Ptr); random_free(random2Ptr); puts("Done."); return 0; }
/* ============================================================================= * initializeManager * ============================================================================= */ static manager_t* initializeManager () { manager_t* managerPtr; long i; long numRelation; random_t* randomPtr; long* ids; bool_t (*manager_add[])(manager_t*, long, long, long) = { &manager_addCar_seq, &manager_addFlight_seq, &manager_addRoom_seq, &addCustomer }; long t; long numTable = sizeof(manager_add) / sizeof(manager_add[0]); printf("Initializing manager... "); fflush(stdout); randomPtr = random_alloc(); managerPtr = manager_alloc(); numRelation = (long)global_params[PARAM_RELATIONS]; ids = (long*)malloc(numRelation * sizeof(long)); for (i = 0; i < numRelation; i++) { ids[i] = i + 1; } for (t = 0; t < numTable; t++) { /* Shuffle ids */ for (i = 0; i < numRelation; i++) { long x = random_generate(randomPtr) % numRelation; long y = random_generate(randomPtr) % numRelation; long tmp = ids[x]; ids[x] = ids[y]; ids[y] = tmp; } /* Populate table */ for (i = 0; i < numRelation; i++) { bool_t status; long id = ids[i]; long num = ((random_generate(randomPtr) % 5) + 1) * 100; long price = ((random_generate(randomPtr) % 5) * 10) + 50; status = manager_add[t](managerPtr, id, num, price); } } /* for t */ puts("done."); fflush(stdout); random_free(randomPtr); free(ids); return managerPtr; }
/* ============================================================================= * client_alloc * -- Returns NULL on failure * ============================================================================= */ client_t* client_alloc (long id, manager_t* managerPtr, long numOperation, long numQueryPerTransaction, long queryRange, long percentUser) { client_t* clientPtr; clientPtr = (client_t*)malloc(sizeof(client_t)); if (clientPtr == NULL) { return NULL; } clientPtr->randomPtr = random_alloc(); if (clientPtr->randomPtr == NULL) { return NULL; } clientPtr->id = id; clientPtr->managerPtr = managerPtr; random_seed(clientPtr->randomPtr, id); clientPtr->numOperation = numOperation; clientPtr->numQueryPerTransaction = numQueryPerTransaction; clientPtr->queryRange = queryRange; clientPtr->percentUser = percentUser; return clientPtr; }
static void tester (long geneLength, long segmentLength, long minNumSegment, bool_t doPrint) { gene_t* genePtr; segments_t* segmentsPtr; random_t* randomPtr; bitmap_t* startBitmapPtr; long i; long j; genePtr = gene_alloc(geneLength); segmentsPtr = segments_alloc(segmentLength, minNumSegment); randomPtr = random_alloc(); startBitmapPtr = bitmap_alloc(geneLength); random_seed(randomPtr, 0); gene_create(genePtr, randomPtr); random_seed(randomPtr, 0); segments_create(segmentsPtr, genePtr, randomPtr); assert(segmentsPtr->minNum == minNumSegment); assert(vector_getSize(segmentsPtr->contentsPtr) >= minNumSegment); if (doPrint) { printf("Gene = %s\n", genePtr->contents); } /* Check that each segment occurs in gene */ for (i = 0; i < vector_getSize(segmentsPtr->contentsPtr); i++) { char *charPtr = strstr(genePtr->contents, (char*)vector_at(segmentsPtr->contentsPtr, i)); assert(charPtr != NULL); j = charPtr - genePtr->contents; bitmap_set(startBitmapPtr, j); if (doPrint) { printf("Segment %li (@%li) = %s\n", i, j, (char*)vector_at(segmentsPtr->contentsPtr, i)); } } /* Check that there is complete overlap */ assert(bitmap_isSet(startBitmapPtr, 0)); for (i = 0, j = 0; i < geneLength; i++ ) { if (bitmap_isSet(startBitmapPtr, i)) { assert((i-j-1) < segmentLength); j = i; } } gene_free(genePtr); segments_free(segmentsPtr); random_free(randomPtr); bitmap_free(startBitmapPtr); }
static void testBasic (long numVar, long numRecord, long numMaxParent, long percentParent) { random_t* randomPtr = random_alloc(); puts("Starting..."); data_t* dataPtr = data_alloc(numVar, numRecord, randomPtr); assert(dataPtr); puts("Init:"); data_generate(dataPtr, 0, numMaxParent, percentParent); long v; for (v = 0; v < numVar; v++) { data_sort(dataPtr, 0, numRecord, v); long s = data_findSplit(dataPtr, 0, numRecord, v); if (s < numRecord) { assert(dataPtr->records[numVar * s + v] == 1); } if (s > 0) { assert(dataPtr->records[numVar * (s - 1) + v] == 0); } } memset(dataPtr->records, 0, dataPtr->numVar * dataPtr->numRecord); for (v = 0; v < numVar; v++) { data_sort(dataPtr, 0, numRecord, v); long s = data_findSplit(dataPtr, 0, numRecord, v); if (s < numRecord) { assert(dataPtr->records[numVar * s + v] == 1); } if (s > 0) { assert(dataPtr->records[numVar * (s - 1) + v] == 0); } assert(s == numRecord); } memset(dataPtr->records, 1, dataPtr->numVar * dataPtr->numRecord); for (v = 0; v < numVar; v++) { data_sort(dataPtr, 0, numRecord, v); long s = data_findSplit(dataPtr, 0, numRecord, v); if (s < numRecord) { assert(dataPtr->records[numVar * s + v] == 1); } if (s > 0) { assert(dataPtr->records[numVar * (s - 1) + v] == 0); } assert(s == 0); } data_free(dataPtr); }
/* ============================================================================= * threadWait * -- Synchronizes all threads to start/stop parallel section * ============================================================================= */ static void threadWait (void* argPtr) { thread_args_t* args = (thread_args_t*) argPtr; long threadId = args->threadId; commits = &(args->commits); aborts = &(args->aborts); retriesProf = &(args->retries); ucbProf = &(args->ucb); int sz = 100; memoized_blocks = (memoized_choices_t*) malloc(sz * sizeof(memoized_choices_t)); for (sz--; sz >= 0; sz-- ) { memoized_choices_t* block = &(memoized_blocks[sz]); block->runs = 0; block->havingCapacityAborts = 0; block->retries = 0; block->commitsHTM = 1; block->believedCapacity = 1; block->believedTransient = 1; block->believedGiveUp = 1; block->abortsCapacity = 0; block->abortsTransient = 0; block->cyclesCapacity = 100; block->cyclesTransient = 100; block->cyclesGiveUp = 100; block->retries = 5; block->lastCycles = 0; block->lastRetries = 5; block->bestEverCycles = 0; block->bestEverRetries = 5; } randomFallback = random_alloc(); random_seed(randomFallback, time(NULL)); THREAD_LOCAL_SET(global_threadId, (long)threadId); bindThread(threadId); while (1) { THREAD_BARRIER(global_barrierPtr, threadId); /* wait for start parallel */ if (global_doShutdown) { break; } global_funcPtr(global_argPtr); THREAD_BARRIER(global_barrierPtr, threadId); /* wait for end parallel */ if (threadId == 0) { break; } } }
/* ============================================================================= * stream_alloc * ============================================================================= */ stream_t* stream_alloc (long percentAttack) { stream_t* streamPtr; streamPtr = (stream_t*)malloc(sizeof(stream_t)); if (streamPtr) { streamPtr->percentAttack = percentAttack; streamPtr->randomPtr = random_alloc(); streamPtr->allocVectorPtr = vector_alloc(1); streamPtr->packetQueuePtr = queue_alloc(-1); streamPtr->attackMapPtr = MAP_ALLOC(NULL, NULL); } return streamPtr; }
int main () { queue_t* queuePtr; random_t* randomPtr; long data[] = {3, 1, 4, 1, 5}; long numData = sizeof(data) / sizeof(data[0]); long i; randomPtr = random_alloc(); assert(randomPtr); random_seed(randomPtr, 0); puts("Starting tests..."); queuePtr = queue_alloc(-1); assert(queue_isEmpty(queuePtr)); for (i = 0; i < numData; i++) { insertData(queuePtr, &data[i]); } assert(!queue_isEmpty(queuePtr)); for (i = 0; i < numData; i++) { long* dataPtr = (long*)queue_pop(queuePtr); printf("Removing %li: ", *dataPtr); printQueue(queuePtr); } assert(!queue_pop(queuePtr)); assert(queue_isEmpty(queuePtr)); puts("All tests passed."); for (i = 0; i < numData; i++) { insertData(queuePtr, &data[i]); } for (i = 0; i < numData; i++) { printf("Shuffle %li: ", i); queue_shuffle(queuePtr, randomPtr); printQueue(queuePtr); } assert(!queue_isEmpty(queuePtr)); queue_free(queuePtr); return 0; }
int main () { gene_t* gene1Ptr; gene_t* gene2Ptr; gene_t* gene3Ptr; random_t* randomPtr; bool_t status = memory_init(1, 4, 2); assert(status); puts("Starting..."); gene1Ptr = gene_alloc(10); gene2Ptr = gene_alloc(10); gene3Ptr = gene_alloc(9); randomPtr = random_alloc(); random_seed(randomPtr, 0); gene_create(gene1Ptr, randomPtr); random_seed(randomPtr, 1); gene_create(gene2Ptr, randomPtr); random_seed(randomPtr, 0); gene_create(gene3Ptr, randomPtr); assert(gene1Ptr->length == strlen(gene1Ptr->contents)); assert(gene2Ptr->length == strlen(gene2Ptr->contents)); assert(gene3Ptr->length == strlen(gene3Ptr->contents)); assert(gene1Ptr->length == gene2Ptr->length); assert(strcmp(gene1Ptr->contents, gene2Ptr->contents) != 0); assert(gene1Ptr->length == (gene3Ptr->length + 1)); assert(strcmp(gene1Ptr->contents, gene3Ptr->contents) != 0); assert(strncmp(gene1Ptr->contents, gene3Ptr->contents, gene3Ptr->length) == 0); gene_free(gene1Ptr); gene_free(gene2Ptr); gene_free(gene3Ptr); random_free(randomPtr); puts("All tests passed."); return 0; }
/* ============================================================================= * initializeWork * ============================================================================= */ static long initializeWork (heap_t* workHeapPtr, mesh_t* meshPtr) { random_t* randomPtr = random_alloc(); random_seed(randomPtr, 0); mesh_shuffleBad(meshPtr, randomPtr); random_free(randomPtr); long numBad = 0; while (1) { element_t* elementPtr = mesh_getBad(meshPtr); if (!elementPtr) { break; } numBad++; bool status = heap_insert(workHeapPtr, (void*)elementPtr); assert(status); element_setIsReferenced(elementPtr, true); } return numBad; }
static void test (long numVar, long numRecord) { random_t* randomPtr = random_alloc(); data_t* dataPtr = data_alloc(numVar, numRecord, randomPtr); assert(dataPtr); data_generate(dataPtr, 0, 10, 10); if (global_doPrint) { printData(dataPtr); } data_t* copyDataPtr = data_alloc(numVar, numRecord, randomPtr); assert(copyDataPtr); data_copy(copyDataPtr, dataPtr); adtree_t* adtreePtr = adtree_alloc(); assert(adtreePtr); TIMER_T start; TIMER_READ(start); adtree_make(adtreePtr, copyDataPtr); TIMER_T stop; TIMER_READ(stop); printf("%lf\n", TIMER_DIFF_SECONDS(start, stop)); if (global_doPrint) { printAdtree(adtreePtr); } testCounts(adtreePtr, dataPtr); adtree_free(adtreePtr); random_free(randomPtr); data_free(dataPtr); }
void *test(void *data) { randomPtr = random_alloc(); unsigned int mySeed = seed + sched_getcpu(); long myOps = operations / nb_threads; long val = -1; int op; while (myOps > 0) { op = rand_r(&mySeed) % 100; if (op < update) { if (val == -1) { /* Add random value */ val = (rand_r(&mySeed) % range) + 1; if(set_add(val) == 0) { val = -1; } } else { /* Remove random value */ int res = set_remove( val); val = -1; } } else { /* Look for random value */ long tmp = (rand_r(&mySeed) % range) + 1; set_contains(tmp); } myOps--; } return NULL; }
void client_run (void* argPtr) { TM_THREAD_ENTER(); /*long id = thread_getId(); volatile long* ptr1 = &(global_array[0].value); volatile long* ptr2 = &(global_array[100].value); long tt = 0; if (id == 0) { while (1) { long v1 = 0; long v2 = 0; acquire_write(&(local_th_data[phys_id]), &the_lock); *ptr1 = (*ptr1) + 1; int f = 1; int ii; for(ii = 1; ii <= 100000000; ii++) { f *= ii; } tt += f; *ptr2 = (*ptr2) + 1; v1 = global_array[0].value; v2 = global_array[100].value; release_write(cluster_id, &(local_th_data[phys_id]), &the_lock); \ if (v1 != v2) { printf("different2! %ld %ld\n", v1, v2); exit(1); } } } else { while (1) { int i = 0; long sum = 0; for (; i < 100000; i++) { int status = _xbegin(); if (status == _XBEGIN_STARTED) { sum += *ptr1; sum += *ptr2; _xend(); } } while(1) { long v1 = 0; long v2 = 0; int status = _xbegin(); if (status == _XBEGIN_STARTED) { v1 = *ptr1; v2 = *ptr2; _xend(); if (v1 != v2) { printf("different! %ld %ld\n", v1, v2); exit(1); } } } } } printf("%ld", tt);*/ random_t* randomPtr = random_alloc(); random_seed(randomPtr, time(0)); // unsigned long myId = thread_getId(); // long numThread = *((long*)argPtr); long operations = (long)global_params[PARAM_OPERATIONS] / (long)global_params[PARAM_THREADS]; long interval = (long)global_params[PARAM_INTERVAL]; printf("operations: %ld \tinterval: %ld\n", operations, interval); long total = 0; long total2 = 0; long i = 0; for (; i < operations; i++) { long random_number = ((long) random_generate(randomPtr)) % ((long)global_params[PARAM_SIZE]); long random_number2 = ((long) random_generate(randomPtr)) % ((long)global_params[PARAM_SIZE]); if (random_number == random_number2) { random_number2 = (random_number2 + 1) % ((long)global_params[PARAM_SIZE]); } TM_BEGIN(); long r1 = (long)TM_SHARED_READ_L(global_array[random_number].value); long r2 = (long)TM_SHARED_READ_L(global_array[random_number2].value); int repeat = 0; for (; repeat < (long) global_params[PARAM_CONTENTION]; repeat++) { total2 += (long) TM_SHARED_READ_L(global_array[((long) random_generate(randomPtr)) % ((long)global_params[PARAM_SIZE])].value); } r1 = r1 + 1; r2 = r2 - 1; int f = 1; int ii; for(ii = 1; ii <= ((unsigned int) global_params[PARAM_WORK]); ii++) { f *= ii; } total += f / 1000000; TM_SHARED_WRITE_L(global_array[random_number].value, r1); TM_SHARED_WRITE_L(global_array[random_number2].value, r2); TM_END(); long k = 0; for (;k < (long)global_params[PARAM_INTERVAL]; k++) { long ru = ((long) random_generate(randomPtr)) % 2; total += ru; } } TM_THREAD_EXIT(); printf("ru ignore %ld - %ld\n", total, total2); }
/* ============================================================================= * genScalData_seq * ============================================================================= */ void genScalData_seq (graphSDG* SDGdataPtr) { /* * STEP 0: Create the permutations required to randomize the vertices */ random_t* stream = random_alloc(); assert(stream); random_seed(stream, 0); ULONGINT_T* permV; /* the vars associated with the graph tuple */ permV = (ULONGINT_T*)malloc(TOT_VERTICES * sizeof(ULONGINT_T)); assert(permV); long i; /* Initialize the array */ for (i = 0; i < TOT_VERTICES; i++) { permV[i] = i; } for (i = 0; i < TOT_VERTICES; i++) { long t1 = random_generate(stream); long t = i + t1 % (TOT_VERTICES - i); if (t != i) { ULONGINT_T t2 = permV[t]; permV[t] = permV[i]; permV[i] = t2; } } /* * STEP 1: Create Cliques */ long* cliqueSizes; long estTotCliques = ceil(1.5 * TOT_VERTICES / ((1+MAX_CLIQUE_SIZE)/2)); /* * Allocate mem for Clique array * Estimate number of clique required and pad by 50% */ cliqueSizes = (long*)malloc(estTotCliques * sizeof(long)); assert(cliqueSizes); /* Generate random clique sizes. */ for (i = 0; i < estTotCliques; i++) { cliqueSizes[i] = 1 + (random_generate(stream) % MAX_CLIQUE_SIZE); } long totCliques = 0; /* * Allocate memory for cliqueList */ ULONGINT_T* lastVsInCliques; ULONGINT_T* firstVsInCliques; lastVsInCliques = (ULONGINT_T*)malloc(estTotCliques * sizeof(ULONGINT_T)); assert(lastVsInCliques); firstVsInCliques = (ULONGINT_T*)malloc(estTotCliques * sizeof(ULONGINT_T)); assert(firstVsInCliques); /* * Sum up vertices in each clique to determine the lastVsInCliques array */ lastVsInCliques[0] = cliqueSizes[0] - 1; for (i = 1; i < estTotCliques; i++) { lastVsInCliques[i] = cliqueSizes[i] + lastVsInCliques[i-1]; if (lastVsInCliques[i] >= TOT_VERTICES-1) { break; } } totCliques = i + 1; /* * Fix the size of the last clique */ cliqueSizes[totCliques-1] = TOT_VERTICES - lastVsInCliques[totCliques-2] - 1; lastVsInCliques[totCliques-1] = TOT_VERTICES - 1; firstVsInCliques[0] = 0; /* * Compute start Vertices in cliques. */ for (i = 1; i < totCliques; i++) { firstVsInCliques[i] = lastVsInCliques[i-1] + 1; } #ifdef WRITE_RESULT_FILES /* Write the generated cliques to file for comparison with Kernel 4 */ FILE* outfp = fopen("cliques.txt", "w"); fprintf(outfp, "No. of cliques - %lu\n", totCliques); for (i = 0; i < totCliques; i++) { fprintf(outfp, "Clq %lu - ", i); long j; for (j = firstVsInCliques[i]; j <= lastVsInCliques[i]; j++) { fprintf(outfp, "%lu ", permV[j]); } fprintf(outfp, "\n"); } fclose(outfp); #endif /* * STEP 2: Create the edges within the cliques */ /* * Estimate number of edges - using an empirical measure */ long estTotEdges; if (SCALE >= 12) { estTotEdges = ceil(((MAX_CLIQUE_SIZE-1) * TOT_VERTICES)); } else { estTotEdges = ceil(1.2 * (((MAX_CLIQUE_SIZE-1)*TOT_VERTICES) * ((1 + MAX_PARAL_EDGES)/2) + TOT_VERTICES*2)); } /* * Initialize edge counter */ long i_edgePtr = 0; float p = PROB_UNIDIRECTIONAL; /* * Partial edgeLists */ ULONGINT_T* startV; ULONGINT_T* endV; long numByte = (estTotEdges) * sizeof(ULONGINT_T); startV = (ULONGINT_T*)malloc(numByte); endV = (ULONGINT_T*)malloc(numByte); assert(startV); assert(endV); /* * Tmp array to keep track of the no. of parallel edges in each direction */ ULONGINT_T** tmpEdgeCounter = (ULONGINT_T**)malloc(MAX_CLIQUE_SIZE * sizeof(ULONGINT_T *)); assert(tmpEdgeCounter); for (i = 0; i < MAX_CLIQUE_SIZE; i++) { tmpEdgeCounter[i] = (ULONGINT_T*)malloc(MAX_CLIQUE_SIZE * sizeof(ULONGINT_T)); assert(tmpEdgeCounter[i]); } /* * Create edges */ long i_clique; for (i_clique = 0; i_clique < totCliques; i_clique++) { /* * Get current clique parameters */ long i_cliqueSize = cliqueSizes[i_clique]; long i_firstVsInClique = firstVsInCliques[i_clique]; /* * First create at least one edge between two vetices in a clique */ for (i = 0; i < i_cliqueSize; i++) { long j; for (j = 0; j < i; j++) { float r = (float)(random_generate(stream) % 1000) / (float)1000; if (r >= p) { startV[i_edgePtr] = i + i_firstVsInClique; endV[i_edgePtr] = j + i_firstVsInClique; i_edgePtr++; tmpEdgeCounter[i][j] = 1; startV[i_edgePtr] = j + i_firstVsInClique; endV[i_edgePtr] = i + i_firstVsInClique; i_edgePtr++; tmpEdgeCounter[j][i] = 1; } else if (r >= 0.5) { startV[i_edgePtr] = i + i_firstVsInClique; endV[i_edgePtr] = j + i_firstVsInClique; i_edgePtr++; tmpEdgeCounter[i][j] = 1; tmpEdgeCounter[j][i] = 0; } else { startV[i_edgePtr] = j + i_firstVsInClique; endV[i_edgePtr] = i + i_firstVsInClique; i_edgePtr++; tmpEdgeCounter[j][i] = 1; tmpEdgeCounter[i][j] = 0; } } /* for j */ } /* for i */ if (i_cliqueSize != 1) { long randNumEdges = (long)(random_generate(stream) % (2*i_cliqueSize*MAX_PARAL_EDGES)); long i_paralEdge; for (i_paralEdge = 0; i_paralEdge < randNumEdges; i_paralEdge++) { i = (random_generate(stream) % i_cliqueSize); long j = (random_generate(stream) % i_cliqueSize); if ((i != j) && (tmpEdgeCounter[i][j] < MAX_PARAL_EDGES)) { float r = (float)(random_generate(stream) % 1000) / (float)1000; if (r >= p) { /* Copy to edge structure. */ startV[i_edgePtr] = i + i_firstVsInClique; endV[i_edgePtr] = j + i_firstVsInClique; i_edgePtr++; tmpEdgeCounter[i][j]++; } } } } } /* for i_clique */ for (i = 0; i < MAX_CLIQUE_SIZE; i++) { free(tmpEdgeCounter[i]); } free(tmpEdgeCounter); /* * Merge partial edge lists */ ULONGINT_T i_edgeStartCounter = 0; ULONGINT_T i_edgeEndCounter = i_edgePtr; long edgeNum = i_edgePtr; /* * Initialize edge list arrays */ ULONGINT_T* startVertex; ULONGINT_T* endVertex; if (SCALE < 10) { long numByte = 2 * edgeNum * sizeof(ULONGINT_T); startVertex = (ULONGINT_T*)malloc(numByte); endVertex = (ULONGINT_T*)malloc(numByte); } else { long numByte = (edgeNum + MAX_PARAL_EDGES * TOT_VERTICES) * sizeof(ULONGINT_T); startVertex = (ULONGINT_T*)malloc(numByte); endVertex = (ULONGINT_T*)malloc(numByte); } assert(startVertex); assert(endVertex); for (i = i_edgeStartCounter; i < i_edgeEndCounter; i++) { startVertex[i] = startV[i-i_edgeStartCounter]; endVertex[i] = endV[i-i_edgeStartCounter]; } ULONGINT_T numEdgesPlacedInCliques = edgeNum; /* * STEP 3: Connect the cliques */ i_edgePtr = 0; p = PROB_INTERCL_EDGES; /* * Generating inter-clique edges as given in the specs */ for (i = 0; i < TOT_VERTICES; i++) { ULONGINT_T tempVertex1 = i; long h = totCliques; long l = 0; long t = -1; while (h - l > 1) { long m = (h + l) / 2; if (tempVertex1 >= firstVsInCliques[m]) { l = m; } else { if ((tempVertex1 < firstVsInCliques[m]) && (m > 0)) { if (tempVertex1 >= firstVsInCliques[m-1]) { t = m - 1; break; } else { h = m; } } } } if (t == -1) { long m; for (m = (l + 1); m < h; m++) { if (tempVertex1<firstVsInCliques[m]) { break; } } t = m-1; } long t1 = firstVsInCliques[t]; ULONGINT_T d; for (d = 1, p = PROB_INTERCL_EDGES; d < TOT_VERTICES; d *= 2, p /= 2) { float r = (float)(random_generate(stream) % 1000) / (float)1000; if (r <= p) { ULONGINT_T tempVertex2 = (i+d) % TOT_VERTICES; h = totCliques; l = 0; t = -1; while (h - l > 1) { long m = (h + l) / 2; if (tempVertex2 >= firstVsInCliques[m]) { l = m; } else { if ((tempVertex2 < firstVsInCliques[m]) && (m > 0)) { if (firstVsInCliques[m-1] <= tempVertex2) { t = m - 1; break; } else { h = m; } } } } if (t == -1) { long m; for (m = (l + 1); m < h; m++) { if (tempVertex2 < firstVsInCliques[m]) { break; } } t = m - 1; } long t2 = firstVsInCliques[t]; if (t1 != t2) { long randNumEdges = random_generate(stream) % MAX_PARAL_EDGES + 1; long j; for (j = 0; j < randNumEdges; j++) { startV[i_edgePtr] = tempVertex1; endV[i_edgePtr] = tempVertex2; i_edgePtr++; } } } /* r <= p */ float r0 = (float)(random_generate(stream) % 1000) / (float)1000; if ((r0 <= p) && (i-d>=0)) { ULONGINT_T tempVertex2 = (i-d) % TOT_VERTICES; h = totCliques; l = 0; t = -1; while (h - l > 1) { long m = (h + l) / 2; if (tempVertex2 >= firstVsInCliques[m]) { l = m; } else { if ((tempVertex2 < firstVsInCliques[m]) && (m > 0)) { if (firstVsInCliques[m-1] <= tempVertex2) { t = m - 1; break; } else { h = m; } } } } if (t == -1) { long m; for (m = (l + 1); m < h; m++) { if (tempVertex2 < firstVsInCliques[m]) { break; } } t = m - 1; } long t2 = firstVsInCliques[t]; if (t1 != t2) { long randNumEdges = random_generate(stream) % MAX_PARAL_EDGES + 1; long j; for (j = 0; j < randNumEdges; j++) { startV[i_edgePtr] = tempVertex1; endV[i_edgePtr] = tempVertex2; i_edgePtr++; } } } /* r0 <= p && (i-d) > 0 */ } /* for d, p */ } /* for i */ i_edgeEndCounter = i_edgePtr; i_edgeStartCounter = 0; edgeNum = i_edgePtr; ULONGINT_T numEdgesPlacedOutside = edgeNum; for (i = i_edgeStartCounter; i < i_edgeEndCounter; i++) { startVertex[i+numEdgesPlacedInCliques] = startV[i-i_edgeStartCounter]; endVertex[i+numEdgesPlacedInCliques] = endV[i-i_edgeStartCounter]; } ULONGINT_T numEdgesPlaced = numEdgesPlacedInCliques + numEdgesPlacedOutside; SDGdataPtr->numEdgesPlaced = numEdgesPlaced; printf("Finished generating edges\n"); printf("No. of intra-clique edges - %lu\n", numEdgesPlacedInCliques); printf("No. of inter-clique edges - %lu\n", numEdgesPlacedOutside); printf("Total no. of edges - %lu\n", numEdgesPlaced); free(cliqueSizes); free(firstVsInCliques); free(lastVsInCliques); free(startV); free(endV); /* * STEP 4: Generate edge weights */ SDGdataPtr->intWeight = (LONGINT_T*)malloc(numEdgesPlaced * sizeof(LONGINT_T)); assert(SDGdataPtr->intWeight); p = PERC_INT_WEIGHTS; ULONGINT_T numStrWtEdges = 0; for (i = 0; i < numEdgesPlaced; i++) { float r = (float)(random_generate(stream) % 1000) / (float)1000; if (r <= p) { SDGdataPtr->intWeight[i] = 1 + (random_generate(stream) % (MAX_INT_WEIGHT-1)); } else { SDGdataPtr->intWeight[i] = -1; numStrWtEdges++; } } long t = 0; for (i = 0; i < numEdgesPlaced; i++) { if (SDGdataPtr->intWeight[i] < 0) { SDGdataPtr->intWeight[i] = -t; t++; } } SDGdataPtr->strWeight = (char*)malloc(numStrWtEdges * MAX_STRLEN * sizeof(char)); assert(SDGdataPtr->strWeight); for (i = 0; i < numEdgesPlaced; i++) { if (SDGdataPtr->intWeight[i] <= 0) { long j; for (j = 0; j < MAX_STRLEN; j++) { SDGdataPtr->strWeight[(-SDGdataPtr->intWeight[i])*MAX_STRLEN+j] = (char) (1 + random_generate(stream) % 127); } } } /* * Choose SOUGHT STRING randomly if not assigned */ if (strlen(SOUGHT_STRING) != MAX_STRLEN) { SOUGHT_STRING = (char*)malloc(MAX_STRLEN * sizeof(char)); assert(SOUGHT_STRING); } t = random_generate(stream) % numStrWtEdges; long j; for (j = 0; j < MAX_STRLEN; j++) { SOUGHT_STRING[j] = (char) ((long) SDGdataPtr->strWeight[t*MAX_STRLEN+j]); } /* * STEP 5: Permute Vertices */ for (i = 0; i < numEdgesPlaced; i++) { startVertex[i] = permV[(startVertex[i])]; endVertex[i] = permV[(endVertex[i])]; } /* * STEP 6: Sort Vertices */ /* * Radix sort with StartVertex as primary key */ numByte = numEdgesPlaced * sizeof(ULONGINT_T); SDGdataPtr->startVertex = (ULONGINT_T*)malloc(numByte); assert(SDGdataPtr->startVertex); SDGdataPtr->endVertex = (ULONGINT_T*)malloc(numByte); assert(SDGdataPtr->endVertex); all_radixsort_node_aux_s3_seq(numEdgesPlaced, startVertex, SDGdataPtr->startVertex, endVertex, SDGdataPtr->endVertex); free(startVertex); free(endVertex); if (SCALE < 12) { /* * Sort with endVertex as secondary key */ long i0 = 0; long i1 = 0; i = 0; while (i < numEdgesPlaced) { for (i = i0; i < numEdgesPlaced; i++) { if (SDGdataPtr->startVertex[i] != SDGdataPtr->startVertex[i1]) { i1 = i; break; } } long j; for (j = i0; j < i1; j++) { long k; for (k = j+1; k < i1; k++) { if (SDGdataPtr->endVertex[k] < SDGdataPtr->endVertex[j]) { long t = SDGdataPtr->endVertex[j]; SDGdataPtr->endVertex[j] = SDGdataPtr->endVertex[k]; SDGdataPtr->endVertex[k] = t; } } } if (SDGdataPtr->startVertex[i0] != TOT_VERTICES-1) { i0 = i1; } else { long j; for (j=i0; j<numEdgesPlaced; j++) { long k; for (k=j+1; k<numEdgesPlaced; k++) { if (SDGdataPtr->endVertex[k] < SDGdataPtr->endVertex[j]) { long t = SDGdataPtr->endVertex[j]; SDGdataPtr->endVertex[j] = SDGdataPtr->endVertex[k]; SDGdataPtr->endVertex[k] = t; } } } } } /* while i < numEdgesPlaced */ } else { ULONGINT_T* tempIndex = (ULONGINT_T*)malloc((TOT_VERTICES + 1) * sizeof(ULONGINT_T)); /* * Update degree of each vertex */ tempIndex[0] = 0; tempIndex[TOT_VERTICES] = numEdgesPlaced; long i0 = 0; for (i=0; i < TOT_VERTICES; i++) { tempIndex[i+1] = tempIndex[i]; long j; for (j = i0; j < numEdgesPlaced; j++) { if (SDGdataPtr->startVertex[j] != SDGdataPtr->startVertex[i0]) { if (SDGdataPtr->startVertex[i0] == i) { tempIndex[i+1] = j; i0 = j; break; } } } } /* * Insertion sort for now, replace with something better later on */ for (i = 0; i < TOT_VERTICES; i++) { long j; for (j = tempIndex[i]; j < tempIndex[i+1]; j++) { long k; for (k = (j + 1); k < tempIndex[i+1]; k++) { if (SDGdataPtr->endVertex[k] < SDGdataPtr->endVertex[j]) { long t = SDGdataPtr->endVertex[j]; SDGdataPtr->endVertex[j] = SDGdataPtr->endVertex[k]; SDGdataPtr->endVertex[k] = t; } } } } free(tempIndex); } /* SCALE >= 12 */ random_free(stream); free(permV); }
static void testAll (long numVar, long numRecord, long numMaxParent, long percentParent) { random_t* randomPtr = random_alloc(); puts("Starting..."); data_t* dataPtr = data_alloc(numVar, numRecord, randomPtr); assert(dataPtr); puts("Init:"); net_t* netPtr = data_generate(dataPtr, 0, numMaxParent, percentParent); net_free(netPtr); printRecords(dataPtr); puts("Sort first half from 0:"); data_sort(dataPtr, 0, numRecord/2, 0); printRecords(dataPtr); puts("Sort second half from 0:"); data_sort(dataPtr, numRecord/2, numRecord-numRecord/2, 0); printRecords(dataPtr); puts("Sort all from mid:"); data_sort(dataPtr, 0, numRecord, numVar/2); printRecords(dataPtr); long split = data_findSplit(dataPtr, 0, numRecord, numVar/2); printf("Split = %li\n", split); long v; for (v = 0; v < numVar; v++) { data_sort(dataPtr, 0, numRecord, v); long s = data_findSplit(dataPtr, 0, numRecord, v); if (s < numRecord) { assert(dataPtr->records[numVar * s + v] == 1); } if (s > 0) { assert(dataPtr->records[numVar * (s - 1) + v] == 0); } } memset(dataPtr->records, 0, dataPtr->numVar * dataPtr->numRecord); for (v = 0; v < numVar; v++) { data_sort(dataPtr, 0, numRecord, v); long s = data_findSplit(dataPtr, 0, numRecord, v); if (s < numRecord) { assert(dataPtr->records[numVar * s + v] == 1); } if (s > 0) { assert(dataPtr->records[numVar * (s - 1) + v] == 0); } assert(s == numRecord); } memset(dataPtr->records, 1, dataPtr->numVar * dataPtr->numRecord); for (v = 0; v < numVar; v++) { data_sort(dataPtr, 0, numRecord, v); long s = data_findSplit(dataPtr, 0, numRecord, v); if (s < numRecord) { assert(dataPtr->records[numVar * s + v] == 1); } if (s > 0) { assert(dataPtr->records[numVar * (s - 1) + v] == 0); } assert(s == 0); } data_free(dataPtr); }
/* ============================================================================= * main * ============================================================================= */ int main (int argc, char** argv) { int result = 0; TIMER_T start; TIMER_T stop; /* Initialization */ parseArgs(argc, (char** const)argv); printf("Creating gene and segments... "); fflush(stdout); long geneLength = global_params[PARAM_GENE]; long segmentLength = global_params[PARAM_SEGMENT]; long minNumSegment = global_params[PARAM_NUMBER]; long numThread = global_params[PARAM_THREAD]; thread_startup(numThread); random_t* randomPtr = random_alloc(); assert(randomPtr != NULL); random_seed(randomPtr, 0); gene_t* genePtr = gene_alloc(geneLength); assert( genePtr != NULL); gene_create(genePtr, randomPtr); char* gene = genePtr->contents; segments_t* segmentsPtr = segments_alloc(segmentLength, minNumSegment); assert(segmentsPtr != NULL); segments_create(segmentsPtr, genePtr, randomPtr); sequencer_t* sequencerPtr = sequencer_alloc(geneLength, segmentLength, segmentsPtr); assert(sequencerPtr != NULL); puts("done."); printf("Gene length = %li\n", genePtr->length); printf("Segment length = %li\n", segmentsPtr->length); printf("Number segments = %li\n", vector_getSize(segmentsPtr->contentsPtr)); fflush(stdout); /* Benchmark */ printf("Sequencing gene... "); fflush(stdout); TIMER_READ(start); #ifdef OTM #pragma omp parallel { sequencer_run(sequencerPtr); } #else thread_start(sequencer_run, (void*)sequencerPtr); #endif TIMER_READ(stop); puts("done."); printf("Time = %lf\n", TIMER_DIFF_SECONDS(start, stop)); fflush(stdout); /* Check result */ { char* sequence = sequencerPtr->sequence; result = strcmp(gene, sequence); printf("Sequence matches gene: %s\n", (result ? "no" : "yes")); if (result) { printf("gene = %s\n", gene); printf("sequence = %s\n", sequence); } fflush(stdout); assert(strlen(sequence) >= strlen(gene)); } /* Clean up */ printf("Deallocating memory... "); fflush(stdout); sequencer_free(sequencerPtr); segments_free(segmentsPtr); gene_free(genePtr); random_free(randomPtr); puts("done."); fflush(stdout); thread_shutdown(); return result; }
int main () { long numNode = 100; puts("Starting tests..."); bool_t status; net_t* netPtr = net_alloc(numNode); assert(netPtr); bitmap_t* visitedBitmapPtr = bitmap_alloc(numNode); assert(visitedBitmapPtr); queue_t* workQueuePtr = queue_alloc(-1); assert(workQueuePtr); assert(!net_isCycle(netPtr)); long aId = 31; long bId = 14; long cId = 5; long dId = 92; net_applyOperation(netPtr, OPERATION_INSERT, aId, bId); assert(net_isPath(netPtr, aId, bId, visitedBitmapPtr, workQueuePtr)); assert(!net_isPath(netPtr, bId, aId, visitedBitmapPtr, workQueuePtr)); assert(!net_isPath(netPtr, aId, cId, visitedBitmapPtr, workQueuePtr)); assert(!net_isPath(netPtr, aId, dId, visitedBitmapPtr, workQueuePtr)); assert(!net_isCycle(netPtr)); net_applyOperation(netPtr, OPERATION_INSERT, bId, cId); net_applyOperation(netPtr, OPERATION_INSERT, aId, cId); net_applyOperation(netPtr, OPERATION_INSERT, dId, aId); assert(!net_isCycle(netPtr)); net_applyOperation(netPtr, OPERATION_INSERT, cId, dId); assert(net_isCycle(netPtr)); net_applyOperation(netPtr, OPERATION_REVERSE, cId, dId); assert(!net_isCycle(netPtr)); net_applyOperation(netPtr, OPERATION_REVERSE, dId, cId); assert(net_isCycle(netPtr)); assert(net_isPath(netPtr, aId, dId, visitedBitmapPtr, workQueuePtr)); net_applyOperation(netPtr, OPERATION_REMOVE, cId, dId); assert(!net_isPath(netPtr, aId, dId, visitedBitmapPtr, workQueuePtr)); bitmap_t* ancestorBitmapPtr = bitmap_alloc(numNode); assert(ancestorBitmapPtr); status = net_findAncestors(netPtr, cId, ancestorBitmapPtr, workQueuePtr); assert(status); assert(bitmap_isSet(ancestorBitmapPtr, aId)); assert(bitmap_isSet(ancestorBitmapPtr, bId)); assert(bitmap_isSet(ancestorBitmapPtr, dId)); assert(bitmap_getNumSet(ancestorBitmapPtr) == 3); bitmap_t* descendantBitmapPtr = bitmap_alloc(numNode); assert(descendantBitmapPtr); status = net_findDescendants(netPtr, aId, descendantBitmapPtr, workQueuePtr); assert(status); assert(bitmap_isSet(descendantBitmapPtr, bId)); assert(bitmap_isSet(descendantBitmapPtr, cId)); assert(bitmap_getNumSet(descendantBitmapPtr) == 2); bitmap_free(visitedBitmapPtr); queue_free(workQueuePtr); bitmap_free(ancestorBitmapPtr); bitmap_free(descendantBitmapPtr); net_free(netPtr); random_t* randomPtr = random_alloc(); assert(randomPtr); netPtr = net_alloc(numNode); assert(netPtr); net_generateRandomEdges(netPtr, 10, 10, randomPtr); net_free(netPtr); puts("All tests passed."); return 0; }
/* ============================================================================= * main * ============================================================================= */ MAIN (argc,argv) { TIMER_T start; TIMER_T stop; GOTO_REAL(); /* Initialization */ parseArgs(argc, (char** const)argv); SIM_GET_NUM_CPU(global_params[PARAM_THREAD]); printf("Creating gene and segments... "); fflush(stdout); long geneLength = global_params[PARAM_GENE]; long segmentLength = global_params[PARAM_SEGMENT]; long minNumSegment = global_params[PARAM_NUMBER]; long numThread = global_params[PARAM_THREAD]; TM_STARTUP(numThread); P_MEMORY_STARTUP(numThread); random_t* randomPtr = random_alloc(); assert(randomPtr != NULL); random_seed(randomPtr, 0); gene_t* genePtr = gene_alloc(geneLength); assert( genePtr != NULL); gene_create(genePtr, randomPtr); char* gene = genePtr->contents; segments_t* segmentsPtr = segments_alloc(segmentLength, minNumSegment); assert(segmentsPtr != NULL); segments_create(segmentsPtr, genePtr, randomPtr); sequencer_t* sequencerPtr = sequencer_alloc(geneLength, segmentLength, segmentsPtr); assert(sequencerPtr != NULL); puts("done."); printf("Gene length = %li\n", genePtr->length); printf("Segment length = %li\n", segmentsPtr->length); printf("Number segments = %li\n", vector_getSize(segmentsPtr->contentsPtr)); fflush(stdout); /* Benchmark */ printf("Sequencing gene... "); fflush(stdout); TIMER_READ(start); GOTO_SIM(); thread_startup(numThread, sequencer_run, (void*)sequencerPtr); thread_start(); GOTO_REAL(); TIMER_READ(stop); puts("done."); printf("Time = %lf\n", TIMER_DIFF_SECONDS(start, stop)); fflush(stdout); /* Check result */ { char* sequence = sequencerPtr->sequence; int result = strcmp(gene, sequence); printf("Sequence matches gene: %s\n", (result ? "no" : "yes")); if (result) { printf("gene = %s\n", gene); printf("sequence = %s\n", sequence); } fflush(stdout); assert(strlen(sequence) >= strlen(gene)); } /* Clean up */ printf("Deallocating memory... "); fflush(stdout); sequencer_free(sequencerPtr); segments_free(segmentsPtr); gene_free(genePtr); random_free(randomPtr); puts("done."); fflush(stdout); al_dump(&sequencerLock); TM_SHUTDOWN(); P_MEMORY_SHUTDOWN(); GOTO_SIM(); thread_shutdown(); MAIN_RETURN(0); }
/* ============================================================================= * main * ============================================================================= */ MAIN(argc, argv) { GOTO_REAL(); /* * Initialization */ parseArgs(argc, (char** const)argv); long numThread = global_params[PARAM_THREAD]; long numVar = global_params[PARAM_VAR]; long numRecord = global_params[PARAM_RECORD]; long randomSeed = global_params[PARAM_SEED]; long maxNumParent = global_params[PARAM_NUMBER]; long percentParent = global_params[PARAM_PERCENT]; global_insertPenalty = global_params[PARAM_INSERT]; global_maxNumEdgeLearned = global_params[PARAM_EDGE]; SIM_GET_NUM_CPU(numThread); TM_STARTUP(numThread); P_MEMORY_STARTUP(numThread); thread_startup(numThread); printf("Random seed = %li\n", randomSeed); printf("Number of vars = %li\n", numVar); printf("Number of records = %li\n", numRecord); printf("Max num parents = %li\n", maxNumParent); printf("%% chance of parent = %li\n", percentParent); printf("Insert penalty = %li\n", global_insertPenalty); printf("Max num edge learned / var = %li\n", global_maxNumEdgeLearned); printf("Operation quality factor = %f\n", global_operationQualityFactor); fflush(stdout); /* * Generate data */ printf("Generating data... "); fflush(stdout); random_t* randomPtr = random_alloc(); assert(randomPtr); random_seed(randomPtr, randomSeed); data_t* dataPtr = data_alloc(numVar, numRecord, randomPtr); assert(dataPtr); net_t* netPtr = data_generate(dataPtr, -1, maxNumParent, percentParent); puts("done."); fflush(stdout); /* * Generate adtree */ adtree_t* adtreePtr = adtree_alloc(); assert(adtreePtr); printf("Generating adtree... "); fflush(stdout); TIMER_T adtreeStartTime; TIMER_READ(adtreeStartTime); adtree_make(adtreePtr, dataPtr); TIMER_T adtreeStopTime; TIMER_READ(adtreeStopTime); puts("done."); fflush(stdout); printf("Adtree time = %f\n", TIMER_DIFF_SECONDS(adtreeStartTime, adtreeStopTime)); fflush(stdout); /* * Score original network */ float actualScore = score(netPtr, adtreePtr); net_free(netPtr); /* * Learn structure of Bayesian network */ learner_t* learnerPtr = learner_alloc(dataPtr, adtreePtr, numThread); assert(learnerPtr); data_free(dataPtr); /* save memory */ printf("Learning structure..."); fflush(stdout); TIMER_T learnStartTime; TIMER_READ(learnStartTime); GOTO_SIM(); learner_run(learnerPtr); GOTO_REAL(); TIMER_T learnStopTime; TIMER_READ(learnStopTime); puts("done."); fflush(stdout); printf("Time = %f\n", TIMER_DIFF_SECONDS(learnStartTime, learnStopTime)); fflush(stdout); /* * Check solution */ bool_t status = net_isCycle(learnerPtr->netPtr); assert(!status); #ifndef SIMULATOR float learnScore = learner_score(learnerPtr); printf("Learn score = %f\n", learnScore); #endif printf("Actual score = %f\n", actualScore); /* * Clean up */ fflush(stdout); random_free(randomPtr); #ifndef SIMULATOR adtree_free(adtreePtr); # if 0 learner_free(learnerPtr); # endif #endif TM_SHUTDOWN(); P_MEMORY_SHUTDOWN(); GOTO_SIM(); thread_shutdown(); MAIN_RETURN(0); }
void client_run (void* argPtr) { TM_THREAD_ENTER(); random_t* randomPtr = random_alloc(); random_seed(randomPtr, time(0)); // unsigned long myId = thread_getId(); // long numThread = *((long*)argPtr); long operations = (long)global_params[PARAM_OPERATIONS] / (long)global_params[PARAM_THREADS]; long interval = (long)global_params[PARAM_INTERVAL]; printf("operations: %ld \tinterval: %ld\n", operations, interval); long total = 0; long total2 = 0; long i = 0; unsigned int cont_size = (unsigned int) global_params[PARAM_CONTENTION]; unsigned int* sorted_locks = (unsigned int*) malloc((2 + cont_size) * sizeof(int)); unsigned int* read_idxs = (unsigned int*) malloc(cont_size * sizeof(int)); for (; i < operations; i++) { long random_number = ((long) random_generate(randomPtr)) % ((long)global_params[PARAM_SIZE]); long random_number2 = ((long) random_generate(randomPtr)) % ((long)global_params[PARAM_SIZE]); if (random_number == random_number2) { random_number2 = (random_number2 + 1) % ((long)global_params[PARAM_SIZE]); } int repeat = 0; for (; repeat < cont_size; repeat++) { read_idxs[repeat] = ((unsigned int) random_generate(randomPtr)) % ((unsigned int)global_params[PARAM_SIZE]); LI_HASH(&global_array[read_idxs[repeat]], &sorted_locks[repeat + 2]); } // TM_BEGIN(); LI_HASH(&global_array[random_number], &sorted_locks[0]); LI_HASH(&global_array[random_number2], &sorted_locks[1]); TM_BEGIN_ARGS(sorted_locks, cont_size + 2); long r1 = (long)TM_SHARED_READ(global_array[random_number].value); long r2 = (long)TM_SHARED_READ(global_array[random_number2].value); for (repeat--; repeat >= 0; repeat--) { total2 += (long) TM_SHARED_READ(global_array[read_idxs[repeat]].value); } r1 = r1 + 1; r2 = r2 - 1; int f = 1; int ii; for(ii = 1; ii <= ((unsigned int) global_params[PARAM_WORK]); ii++) { f *= ii; } total += f / 1000000; TM_SHARED_WRITE(global_array[random_number].value, r1); TM_SHARED_WRITE(global_array[random_number2].value, r2); TM_END_ARGS(sorted_locks, cont_size + 2); long k = 0; for (;k < (long)global_params[PARAM_INTERVAL]; k++) { long ru = ((long) random_generate(randomPtr)) % 2; total += ru; } } TM_THREAD_EXIT(); printf("ru ignore %ld - %ld\n", total, total2); }
/* ============================================================================= * main * ============================================================================= */ MAIN (argc,argv) { TIMER_T start; TIMER_T stop; /* Initialization */ parseArgs(argc, (char** const)argv); SIM_GET_NUM_CPU(global_params[PARAM_THREAD]); printf("Creating gene and segments... "); fflush(stdout); long geneLength = global_params[PARAM_GENE]; long segmentLength = global_params[PARAM_SEGMENT]; long minNumSegment = global_params[PARAM_NUMBER]; long numThread = global_params[PARAM_THREAD]; random_t* randomPtr; gene_t* genePtr; char* gene; segments_t* segmentsPtr; sequencer_t* sequencerPtr; TM_STARTUP(numThread); P_MEMORY_STARTUP(numThread); TM_THREAD_ENTER(); // TM_BEGIN(); randomPtr= random_alloc(); assert(randomPtr != NULL); random_seed(randomPtr, 0); genePtr = gene_alloc(geneLength); assert( genePtr != NULL); gene_create(genePtr, randomPtr); gene = genePtr->contents; segmentsPtr = segments_alloc(segmentLength, minNumSegment); assert(segmentsPtr != NULL); segments_create(segmentsPtr, genePtr, randomPtr); sequencerPtr = sequencer_alloc(geneLength, segmentLength, segmentsPtr); assert(sequencerPtr != NULL); //TM_END(); thread_startup(numThread); puts("done."); printf("Gene length = %li\n", genePtr->length); printf("Segment length = %li\n", segmentsPtr->length); printf("Number segments = %li\n", vector_getSize(segmentsPtr->contentsPtr)); fflush(stdout); /* Benchmark */ printf("Sequencing gene... "); fflush(stdout); // NB: Since ASF/PTLSim "REAL" is native execution, and since we are using // wallclock time, we want to be sure we read time inside the // simulator, or else we report native cycles spent on the benchmark // instead of simulator cycles. GOTO_SIM(); TIMER_READ(start); #ifdef OTM #pragma omp parallel { sequencer_run(sequencerPtr); } #else thread_start(sequencer_run, (void*)sequencerPtr); #endif TIMER_READ(stop); // NB: As above, timer reads must be done inside of the simulated region // for PTLSim/ASF GOTO_REAL(); puts("done."); printf("Time = %lf\n", TIMER_DIFF_SECONDS(start, stop)); fflush(stdout); /* Check result */ { char* sequence; int result; //TM_BEGIN(); sequence= sequencerPtr->sequence; result = strcmp(gene, sequence); //TM_END(); printf("Sequence matches gene: %s\n", (result ? "no" : "yes")); if (result) { printf("gene = %s\n", gene); printf("sequence = %s\n", sequence); } fflush(stdout); assert(strlen(sequence) >= strlen(gene)); } /* Clean up */ printf("Deallocating memory... "); fflush(stdout); sequencer_free(sequencerPtr); segments_free(segmentsPtr); gene_free(genePtr); random_free(randomPtr); puts("done."); fflush(stdout); TM_SHUTDOWN(); P_MEMORY_SHUTDOWN(); thread_shutdown(); MAIN_RETURN(0); }