int main(void)
{
// create memory system with 256 words and a cache
// with 8 sets, N lines per set and a block size of 4 words.
void *a = initializeMemorySystem(SIZE, 1, 4, 8, N, 1);
if (a == NULL)
{
fprintf(stderr, "initializeMemorySystem failed!\n");
exit(-1);
}
int i, sum, sum2;
// initialize the array
for (i = 0; i < SIZE; i++)
{
writeInt(a, 0, i, i);
}
// now sum it
sum = 0;
sum2 = 0;
for (i = 0; i < SIZE; i++)
{
int tmp = readInt(a, 0, i);
// printf("# %d %d\n", tmp, i);
sum += tmp;
sum2 += i;
}
printf("sum is %d (should be %d)\n", sum, sum2);
// print stats
printf("\n");
printStatistics(a);
printf("\n");
return 0;
}
int main(void)
{
// create memory system with 256 words and a direct-mapped cache
// with 8 sets and a block size of 4 words.
void *a = initializeMemorySystem(SIZE, 1, 4, 8, 1, 1);
if (a == NULL)
{
fprintf(stderr, "initializeMemorySystem failed!\n");
exit(-1);
}
int i;
// initialize the array
for (i = 0; i < SIZE; i++)
{
writeFloat(a, 0, i, (float) i);
}
// now sum it
float sum = 0.0;
float sum2 = 0.0;
for (i = 0; i < SIZE; i++)
{
float tmp = readFloat(a, 0, i);
sum += tmp;
sum2 += ((float) i);
}
printf("sum is %f (should be %f)\n", sum, sum2);
// print stats
printf("\n");
printStatistics(a);
printf("\n");
return 0;
}
void
MersenneTwister::printStats()
{
if(sampleArgs->timing)
{
std::string strArray[4] =
{
"Generated Numbers",
"Time(sec)",
"[Transfer+Kernel]Time(sec)",
"Numbers/sec"
};
std::string stats[4];
sampleTimer->totalTime = setupTime + kernelTime;
stats[0] = toString(height * width * mulFactor * 4, std::dec);
stats[1] = toString(sampleTimer->totalTime, std::dec);
stats[2] = toString(kernelTime, std::dec);
stats[3] = toString(height * width * mulFactor * 4 / kernelTime, std::dec);
printStatistics(strArray, stats, 4);
}
}
void
ComputeBench::printStats()
{
std::string strArray[3];
std::string stats[3];
sampleArgs->timing = true;
int sizeInBytesPerIter = (int) (NUM_READS * vectorSize * sizeof (
cl_float) * globalThreads);
std::cout << std::endl << std::setw(18) << std::left
<< "Vector width used " << ": " << ((vec3) ? 3 : vectorSize) << std::endl;
std::cout << std::setw(18) << std::left
<< "Setup Time " << ": " << setupTime << " secs" << std::endl << std::endl;
std::cout << "\n1. Add" << std::endl;
strArray[0] = "Times";
stats[0] = toString(sizeInBytesPerIter, std::dec);
strArray[1] = "Avg. Kernel Time (sec)";
stats[1] = toString(KaddTime, std::dec);
strArray[2] = "Avg Throughput ( GRPS )";
stats[2] = toString(KaddGbps, std::dec);
printStatistics(strArray, stats, 3);
}
void
URNG::printStats()
{
std::string strArray[4] =
{
"Width",
"Height",
"Time(sec)",
"[Transfer+kernel]Time(sec)"
};
std::string stats[4];
sampleTimer->totalTime = setupTime + kernelTime;
stats[0] = toString(width, std::dec);
stats[1] = toString(height, std::dec);
stats[2] = toString(sampleTimer->totalTime, std::dec);
stats[3] = toString(kernelTime, std::dec);
if(sampleArgs->timing)
{
printStatistics(strArray, stats, 4);
}
}
void * compute_loop(void * data,int print_stats) {
NbodyModel *theModel = (NbodyModel *)data;
int first_time=1;
int done=0;
while (!done) {
if(first_time) {
#ifdef HAS_MPI
copy2X(theModel);
MPI_Bcast(theModel->X,theModel->n*6,MPI_DOUBLE,0,MPI_COMM_WORLD);
copy2xyz(theModel);
#endif
first_time=0;
if(rank==0&&print_stats) {
printStatistics(theModel);
energy = theModel->PE+theModel->KE;
}
} else {
//if((rank==0&&drand(0.0,1.0)<0.5)||rank!=0) stepNbodyModel(theModel);
stepNbodyModel(theModel);
sleep(delay/1000000);
usleep(delay%1000000);
if(rank==0) {
if((count_updates++)%skip_updates==0&&show_updates) {
updateNbodyModel(theModel,update_method);
}
}
if(theModel->t>=theModel->tFinal) {
done=1;
}
}
}
#ifdef _USE_PTHREADS
pthread_exit(NULL);
#endif
return NULL;
}
void
CompilerOutputter::printFailureReport()
{
printFailuresList();
printStatistics();
}
int main()
{
uint32 i;
SM_guardTest_Handle sMachine;
GuardTest_IfaceHandle* interfaceHandle=0;
uint32 statesCount[st_GuardTest_MAX];
SimElement* simListe = NULL;
ResElement* resListe = NULL;
/* create some triggers */
/* Loop 1: trigger1 is set and value is correct */
addSimElementVar(&simListe, 100, gValue, 3);
addSimElementVar(&simListe, 100, out, 0);
addSimElementTrig(&simListe, 100, trigger1);
/* back */
addSimElementTrig(&simListe, 200, trigger4);
addResElementVar(&resListe, 100, startState, 0);
addResElementVar(&resListe, 100, state1, 1);
addResElementVar(&resListe, 100, state2, 0);
addResElementVar(&resListe, 100, state3, 0);
addResElementVar(&resListe, 100, state4, 0);
addResElementVar(&resListe, 100, state5, 0);
addResElementVar(&resListe, 100, state6, 0);
addResElementVar(&resListe, 100, out, 0);
/* Loop 2: trigger1 is set value is 1 */
addSimElementVar(&simListe, 300, gValue, 5);
addSimElementVar(&simListe, 300, out, 0);
addSimElementTrig(&simListe, 300, trigger1);
/* back */
addSimElementTrig(&simListe, 400, trigger4);
addResElementVar(&resListe, 300, startState, 0);
addResElementVar(&resListe, 300, state1, 0);
addResElementVar(&resListe, 300, state2, 1);
addResElementVar(&resListe, 300, state3, 0);
addResElementVar(&resListe, 300, state4, 0);
addResElementVar(&resListe, 300, state5, 0);
addResElementVar(&resListe, 300, state6, 0);
addResElementVar(&resListe, 300, out, 0);
/* Loop 3: trigger1 is set, value is 1 */
addSimElementVar(&simListe, 500, gValue, 1);
addSimElementVar(&simListe, 500, out, 0);
addSimElementTrig(&simListe, 500, trigger2);
/* back */
addSimElementTrig(&simListe, 600, trigger4);
addResElementVar(&resListe, 500, startState, 0);
addResElementVar(&resListe, 500, state1, 0);
addResElementVar(&resListe, 500, state2, 0);
addResElementVar(&resListe, 500, state3, 1);
addResElementVar(&resListe, 500, state4, 0);
addResElementVar(&resListe, 500, state5, 0);
addResElementVar(&resListe, 500, state6, 0);
addResElementVar(&resListe, 500, out, 4);
/* Loop 4: trigger1 is set and value is correct */
addSimElementVar(&simListe, 700, gValue, 3);
addSimElementVar(&simListe, 700, out, 0);
addSimElementTrig(&simListe, 700, trigger2);
/* back */
addSimElementTrig(&simListe, 800, trigger4);
addResElementVar(&resListe, 700, startState, 0);
addResElementVar(&resListe, 700, state1, 1);
addResElementVar(&resListe, 700, state2, 0);
addResElementVar(&resListe, 700, state3, 0);
addResElementVar(&resListe, 700, state4, 0);
addResElementVar(&resListe, 700, state5, 0);
addResElementVar(&resListe, 700, state6, 0);
addResElementVar(&resListe, 700, out, 1);
/* Loop 5: trigger1 is set value is 1 */
addSimElementVar(&simListe, 900, gValue, 5);
addSimElementVar(&simListe, 900, out, 0);
addSimElementTrig(&simListe, 900, trigger2);
/* back */
addSimElementTrig(&simListe, 1000, trigger4);
addResElementVar(&resListe, 900, startState, 0);
addResElementVar(&resListe, 900, state1, 0);
addResElementVar(&resListe, 900, state2, 1);
addResElementVar(&resListe, 900, state3, 0);
addResElementVar(&resListe, 900, state4, 0);
addResElementVar(&resListe, 900, state5, 0);
addResElementVar(&resListe, 900, state6, 0);
addResElementVar(&resListe, 900, out, 2);
/* Loop 6: trigger1 is set, value is 1 */
addSimElementVar(&simListe, 1100, gValue, 2);
addSimElementVar(&simListe, 1100, out, 0);
addSimElementTrig(&simListe, 1100, trigger3);
/* back */
addSimElementTrig(&simListe, 1200, trigger4);
addResElementVar(&resListe, 1100, startState, 0);
addResElementVar(&resListe, 1100, state1, 0);
addResElementVar(&resListe, 1100, state2, 0);
addResElementVar(&resListe, 1100, state3, 1);
addResElementVar(&resListe, 1100, state4, 0);
addResElementVar(&resListe, 1100, state5, 0);
addResElementVar(&resListe, 1100, state6, 0);
addResElementVar(&resListe, 1100, out, 3);
/* Loop 7: Test for wrong triggers */
addSimElementVar(&simListe, 1300, gValue, 0);
addSimElementVar(&simListe, 1300, out, 0);
addSimElementTrig(&simListe, 1300, trigger4);
addResElementVar(&resListe, 1300, startState, 1);
addResElementVar(&resListe, 1300, state1, 0);
addResElementVar(&resListe, 1300, state2, 0);
addResElementVar(&resListe, 1300, state3, 0);
addResElementVar(&resListe, 1300, state4, 0);
addResElementVar(&resListe, 1300, state5, 0);
addResElementVar(&resListe, 1300, state6, 0);
addResElementVar(&resListe, 1300, out, 0);
/* Loop 8: Test for wrong triggers */
addSimElementVar(&simListe, 1400, gValue, 0);
addSimElementVar(&simListe, 1400, out, 0);
addSimElementTrig(&simListe, 1400, trigger5);
addResElementVar(&resListe, 1400, startState, 1);
addResElementVar(&resListe, 1400, state1, 0);
addResElementVar(&resListe, 1400, state2, 0);
addResElementVar(&resListe, 1400, state3, 0);
addResElementVar(&resListe, 1400, state4, 0);
addResElementVar(&resListe, 1400, state5, 0);
addResElementVar(&resListe, 1400, state6, 0);
addResElementVar(&resListe, 1400, out, 0);
/* Loop 9: Test for reachability of state4 */
addSimElementVar(&simListe, 1600, value1, 11);
addSimElementVar(&simListe, 1600, value2, 3);
/* addSimElementTrig(&simListe, 1600, trigger1); */
addSimElementTrig(&simListe, 1800, trigger4);
addResElementVar(&resListe, 1700, startState, 0);
addResElementVar(&resListe, 1700, state1, 0);
addResElementVar(&resListe, 1700, state2, 0);
addResElementVar(&resListe, 1700, state3, 0);
addResElementVar(&resListe, 1700, state4, 1);
addResElementVar(&resListe, 1700, state5, 0);
addResElementVar(&resListe, 1700, state6, 0);
/* does the state machine returns back after trigger */
addResElementVar(&resListe, 1900, startState, 1);
addResElementVar(&resListe, 1900, state1, 0);
addResElementVar(&resListe, 1900, state2, 0);
addResElementVar(&resListe, 1900, state3, 0);
addResElementVar(&resListe, 1900, state4, 0);
addResElementVar(&resListe, 1900, state5, 0);
addResElementVar(&resListe, 1900, state6, 0);
/* Loop 10: Test for unreachability of state4 */
addSimElementVar(&simListe, 2000, value1, 10);
addSimElementVar(&simListe, 2000, value2, 3);
addResElementVar(&resListe, 2000, startState, 1);
addResElementVar(&resListe, 2000, state1, 0);
addResElementVar(&resListe, 2000, state2, 0);
addResElementVar(&resListe, 2000, state3, 0);
addResElementVar(&resListe, 2000, state4, 0);
addResElementVar(&resListe, 2000, state5, 0);
addResElementVar(&resListe, 2000, state6, 0);
/* Loop 11: Test for unreachability of state4 */
addSimElementVar(&simListe, 2100, value1, 11);
addSimElementVar(&simListe, 2100, value2, 2);
addResElementVar(&resListe, 2100, startState, 1);
addResElementVar(&resListe, 2100, state1, 0);
addResElementVar(&resListe, 2100, state2, 0);
addResElementVar(&resListe, 2100, state3, 0);
addResElementVar(&resListe, 2100, state4, 0);
addResElementVar(&resListe, 2100, state5, 0);
addResElementVar(&resListe, 2100, state6, 0);
/* Loop 12: Test Choice first path ( value1 > 100 ) */
addSimElementVar(&simListe, 2200, value1, 110);
addSimElementVar(&simListe, 2200, value2, 10);
addResElementVar(&resListe, 2200, startState, 0);
addResElementVar(&resListe, 2200, state1, 0);
addResElementVar(&resListe, 2200, state2, 0);
addResElementVar(&resListe, 2200, state3, 0);
addResElementVar(&resListe, 2200, state4, 0);
addResElementVar(&resListe, 2200, state5, 1);
addResElementVar(&resListe, 2200, state6, 0);
/* Loop 13: Test for Junction back to state 1 */
addSimElementTrig(&simListe, 2300, trigger4);
addSimElementVar(&simListe, 2300, value2, 0); /* should not met the value again */
addResElementVar(&resListe, 2300, startState, 1);
addResElementVar(&resListe, 2300, state1, 0);
addResElementVar(&resListe, 2300, state2, 0);
addResElementVar(&resListe, 2300, state3, 0);
addResElementVar(&resListe, 2300, state4, 0);
addResElementVar(&resListe, 2300, state5, 0);
addResElementVar(&resListe, 2300, state6, 0);
/* Loop 12: Test Choice first path ( value1 < 100 ) */
addSimElementVar(&simListe, 2400, value1, 80);
addSimElementVar(&simListe, 2400, value2, 10);
addResElementVar(&resListe, 2400, startState, 0);
addResElementVar(&resListe, 2400, state1, 0);
addResElementVar(&resListe, 2400, state2, 0);
addResElementVar(&resListe, 2400, state3, 0);
addResElementVar(&resListe, 2400, state4, 0);
addResElementVar(&resListe, 2400, state5, 0);
addResElementVar(&resListe, 2400, state6, 1);
/* Loop 13: Test for Junction back to state 1 */
addSimElementTrig(&simListe, 2500, trigger4);
addSimElementVar(&simListe, 2500, value2, 0); /* should not met the value again */
addResElementVar(&resListe, 2500, startState, 1);
addResElementVar(&resListe, 2500, state1, 0);
addResElementVar(&resListe, 2500, state2, 0);
addResElementVar(&resListe, 2500, state3, 0);
addResElementVar(&resListe, 2500, state4, 0);
addResElementVar(&resListe, 2500, state5, 0);
addResElementVar(&resListe, 2500, state6, 0);
/* carries the information, which state has been reached, and how often */
for(i=0; i<st_GuardTest_MAX; ++i)
statesCount[i] = 0;
guardTest_init(&sMachine, &interfaceHandle);
guardTest_Iface_cleanTriggers(interfaceHandle);
guardTest_Iface_cleanVariables(interfaceHandle);
for(i=0; i<MAX_SIM_CYCLES; ++i) {
BOOL stateMachineFinished = FALSE;
installChange(simListe, interfaceHandle, sys_time());
GuardTest_timerIface_trigger(sys_time());
while (stateMachineFinished == FALSE) {
stateMachineFinished = guardTest_runCycle(&sMachine);
guardTest_Iface_cleanInputTriggers(interfaceHandle);
}
compareResults(resListe, interfaceHandle, sys_time());
guardTest_Iface_cleanTriggers(interfaceHandle);
statesCount[sMachine.state]++;
#ifdef DEBUG
printf("\r %d ", i);
#endif
/* printf(" %d ", *stateIDVar); */
stepTime(10); /* add 10ms for the next cycle */
}
printf("\n\nFinished\n\n");
for(i=0; i<st_GuardTest_MAX; ++i) {
printf(" State No. %d -> %d\n",i, statesCount[i]);
}
printStatistics(resListe);
return(0);
}
PerformanceCounter::~PerformanceCounter()
{
printStatistics();
}
int main(int argc, char *argv[])
{
if ((argc < 4) || (argc > 6))
{
usage(argv[0]);
exit(EXIT_FAILURE);
}
int arrayTraceOption = getIntArg(argv[1]);
int wrapSize = getIntArg(argv[2]);
int numWraps = getIntArg(argv[3]);
if ((arrayTraceOption < 0) || (wrapSize < 0) || (numWraps < 0))
{
usage(argv[0]);
exit(EXIT_FAILURE);
}
int wrapType;
int wrapOptions;
if (argc >= 5)
{
wrapType = getIntArg(argv[4]);
if (wrapType < 0)
{
usage(argv[0]);
exit(EXIT_FAILURE);
}
setWrapImpl((WrapImplType)wrapType);
if (argc >= 6)
{
wrapOptions = getIntArg(argv[5]);
if (wrapOptions < 0)
{
usage(argv[0]);
exit(EXIT_FAILURE);
}
setWrapImplOptions(wrapOptions);
}
}
// Display memory attributes.
printMemoryAttributes();
if (arrayTraceOption == 0)
arraySize = numWraps * wrapSize * IntsPerLine;
else if (arrayTraceOption == 1)
arraySize = numWraps * wrapSize;
else if (arrayTraceOption == 2)
arraySize = wrapSize*numWraps;
//arraySize = dmax(BlockSize, wrapSize * numWraps);
else if (arrayTraceOption == 3)
arraySize = BlockSize /sizeof(int) * numWraps;
else if (arrayTraceOption == 4)
arraySize = (BlockSize / sizeof(int))*numWraps;
else
assert(0);
StartPhysicalTracer();
startStatistics();
arraySize = 20000;
int *data = (int *)pmalloc(arraySize * sizeof(int));
printf("Array size=%d integers with start address: %p\n", arraySize, data);
//init(data, arraysize, hotCache);
if (arrayTraceOption == 4)
blockCow(data, numWraps, wrapSize, arraySize);
else
trace(data, numWraps, wrapSize, IntsPerLine, arrayTraceOption);
EndPhysicalTracer();
printf("%s \t%s \t%s \t%s \t", argv[0], argv[1], argv[2], argv[3]);
printStatistics(stdout);
wrapCleanup();
pfree(data);
// Shadow Paging cleanup.
if (shadowPaging != NULL)
pfree(shadowPaging);
return 0;
}
//1- porta
//2- modo (SEND | RECEIVE)
//3- filepath
int main(int argc, char **argv){
//int fdesc = llopen(argv[1], SEND);
//exit(-1);
setbuf(stdout, NULL);
ll.timeOut = 3;
ll.sequenceNumber = 0;
ll.numTransmissions = 3;
int mode;
if(argc == 2 && !strcmp("--help", argv[1])){
printTutorial();
exit(0);
}
if(argc >= 3){
if(!strcmp(argv[2], "send"))
mode = 0;
else if(!strcmp(argv[2], "receive")){
mode = 1;
}
else{
printUsage(argv[0]);
exit(-1);
}
}
else
exit(-1);
if( (argc < 4 && mode == SEND) || (argc<3 && mode == RECEIVE) || strncmp(argv[1], "/dev/ttyS", strlen("dev/ttyS"))) {
printUsage(argv[0]);
exit(-1);
}
if((argc > 4 && mode == SEND) || (argc > 3 && mode == RECEIVE)){
int i;
for(i = 0; i < argc-(mode==SEND?4:3); i++){
if(parseParams(argv[i+(mode==SEND?4:3)]) == -1)
return -1;
}
}
int fd;
if (mode == SEND && (fd = open(argv[3], O_RDONLY)) == ENOENT){
perror("");
exit(-1);
}
int serialPort = llopen(argv[1], mode);
if (serialPort < 0){
perror("");
exit(-1);
}
int result;
if (mode == SEND){
result = sendFile(serialPort, fd, argv[3]);
}
else if (mode == RECEIVE){
result = readFile(serialPort);
}
if(result){
perror("could not transmit file");
return result;
}
printStatistics(visMode);
return 0;
}
int main(int argc, char *argv[])
{
pArgc = &argc;
pArgv = argv;
sdkCreateTimer(&frame_timer);
sdkResetTimer(&frame_timer);
sdkCreateTimer(&global_timer);
sdkResetTimer(&global_timer);
// parse the command line arguments
parseCommandLineArguments(argc, argv);
// create window (after we know the size of the input file size)
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
sAppName, NULL
};
RegisterClassEx(&wc);
// Find out the video size
g_bIsProgressive = loadVideoSource(sFileName.c_str(),
g_nVideoWidth, g_nVideoHeight,
g_nWindowWidth, g_nWindowHeight);
// figure out the window size we must create to get a *client* area
// that is of the size requested by m_dimensions.
RECT adjustedWindowSize;
DWORD dwWindowStyle;
HWND hWnd = NULL;
{
dwWindowStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
SetRect(&adjustedWindowSize, 0, 0, g_nVideoWidth , g_nVideoHeight);
AdjustWindowRect(&adjustedWindowSize, dwWindowStyle, false);
g_nWindowWidth = adjustedWindowSize.right - adjustedWindowSize.left;
g_nWindowHeight = adjustedWindowSize.bottom - adjustedWindowSize.top;
// Create the application's window
hWnd = CreateWindow(wc.lpszClassName, sAppName,
dwWindowStyle,
0, 0,
g_nWindowWidth,
g_nWindowHeight,
NULL, NULL, wc.hInstance, NULL);
}
// Initialize CUDA
cuInit(0);
int bTCC = 0;
// If we are using TCC driver, then always turn off interop
if (bTCC)
{
g_bUseInterop = false;
}
if (g_bUseInterop)
{
// Initialize Direct3D
if (initD3D9(hWnd, argc, argv, &bTCC) == false)
{
g_bAutoQuit = true;
g_bWaived = true;
goto ExitApp;
}
}
// Initialize CUDA/D3D9 context and other video memory resources
if (initCudaResources(argc, argv, g_bUseInterop, bTCC) == E_FAIL)
{
g_bAutoQuit = true;
g_bException = true;
g_bWaived = true;
goto ExitApp;
}
g_pVideoSource->start();
g_bRunning = true;
if (!g_bQAReadback && !bTCC)
{
ShowWindow(hWnd, SW_SHOWDEFAULT);
UpdateWindow(hWnd);
}
// the main loop
sdkStartTimer(&frame_timer);
sdkStartTimer(&global_timer);
sdkResetTimer(&global_timer);
if (!g_bUseInterop)
{
// On this case we drive the display with a while loop (no openGL calls)
while (g_pVideoSource->isStarted() && !g_pFrameQueue->isEndOfDecode())
{
renderVideoFrame(hWnd, g_bUseInterop);
}
}
else
{
// Standard windows loop
while (!g_bDone)
{
MSG msg;
ZeroMemory(&msg, sizeof(msg));
while (msg.message!=WM_QUIT)
{
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
renderVideoFrame(hWnd, g_bUseInterop);
}
if (g_bAutoQuit && g_bDone)
{
break;
}
}
} // while loop
}
g_pFrameQueue->endDecode();
g_pVideoSource->stop();
printStatistics();
// clean up CUDA and D3D resources
ExitApp:
cleanup(g_bWaived ? false : true);
if (!g_bQAReadback)
{
// Unregister windows class
UnregisterClass(wc.lpszClassName, wc.hInstance);
}
if (g_bAutoQuit)
{
PostQuitMessage(0);
}
if (hWnd)
{
DestroyWindow(hWnd);
}
if (g_bWaived)
{
exit(EXIT_WAIVED);
}
else
{
exit(g_bException ? EXIT_FAILURE : EXIT_SUCCESS);
}
}
/**
* returns the accuracy
*/
float LacSupervised::predict(Trainning &trainning, char *ftest, AssociationRule* associationRule){
ui ntransactions = 0;
ui nhits = 0;
ui totalRules = 0;
FILE* file=fopen(ftest,"r");
if(file==NULL) {
fprintf(stderr,"Test set %s not found.\n\n", ftest);
exit(-1);
}
SymbolTable* featureTable = SymbolTable::FeaturesTable();
SymbolTable* classesTable = SymbolTable::ClassesTable();
vector<pair<string, ui> > classes;
classesTable->getTableName(classes);
unordered_set<ui> featureIds;
const ui bufferSize = 200*1024;
char line[bufferSize];
ui tid, classId;
ui nclasses = trainning.getNumberOfClasses();
vector<float> scores(nclasses);
ui defaultClass = trainning.getMostFrequentClass();
while(fgets(line, bufferSize, file)){
++ntransactions;
classId = 10000000;
processLineInput(line, featureTable, classesTable, tid, classId, featureIds);
if(classId == 10000000){
throw string("Class Id not found: ") + line ;
}
Projection* projection = trainning.geProjection(featureIds);
fill_n(scores.begin(), scores.size(), 0.0f);
float totalScore = 0.0f;
ui nrules = 0;
ui prediction = defaultClass;
AssociationRule::RulesResult result = associationRule->induceRules(projection, minSupport, iminSupport, nclasses);
for(ui classId = 0; classId < nclasses; ++classId){
nrules += result.classesNRules[classId];
float score = result.score(classId);
totalScore += score;
scores[classId] = score;
if(cmp(scores[prediction], score) < 0){
prediction = classId;
}
}
totalRules += nrules;
nhits += prediction == classId;;
printStatistics(trainning, tid, classesTable, classes, classId, prediction, scores, totalScore, nrules);
delete projection;
}
fclose(file);
//printf("%u\n", totalRules);
return ntransactions == 0 ? 1.0 : static_cast<float>(nhits)/static_cast<float>(ntransactions);
}
int main(int argc, char **argv) {
#ifdef USE_MPI
MPI_Init(&argc, &argv);
#endif
if (argc != 5) {
LOG_ERROR("I want width, height, zombies, iterations.\n");
#ifdef USE_MPI
MPI_Finalize();
#endif
exit(1);
}
int width = atoi(argv[1]);
int height = atoi(argv[2]);
int people = (int) (width * height * INITIAL_DENSITY);
int zombies = atoi(argv[3]);
int iters = atoi(argv[4]);
initRandom(0);
WorldPtr input, output;
double ratio = divideWorld(&width, &height, &input, &output);
// there should not be any output prior to this point
#ifdef REDIRECT
initRedirectToFiles(input);
#endif
LOG_DEBUG("World size is %d x %d at position [%d, %d] of %d x %d\n",
input->localWidth, input->localHeight, input->globalX,
input->globalY, input->globalColumns, input->globalRows);
if (input->globalX == 0 && input->globalY == 0) {
randomDistribution(input, people * ratio, zombies, 0);
} else {
// no zombies elsewhere
randomDistribution(input, people * ratio, 0, 0);
}
#ifndef NIMAGES
printWorld(input, false);
#endif
Timer timer = startTimer();
Stats cumulative = NO_STATS;
for (int i = 0; i < iters; i++) {
simulateStep(input, output);
output->stats.clock = cumulative.clock = output->clock;
Stats stats = output->stats;
mergeStats(&cumulative, stats, false);
printStatistics(output, cumulative);
WorldPtr temp = input;
input = output;
output = temp;
input->stats = stats;
}
double elapsedTime = getElapsedTime(timer);
#ifdef _OPENMP
int numThreads = omp_get_max_threads();
#else
int numThreads = 1;
#endif
LOG_TIME("Simulation took %f milliseconds with %d threads\n", elapsedTime,
numThreads);
// this is a clean up
// we destroy both worlds
destroyWorld(input);
destroyWorld(output);
destroyRandom();
#ifdef REDIRECT
finishRedirectToFiles();
#endif
#ifdef USE_MPI
MPI_Finalize();
#endif
}
bool updateProject(Output* output, const char* path)
{
auto start = std::chrono::high_resolution_clock::now();
output->print("Updating %s:\n", path);
std::unique_ptr<ProjectGroup> group = parseProject(output, path);
if (!group)
return false;
removeFile(replaceExtension(path, ".qgc").c_str());
output->print("Scanning project...\r");
std::vector<FileInfo> files = getProjectGroupFiles(output, group.get());
output->print("Building file table...\r");
if (!buildFiles(output, path, files))
return false;
std::string targetPath = replaceExtension(path, ".qgd");
std::string tempPath = targetPath + "_";
UpdateStatistics stats = {};
unsigned int totalChunks = 0;
{
BuildContext* builder = buildStart(output, tempPath.c_str(), files.size());
if (!builder)
return false;
UpdateFileIterator fileit = {files, 0};
// update contents using existing database (if any)
if (!processFile(output, builder, fileit, stats, targetPath.c_str()))
{
buildFinish(builder);
return false;
}
// update all unprocessed files
while (fileit)
{
buildAppendFile(builder, fileit->path.c_str(), fileit->timeStamp, fileit->fileSize);
++fileit;
stats.filesAdded++;
}
totalChunks = buildFinish(builder);
}
output->print("\n");
auto time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - start);
printStatistics(output, stats, totalChunks, time.count() / 1e3);
if (!renameFile(tempPath.c_str(), targetPath.c_str()))
{
output->error("Error saving data file %s\n", targetPath.c_str());
return false;
}
return true;
}
int main(int argc, char ** argv) {
NbodyModel *theModel = NULL;
int n=500;
double tStep = 0.1; // My
double tFinal = 1000.0; // My
double rotation_factor=0.0;
double initial_v=0.0;
double soft_fac=0.0;
double srad_fac=5.0;
double treeRangeCoefficient=1.2;
double scale=13.0;//parsecs
double mass=800.0; //solar masses
int color=0; // color code in old style galaxsee format
double G=0.0044994; //pc^3/solar_mass/Myr^2
int i;
time_t begin;
time_t end;
int int_method = INT_METHOD_RK4;
int force_method = FORCE_METHOD_DIRECT;
int ngrid = 32;
double drag=0.0;
double expansion=0.0;
double anisotropy=0.01;
double pointsize=0.02;
double ksigma=2.0;
double knear=1.0;
int seed=-1;
int distribution = DISTRIBUTION_SPHERICAL_RANDOM;
double distribution_z_scale = 1.0;
FILE *fp;
char file_line[READLINE_MAX];
char tag[READLINE_MAX];
char value[READLINE_MAX];
char prefix[READLINE_MAX];
char g2gprefix[READLINE_MAX];
char g2gpath[READLINE_MAX];
double g2glength=1.0;
double g2gmass=1.0;
double g2gvelocity=1.0;
int print_stats=0;
int stats_size = 0;
double force_total_sum=0.0;
#ifdef _USE_PTHREADS
pthread_t compute_thread;
#endif
#ifdef STAT_KIT
startTimer();
#endif
time(&begin);
strcpy(prefix,"out");
strcpy(g2gprefix,"");
strcpy(g2gpath,"");
#ifdef HAS_MPI
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD,&rank);
MPI_Comm_size(MPI_COMM_WORLD,&size);
stats_size = size;
#else
rank=0;
size=1;
#endif
// command line arguments
if(rank==0) {
printf("USAGE: galaxsee [filename]\n");
printf("USAGE: if no filename is entered input is assumed to be stdin\n");
}
fp=NULL;
if(argc>1) {
fp=fopen(argv[1],"r");
if(fp==NULL) {
printf("ERROR OPENING INPUT FILE\n");
exit(0);
}
} else {
fp=stdin;
}
while(readline(file_line,READLINE_MAX,fp)) {
gettagline_rl(file_line,tag,value);
if(stricmp_rl(tag,"UPDATE_METHOD")==0) getint_rl(value,&update_method);
else if(stricmp_rl(tag,"SHOW_DISPLAY")==0) getint_rl(value,&show_updates);
else if(stricmp_rl(tag,"SKIP_UPDATES")==0) getint_rl(value,&skip_updates);
else if(stricmp_rl(tag,"SRAD_FACTOR")==0) getdouble_rl(value,&srad_fac);
else if(stricmp_rl(tag,"SOFT_FACTOR")==0) getdouble_rl(value,&soft_fac);
else if(stricmp_rl(tag,"TIMESTEP")==0) getdouble_rl(value,&tStep);
else if(stricmp_rl(tag,"TREE_RANGE_COEFFICIENT")==0) getdouble_rl(value,&treeRangeCoefficient);
else if(stricmp_rl(tag,"FORCE_METHOD")==0) getint_rl(value,&force_method);
else if(stricmp_rl(tag,"INT_METHOD")==0) getint_rl(value,&int_method);
else if(stricmp_rl(tag,"INITIAL_V")==0) getdouble_rl(value,&initial_v);
else if(stricmp_rl(tag,"ROTATION_FACTOR")==0) getdouble_rl(value,&rotation_factor);
else if(stricmp_rl(tag,"TFINAL")==0) getdouble_rl(value,&tFinal);
else if(stricmp_rl(tag,"N")==0) getint_rl(value,&n);
else if(stricmp_rl(tag,"SCALE")==0) getdouble_rl(value,&scale);
else if(stricmp_rl(tag,"MASS")==0) getdouble_rl(value,&mass);
else if(stricmp_rl(tag,"COLOR")==0) getint_rl(value,&color);
else if(stricmp_rl(tag,"G")==0) getdouble_rl(value,&G);
else if(stricmp_rl(tag,"NGRID")==0) getint_rl(value,&ngrid);
else if(stricmp_rl(tag,"DELAY")==0) getint_rl(value,&delay);
else if(stricmp_rl(tag,"SEED")==0) getint_rl(value,&seed);
else if(stricmp_rl(tag,"DRAG_COEFFICIENT")==0) getdouble_rl(value,&drag);
else if(stricmp_rl(tag,"EXPANSION")==0) getdouble_rl(value,&expansion);
else if(stricmp_rl(tag,"ANISOTROPY")==0) getdouble_rl(value,&anisotropy);
else if(stricmp_rl(tag,"KSIGMA")==0) getdouble_rl(value,&ksigma);
else if(stricmp_rl(tag,"KNEAR")==0) getdouble_rl(value,&knear);
else if(stricmp_rl(tag,"FILE_PREFIX")==0) getword_rl(value,prefix);
else if(stricmp_rl(tag,"GADGET2_PREFIX")==0) getword_rl(value,g2gprefix);
else if(stricmp_rl(tag,"GADGET2_PATH")==0) getword_rl(value,g2gpath);
else if(stricmp_rl(tag,"GADGET2_LENGTH")==0) getdouble_rl(value,&g2glength);
else if(stricmp_rl(tag,"GADGET2_MASS")==0) getdouble_rl(value,&g2gmass);
else if(stricmp_rl(tag,"GADGET2_VELOCITY")==0) getdouble_rl(value,&g2gvelocity);
else if(stricmp_rl(tag,"DISTRIBUTION")==0) getint_rl(value,&distribution);
else if(stricmp_rl(tag,"DISTRIBUTION_Z_SCALE")==0) getdouble_rl(value,&distribution_z_scale);
else if(stricmp_rl(tag,"POINTSIZE")==0) getdouble_rl(value,&pointsize);
else if(stricmp_rl(tag,"PRINT_STATISTICS")==0) getint_rl(value,&print_stats);
else if(stricmp_rl(tag,"COORDS")==0) 0; // ignore for now
else {
printf("WARNING, difficulty parsing line\n -- %s\n",file_line);
}
}
if(fp!=NULL&&fp!=stdin) rewind(fp);
if(rank==0) {
printf("Model Summary\n");
printf("N = %d\n",n);
printf("TFINAL = %lf\n",tFinal);
printf("TIMESTEP = %lf\n",tStep);
printf("INITIAL_V = %lf\n",initial_v);
printf("ROTATION_FACTOR = %lf\n",rotation_factor);
printf("DRAG_COEFFICIENT = %lf\n",drag);
printf("SCALE = %lf\n",scale);
printf("MASS = %lf\n",mass);
printf("G = %lf\n",G);
printf("EXPANSION = %lf\n",expansion);
printf("INT_METHOD = %d\n",int_method);
printf("FORCE_METHOD = %d\n",force_method);
printf("TREE_RANGE_COEFFICIENT = %lf\n",treeRangeCoefficient);
printf("NGRID = %d\n",ngrid);
printf("KSIGMA = %lf\n",ksigma);
printf("KNEAR = %lf\n",knear);
printf("DISTRIBUTION = %d\n",distribution);
printf("DISTRIBUTION_Z_SCALE = %lf\n",distribution_z_scale);
printf("ANISOTROPY = %lf\n",anisotropy);
printf("POINTSIZE = %lf\n",pointsize);
printf("SRAD_FAC = %lf\n",srad_fac);
printf("SOFT_FAC = %lf\n",soft_fac);
printf("MPI_SIZE = %d\n",size);
printf("FILE_PREFIX = %s\n",prefix);
printf("DELAY = %d\n",delay);
if (seed<0) {
printf("SEED = TIME BASED\n");
} else {
printf("SEED = %d\n",seed);
}
}
theModel = allocateNbodyModel(n,ngrid);
setPointsizeNbodyModel(theModel,pointsize);
setAnisotropyNbodyModel(theModel,anisotropy);
setDistributionNbodyModel(theModel,distribution);
setDistributionZScaleNbodyModel(theModel,distribution_z_scale);
setPPPMCoeffsNbodyModel(theModel,ksigma,knear);
setExpansionNbodyModel(theModel,expansion);
setDragNbodyModel(theModel,drag);
setPrefixNbodyModel(theModel,prefix);
setSradNbodyModel(theModel,srad_fac);
setSofteningNbodyModel(theModel,soft_fac);
setScaleNbodyModel(theModel,scale); // parsecs
setMassNbodyModel(theModel,mass/(double)n); // solar masses
setColorNbodyModel(theModel,color);
setGNbodyModel(theModel,G); // pc^3/solar_mass/My^2
setRotationFactor(theModel,rotation_factor);
setInitialV(theModel,initial_v);
setTFinal(theModel,tFinal);
setTStep(theModel,tStep);
setIntMethod(theModel,int_method);
setForceMethod(theModel,force_method);
setTreeRangeCoefficient(theModel,treeRangeCoefficient);
initializeNbodyModel(theModel);
if (theModel->rotation_factor>0.0) {
spinNbodyModel(theModel);
}
if (theModel->initial_v>0.0) {
speedNbodyModel(theModel);
}
i=0;
while(readline(file_line,READLINE_MAX,fp)) {
gettagline_rl(file_line,tag,value);
if(stricmp_rl(tag,"COORDS")==0) {
if(i<theModel->n) {
sscanf(value,"%lf %lf %lf %lf %lf %lf %lf %d",&(theModel->x[i]),
&(theModel->y[i]),&(theModel->z[i]),
&(theModel->vx[i]),&(theModel->vy[i]),&(theModel->vz[i]),
&(theModel->mass[i]),&(theModel->color[i]));
} else {
printf("WARNING, NUMBER OF COORDINATES IN INPUT FILE \n");
printf("EXCEED VALUE OF N = %d\n",theModel->n);
}
i++;
}
}
if(i>0&&i!=theModel->n) {
printf("WARNING, COORDINATES ENTERED IN INPUT FILE (%d) \n",i);
printf("NOT EQUAL TO N (%d) \n",theModel->n);
}
if(fp!=NULL&&fp!=stdin) fclose(fp);
if(seed<0) {
seed_by_time(0);
} else {
srand(seed);
}
if(strcmp(g2gprefix,"")) {
gal2gad2(theModel,(const char *)g2gprefix,(const char *)g2gpath,g2glength, g2gmass, g2gvelocity);
exit(0);
}
#ifdef _USE_PTHREADS
pthread_create(&compute_thread,NULL,compute_loop,theModel);
if(rank==0) {
while(theModel->t<theModel->tFinal) {
nbodyEvents(theModel,update_method);
}
}
pthread_join(compute_thread,NULL);
#else
compute_loop(theModel,print_stats);
#endif
time(&end);
#ifdef HAS_MPI
MPI_Reduce(&(theModel->force_total),&force_total_sum,1,MPI_DOUBLE,
MPI_SUM, 0, MPI_COMM_WORLD);
if(rank==0) {
#endif
printf("\n");
if(print_stats) {
printStatistics(theModel);
energy = ((theModel->PE+theModel->KE)-energy)/fabs(energy)*100.0;
printf("Energy Loss--Gain = %lf percent \n",energy);
}
printf("Wall Time Elapsed = %8.lf seconds\n",difftime(end,begin));
printf("Time in Force Calculation, root node = %8.lf seconds\n",
theModel->force_total);
#ifdef HAS_MPI
printf("Time in Force Calculation, all nodes = %8.lf seconds\n",
force_total_sum);
}
#endif
freeNbodyModel(theModel);
#ifdef HAS_MPI
MPI_Finalize();
#endif
#ifdef STAT_KIT
printStats("galaxsee-v2", stats_size, "mpi", n, "2.0",0, 0);
#endif
return 1;
}
int main(int argc, char *argv[])
{
if ((argc < 6) || (argc > 9))
{
usage(argv[0]);
exit(EXIT_FAILURE);
}
//mtarray numThreads threadMemSize rwRatio maxWrapSize numWraps [wrapType [options]
numThreads = getIntArg(argv[1]);
threadMemSize = getIntArg(argv[2]);
rwRatio = getIntArg(argv[3]);
wrapSize = getIntArg(argv[4]);
numWraps = getIntArg(argv[5]);
delay = getIntArg(argv[6]);
if ((numThreads < 0) || (threadMemSize < 0) || (delay < 0) || (rwRatio < 0) || (wrapSize < 0) || (numWraps < 0))
{
usage(argv[0]);
exit(EXIT_FAILURE);
}
int wrapType;
int wrapOptions;
if (argc >= 8)
{
wrapType = getIntArg(argv[7]);
if (wrapType < 0)
{
usage(argv[0]);
exit(EXIT_FAILURE);
}
if (wrapType == Wrap_Software)
{
setAliasTableWorkers(numThreads);
}
setWrapImpl((WrapImplType)wrapType);
if (argc >= 9)
{
wrapOptions = getIntArg(argv[8]);
if (wrapOptions < 0)
{
usage(argv[0]);
exit(EXIT_FAILURE);
}
setWrapImplOptions(wrapOptions);
}
}
// Display memory attributes.
printMemoryAttributes();
arraySize = numThreads * threadMemSize;
StartPhysicalTracer();
startStatistics();
//data = (int *)pmalloc(arraySize * sizeof(int));
//printf("Array size=%d integers with start address: %p\n", arraySize, data);
// Create the test threads
pthread_t *testers = (pthread_t *)malloc(numThreads * sizeof(pthread_t));
for (int i = 0; i < numThreads; i++)
{
pthread_create(&testers[i], NULL, test, (void*)(int64_t)i);
}
printf("joining\n");
for (int i = 0; i < numThreads; i++)
{
pthread_join(testers[i], NULL);
}
free(testers);
EndPhysicalTracer();
printf("%s \t%s \t%s \t%s \t", argv[0], argv[1], argv[2], argv[3]);
printStatistics(stdout);
wrapCleanup();
return 0;
}
/*..........................................................................*/
int main(int argc, char *argv[]) {
int j;
QHsmTst_ctor(); /* instantiate the HSM */
if (argc > 1) { /* file name provided? */
l_outFile = fopen(argv[1], "w");
}
if (l_outFile == (FILE *)0) { /* interactive version? */
l_outFile = stdout; /* use the stdout as the output file */
printf("QHsmTst example, built on %s at %s,\n"
"QP-nano: %s.\nPress ESC to quit...\n",
__DATE__, __TIME__, QP_getVersion());
QHsm_init((QHsm *)&HSM_QHsmTst); /* take the initial transitioin */
for (;;) { /* event loop */
int c;
printf("\n>");
c = getchar();
printf(": ");
/*
if ('a' <= c && c <= 'i') { // in range?
Q_SIG((QHsm *)&HSM_QHsmTst) = (QSignal)(c - 'a' + A_SIG);
}
else if ('A' <= c && c <= 'I') { // in range?
Q_SIG((QHsm *)&HSM_QHsmTst) = (QSignal)(c - 'A' + A_SIG);
}
else if (c == '\33') { // the ESC key?
Q_SIG((QHsm *)&HSM_QHsmTst) = TERMINATE_SIG;
}
else {
Q_SIG((QHsm *)&HSM_QHsmTst) = IGNORE_SIG;
}
*/
//QHsm_dispatch((QHsm *)&HSM_QHsmTst); /* dispatch the event */
}
}
else { /* batch version */
printf("QHsmTst example, built on %s at %s, QP-nano %s\n"
"output saved to %s\n",
__DATE__, __TIME__, QP_getVersion(),
argv[1]);
fprintf(l_outFile, "QHsmTst example, QP-nano %s\n",
QP_getVersion());
QHsm_init((QHsm *)&HSM_QHsmTst); /* take the initial transitioin */
extern storeWait waiting [5];
//init
int iterations;
int timerCheckPoint = 0;
direct = NA;
maxFloor = 4;
for ( ; timePassed < 3000000; ){
timerCheckPoint = timePassed;
//Controller loop
switch (direct){
case UP: {
if (ordersExistInDir(UP)){
dispatch(GO_UP);
dispatch(FLOOR_REACHED);
}
else {
direct = NA;
}
break;
}
case DOWN: {
if (ordersExistInDir(DOWN)){
dispatch(GO_DOWN);
dispatch(FLOOR_REACHED);
}
else {
direct = NA;
}
break;
}
case NA: {
if (ordersExistInDir(UP)){
dispatch(GO_UP);
dispatch(FLOOR_REACHED);
}
else if (ordersExistInDir(DOWN)){
dispatch(GO_DOWN);
dispatch(FLOOR_REACHED);
}
break;
}
}
//To make the time go if nothing has been done in the elevator
if (timerCheckPoint == timePassed){
tick5();
}
//printStatus(waiting);
//printf("iteration no: %d",iterations);
assert(currentFloor <= maxFloor && currentFloor >= 0);
}
printStatistics(waiting);
fclose(l_outFile);
}
return 0;
}
