void SMemFunctionalTests::testGreaterOrEqual() { SoarHelper::setStopPhase(agent, SoarHelper::StopPhase::OUTPUT); runTest("testGreaterOrEqual", 1); }
int test_BR_LLSC_6_20_010(MYKI_BR_ContextData_t *pData) { int rv = TRUE; CardImage_t CardImage; /* ** Test with */ if (CreateCardImage_Empty(&CardImage) < 0) { return FALSE; } CreateProduct( &CardImage, 1, PRODUCT_ID_NHOUR, 1, 1, pData->DynamicData.currentDateTime ); CardImage.pMYKI_TAControl->ProductInUse = 1; /* ** Setup Transport locations ** Not a Border Trip */ pData->DynamicData.transportLocationsCount = 3; pData->DynamicData.transportLocations[0].inner_zone = 3; pData->DynamicData.transportLocations[0].zone = 3; pData->DynamicData.transportLocations[0].outer_zone = 4; pData->DynamicData.transportLocations[1].inner_zone = 4; pData->DynamicData.transportLocations[1].zone = 4; pData->DynamicData.transportLocations[1].outer_zone = 5; pData->DynamicData.transportLocations[2].inner_zone = 5; pData->DynamicData.transportLocations[2].zone = 6; pData->DynamicData.transportLocations[2].outer_zone = 6; /* ** Run the Test and examine the results */ if (!runTest(pData, RULE_RESULT_EXECUTED, 302)) { return FALSE; } /* ** Examine conditions */ if (pData->DynamicData.transportLocationsCount) { CsVerbose("test_BR_LLSC_6_20 - transportLocationsCount NOT zero as expected" ); rv = FALSE; } if (pData->DynamicData.currentTripZoneLow != 4) { CsVerbose("test_BR_LLSC_6_20 - currentTripZoneLow NOT as expected. Was:%d",pData->DynamicData.currentTripZoneLow ); rv = FALSE; } if (pData->DynamicData.currentTripZoneHigh != 5) { CsVerbose("test_BR_LLSC_6_20 - currentTripZoneHigh NOT as expected. Was:%d",pData->DynamicData.currentTripZoneHigh ); rv = FALSE; } return rv; }
int main (int argc, char *argv[]) { int i = 0; CRITICAL_SECTION cs; old_mutex_t ox; pthread_mutexattr_init(&ma); printf( "=============================================================================\n"); printf( "\nLock plus unlock on an unlocked mutex.\n%ld iterations\n\n", ITERATIONS); printf( "%-45s %15s %15s\n", "Test", "Total(msec)", "average(usec)"); printf( "-----------------------------------------------------------------------------\n"); /* * Time the loop overhead so we can subtract it from the actual test times. */ TESTSTART assert(1 == one); assert(1 == one); TESTSTOP durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; overHeadMilliSecs = durationMilliSecs; TESTSTART assert((dummy_call(&i), 1) == one); assert((dummy_call(&i), 1) == one); TESTSTOP durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Dummy call x 2", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); TESTSTART assert((interlocked_inc_with_conditionals(&i), 1) == one); assert((interlocked_dec_with_conditionals(&i), 1) == one); TESTSTOP durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Dummy call -> Interlocked with cond x 2", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); TESTSTART assert((InterlockedIncrement(&i), 1) == one); assert((InterlockedDecrement(&i), 1) == one); TESTSTOP durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "InterlockedOp x 2", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); InitializeCriticalSection(&cs); TESTSTART assert((EnterCriticalSection(&cs), 1) == one); assert((LeaveCriticalSection(&cs), 1) == one); TESTSTOP DeleteCriticalSection(&cs); durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Simple Critical Section", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); old_mutex_use = OLD_WIN32CS; assert(old_mutex_init(&ox, NULL) == 0); TESTSTART assert(old_mutex_lock(&ox) == zero); assert(old_mutex_unlock(&ox) == zero); TESTSTOP assert(old_mutex_destroy(&ox) == 0); durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Old PT Mutex using a Critical Section (WNT)", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); old_mutex_use = OLD_WIN32MUTEX; assert(old_mutex_init(&ox, NULL) == 0); TESTSTART assert(old_mutex_lock(&ox) == zero); assert(old_mutex_unlock(&ox) == zero); TESTSTOP assert(old_mutex_destroy(&ox) == 0); durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Old PT Mutex using a Win32 Mutex (W9x)", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); printf( ".............................................................................\n"); /* * Now we can start the actual tests */ #ifdef PTW32_MUTEX_TYPES runTest("PTHREAD_MUTEX_DEFAULT (W9x,WNT)", PTHREAD_MUTEX_DEFAULT); runTest("PTHREAD_MUTEX_NORMAL (W9x,WNT)", PTHREAD_MUTEX_NORMAL); runTest("PTHREAD_MUTEX_ERRORCHECK (W9x,WNT)", PTHREAD_MUTEX_ERRORCHECK); runTest("PTHREAD_MUTEX_RECURSIVE (W9x,WNT)", PTHREAD_MUTEX_RECURSIVE); #else runTest("Non-blocking lock", 0); #endif printf( "=============================================================================\n"); /* * End of tests. */ pthread_mutexattr_destroy(&ma); return 0; }
TEST(WTF_Condition, TenProducersTenConsumersHundredSlotsNotifyAll) { runTest(10, 10, 100, 50000, TacticallyNotifyAll); }
int test_BR_LLSC_6_20_008(MYKI_BR_ContextData_t *pData) { int rv = TRUE; CardImage_t CardImage; pData->InternalData.TransportMode = TRANSPORT_MODE_BUS; pData->DynamicData.lineId = 1; pData->DynamicData.stopId = 1; /* ** Test with */ if ( CreateCardImage_Empty( &CardImage ) < 0 ) { return FALSE; } CreateProduct( &CardImage, 1, PRODUCT_ID_NHOUR, 1, 1, pData->DynamicData.currentDateTime + 60 ); // Don't care but make it sensible CardImage.pMYKI_TAProduct[ 0 ]->LastUsage.DateTime = pData->DynamicData.currentDateTime - 60; // Don't care but make it sensible CardImage.pMYKI_TAProduct[ 0 ]->LastUsage.Location.EntryPointId = 10500; // Station ID CardImage.pMYKI_TAProduct[ 0 ]->LastUsage.Location.RouteId = 0; // Not set CardImage.pMYKI_TAProduct[ 0 ]->LastUsage.Location.StopId = 0; // Not set CardImage.pMYKI_TAProduct[ 0 ]->LastUsage.ProviderId = 0; // Rail provider CardImage.pMYKI_TAProduct[ 0 ]->LastUsage.Zone = 0; // Don't care CardImage.pMYKI_TAControl->ProductInUse = 1; /* ** Setup Transport locations ** Not a Border Trip */ pData->DynamicData.transportLocationsCount = 2; pData->DynamicData.transportLocations[0].inner_zone = 3; pData->DynamicData.transportLocations[0].zone = 3; pData->DynamicData.transportLocations[0].outer_zone = 4; pData->DynamicData.transportLocations[1].inner_zone = 4; pData->DynamicData.transportLocations[1].zone = 4; pData->DynamicData.transportLocations[1].outer_zone = 5; /* ** Forced Scan Off not set (testing scan-on/off modes of transport instead) */ pData->DynamicData.isForcedScanOff = FALSE; /* ** Run the Test and examine the results */ if (!runTest(pData, RULE_RESULT_EXECUTED, 102)) { return FALSE; } /* ** Examine conditions */ if (pData->DynamicData.transportLocationsCount) { CsVerbose("test_BR_LLSC_6_20 - transportLocationsCount NOT zero as expected" ); rv = FALSE; } if (pData->DynamicData.currentTripZoneLow != 4) { CsVerbose("test_BR_LLSC_6_20 - currentTripZoneLow NOT as expected. Was:%d",pData->DynamicData.currentTripZoneLow ); rv = FALSE; } if (pData->DynamicData.currentTripZoneHigh != 4) { CsVerbose("test_BR_LLSC_6_20 - currentTripZoneHigh NOT as expected. Was:%d",pData->DynamicData.currentTripZoneHigh ); rv = FALSE; } return rv; }
int main(void){ srand(NdbTick_CurrentMillisecond()); #if 0 for(int i = 0; i<100; i++) ndbout_c("randRange(0, 3) = %d", randRange(0, 3)); return 0; #endif SignalSender ss; ndbout << "Connecting..."; if(!ss.connect(30)){ ndbout << "failed" << endl << "Exiting" << endl; return 0; } ndbout << "done" << endl; ndbout_c("Connected as block=%d node=%d", refToBlock(ss.getOwnRef()), refToNode(ss.getOwnRef())); Uint32 data[25]; Uint32 sec0[70]; Uint32 sec1[123]; Uint32 sec2[10]; data[0] = ss.getOwnRef(); data[1] = 1; data[2] = 76; data[3] = 1; data[4] = 1; data[5] = 70; data[6] = 123; data[7] = 10; const Uint32 theDataLen = 18; for(Uint32 i = 0; i<70; i++) sec0[i] = i; for(Uint32 i = 0; i<123; i++) sec1[i] = 70+i; for(Uint32 i = 0; i<10; i++) sec2[i] = (i + 1)*(i + 1); SimpleSignal signal1; signal1.set(ss, 0, CMVMI, GSN_TESTSIG, theDataLen + 2); signal1.header.m_noOfSections = 1; signal1.header.m_fragmentInfo = 1; memcpy(&signal1.theData[0], data, 4 * theDataLen ); signal1.theData[theDataLen + 0] = 0; signal1.theData[theDataLen + 1] = 7; // FragmentId signal1.ptr[0].sz = 60; signal1.ptr[0].p = &sec0[0]; SimpleSignal signal2; Uint32 idx = 0; memcpy(&signal2.theData[0], data, 4 * theDataLen ); signal2.theData[theDataLen + idx] = 0; idx++; signal2.theData[theDataLen + idx] = 1; idx++; //signal2.theData[theDataLen + idx] = 2; idx++; signal2.theData[theDataLen + idx] = 7; idx++; // FragmentId signal2.set(ss, 0, CMVMI, GSN_TESTSIG, theDataLen + idx); signal2.header.m_fragmentInfo = 3; signal2.header.m_noOfSections = idx - 1; signal2.ptr[0].sz = 10; signal2.ptr[0].p = &sec0[60]; signal2.ptr[1].sz = 123; signal2.ptr[1].p = &sec1[0]; signal2.ptr[2].sz = 10; signal2.ptr[2].p = &sec2[0]; char * buf; while((buf = readline("Enter command: "))){ add_history(buf); data[1] = atoi(buf); if(strcmp(buf, "r") == 0){ SimpleSignal * ret1 = ss.waitFor(); (* ret1).print(); delete ret1; continue; } if(strcmp(buf, "a") == 0){ runTest(ss, 10, true); print_help(); continue; } if(strcmp(buf, "b") == 0){ runTest(ss, 100, false); print_help(); continue; } if(strcmp(buf, "c") == 0){ runTest(ss, 1000000, false); print_help(); continue; } if(data[1] >= 1 && data[1] <= 12){ Uint32 nodeId = ss.getAliveNode(); ndbout_c("Sending 2 fragmented to node %d", nodeId); ss.sendSignal(nodeId, &signal1); ss.sendSignal(nodeId, &signal2); if(data[1] >= 5){ continue; } ndbout_c("Waiting for signal from %d", nodeId); SimpleSignal * ret1 = ss.waitFor((Uint16)nodeId); (* ret1).print(); Uint32 count = ret1->theData[4] - 1; delete ret1; while(count > 0){ ndbout << "Waiting for " << count << " signals... "; SimpleSignal * ret1 = ss.waitFor(); ndbout_c("received from node %d", refToNode(ret1->header.theSendersBlockRef)); (* ret1).print(); delete ret1; count--; } } else if (data[1] == 13) { const Uint32 count = 3500; const Uint32 loop = 1000; signal1.set(ss, 0, CMVMI, GSN_TESTSIG, 25); signal1.header.m_fragmentInfo = 0; signal1.header.m_noOfSections = 0; signal1.theData[1] = 14; signal1.theData[3] = 0; // Print signal1.theData[8] = count; signal1.theData[9] = loop; Uint32 nodeId = ss.getAliveNode(); ndbout_c("Sending 25 len signal to node %d", nodeId); ss.sendSignal(nodeId, &signal1); Uint32 total; { SimpleSignal * ret1 = ss.waitFor((Uint16)nodeId); ndbout_c("received from node %d", refToNode(ret1->header.theSendersBlockRef)); total = ret1->theData[10] - 1; delete ret1; } do { ndbout << "Waiting for " << total << " signals... " << flush; SimpleSignal * ret1 = ss.waitFor((Uint16)nodeId); ndbout_c("received from node %d", refToNode(ret1->header.theSendersBlockRef)); delete ret1; total --; } while(total > 0); } else { print_help(); } } ndbout << "Exiting" << endl; };
TEST(WTF_Condition, OneProducerOneConsumerHundredSlots) { runTest(1, 1, 100, 1000000, TacticallyNotifyAll); }
void SMemFunctionalTests::testNegStringFloat() { runTest("testNegStringFloat", 5); }
void SMemFunctionalTests::testNegQueryNoHash() { runTest("testNegQueryNoHash", 1); }
void SMemFunctionalTests::testSimpleNonCueBasedRetrievalOfNonExistingLTI() { runTest("testSimpleNonCueBasedRetrievalOfNonExistingLTI", 1); }
void SMemFunctionalTests::testNegQuery() { runTest("testNegQuery", 248); }
void SMemFunctionalTests::testMaxDoublePrecision() { runTest("testMaxDoublePrecision", 5); }
void SMemFunctionalTests::testMaxDoublePrecision_Irrational() { runTest("testMaxDoublePrecision-Irrational", 5); }
void SMemFunctionalTests::testSimpleFloat() { runTest("testSimpleFloat", 5); }
void SMemFunctionalTests::testLess() { SoarHelper::setStopPhase(agent, SoarHelper::StopPhase::OUTPUT); runTest("testLess", 1); }
void SMemFunctionalTests::testSimpleNonCueBasedRetrieval() { SoarHelper::setStopPhase(agent, SoarHelper::StopPhase::OUTPUT); runTest("testSimpleNonCueBasedRetrieval", 2); }
int main(int argc, const char * argv[]) { printf("XPC Tests-c "); #ifdef _WIN32 printf("(Windows)\n"); #elif (__APPLE__) printf("(Mac) \n"); #elif (__linux) printf("(Linux) \n"); #else printf("(Unable to determine operating system) \n") #endif // Basic Networking runTest(testOpen, "open"); runTest(testClose, "close"); // Datarefs runTest(testGETD_Basic, "GETD"); runTest(testGETD_Types, "GETD (types)"); runTest(testGETD_TestFloat, "GETD (test float)"); runTest(testDREF, "DREF"); // Pause runTest(testSIMU_Basic, "SIMU"); runTest(testSIMU_Toggle, "SIMU (toggle)"); // CTRL runTest(testCTRL_Player, "CTRL (player)"); runTest(testCTRL_NonPlayer, "CTRL (non-player)"); runTest(testCTRL_Speedbrakes, "CTRL (speedbrakes)"); // POSI runTest(testPOSI_Player, "POSI (player)"); runTest(testPOSI_NonPlayer, "POSI (non-player)"); // Data runTest(testDATA, "DATA"); // Text runTest(testTEXT, "TEXT"); // Waypoints runTest(testWYPT, "WYPT"); // View runTest(testView, "VIEW"); // setConn runTest(testCONN, "CONN"); printf( "----------------\nTest Summary\n\tFailed: %i\n\tPassed: %i\n", testFailed, testPassed ); printf("Press any key to exit."); getchar(); return 0; }
void SMemFunctionalTests::testSimpleStore() { SoarHelper::setStopPhase(agent, SoarHelper::StopPhase::OUTPUT); runTest("testSimpleStore", 2); }
int main (int argc, char *argv[]) { pthread_mutexattr_init(&ma); printf( "=============================================================================\n"); printf( "Trylock plus unlock on an unlocked mutex.\n"); printf( "%ld iterations.\n\n", ITERATIONS); printf( "%-45s %15s %15s\n", "Test", "Total(msec)", "average(usec)"); printf( "-----------------------------------------------------------------------------\n"); /* * Time the loop overhead so we can subtract it from the actual test times. */ TESTSTART TESTSTOP durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; overHeadMilliSecs = durationMilliSecs; old_mutex_use = OLD_WIN32CS; assert(old_mutex_init(&ox, NULL) == 0); TESTSTART (void) old_mutex_trylock(&ox); (void) old_mutex_unlock(&ox); TESTSTOP assert(old_mutex_destroy(&ox) == 0); durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Old PT Mutex using a Critical Section (WNT)", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); old_mutex_use = OLD_WIN32MUTEX; assert(old_mutex_init(&ox, NULL) == 0); TESTSTART (void) old_mutex_trylock(&ox); (void) old_mutex_unlock(&ox); TESTSTOP assert(old_mutex_destroy(&ox) == 0); durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Old PT Mutex using a Win32 Mutex (W9x)", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); printf( ".............................................................................\n"); /* * Now we can start the actual tests */ #ifdef __PTW32_MUTEX_TYPES runTest("PTHREAD_MUTEX_DEFAULT", PTHREAD_MUTEX_DEFAULT); runTest("PTHREAD_MUTEX_NORMAL", PTHREAD_MUTEX_NORMAL); runTest("PTHREAD_MUTEX_ERRORCHECK", PTHREAD_MUTEX_ERRORCHECK); runTest("PTHREAD_MUTEX_RECURSIVE", PTHREAD_MUTEX_RECURSIVE); #else runTest("Non-blocking lock", 0); #endif printf( ".............................................................................\n"); pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST); #ifdef __PTW32_MUTEX_TYPES runTest("PTHREAD_MUTEX_DEFAULT (Robust)", PTHREAD_MUTEX_DEFAULT); runTest("PTHREAD_MUTEX_NORMAL (Robust)", PTHREAD_MUTEX_NORMAL); runTest("PTHREAD_MUTEX_ERRORCHECK (Robust)", PTHREAD_MUTEX_ERRORCHECK); runTest("PTHREAD_MUTEX_RECURSIVE (Robust)", PTHREAD_MUTEX_RECURSIVE); #else runTest("Non-blocking lock", 0); #endif printf( "=============================================================================\n"); /* * End of tests. */ pthread_mutexattr_destroy(&ma); return 0; }
void SMemFunctionalTests::testISupport() { runTest("smem-i-support", 6); }
TEST(WTF_Condition, TenProducersTenConsumersOneSlot) { runTest(10, 10, 1, 50000, TacticallyNotifyAll); }
void SMemFunctionalTests::testISupportWithLearning() { std::string result = agent->ExecuteCommandLine("chunk always") ; runTest("smem-i-support", 6); }
TEST(WTF_Condition, TenProducersTenConsumersHundredSlotsNotifyOne) { runTest(10, 10, 100, 50000, AlwaysNotifyOne); }
void SMemFunctionalTests::testBadMathQuery() { SoarHelper::setStopPhase(agent, SoarHelper::StopPhase::OUTPUT); runTest("testBadMathQuery", 2); }
int test_BR_LLSC_6_20_009(MYKI_BR_ContextData_t *pData) { int rv = TRUE; CardImage_t CardImage; MYKI_CD_DifferentialPricing_t differentialPricing; /* ** Test with */ if (CreateCardImage_Empty(&CardImage) < 0) { return FALSE; } CreateProduct( &CardImage, 1, PRODUCT_ID_NHOUR, 1, 1, pData->DynamicData.currentDateTime ); CardImage.pMYKI_TAControl->ProductInUse = 1; /* ** Setup Transport locations ** Not a Border Trip */ pData->DynamicData.transportLocationsCount = 2; pData->DynamicData.transportLocations[0].inner_zone = 3; pData->DynamicData.transportLocations[0].zone = 3; pData->DynamicData.transportLocations[0].outer_zone = 4; pData->DynamicData.transportLocations[1].inner_zone = 4; pData->DynamicData.transportLocations[1].zone = 4; pData->DynamicData.transportLocations[1].outer_zone = 5; /* ** Setup a Differential Price to be processed by the Rule */ differentialPricing.discount_type = MYKI_CD_DISCOUNT_TYPE_PERCENT; differentialPricing.applied_discount = 33; strcpy(differentialPricing.short_desc,"Test 008"); MYKI_CD_setDifferentialPriceStructure(&differentialPricing); /* ** Run the Test and examine the results */ if (!runTest(pData, RULE_RESULT_EXECUTED, 202)) { return FALSE; } /* ** Examine conditions */ if (pData->DynamicData.transportLocationsCount) { CsVerbose("test_BR_LLSC_6_20 - transportLocationsCount NOT zero as expected" ); rv = FALSE; } if (pData->DynamicData.currentTripZoneLow != 4) { CsVerbose("test_BR_LLSC_6_20 - currentTripZoneLow NOT as expected. Was:%d",pData->DynamicData.currentTripZoneLow ); rv = FALSE; } if (pData->DynamicData.currentTripZoneHigh != 4) { CsVerbose("test_BR_LLSC_6_20 - currentTripZoneHigh NOT as expected. Was:%d",pData->DynamicData.currentTripZoneHigh ); rv = FALSE; } if (pData->DynamicData.offPeakDiscountRate != 33) { CsVerbose("test_BR_LLSC_6_20 - offPeakDiscountRate NOT as expected" ); rv = FALSE; } if (pData->DynamicData.isOffPeak != TRUE) { CsVerbose("test_BR_LLSC_6_20 - isOffPeak NOT as expected" ); rv = FALSE; } return rv; }
void SMemFunctionalTests::testMaxMultivalued() { SoarHelper::setStopPhase(agent, SoarHelper::StopPhase::OUTPUT); runTest("testMaxMultivalued", 1); }
static void testWebKitDOMXPathNSResolverCustom(WebViewTest* test, gconstpointer) { test->loadURI(kServer->getURIForPath("/custom").data()); test->waitUntilLoadFinished(); runTest(test, "custom"); }
void SMemFunctionalTests::testMaxNegQuery() { SoarHelper::setStopPhase(agent, SoarHelper::StopPhase::OUTPUT); runTest("testMaxNegation", 1); }
int main (int argc, char** argv) { if(argc < 4) { std::cout << "3 command line arguments are needed.\nPlease execute with ./hw0 <input_filename> <process #> <number of match list>\n"; return 0; } FILE* fPtr; //file pointer to file to be parsed char *line; //line to parse file line by line fPtr = fopen(argv[1], "r"); int total_rows = 0; line = (char*)malloc(sizeof(char)*LINE_MAX); VectorsMap points; Parser fileParser; //vectors that will be generated for the runs. std::vector<std::vector<float>> generated_vectors(30); //parse the file line by line while(fgets(line, LINE_MAX, fPtr)) { //make sure that we do not read an empty line if(line[0] != '\0') { //send the line to be further parsed points.push_back(fileParser.parseLine(line)); //increment total rows count total_rows++; } } free(line); fclose(fPtr); srand(34122); int i,j, process_count=atoi(argv[2]), num_max=atoi(argv[3]), size=0; //the size of the search vectors int sizes[] = {9,11,17,29}; int sizes_count = 4; //will hold the offsets for each process std::vector<segment> segments(process_count); //initialize shared memory size_t memory_space = process_count*4*num_max; float shm_size = memory_space * sizeof(float); int shmId; // use current time as seed for random generator std::srand(std::time(0)); key_t shmKey = std::rand(); int shmFlag = IPC_CREAT | 0666; float * shm; /* Initialize shared memory */ if((shmId = shmget(shmKey, shm_size, shmFlag)) < 0) { std::cerr << "Init: Failed to initialize shared memory (" << shmId << ")" << std::endl; exit(1); } if((shm = (float *)shmat(shmId, NULL, 0)) == (float *) -1) { std::cerr << "Init: Failed to attach shared memory (" << shmId << ")" << std::endl; exit(1); } //get number of items for each process in shared memory const unsigned int per_procc_mem = num_max*4; //initialize offsets for(i=0; i< process_count; i++) { //get segments for dataset int size = total_rows/process_count; segments.at(i).start = size*i; segments.at(i).end = size*i + size; //get segments for shared memory location segment for each process segments.at(i).shm_start = i*per_procc_mem; segments.at(i).shm_end = i*per_procc_mem + per_procc_mem; //if at the last process, check to see if the division is not even if(i==process_count-1) segments.at(i).end += total_rows%process_count; } //create the final results vector //reserve enough space to be able to merge all of our processes' stuff std::vector<ResultType> final_results; std::vector<float> copy; final_results.reserve(process_count*num_max); //create start and end chrono time points std::chrono::time_point<std::chrono::system_clock> start, end; std::map<int, double> times; //loop through the 4 different sizes of vectors for(i=0; i<sizes_count; i++) { std::cout << "\n\n==============TEST BEGIN==================\n" << std::endl; //run the test: copy = generateScottVector(sizes[i]); final_results = circularSubvectorMatch(sizes[i], ©, &points, num_max, 0, total_rows, 0, 0, NULL, true); copy.clear(); //run the test if(runTest(sizes[i], &final_results, num_max)) { std::cout << "Test was SUCCESSFUL against vector: \n" << std::endl; std::cout << scottgs::vectorToCSV(generateScottVector(sizes[i])) << "\n\n" << std::endl; } else { std::cout << "Test FAILED against vector: \n" << std::endl; std::cout << scottgs::vectorToCSV(generateScottVector(sizes[i])) << "\n\n" << std::endl; //exit(-1); } std::cout << "Expected vector results" << std::endl; printVector(num_max, final_results, sizes[i]); std::cout << "\n\nGenerated vector results" << std::endl; printVector(num_max, generateVectorTest(sizes[i]), sizes[i]); final_results.clear(); std::cout << "\n\n==============TEST END==================\n\n\n" << std::endl; //generate 30 random vectors of size size[i] for(int ii=0; ii< 30; ii++) { generated_vectors.at(ii) = generateRandomVector(sizes[i]); } //for testing purposes I am only doing 1. //generated_vectors.at(0).reserve(sizes[i]); //generated_vectors.at(0) = generateScottVector(sizes[i]); //loop through the (30 vectors specified in the description) for(j=0; j<30; j++) { //let the first process print the results. std::cout << "\n-----------------" << std::endl; std::cout << "Search: "<< sizes[i] << "-D" << std::endl; std::cout << "-----------------" << std::endl; //get an object of the process spawner class.. start = std::chrono::system_clock::now(); scottgs::Splitter splitter; for (int p = 0; p < process_count; ++p) { pid_t pid = splitter.spawn(); if (pid < 0) { std::cerr << "Could not fork!!! ("<< pid <<")" << std::endl; // do not exit, we may have a process // spawned from an earlier iteration break; } if (0 == pid) // Child { /* Attach shared memory */ if((shm = (float *)shmat(shmId, NULL, 0)) == (float *) -1) { std::cerr << "Init: Failed to attach shared memory (" << shmId << ")" << std::endl; exit(1); } //let only process 0 to print this vector. if(p == 0) { std::cout << "\nSearch Vector: " << std::endl; //print the created vector. std::cout << scottgs::vectorToCSV(generated_vectors[j]) << std::endl; } //perform the test(delete this as it is not needed) //pas the size of the search vector, the auto generated vector, the vectors from the file, //the number of top results to return, and the offset from which to search. circularSubvectorMatch(sizes[i], &generated_vectors[j], &points, num_max, segments.at(p).start, segments.at(p).end, segments.at(p).shm_start, segments.at(p).shm_end, shm, false); //child exists _exit(0); }//end if pid==0 } //wait for all children before looping again.. splitter.reap_all(); //calculate end time. end = std::chrono::system_clock::now(); //now perform printing and stuff. from shared memory. //print end time std::chrono::duration<double, std::milli> elapsed_seconds = end-start; //std::cout << "\nTime: " << elapsed_seconds.count() << " milliseconds\n" << std::endl; //keep a record of the time times[sizes[i]] += elapsed_seconds.count(); //print top num_max results printResults(shm, num_max, process_count, sizes[i]); }//end 30 vectors loop }//end vector_size loop std::cout << "\n-----------------" << std::endl; std::cout << "Final Results:" << std::endl; std::cout << "-----------------\n" << std::endl; std::cout << "Size" << "|" << "Average Time" << std::endl; std::cout << "-----------------" << std::endl; std::cout << times[sizes[0]]/1 << " " << times[sizes[1]]/1 << " " << times[sizes[2]]/1 << " " << times[sizes[3]]/1 << std::endl; //detach the memory shmdt(shm); //delete shared memory after we are done with it. shmctl(shmId, IPC_RMID, NULL); return 0; }
int main (int argc, char *argv[]) { assert(pthread_mutexattr_init(&ma) == 0); printf( "=============================================================================\n"); printf( "\nLock plus unlock on a locked mutex.\n"); printf("%ld iterations, four locks/unlocks per iteration.\n\n", ITERATIONS); printf( "%-45s %15s %15s\n", "Test", "Total(msec)", "average(usec)"); printf( "-----------------------------------------------------------------------------\n"); /* * Time the loop overhead so we can subtract it from the actual test times. */ running = 1; assert(pthread_create(&worker, NULL, overheadThread, NULL) == 0); TESTSTART sched_yield(); sched_yield(); TESTSTOP running = 0; assert(pthread_join(worker, NULL) == 0); durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; overHeadMilliSecs = durationMilliSecs; InitializeCriticalSection(&cs1); InitializeCriticalSection(&cs2); EnterCriticalSection(&cs1); EnterCriticalSection(&cs2); running = 1; assert(pthread_create(&worker, NULL, CSThread, NULL) == 0); TESTSTART LeaveCriticalSection(&cs1); sched_yield(); LeaveCriticalSection(&cs2); EnterCriticalSection(&cs1); EnterCriticalSection(&cs2); TESTSTOP running = 0; LeaveCriticalSection(&cs2); LeaveCriticalSection(&cs1); assert(pthread_join(worker, NULL) == 0); DeleteCriticalSection(&cs2); DeleteCriticalSection(&cs1); durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Simple Critical Section", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS / 4 ); old_mutex_use = OLD_WIN32CS; assert(old_mutex_init(&ox1, NULL) == 0); assert(old_mutex_init(&ox2, NULL) == 0); assert(old_mutex_lock(&ox1) == 0); assert(old_mutex_lock(&ox2) == 0); running = 1; assert(pthread_create(&worker, NULL, oldThread, NULL) == 0); TESTSTART (void) old_mutex_unlock(&ox1); sched_yield(); (void) old_mutex_unlock(&ox2); (void) old_mutex_lock(&ox1); (void) old_mutex_lock(&ox2); TESTSTOP running = 0; assert(old_mutex_unlock(&ox1) == 0); assert(old_mutex_unlock(&ox2) == 0); assert(pthread_join(worker, NULL) == 0); assert(old_mutex_destroy(&ox2) == 0); assert(old_mutex_destroy(&ox1) == 0); durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Old PT Mutex using a Critical Section (WNT)", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS / 4); old_mutex_use = OLD_WIN32MUTEX; assert(old_mutex_init(&ox1, NULL) == 0); assert(old_mutex_init(&ox2, NULL) == 0); assert(old_mutex_lock(&ox1) == 0); assert(old_mutex_lock(&ox2) == 0); running = 1; assert(pthread_create(&worker, NULL, oldThread, NULL) == 0); TESTSTART (void) old_mutex_unlock(&ox1); sched_yield(); (void) old_mutex_unlock(&ox2); (void) old_mutex_lock(&ox1); (void) old_mutex_lock(&ox2); TESTSTOP running = 0; assert(old_mutex_unlock(&ox1) == 0); assert(old_mutex_unlock(&ox2) == 0); assert(pthread_join(worker, NULL) == 0); assert(old_mutex_destroy(&ox2) == 0); assert(old_mutex_destroy(&ox1) == 0); durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Old PT Mutex using a Win32 Mutex (W9x)", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS / 4); printf( ".............................................................................\n"); /* * Now we can start the actual tests */ #ifdef PTW32_MUTEX_TYPES runTest("PTHREAD_MUTEX_DEFAULT (W9x,WNT)", PTHREAD_MUTEX_DEFAULT); runTest("PTHREAD_MUTEX_NORMAL (W9x,WNT)", PTHREAD_MUTEX_NORMAL); runTest("PTHREAD_MUTEX_ERRORCHECK (W9x,WNT)", PTHREAD_MUTEX_ERRORCHECK); runTest("PTHREAD_MUTEX_RECURSIVE (W9x,WNT)", PTHREAD_MUTEX_RECURSIVE); #else runTest("Blocking locks", 0); #endif printf( "=============================================================================\n"); /* * End of tests. */ pthread_mutexattr_destroy(&ma); return 0; }