void Map_find_string::setUpParams( const CppUnitMini::TestCfg& cfg )
{
c_nThreadCount = cfg.getSizeT("ThreadCount", c_nThreadCount );
c_nMapSize = cfg.getSizeT("MapSize", c_nMapSize);
c_nPercentExists = cfg.getSizeT("PercentExists", c_nPercentExists);
c_nPassCount = cfg.getSizeT("PassCount", c_nPassCount);
c_nMaxLoadFactor = cfg.getSizeT("MaxLoadFactor", c_nMaxLoadFactor);
c_bPrintGCState = cfg.getBool("PrintGCStateFlag", c_bPrintGCState );
c_nCuckooInitialSize = cfg.getSizeT("CuckooInitialSize", c_nCuckooInitialSize);
c_nCuckooProbesetSize = cfg.getSizeT("CuckooProbesetSize", c_nCuckooProbesetSize);
c_nCuckooProbesetThreshold = cfg.getSizeT("CuckooProbesetThreshold", c_nCuckooProbesetThreshold);
c_nFeldmanMap_HeadBits = cfg.getSizeT("FeldmanMapHeadBits", c_nFeldmanMap_HeadBits);
c_nFeldmanMap_ArrayBits = cfg.getSizeT("FeldmanMapArrayBits", c_nFeldmanMap_ArrayBits);
if ( c_nThreadCount == 0 )
c_nThreadCount = std::thread::hardware_concurrency();
CPPUNIT_MSG( "Generating test data...\n");
cds::OS::Timer timer;
generateSequence();
CPPUNIT_MSG( " Duration=" << timer.duration() << "\n" );
}
void Map_find_string::initTestSequence()
{
if ( !m_bSeqInit ) {
m_bSeqInit = true;
CPPUNIT_MSG( "Generating test data...");
cds::OS::Timer timer;
generateSequence();
CPPUNIT_MSG( " Duration=" << timer.duration() );
CPPUNIT_MSG( "Map size=" << m_nRealMapSize << " find key loop=" << m_Arr.size() << " (" << c_nPercentExists << "% success)" );
CPPUNIT_MSG( "Thread count=" << c_nThreadCount << " Pass count=" << c_nPassCount );
}
}
void Map_find_int::SetUpTestCase()
{
cds_test::config const& cfg = get_config( "map_find_int" );
s_nMapSize = cfg.get_size_t( "MapSize", s_nMapSize );
if ( s_nMapSize < 1000 )
s_nMapSize = 1000;
s_nThreadCount = cfg.get_size_t( "ThreadCount", s_nThreadCount );
if ( s_nThreadCount == 0 )
s_nThreadCount = 1;
s_nMaxLoadFactor = cfg.get_size_t( "MaxLoadFactor", s_nMaxLoadFactor );
if ( s_nMaxLoadFactor == 0 )
s_nMaxLoadFactor = 1;
s_nCuckooInitialSize = cfg.get_size_t( "CuckooInitialSize", s_nCuckooInitialSize );
if ( s_nCuckooInitialSize < 256 )
s_nCuckooInitialSize = 256;
s_nCuckooProbesetSize = cfg.get_size_t( "CuckooProbesetSize", s_nCuckooProbesetSize );
if ( s_nCuckooProbesetSize < 8 )
s_nCuckooProbesetSize = 8;
s_nCuckooProbesetThreshold = cfg.get_size_t( "CuckooProbesetThreshold", s_nCuckooProbesetThreshold );
s_nFeldmanMap_HeadBits = cfg.get_size_t( "FeldmanMapHeadBits", s_nFeldmanMap_HeadBits );
if ( s_nFeldmanMap_HeadBits == 0 )
s_nFeldmanMap_HeadBits = 2;
s_nFeldmanMap_ArrayBits = cfg.get_size_t( "FeldmanMapArrayBits", s_nFeldmanMap_ArrayBits );
if ( s_nFeldmanMap_ArrayBits == 0 )
s_nFeldmanMap_ArrayBits = 2;
generateSequence();
}
static uint8_t mainStateFunc(StateM* sm)
{
uint8_t retValue = 0;
switch(sm->getCurrent())
{
case GAME_STATE_POR:
{
currentLevel = 1;
generateSequence();
sm->setNext(GAME_STATE_PRE_GAME);
break;
}
case GAME_STATE_PRE_GAME:
{
static uint8_t leds = LOW;
if(sm->isStateEntered())
{
}
else
{
if(getInput() != NO_KEY)
{
sm->setNext(GAME_STATE_PLAY_SEQUENCE_INIT);
leds = LOW;
}
else if(sm->getDuration() > 500)
{
sm->resetEnterTime();
leds = leds ? LOW : HIGH;
}
digitalWrite(RED_LED_PIN, leds);
digitalWrite(GREEN_LED_PIN, leds);
digitalWrite(BLUE_LED_PIN, leds);
digitalWrite(YELLOW_LED_PIN, leds);
}
break;
}
case GAME_STATE_PLAY_SEQUENCE_INIT:
{
if(sm->getDuration() > 2000)
{
Serial.print("Level: ");
Serial.println(currentLevel);
currentStep = 0;
sm->setNext(GAME_STATE_PLAY_SEQUENCE_INDICATE_STEP);
}
break;
}
case GAME_STATE_PLAY_SEQUENCE_INDICATE_STEP:
{
doIndicateStep(currentStep);
sm->setNext(GAME_STATE_PLAY_SEQUENCE_INDICATE_DELAY);
break;
}
case GAME_STATE_PLAY_SEQUENCE_INDICATE_DELAY:
{
if( sm->getDuration() > STEP_DURATION )
{
stepEnd();
currentStep++;
if(currentStep >= currentLevel)
{
//All done, now handle player repeating this level
sm->setNext(GAME_STATE_CHECK_SEQUENCE_PAUSE);
}
else
{
//Play next step in this sequence
sm->setNext(GAME_STATE_PLAY_SEQUENCE_INDICATE_STEP);
}
}
break;
}
case GAME_STATE_CHECK_SEQUENCE_PAUSE:
{
if( sm->getDuration() > 1000 )
{
currentStep = 0;
sm->setNext(GAME_STATE_CHECK_SEQUENCE);
}
break;
}
case GAME_STATE_CHECK_SEQUENCE:
{
if( sm->getDuration() > REPEAT_STEP_TO )
{
Serial.println("Too slow!!!");
sm->setNext(GAME_STATE_GAME_OVER);
}
else
{
uint8_t playerKey = getInput();
if(playerKey != NO_KEY)
{
Serial.print("Key: ");
Serial.println(playerKey);
if(sequence[currentStep] == playerKey)
{
doIndicateStep(currentStep);
sm->setNext(GAME_STATE_CHECK_SEQUENCE_INDICATE);
}
else
{
Serial.println("Wrong Key!!!");
Serial.print("Excpected: ");
Serial.println(sequence[currentStep]);
sm->setNext(GAME_STATE_GAME_OVER);
}
}
}
break;
}
case GAME_STATE_CHECK_SEQUENCE_INDICATE:
{
if( sm->getDuration() > STEP_DURATION )
{
stepEnd();
currentStep++;
if(currentStep >= currentLevel)
{
//All done, now handle player repeating this level
currentLevel++;
if(currentLevel > MAX_LEVEL )
{
Serial.println("You won!!");
sm->setNext(GAME_STATE_GAME_OVER);
}
else
{
Serial.println("Level complete!!");
sm->setNext(GAME_STATE_PLAY_SEQUENCE_INIT);
}
}
else
{
//Play next step in this sequence
sm->setNext(GAME_STATE_CHECK_SEQUENCE);
}
}
break;
}
case GAME_STATE_GAME_OVER:
{
if(sm->isStateEntered())
{
indicateFail();
}
else if(sm->getDuration() > 4000)
{
stepEnd();
sm->setNext(GAME_STATE_POR);
}
break;
}
case StateM::STATE_INVALID:
default:
{
sm->setNext(GAME_STATE_POR);
break;
}
}
return retValue;
}
int main(int argc, char *argv[]){
int numberTrials;
char fileName[100];
char input[1];
int c,d,i;
int sfd;
pthread_t optimalThread;
pthread_t fifoThread;
pthread_t lruThread;
pthread_t mruThread;
pthread_t lfuThread;
pthread_t mfuThread;
pthread_t randThread;
pthread_attr_t attr;
if (argc == 2){
sequenceLength = 0;
strcpy(fileName, argv[1]);
numberTrials = 1;
FILE* file = fopen(fileName, "r");
c = 0;
fscanf (file, "%d", &c);
while (!feof(file)){
sequenceLength++;
fscanf(file, "%d", &c);
}
fclose(file);
}
else if(argc == 3){
sequenceLength = atoi(argv[1]);
numberTrials = atoi(argv[2]);
printf("Testing Belady's Anomaly using %d random sequences and Trying %d time\n", sequenceLength, numberTrials);
}
else{
printf("Usage : \n");
printf("PERPA <sequence-file> | <sequence-length> <trials-number> \n");
exit(1);
}
int pageSequence[sequenceLength];
if(argc == 2){
FILE* file = fopen(fileName, "r");
c = 0;
d = 0;
fscanf(file, "%d", &c);
while(!feof(file)){
pageSequence[d] = c;
fscanf (file, "%d", &c);
d++;
}
fclose(file);
}
printf("\n");
srand(time(NULL) + getpid() *42);
pthread_attr_init(&attr);
initializeBeladySummary();
totalBeladyCount = 0;
for(i = 0; i < numberTrials; i++){
trialCounter = i;
//initializeReportData();
//initializeBeladyReport();
if(argc == 3){
printf("Trial #%d\n", i+1);
generateSequence(pageSequence);
}
else{
printf("Using Sequence stored in File: %s\n", fileName);
}
pthread_create(&optimalThread, &attr, optimalPage, (void *) pageSequence);
pthread_create(&fifoThread, &attr, FIFO, (void *) pageSequence);
pthread_create(&lruThread, &attr, leastRecent, (void *) pageSequence);
pthread_create(&mruThread, &attr, mostRecent, (void *) pageSequence);
pthread_create(&lfuThread, &attr, leastFrequent, (void *) pageSequence);
pthread_create(&mfuThread, &attr, mostFrequent, (void *) pageSequence);
pthread_create(&randThread, &attr, randomSelect, (void *) pageSequence);
sleep(2);
printReport((i+1), pageSequence);
beladyReport();
}
beladySummary();
exit(0);
}
