void FW(Graph<int, int> & g){ int V = (int)g.getVertices()->size(); int ** dist = Helper::buildMatrix<int>(V, V); for (int i = 0; i < V; ++i) { for (int j = 0; j < V; ++j) { if (i == j) dist[i][j] = 0; else dist[i][j] = 1000; } } for (int i = 0; i < (int)g.getEdges()->size(); ++i) { Edge<int, int> * e = g.getEdgeAt(i); int origin = *(e->getOrigin()->getInfo()); int destination = *(e->getDestination()->getInfo()); dist[origin - 1][destination - 1] = *e->getInfo(); } for (int k = 0; k < V; ++k) { PM(dist, V, V); for (int i = 0; i < V; ++i) { for (int j = 0; j < V; ++j) { if (dist[i][k] + dist[k][j] < dist[i][j]) { dist[i][j] = dist[i][k] + dist[k][j]; } } } } PM(dist, V, V); }
std::pair<MayMustMap, std::set<llvm::GlobalVariable*> > getMayMustMap(llvm::Function *function) { llvm::Module *module = function->getParent(); #if LLVM_VERSION < VERSION(3, 2) llvm::TargetData *TD = NULL; #elif LLVM_VERSION < VERSION(3, 5) llvm::DataLayout *TD = NULL; #elif LLVM_VERSION < VERSION(3, 7) llvm::DataLayoutPass *TD = NULL; #endif #if LLVM_VERSION < VERSION(3, 5) const std::string &ModuleDataLayout = module->getDataLayout(); #elif LLVM_VERSION == VERSION(3, 5) const std::string &ModuleDataLayout = module->getDataLayout()->getStringRepresentation(); #endif #if LLVM_VERSION < VERSION(3, 2) if (!ModuleDataLayout.empty()) { TD = new llvm::TargetData(ModuleDataLayout); } #elif LLVM_VERSION < VERSION(3, 5) if (!ModuleDataLayout.empty()) { TD = new llvm::DataLayout(ModuleDataLayout); } #elif LLVM_VERSION == VERSION(3, 5) if (!ModuleDataLayout.empty()) { TD = new llvm::DataLayoutPass(llvm::DataLayout(ModuleDataLayout)); } #elif LLVM_VERSION < VERSION(3, 7) TD = new llvm::DataLayoutPass(); #endif // pass manager #if LLVM_VERSION < VERSION(3, 7) llvm::FunctionPassManager PM(module); #else llvm::legacy::FunctionPassManager PM(module); #endif #if LLVM_VERSION < VERSION(3, 7) if (TD != NULL) { PM.add(TD); } #endif #if LLVM_VERSION < VERSION(3, 8) PM.add(llvm::createBasicAliasAnalysisPass()); #else PM.add(llvm::createBasicAAWrapperPass()); #endif MemoryAnalyzer *maPass = createMemoryAnalyzerPass(); PM.add(maPass); PM.run(*function); return std::make_pair(maPass->getMayMustMap(), maPass->getMayZap()); }
void reboot () { int rstc; rstc = PM(RSTC); PM(WDOG) = PASSWORD | (10 & WDOG_TIME_SET); PM(RSTC) = PASSWORD | (rstc & RSTC_WRCFG_CLR) | RSTC_WRCFG_FULL_RESET; }
void measurement_overhead() { printf("Measurement, 0, 0\n"); PM("","RDTSC, "O_STR); #define FOR_MEAS for (int k = 0; k < 100; ++k) { ; } double m; uint64_t med, se, min, max; measure(FOR_MEAS,m,med,se,min,max,10000); printf("Loop, "O_STR, m/100, med/100, se/100, min/100, max/100); printf("Function Calls, 0, 0\n"); PM_COUNT(p0(), "p0, "O_STR,1000000); PM_COUNT(p1(1), "p1, "O_STR,1000000); PM_COUNT(p2(1,2), "p2, "O_STR,1000000); PM_COUNT(p3(1,2,3), "p3, "O_STR,1000000); PM_COUNT(p4(1,2,3,4), "p4, "O_STR,1000000); PM_COUNT(p5(1,2,3,4,5), "p5, "O_STR,1000000); PM_COUNT(p6(1,2,3,4,5,6), "p6, "O_STR,1000000); PM_COUNT(p7(1,2,3,4,5,6,7), "p7, "O_STR,1000000); }
TrueFalseMap getConditionPropagationMap(llvm::Function *function, std::set<llvm::BasicBlock*> lcbs) { llvm::Module *module = function->getParent(); // pass manager #if LLVM_VERSION < VERSION(3, 7) llvm::FunctionPassManager PM(module); #else llvm::legacy::FunctionPassManager PM(module); #endif ConditionPropagator *cpPass = createConditionPropagatorPass(debug, onlyLoopConditions, lcbs); PM.add(cpPass); PM.run(*function); return cpPass->getTrueFalseMap(); }
ConditionMap getExplicitizedLoopConditionMap(llvm::Function *function) { llvm::Module *module = function->getParent(); // pass manager #if LLVM_VERSION < VERSION(3, 7) llvm::FunctionPassManager PM(module); #else llvm::legacy::FunctionPassManager PM(module); #endif LoopConditionExplicitizer *lcePass = createLoopConditionExplicitizerPass(debug); PM.add(lcePass); PM.run(*function); return lcePass->getConditionMap(); }
std::set<llvm::BasicBlock*> getLoopConditionBlocks(llvm::Function *function) { llvm::Module *module = function->getParent(); // pass manager #if LLVM_VERSION < VERSION(3, 7) llvm::FunctionPassManager PM(module); #else llvm::legacy::FunctionPassManager PM(module); #endif LoopConditionBlocksCollector *lcbPass = createLoopConditionBlocksCollectorPass(); PM.add(lcbPass); PM.run(*function); return lcbPass->getLoopConditionBlocks(); }
static void NotebookTabElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { if (qApp == NULL) NULL_Q_APP; NULL_PROXY_WIDGET(TileQt_QTabBar_Widget); Tcl_MutexLock(&tileqtMutex); #ifdef TILEQT_QT_VERSION_4 QStyleOptionTab option; option.initFrom(wc->TileQt_QTabBar_Widget); #endif /* TILEQT_QT_VERSION_4 */ int PM_TabBarTabVSpace = PM(PM_TabBarTabVSpace), PM_TabBarTabHSpace = PM(PM_TabBarTabHSpace); Tcl_MutexUnlock(&tileqtMutex); *paddingPtr = Ttk_MakePadding( PM_TabBarTabHSpace/2, #ifdef TILEQT_QT_VERSION_4 PM_TabBarTabVSpace, PM_TabBarTabHSpace/2, 0 #endif /* TILEQT_QT_VERSION_4 */ ); }
void gpio_init(gpio_t *obj, PinName pin) { int group ; obj->pin = pin; if(pin == NC) return; obj->mask = gpio_set(pin); group = PINGROUP(pin); if (group > 11) return; obj->reg_set = (volatile uint32_t *)PORT(group); obj->reg_in = (volatile uint32_t *) PPR(group); obj->reg_dir = (volatile uint32_t *) PM(group); obj->reg_buf = (volatile uint32_t *)PIBC(group); }
static void init_uart0 () { initted = 1; PER0 = 0xff; SPS0 = 0x0011; /* 16 MHz */ SMR00 = 0x0022; /* uart mode */ SCR00 = 0x8097; /* 8-N-1 */ SDR00 = 0x8a00; /* baud in MSB - 115200 */ SOL0 = 0x0000; /* not inverted */ SO0 = 0x000f; /* initial value */ SOE0 = 0x0001; /* enable TxD0 */ P(1) |= 0b00000100; PM(1) &= 0b11111011; SS0 = 0x0001; }
EXTRADECLS #endif /***************************************************************************** * * * This is a program which illustrates the use of nauty. * * Commands are read from stdin, and may be separated by white space, * * commas or not separated. Output is written to stdout. * * For a short description, see the nauty User's Guide. * * * *****************************************************************************/ main() { int m,n,newm,newn; boolean gvalid,ovalid,cvalid,pvalid,minus,prompt,doquot; int i,worksize,numcells,refcode,umask,qinvar; int oldorg; char *s1,*s2,*invarprocname; int c,d; register long li; set *gp; double timebefore,timeafter; char filename[100]; graph *savedg; nvector *savedlab; int sgn,sgactn,sgorg; int cgactn,gactn; curfile = 0; fileptr[curfile] = stdin; prompt = DOPROMPT(INFILE); outfile = stdout; n = m = 1; #ifdef INITSEED INITSEED; #endif umask = 0; pvalid = FALSE; gvalid = FALSE; ovalid = FALSE; cvalid = FALSE; minus = FALSE; worksize = 2*MAXM*WORKSIZE; labelorg = oldorg = 0; cgactn = sgactn = gactn = 0; #ifdef DYNALLOC workspace = (setword*) ALLOCS(WORKSIZE,2*MAXM*sizeof(setword)); ptn = (nvector*) ALLOCS(MAXN,sizeof(nvector)); orbits = (nvector*) ALLOCS(MAXN,sizeof(nvector)); perm = (permutation*) ALLOCS(MAXN,sizeof(permutation)); if (workspace == NILSET || ptn == (nvector*)NULL || orbits == (nvector*)NULL || perm == (permutation*)NULL) { fprintf(ERRFILE,"ALLOCS failed; reduce MAXN.\n\n"); EXIT; } #endif #ifdef INITIALIZE INITIALIZE; #endif allocg(&g,&lab,&gactn,n); if (gactn == 0) { fprintf(ERRFILE,"ALLOCS failed for g: this shouldn't happen.\n\n"); EXIT; } invarprocname = "none"; if (prompt) { fprintf(PROMPTFILE,"Dreadnaut version %s.\n",DREADVERSION); fprintf(PROMPTFILE,"> "); } /* Calling dummy routines in nautinv.c, nauty.c and nautil.c causes those segments to get loaded in various Macintosh variants. This causes an apparent, but illusory, improvement in the time required for the first call to nauty(). */ nautinv_null(); nautil_null(); nauty_null(); while (curfile >= 0) if ((c = getc(INFILE)) == EOF || c == '\004') { fclose(INFILE); --curfile; if (curfile >= 0) prompt = DOPROMPT(INFILE); } else switch (c) { case '\n': /* possibly issue prompt */ if (prompt) fprintf(PROMPTFILE,"> "); minus = FALSE; break; case ' ': /* do nothing */ case '\t': #ifndef NLMAP case '\r': #endif case '\f': break; case '-': /* remember this for next time */ minus = TRUE; break; case '+': /* forget - */ case ',': case ';': minus = FALSE; break; case '<': /* new input file */ minus = FALSE; if (curfile == MAXIFILES - 1) fprintf(ERRFILE,"exceeded maximum input nesting of %d\n\n", MAXIFILES); if (!readstring(INFILE,filename)) { fprintf(ERRFILE, "missing file name on '>' command : ignored\n\n"); break; } if ((fileptr[curfile+1] = fopen(filename,"r")) == NULL) { for (s1 = filename; *s1 != '\0'; ++s1) {} for (s2 = def_ext; (*s1 = *s2) != '\0'; ++s1, ++s2) {} fileptr[curfile+1] = fopen(filename,"r"); } if (fileptr[curfile+1] != NULL) { ++curfile; prompt = DOPROMPT(INFILE); if (prompt) fprintf(PROMPTFILE,"> "); } else fprintf(ERRFILE,"can't open input file\n\n"); break; case '>': /* new output file */ if ((d = getc(INFILE)) != '>') ungetc((char)d,INFILE); if (minus) { minus = FALSE; if (outfile != stdout) { fclose(outfile); outfile = stdout; } } else { if (!readstring(INFILE,filename)) { fprintf(ERRFILE, "improper file name, reverting to stdout\n\n"); outfile = stdout; break; } OPENOUT(outfile,filename,d=='>'); if (outfile == NULL) { fprintf(ERRFILE, "can't open output file, reverting to stdout\n\n"); outfile = stdout; } } break; case '!': /* ignore rest of line */ do c = getc(INFILE); while (c != '\n' && c != EOF); if (c == '\n') ungetc('\n',INFILE); break; case 'n': /* read n value */ minus = FALSE; i = getint(INFILE); if (i <= 0 || i > MAXN) fprintf(ERRFILE, " n can't be less than 1 or more than %d\n\n",MAXN); else { gvalid = FALSE; ovalid = FALSE; cvalid = FALSE; pvalid = FALSE; n = i; m = (n + WORDSIZE - 1) / WORDSIZE; allocg(&g,&lab,&gactn,n); if (gactn == 0) { fprintf(ERRFILE,"can't allocate space for graph\n"); n = m = 1; break; } } break; case 'g': /* read graph */ minus = FALSE; readgraph(INFILE,g,options.digraph,prompt,FALSE, options.linelength,m,n); gvalid = TRUE; cvalid = FALSE; ovalid = FALSE; break; case 'e': /* edit graph */ minus = FALSE; readgraph(INFILE,g,options.digraph,prompt,gvalid, options.linelength,m,n); gvalid = TRUE; cvalid = FALSE; ovalid = FALSE; break; case 'r': /* relabel graph and current partition */ minus = FALSE; if (gvalid) { allocg(&canong,(nvector**)NULL,&cgactn,n); if (cgactn == 0) { fprintf(ERRFILE, "can't allocate work space for 'r'\n\n"); break; } readperm(INFILE,perm,prompt,n); relabel(g,(pvalid ? lab : (nvector*)NULL),perm,canong,m,n); cvalid = FALSE; ovalid = FALSE; } else fprintf(ERRFILE,"g is not defined\n\n"); break; case '_': /* complement graph */ minus = FALSE; if (gvalid) { complement(g,m,n); cvalid = FALSE; ovalid = FALSE; } else fprintf(ERRFILE,"g is not defined\n\n"); break; case '@': /* copy canong into savedg */ minus = FALSE; if (cvalid) { allocg(&savedg,&savedlab,&sgactn,n); if (sgactn == 0) { fprintf(ERRFILE,"can`t allocate space for h'\n\n"); break; } sgn = n; for (li = (long)n * (long)m; --li >= 0;) savedg[li] = canong[li]; for (i = n; --i >= 0;) savedlab[i] = lab[i]; sgorg = labelorg; } else fprintf(ERRFILE,"h is not defined\n\n"); break; case '#': /* compare canong to savedg */ if ((d = getc(INFILE)) != '#') ungetc((char)d,INFILE); if (cvalid) { if (sgactn > 0) { if (sgn != n) fprintf(OUTFILE, "h and h' have different sizes.\n"); else { for (li = (long)n * (long)m; --li >= 0;) if (savedg[li] != canong[li]) break; if (li >= 0) fprintf(OUTFILE, "h and h' are different.\n"); else { fprintf(OUTFILE, "h and h' are identical.\n"); if (d == '#') putmapping(OUTFILE,savedlab,sgorg, lab,labelorg,options.linelength,n); } } } else fprintf(ERRFILE,"h' is not defined\n\n"); } else fprintf(ERRFILE,"h is not defined\n\n"); break; case 'j': /* relabel graph randomly */ minus = FALSE; if (gvalid) { allocg(&canong,(nvector**)NULL,&cgactn,n); if (cgactn == 0) { fprintf(ERRFILE, "can't allocate work space for 'j'\n\n"); break; } ranperm(perm,n); relabel(g,(pvalid ? lab : (nvector*)NULL),perm,canong,m,n); cvalid = FALSE; ovalid = FALSE; } else fprintf(ERRFILE,"g is not defined\n\n"); break; case 'v': /* write vertex degrees */ minus = FALSE; if (gvalid) putdegs(OUTFILE,g,options.linelength,m,n); else fprintf(ERRFILE,"g is not defined\n\n"); break; case '%': /* do Mathon doubling operation */ minus = FALSE; if (gvalid) { if (2L * ((long)n + 1L) > MAXN) { fprintf(ERRFILE,"n can't be more than %d\n\n",MAXN); break; } newn = 2 * (n + 1); newm = (newn + WORDSIZE - 1) / WORDSIZE; allocg(&canong,(nvector**)NULL,&cgactn,n); if (cgactn == 0) { fprintf(ERRFILE, "can't allocate work space for '%'\n\n"); break; } for (li = (long)n * (long)m; --li >= 0;) canong[li] = g[li]; allocg(&g,&lab,&gactn,newn); if (gactn == 0) { fprintf(ERRFILE,"can't allocate space for graph \n\n"); break; } mathon(canong,m,n,g,newm,newn); m = newm; n = newn; cvalid = FALSE; ovalid = FALSE; pvalid = FALSE; } else fprintf(ERRFILE,"g is not defined\n\n"); break; case 's': /* generate random graph */ minus = FALSE; i = getint(INFILE); if (i <= 0) i = 2; rangraph(g,options.digraph,i,m,n); gvalid = TRUE; cvalid = FALSE; ovalid = FALSE; break; case 'q': /* quit */ EXIT; break; case '"': /* copy comment to output */ minus = FALSE; copycomment(INFILE,OUTFILE,'"'); break; case 'I': /* do refinement and invariants procedure */ if (!pvalid) unitptn(lab,ptn,&numcells,n); cellstarts(ptn,0,active,m,n); #ifdef CPUTIME timebefore = CPUTIME; #endif doref(g,lab,ptn,0,&numcells,&qinvar,perm,active,&refcode, refine,options.invarproc, 0,0,options.invararg,options.digraph,m,n); #ifdef CPUTIME timeafter = CPUTIME; #endif fprintf(OUTFILE," %d cell%s; code = %x", SS(numcells,"","s"),refcode); if (options.invarproc != NILFUNCTION) fprintf(OUTFILE," (%s %s)",invarprocname, (qinvar == 2 ? "worked" : "failed")); #ifdef CPUTIME fprintf(OUTFILE,"; cpu time = %.2f seconds\n", timeafter-timebefore); #else fprintf(OUTFILE,"\n"); #endif if (numcells > 1) pvalid = TRUE; break; case 'i': /* do refinement */ if (!pvalid) unitptn(lab,ptn,&numcells,n); cellstarts(ptn,0,active,m,n); if (m == 1) refine1(g,lab,ptn,0,&numcells,perm,active,&refcode,m,n); else refine(g,lab,ptn,0,&numcells,perm,active,&refcode,m,n); fprintf(OUTFILE," %d cell%s; code = %x\n", SS(numcells,"","s"),refcode); if (numcells > 1) pvalid = TRUE; break; case 'x': /* execute nauty */ minus = FALSE; ovalid = FALSE; cvalid = FALSE; if (!gvalid) { fprintf(ERRFILE,"g is not defined\n\n"); break; } if (pvalid) { fprintf(OUTFILE,"[fixing partition]\n"); options.defaultptn = FALSE; } else options.defaultptn = TRUE; options.outfile = outfile; if (options.getcanon) { allocg(&canong,(nvector**)NULL,&cgactn,n); if (cgactn == 0) { fprintf(ERRFILE,"can't allocate space for h\n\n"); break; } } firstpath = TRUE; #ifdef CPUTIME timebefore = CPUTIME; #endif nauty(g,lab,ptn,NILSET,orbits,&options,&stats,workspace, worksize,m,n,canong); #ifdef CPUTIME timeafter = CPUTIME; #endif if (stats.errstatus != 0) fprintf(ERRFILE, "nauty returned error status %d [this can't happen]\n\n", stats.errstatus); else { if (options.getcanon) cvalid = TRUE; ovalid = TRUE; fprintf(OUTFILE,"%d orbit%s",SS(stats.numorbits,"","s")); if (stats.grpsize2 == 0) fprintf(OUTFILE,"; grpsize=%.0f",stats.grpsize1+0.1); else { while (stats.grpsize1 >= 10.0) { stats.grpsize1 /= 10.0; ++stats.grpsize2; } fprintf(OUTFILE,"; grpsize=%12.10fe%d", stats.grpsize1,stats.grpsize2); } fprintf(OUTFILE,"; %d gen%s", SS(stats.numgenerators,"","s")); fprintf(OUTFILE,"; %ld node%s",SS(stats.numnodes,"","s")); if (stats.numbadleaves) fprintf(OUTFILE," (%ld bad lea%s)", SS(stats.numbadleaves,"f","ves")); fprintf(OUTFILE,"; maxlev=%d\n", stats.maxlevel); fprintf(OUTFILE,"tctotal=%ld",stats.tctotal); if (options.getcanon) fprintf(OUTFILE,"; canupdates=%ld",stats.canupdates); #ifdef CPUTIME fprintf(OUTFILE,"; cpu time = %.2f seconds\n", timeafter-timebefore); #else fprintf(OUTFILE,"\n"); #endif if (options.invarproc != NILFUNCTION && options.maxinvarlevel != 0) { fprintf(OUTFILE,"invarproc \"%s\" succeeded %ld/%ld", invarprocname,stats.invsuccesses,stats.invapplics); if (stats.invarsuclevel > 0) fprintf(OUTFILE," beginning at level %d.\n", stats.invarsuclevel); else fprintf(OUTFILE,".\n"); } } break; case 'f': /* read initial partition */ if (minus) { pvalid = FALSE; minus = FALSE; } else { readptn(INFILE,lab,ptn,&numcells,prompt,n); pvalid = TRUE; } break; case 't': /* type graph */ minus = FALSE; if (!gvalid) fprintf(ERRFILE,"g is not defined\n\n"); else putgraph(OUTFILE,g,options.linelength,m,n); break; case 'T': /* type graph preceded by n, $ and g commands */ minus = FALSE; if (!gvalid) fprintf(ERRFILE,"g is not defined\n\n"); else { fprintf(OUTFILE,"n=%d $=%d g\n",n,labelorg); putgraph(OUTFILE,g,options.linelength,m,n); fprintf(OUTFILE,"$$\n"); } break; case 'u': /* call user procs */ if (minus) { umask = 0; minus = FALSE; } else { umask = getint(INFILE); if (umask < 0) umask = ~0; } if (umask & U_NODE) options.usernodeproc = NODEPROC; else options.usernodeproc = NILFUNCTION; if (umask & U_AUTOM) options.userautomproc = AUTOMPROC; else options.userautomproc = NILFUNCTION; if (umask & U_LEVEL) options.userlevelproc = LEVELPROC; else options.userlevelproc = NILFUNCTION; if (umask & U_TCELL) options.usertcellproc = TCELLPROC; else options.usertcellproc = NILFUNCTION; if (umask & U_REF) options.userrefproc = REFPROC; else options.userrefproc = NILFUNCTION; break; case 'o': /* type orbits */ minus = FALSE; if (ovalid) putorbits(OUTFILE,orbits,options.linelength,n); else fprintf(ERRFILE,"orbits are not defined\n\n"); break; case 'b': /* type canonlab and canong */ minus = FALSE; if (cvalid) putcanon(OUTFILE,lab,canong,options.linelength,m,n); else fprintf(ERRFILE,"h is not defined\n\n"); break; case 'z': /* type hashcode for canong */ minus = FALSE; if (cvalid) fprintf(OUTFILE,"[%8lx %8lx]\n", hash(canong,(long)m * (long)n,13), hash(canong,(long)m * (long)n,7)); else fprintf(ERRFILE,"h is not defined\n\n"); break; case 'c': /* set getcanon option */ options.getcanon = !minus; minus = FALSE; break; case 'w': /* read size of workspace */ minus = FALSE; worksize = getint(INFILE); if (worksize > 2*MAXM*WORKSIZE) { fprintf(ERRFILE, "too big - setting worksize = %d\n\n", 2*MAXM*WORKSIZE); worksize = 2*MAXM*WORKSIZE; } break; case 'l': /* read linelength for output */ options.linelength = getint(INFILE); minus = FALSE; break; case 'y': /* set tc_level field of options */ options.tc_level = getint(INFILE); minus = FALSE; break; case 'k': /* set invarlev fields of options */ options.mininvarlevel = getint(INFILE); options.maxinvarlevel = getint(INFILE); minus = FALSE; break; case 'K': /* set invararg field of options */ options.invararg = getint(INFILE); minus = FALSE; break; case '*': /* set invarproc field of options */ minus = FALSE; d = getint(INFILE); if (d >= -1 && d <= NUMINVARS-2) { options.invarproc = invarproc[d+1].entrypoint; invarprocname = invarproc[d+1].name; } else fprintf(ERRFILE,"no such vertex-invariant\n\n"); break; case 'a': /* set writeautoms option */ options.writeautoms = !minus; minus = FALSE; break; case 'm': /* set writemarkers option */ options.writemarkers = !minus; minus = FALSE; break; case 'p': /* set cartesian option */ options.cartesian = !minus; minus = FALSE; break; case 'd': /* set digraph option */ if (options.digraph && minus) gvalid = FALSE; options.digraph = !minus; minus = FALSE; break; case '$': /* set label origin */ if ((d = getc(INFILE)) == '$') labelorg = oldorg; else { ungetc((char)d,INFILE); oldorg = labelorg; i = getint(INFILE); if (i < 0) fprintf(ERRFILE,"labelorg must be >= 0\n\n"); else labelorg = i; } break; case '?': /* type options, etc. */ minus = FALSE; fprintf(OUTFILE,"m=%d n=%d labelorg=%d",m,n,labelorg); if (!gvalid) fprintf(OUTFILE," g=undef"); else { li = 0; for (i = 0, gp = g; i < n; ++i, gp += m) li += setsize(gp,m); if (options.digraph) fprintf(OUTFILE," arcs=%ld",li); else fprintf(OUTFILE," edges=%ld",li/2); } fprintf(OUTFILE," options=(%cc%ca%cm%cp%cd", PM(options.getcanon),PM(options.writeautoms), PM(options.writemarkers),PM(options.cartesian), PM(options.digraph)); if (umask & 31) fprintf(OUTFILE," u=%d",umask&31); if (options.tc_level > 0) fprintf(OUTFILE," y=%d",options.tc_level); if (options.mininvarlevel != 0 || options.maxinvarlevel != 0) fprintf(OUTFILE," k=(%d,%d)", options.mininvarlevel,options.maxinvarlevel); if (options.invararg > 0) fprintf(OUTFILE," K=%d",options.invararg); fprintf(OUTFILE,")\n"); fprintf(OUTFILE,"linelen=%d worksize=%d input_depth=%d", options.linelength,worksize,curfile); if (options.invarproc != NILFUNCTION) fprintf(OUTFILE," invarproc=%s",invarprocname); if (pvalid) fprintf(OUTFILE,"; %d cell%s",SS(numcells,"","s")); else fprintf(OUTFILE,"; 1 cell"); fprintf(OUTFILE,"\n"); if (OUTFILE != PROMPTFILE) fprintf(PROMPTFILE,"m=%d n=%d depth=%d labelorg=%d\n", m,n,curfile,labelorg); break; case '&': /* list the partition and possibly the quotient */ if ((d = getc(INFILE)) == '&') doquot = TRUE; else { ungetc((char)d,INFILE); doquot = FALSE; } minus = FALSE; if (pvalid) putptn(OUTFILE,lab,ptn,0,options.linelength,n); else fprintf(OUTFILE,"unit partition\n"); if (doquot) { if (!pvalid) unitptn(lab,ptn,&numcells,n); putquotient(OUTFILE,g,lab,ptn,0,options.linelength,m,n); } break; case 'h': /* type help information */ minus = FALSE; help(PROMPTFILE); break; default: /* illegal command */ fprintf(ERRFILE,"'%c' is illegal - type 'h' for help\n\n",c); flushline(INFILE); if (prompt) fprintf(PROMPTFILE,"> "); break; } /* end of switch */ }
int initOgreAR(aruco::CameraParameters camParams, unsigned char* buffer, std::string resourcePath) { /// INIT OGRE FUNCTIONS root = new Ogre::Root(resourcePath + "plugins.cfg", resourcePath + "ogre.cfg"); if (!root->showConfigDialog()) return -1; Ogre::SceneManager* smgr = root->createSceneManager(Ogre::ST_GENERIC); /// CREATE WINDOW, CAMERA AND VIEWPORT Ogre::RenderWindow* window = root->initialise(true); Ogre::Camera *camera; Ogre::SceneNode* cameraNode; camera = smgr->createCamera("camera"); camera->setNearClipDistance(0.01f); camera->setFarClipDistance(10.0f); camera->setProjectionType(Ogre::PT_ORTHOGRAPHIC); camera->setPosition(0, 0, 0); camera->lookAt(0, 0, 1); double pMatrix[16]; camParams.OgreGetProjectionMatrix(camParams.CamSize,camParams.CamSize, pMatrix, 0.05,10, false); Ogre::Matrix4 PM(pMatrix[0], pMatrix[1], pMatrix[2] , pMatrix[3], pMatrix[4], pMatrix[5], pMatrix[6] , pMatrix[7], pMatrix[8], pMatrix[9], pMatrix[10], pMatrix[11], pMatrix[12], pMatrix[13], pMatrix[14], pMatrix[15]); camera->setCustomProjectionMatrix(true, PM); camera->setCustomViewMatrix(true, Ogre::Matrix4::IDENTITY); window->addViewport(camera); cameraNode = smgr->getRootSceneNode()->createChildSceneNode("cameraNode"); cameraNode->attachObject(camera); /// CREATE BACKGROUND FROM CAMERA IMAGE int width = camParams.CamSize.width; int height = camParams.CamSize.height; // create background camera image mPixelBox = Ogre::PixelBox(width, height, 1, Ogre::PF_R8G8B8, buffer); // Create Texture mTexture = Ogre::TextureManager::getSingleton().createManual("CameraTexture",Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D,width,height,0,Ogre::PF_R8G8B8,Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE); //Create Camera Material Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create("CameraMaterial", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); Ogre::Technique *technique = material->createTechnique(); technique->createPass(); material->getTechnique(0)->getPass(0)->setLightingEnabled(false); material->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false); material->getTechnique(0)->getPass(0)->createTextureUnitState("CameraTexture"); Ogre::Rectangle2D* rect = new Ogre::Rectangle2D(true); rect->setCorners(-1.0, 1.0, 1.0, -1.0); rect->setMaterial("CameraMaterial"); // Render the background before everything else rect->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND); // Hacky, but we need to set the bounding box to something big, use infinite AAB to always stay visible Ogre::AxisAlignedBox aabInf; aabInf.setInfinite(); rect->setBoundingBox(aabInf); // Attach background to the scene Ogre::SceneNode* node = smgr->getRootSceneNode()->createChildSceneNode("Background"); node->attachObject(rect); /// CREATE SIMPLE OGRE SCENE // add sinbad.mesh Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Sinbad.zip", "Zip", "Popular"); Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups(); Ogre::Entity* ogreEntity = smgr->createEntity("Board", "Sinbad.mesh"); ogreNode = smgr->getRootSceneNode()->createChildSceneNode(); // add entity to a child node to correct position (this way, entity axis is on feet of sinbad) Ogre::SceneNode *ogreNodeChild = ogreNode->createChildSceneNode(); ogreNodeChild->attachObject(ogreEntity); Ogre::Real offset = ogreEntity->getBoundingBox().getHalfSize().y; // Sinbad is placed along Y axis, we need to rotate to put it along Z axis so it stands up over the board // first rotate along X axis, then add offset in Z dir so it is over the board and not in the middle of it ogreNodeChild->rotate(Ogre::Vector3(1,0,0), Ogre::Radian(Ogre::Degree(-90))); ogreNodeChild->translate(0,0,-offset,Ogre::Node::TS_PARENT); // board Z axis is pointing down, so we need to negate offset // mesh is too big, rescale! const float scale = 0.01675f; ogreNode->setScale(scale, scale, scale); // Init animation ogreEntity->getSkeleton()->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE); baseAnim = ogreEntity->getAnimationState("RunBase"); topAnim = ogreEntity->getAnimationState("RunTop"); baseAnim->setLoop(true); topAnim->setLoop(true); baseAnim->setEnabled(true); topAnim->setEnabled(true); /// KEYBOARD INPUT READING size_t windowHnd = 0; window->getCustomAttribute("WINDOW", &windowHnd); im = OIS::InputManager::createInputSystem(windowHnd); keyboard = static_cast<OIS::Keyboard*>(im->createInputObject(OIS::OISKeyboard, true)); return 1; }
static void NotebookTabElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { if (qApp == NULL) NULL_Q_APP; NULL_PROXY_WIDGET(TileQt_QTabBar_Widget); int width = b.width, height = b.height; Tcl_MutexLock(&tileqtMutex); int PM_DefaultFrameWidth = 0, PM_TabBarBaseOverlap = 0; // TileQt_StateInfo(state, tkwin); #ifdef TILEQT_QT_VERSION_4 QStyleOptionTab::TabPosition position; int position_int; QStyleOptionTabV2 option; option.initFrom(wc->TileQt_QTabBar_Widget); option.state |= (QStyle::StateFlag) TileQt_StateTableLookup(notebook_statemap, state); #endif /* TILEQT_QT_VERSION_4 */ PM_DefaultFrameWidth = PM(PM_DefaultFrameWidth); if (TileQt_ThemeIs(wc, "bluecurve")) { PM_DefaultFrameWidth = 2; } PM_TabBarBaseOverlap = PM(PM_TabBarBaseOverlap); height += PM_TabBarBaseOverlap; if ((state & TTK_STATE_USER1) && (state & TTK_STATE_USER2)) { /* Only tab */ #ifdef TILEQT_QT_VERSION_4 wc->TileQt_QTabBar_Widget->addTab(""); position = QStyleOptionTab::OnlyOneTab; position_int = 0; #endif /* TILEQT_QT_VERSION_4 */ } else if (state & TTK_STATE_USER1) { /* Left-most tab */ #ifdef TILEQT_QT_VERSION_4 wc->TileQt_QTabBar_Widget->addTab(""); wc->TileQt_QTabBar_Widget->addTab(""); position = QStyleOptionTab::Beginning; position_int = 0; #endif /* TILEQT_QT_VERSION_4 */ } else if (state & TTK_STATE_USER2) { /* Right-most tab */ #ifdef TILEQT_QT_VERSION_4 wc->TileQt_QTabBar_Widget->addTab(""); wc->TileQt_QTabBar_Widget->addTab(""); position = QStyleOptionTab::End; position_int = 1; #endif /* TILEQT_QT_VERSION_4 */ } else { /* A regular tab, in the middle of tab bar */ #ifdef TILEQT_QT_VERSION_4 wc->TileQt_QTabBar_Widget->addTab(""); wc->TileQt_QTabBar_Widget->addTab(""); wc->TileQt_QTabBar_Widget->addTab(""); position = QStyleOptionTab::Middle; position_int = 1; #endif /* TILEQT_QT_VERSION_4 */ } #ifdef TILEQT_QT_VERSION_4 if (state & TTK_STATE_DISABLED) { wc->TileQt_QTabBar_Widget->setTabEnabled(position_int, false); } else wc->TileQt_QTabBar_Widget->setTabEnabled(position_int, true); #endif /* TILEQT_QT_VERSION_4 */ QPixmap pixmap(width, height); QPainter painter(&pixmap); TILEQT_PAINT_BACKGROUND(width, height); TILEQT_SET_FOCUS(state); #ifdef TILEQT_QT_VERSION_4 option.rect = QRect(0, 0, width, height); option.position = position; option.selectedPosition = QStyleOptionTab::NotAdjacent; wc->TileQt_Style->drawControl(QStyle::CE_TabBarTabShape, &option, &painter, wc->TileQt_QTabBar_Widget); #endif /* TILEQT_QT_VERSION_4 */ TILEQT_CLEAR_FOCUS(state); TileQt_CopyQtPixmapOnToDrawable(pixmap, d, tkwin, 0, 0, width, height, b.x, b.y + PM_DefaultFrameWidth); #ifdef TILEQT_QT_VERSION_4 for (int i = 0; i < wc->TileQt_QTabBar_Widget->count(); ++i) { wc->TileQt_QTabBar_Widget->removeTab(i); } #endif /* TILEQT_QT_VERSION_4 */ Tcl_MutexUnlock(&tileqtMutex); }
void CheckLoad(uint32 type, int16 id, uint16 *p, uint32 size) { uint16 *p16; uint32 base; D(bug("vCheckLoad %c%c%c%c (%08x) ID %d, data %p, size %d\n", type >> 24, (type >> 16) & 0xff, (type >> 8) & 0xff, type & 0xff, type, id, p, size)); // Don't modify resources in ROM if ((uintptr)p >= (uintptr)ROMBaseHost && (uintptr)p <= (uintptr)(ROMBaseHost + ROM_SIZE)) return; if (type == FOURCC('b','o','o','t') && id == 3) { D(bug("boot 3 found\n")); size >>= 1; while (size--) { if (PM(0,0x51c9) && PM(2,0x2e49)) { // Set boot stack pointer (7.5.2, 7.5.3, 7.5.5, 7.6, 7.6.1, 8.0, 8.1, 8.5, 8.6, 9.0) p[2] = htons(M68K_EMUL_OP_FIX_BOOTSTACK); D(bug(" patch 1 applied\n")); } else if (PM(0,0x4267) && PM(1,0x3f01) && PM(2,0x3f2a) && PM(3,0x0006) && PM(4,0x6100)) { // Check when ntrb 17 is installed (for native Resource Manager patch) (7.5.3, 7.5.5) p[7] = htons(M68K_EMUL_OP_NTRB_17_PATCH3); D(bug(" patch 2 applied\n")); } else if (PM(0,0x3f2a) && PM(1,0x0006) && PM(2,0x3f2a) && PM(3,0x0002) && PM(4,0x6100)) { // Check when ntrb 17 is installed (for native Resource Manager patch) (7.6, 7.6.1, 8.0, 8.1) p[7] = htons(M68K_EMUL_OP_NTRB_17_PATCH); D(bug(" patch 3 applied\n")); } else if (PM(0,0x3f2a) && PM(1,0x0006) && PM(2,0x3f2a) && PM(3,0x0002) && PM(4,0x61ff) && PM(8,0x245f)) { // Check when ntrb 17 is installed (for native Resource Manager patch) (8.5, 8.6) p[8] = htons(M68K_EMUL_OP_NTRB_17_PATCH); D(bug(" patch 4 applied\n")); } else if (PM(0,0x3f2a) && PM(1,0x0006) && PM(2,0x3f2a) && PM(3,0x0002) && PM(4,0x61ff) && PM(7,0x301f)) { // Check when ntrb 17 is installed (for native Resource Manager patch) (9.0) p[7] = htons(M68K_EMUL_OP_NTRB_17_PATCH4); p[8] = htons(ntohs(p[8]) & 0xf0ff); // bra D(bug(" patch 5 applied\n")); } else if (PM(0,0x0c39) && PM(1,0x0001) && PM(2,0xf800) && PM(3,0x0008) && PM(4,0x6f00)) { // Don't read from 0xf8000008 (8.5 with Zanzibar ROM, 8.6, 9.0) p[0] = htons(M68K_NOP); p[1] = htons(M68K_NOP); p[2] = htons(M68K_NOP); p[3] = htons(M68K_NOP); p[4] = htons(0x6000); // bra D(bug(" patch 6 applied\n")); } else if (PM(0,0x2f3c) && PM(1,0x6b72) && PM(2,0x6e6c) && PM(3,0x4267) && PM(4,0xa9a0) && PM(5,0x265f) && PM(6,0x200b) && PM(7,0x6700)) { // Don't replace nanokernel ("krnl" resource) (8.6, 9.0) p[0] = htons(M68K_NOP); p[1] = htons(M68K_NOP); p[2] = htons(M68K_NOP); p[3] = htons(M68K_NOP); p[4] = htons(M68K_NOP); p[7] = htons(0x6000); // bra D(bug(" patch 7 applied\n")); } else if (PM(0,0xa8fe) && PM(1,0x3038) && PM(2,0x017a) && PM(3,0x0c40) && PM(4,0x8805) && PM(5,0x6710)) { // No SCSI (calls via 0x205c jump vector which is not initialized in NewWorld ROM 1.6) (8.6) if (ROMType == ROMTYPE_NEWWORLD) { p[5] = htons(0x6010); // bra D(bug(" patch 8 applied\n")); } } else if (PM(0,0x2f3c) && PM(1,0x7665) && PM(2,0x7273) && PM(3,0x3f3c) && PM(4,0x0001) && PM(10,0x2041) && PM(11,0x2248) && PM(12,0x2050) && PM(20,0x7066) && PM(21,0xa9c9)) { // Check when vers 1 is installed (for safe abort if MacOS < 8.1 is used with a NewWorld ROM) p[10] = htons(M68K_EMUL_OP_CHECK_SYSV); p[11] = htons(0x4a81); // tst.l d1 p[12] = htons(0x670e); // beq.s <SysError #dsOldSystem> D(bug(" patch 9 applied\n")); } p++; } } else if (type == FOURCC('g','n','l','d') && id == 0) {
bool PowerSeriesWP::isTrivial(const Word& w) { // Construct two possible types of monomials: // PM: (1 + x) and NM: ( 1 - x + x^2 - x^3 + ... x^c ) int wLen = w.length(); int numOfGens = F.numberOfGenerators(); VectorOf<int> PM(c), NM(c); for( int i = 0; i < c; ++i ) { PM[i] = 0; if( odd(i+1) ) NM[i] = -1; else NM[i] = 1; } PM[0] = 1; // Construct all monomials VectorOf<int>* M[wLen]; for( int i = 0; i < wLen; ++i ) if( ord(Generator(w[i])) > 0 ) M[i] = &PM; else M[i] = &NM; // Enumerate all possible monomials and compute their coefficients. // They all are equal to 0 iff the word is trivial. VectorOf<int> v(c); for( int i = 0; i < c; ++i ) v[i] = 0; // The main cycle while( true ) { // Construct the current monomial v int i = c-1; while( true ) { if( ++v[i] <= numOfGens ) break; v[i--] = 1; if( i < 0 ) return true; } for( i = 0; i < c; ++i ) if( v[i] > 0 ) break; // Compute the sum of it's coefficients in M int sum = 0; Stack stack(c); State state(1, -1, i); bool checkPower = false; while( true ) { if( checkPower && v[state.vPos] == v[state.vPos + state.power] && (*M[state.wPos])[state.power] != 0 ) { //state.vPos += state.power; ++state.power; } else { ++state.wPos; state.power = 1; for( ; state.wPos < wLen; ++state.wPos ) if( abs(ord(Generator(w[state.wPos]))) == v[state.vPos] ) break; } if( state.wPos == wLen) { if( stack.length() == 0 ) break; stack.get(state); checkPower = true; } else { stack.put(state); if( checkPower ) { state.coef *= (*M[state.wPos])[state.power-1]; state.vPos += state.power; state.power = 1; } else { state.coef *= (*M[state.wPos])[0]; ++state.vPos; } checkPower = false; if( state.vPos >= c ) { sum += state.coef; stack.get(state); } } } #ifdef debug_fnwp cout << "Monomial: " << v << " Sum = " << sum << endl; #endif if( sum != 0 ) return false; } }
void printCPUInfo(int processor, const CPUInfo& info) { printf("Processor %d:\n", processor); if (!info.supportsCPUID) { printf(" No CPUID Support\n"); printf("\n"); return; } printf(" Vendor: %s\n", info.getVendorName()); printf(" Name: %s\n", info.getProcessorName().c_str()); printf(" Type: %s\n", info.getProcessorTypeName()); printf(" Brand: %s\n", info.getProcessorBrandName().c_str()); printf(" Classical Name: %s\n", info.getClassicalProcessorName()); printf("\n"); printf(" Family: %d\n", info.identity.family); printf(" Model: %d\n", info.identity.model); printf(" Stepping: %d\n", info.identity.stepping); printf("\n"); printf(" Frequency: %d MHz\n", info.frequency); printf("\n"); printf(" Features:\n"); bool featureflag = false; #define F(flag, desc) \ if (info.features.flag) { \ featureflag = true; \ printf(" %8s: %s\n", #flag, desc); \ } F(fpu, "Floating Point Unit"); F(vme, "Virtual-8086 Mode Enhancement"); F(de, "Debugging Extensions"); F(pse, "Page Size Extensions"); F(tsc, "Time Stamp Counter"); F(msr, "RDMSR and WRMSR Support"); F(pae, "Physical Address Extensions"); F(mce, "Machine Check Exception"); F(cx8, "CMPXCHG8B Instruction"); F(apic, "APIC on Chip"); F(sep, "SYSENTER and SYSEXIT"); F(mtrr, "Memory Type Range Registers"); F(pge, "PTE Global Bit"); F(mca, "Machine Check Architecture"); F(cmov, "Conditional Move/Compare Instructions"); F(pat, "Page Attribute Table"); F(pse36, "Page Size Extension"); F(serial, "Serial Number Available"); F(clfsh, "CLFLUSH Instruction"); F(ds, "Debug Store"); F(acpi, "Thermal Monitor and Clock Control"); F(mmx, "MMX Technology"); F(fxsr, "FXSAVE/FXRSTOR Instructions"); F(sse, "SSE Extensions"); F(ssefp, "SSE Floating Point"); F(sse2, "SSE2 Extensions"); F(ss, "Self Snoop"); F(htt, "Hyper-Threading Technology"); F(thermal, "Thermal Monitor"); F(ia64, "IA64 Instructions"); F(pbe, "Pending Break Enable"); F(sse3, "SSE3 Extensions"); F(monitor, "MONITOR/MWAIT"); F(ds_cpl, "CPL Qualified Debug Store"); F(est, "Enhanced Intel SpeedStep Technology"); F(tm2, "Thermal Monitor 2"); F(cnxt_id, "L1 Context ID"); F(_3dnow, "3DNow! Instructions"); F(_3dnowPlus, "3DNow! Instructions Extensions"); F(ssemmx, "SSE MMX"); F(mmxPlus, "MMX+"); F(supportsMP, "Supports Multiprocessing"); #undef F if (!featureflag) { printf(" None\n"); } printf("\n"); if (info.features.serial) { printf(" Serial Number: %s\n", info.features.serialNumber); } if (info.features.htt) { printf(" Logical Processors per Physical: %d\n", info.features.logicalProcessorsPerPhysical); } if (info.features.clfsh) { printf(" CLFLUSH Cache Line Size: %d bytes\n", info.features.CLFLUSHCacheLineSize); } if (info.features.apic) { printf(" APIC ID: %d\n", info.features.APIC_ID); } printf("\n"); printf(" Cache:\n"); if (info.cache.L1CacheSize != -1) { printf(" L1 Size: %d kB\n", info.cache.L1CacheSize); } if (info.cache.L2CacheSize != -1) { printf(" L2 Size: %d kB\n", info.cache.L2CacheSize); } if (info.cache.L3CacheSize != -1) { printf(" L3 Size: %d kB\n", info.cache.L3CacheSize); } printf("\n"); printf(" Enhanced Power Management:\n"); bool pmflag = false; #define PM(flag, desc) \ if (info.powerManagement.flag) { \ pmflag = true; \ printf(" %8s: %s\n", #flag, desc); \ } PM(ts, "Temperature Sensor"); PM(fid, "Frequency ID"); PM(vid, "Voltage ID"); PM(ttp, "Thermal Trip"); PM(tm, "Thermal Monitoring"); PM(stc, "Software Thermal Control"); #undef PM if (!pmflag) { printf(" None\n"); } printf("\n\n"); }
int main ( void ) { # if defined(VGO_darwin) // Mac OS X has neither memalign() nor posix_memalign(); do nothing. // Still true for 10.6 / 10.7 ? # else // Nb: assuming VG_MIN_MALLOC_SZB is 8 or more... int* p; int* piece; int res; assert(sizeof(long int) == sizeof(void*)); // Check behaviour of memalign/free for big alignment. // In particular, the below aims at checking that a // superblock with a big size is not marked as reclaimable // if the superblock is used to provide a big aligned block // (see bug 250101, comment #14). // Valgrind m_mallocfree.c will allocate a big superblock for the memalign // call and will split it in two. This split superblock was // wrongly marked as reclaimable, which was then causing // assert failures (as reclaimable blocks cannot be split). p = memalign(1024 * 1024, 4 * 1024 * 1024 + 1); assert(0 == (long)p % (1024 * 1024)); // We allocate (and then free) a piece of memory smaller than // the hole created in the big superblock. // If the superblock is marked as reclaimable, the below free(s) will cause // an assert. Note that the test has to be run with a --free-list-vol // parameter smaller than the released blocks size to ensure the free is directly // executed (otherwise memcheck does not really release the memory and so // the bug is not properly tested). piece = malloc(1024 * 1000); assert (piece); free (piece); free (p); // Same as above but do the free in the reverse order. p = memalign(1024 * 1024, 4 * 1024 * 1024 + 1); assert(0 == (long)p % (1024 * 1024)); piece = malloc(1024 * 100); assert (piece); free (p); free (piece); p = memalign(0, 100); assert(0 == (long)p % 8); p = memalign(1, 100); assert(0 == (long)p % 8); p = memalign(2, 100); assert(0 == (long)p % 8); p = memalign(3, 100); assert(0 == (long)p % 8); p = memalign(4, 100); assert(0 == (long)p % 8); p = memalign(5, 100); assert(0 == (long)p % 8); p = memalign(7, 100); assert(0 == (long)p % 8); p = memalign(8, 100); assert(0 == (long)p % 8); p = memalign(9, 100); assert(0 == (long)p % 16); p = memalign(31, 100); assert(0 == (long)p % 32); p = memalign(32, 100); assert(0 == (long)p % 32); p = memalign(33, 100); assert(0 == (long)p % 64); p = memalign(4095, 100); assert(0 == (long)p % 4096); p = memalign(4096, 100); assert(0 == (long)p % 4096); p = memalign(4097, 100); assert(0 == (long)p % 8192); p = memalign(4 * 1024 * 1024, 100); assert(0 == (long)p % (4 * 1024 * 1024)); p = memalign(16 * 1024 * 1024, 100); assert(0 == (long)p % (16 * 1024 * 1024)); # define PM(a,b,c) posix_memalign((void**)a, b, c) res = PM(&p, -1,100); assert(EINVAL == res); res = PM(&p, 0, 100); assert(0 == res && 0 == (long)p % 8); res = PM(&p, 1, 100); assert(EINVAL == res); res = PM(&p, 2, 100); assert(EINVAL == res); res = PM(&p, 3, 100); assert(EINVAL == res); res = PM(&p, sizeof(void*), 100); assert(0 == res && 0 == (long)p % sizeof(void*)); res = PM(&p, 31, 100); assert(EINVAL == res); res = PM(&p, 32, 100); assert(0 == res && 0 == (long)p % 32); res = PM(&p, 33, 100); assert(EINVAL == res); res = PM(&p, 4095, 100); assert(EINVAL == res); res = PM(&p, 4096, 100); assert(0 == res && 0 == (long)p % 4096); res = PM(&p, 4097, 100); assert(EINVAL == res); res = PM(&p, 4 * 1024 * 1024, 100); assert(0 == res && 0 == (long)p % (4 * 1024 * 1024)); res = PM(&p, 16 * 1024 * 1024, 100); assert(0 == res && 0 == (long)p % (16 * 1024 * 1024)); # endif return 0; }
int main (int argc, char *argv[]) { char * bptr, * eptr; int i; int html_mode = 0; char * enc_name = 0; char * tenc_name = 0; for (;;) { i = getopt (argc, argv, "hf:e:t:"); if (i == -1) break; switch (i) { case 'h': html_mode = 1; #ifdef UNIT_DEBUG printf ("HTML mode!\n"); #endif break; case 'e': enc_name = optarg; break; case 't': tenc_name = optarg; break; case 'f': f = fopen (optarg, "r"); if (f) break; perror ("can't open file\n"); exit (2); default: exit (-1); } } if (argc <= optind) { printf ("USAGE: %s 'STRING'\n", argv[0]); exit (-1); } /* dk_memory_initialize (); dk_alloc (1); */ bptr = argv[1]; eptr = bptr + strlen (bptr); bsize = argc - optind - 1; buf = malloc (bsize); for (i = optind + 1; i < bsize; i++) buf[i] = strtol (argv[i + 2], 0, 0); for (i = 0; i < 1; i++) { parser = XML_ParserCreate (tenc_name); printf ("sizeof (*parser) = %d\n", sizeof (*parser)); XML_SetEntityEncoding (parser, enc_name); XML_ParserInput (parser, ff, 0); XML_SetElementHandler (parser, start_element_handler, end_element_handler); XML_SetCharacterDataHandler (parser, cdh); XML_SetEntityRefHandler (parser, erh); if (XML_Parse (parser, argv[optind], strlen (argv[optind]), 1)) printf ("Successfully parsed!\n"); else if (PM(err)) printf ("ERROR %d: %s\n", PM(err), XML_ErrorString (PM(err))); XML_ParserFree (parser); } exit (0); }
// Methods for class Direct3D //////////////////////////////////////////// // In place of constructor, mainly so that there can be a return value HRESULT Direct3D::Init(HWND Window, // Window to initialize in INT ScreenWidth, // ScreenWidth INT ScreenHeight, // ScreenHeight BOOL FreeForm) // Whether to initialize in freeform mode { // Set the freeform member to the value passed IsFreeForm = FreeForm; static DDSURFACEDESC2 SD; static HRESULT Return; // First, if this is a freeform initialization, we need to copy the screen to a // DC owned by this module HDC Screen; HBITMAP ScreenData; if(IsFreeForm) { // Force GDI to repaint the screen InvalidateRect(0, 0, FALSE); // wait for repaint to finish Sleep(500); HDC Desktop = GetDC(0); Screen = CreateCompatibleDC(Desktop); ScreenData = CreateCompatibleBitmap(Desktop, ScreenWidth, ScreenHeight); SelectObject(Screen, ScreenData); StretchBlt(Screen, 0, 0, ScreenWidth, ScreenHeight, Desktop, 0, 0, ScreenWidth, ScreenHeight, SRCCOPY); ReleaseDC(0, Desktop); } // end if else ShowCursor(0); // Create the master DirectDraw interface Return = DirectDrawCreateEx(0, (LPVOID*)&DirectDraw, IID_IDirectDraw7, 0); if(FAILED(Return)) return Return; // Set the cooperative level with other apps, allow ctrl-alt-delete and that's about it Return = DirectDraw->SetCooperativeLevel(Window, DDSCL_ALLOWREBOOT | DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE); if(FAILED(Return)) return Return; // Set the display mode Return = DirectDraw->SetDisplayMode(ScreenWidth, ScreenHeight, 16, // Force 16 bit color 0, 0); if(FAILED(Return)) return Return; // Create the backbuffer's clipper Return = DirectDraw->CreateClipper(0, &Clipper, 0); if(FAILED(Return)) return Return; // Set the clipper's clip list -- do it the easy way Return = Clipper->SetHWnd(0, Window); if(FAILED(Return)) return Return; // Create the primary surface ZeroMemory(&SD, sizeof(SD)); SD.dwSize = sizeof(SD); SD.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; SD.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_3DDEVICE | DDSCAPS_COMPLEX; SD.dwBackBufferCount = 1; Return = DirectDraw->CreateSurface(&SD, &PrimarySurface, 0); if(FAILED(Return)) return Return; // Get the attached surface (backbuffer) static DDSCAPS2 C; ZeroMemory(&C, sizeof(C)); C.dwCaps = DDSCAPS_BACKBUFFER; Return = PrimarySurface->GetAttachedSurface(&C, &BackBuffer); if(FAILED(Return)) return Return; // Attach the clipper to the backbuffer Return = BackBuffer->SetClipper(Clipper); if(FAILED(Return)) return Return; // Get master 3D interface Return = DirectDraw->QueryInterface(IID_IDirect3D7, (LPVOID*)&D3D); if(FAILED(Return)) return Return; // Create the zbuffer, not a fun thing to do // Stores the INT ZBufFormat = 0; // Enumerate the Z-buffer formats, making sure they fit the device. // First try hardware with accelerated transform and lighting. // If you cannot get that, just keep trying with worse and worse devices :) static DDPIXELFORMAT ZBufferPF; ZeroMemory(&ZBufferPF, sizeof(ZBufferPF)); ZBufferPF.dwSize = sizeof(ZBufferPF); ZBufferPF.dwFlags = DDPF_ZBUFFER ; D3D->EnumZBufferFormats( IID_IDirect3DTnLHalDevice, EnumZBufferFormatsCallback, (VOID*)&ZBufferPF ); if(ZBufFound) ZBufFormat = 1; else { D3D->EnumZBufferFormats( IID_IDirect3DHALDevice, EnumZBufferFormatsCallback, (VOID*)&ZBufferPF ); if(ZBufFound) ZBufFormat=2; else { D3D->EnumZBufferFormats( IID_IDirect3DMMXDevice, EnumZBufferFormatsCallback, (VOID*)&ZBufferPF ); if(ZBufFound) ZBufFormat=3; else { D3D->EnumZBufferFormats( IID_IDirect3DRGBDevice, EnumZBufferFormatsCallback, (VOID*)&ZBufferPF ); if(ZBufFound) ZBufFormat=4; } // end else } // end else } // end else // Create the zbuffer ZeroMemory(&SD, sizeof(SD)); SD.dwSize = sizeof(SD); SD.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; // Use counter to check if we should create z-buffer in video or system memory // Note flag that specifies that this is a z-buffer surface. if(ZBufFormat<3) SD.ddsCaps.dwCaps = DDSCAPS_ZBUFFER|DDSCAPS_VIDEOMEMORY; else SD.ddsCaps.dwCaps = DDSCAPS_ZBUFFER|DDSCAPS_SYSTEMMEMORY; // Set it the to size of screen SD.dwWidth = ScreenWidth; SD.dwHeight = ScreenHeight; SD.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT); SD.ddpfPixelFormat.dwFlags = DDPF_ZBUFFER; memcpy(&SD.ddpfPixelFormat, &ZBufferPF, sizeof(DDPIXELFORMAT)); Return = DirectDraw->CreateSurface(&SD, &ZBuffer, 0); if(FAILED(Return)) return Return; // Attach z-buffer to the backbuffer... Return = BackBuffer->AddAttachedSurface(ZBuffer); if(FAILED(Return)) return Return; // Set up the best hardware interface, really dumb, brute-forcish way to do it if(FAILED(D3D->CreateDevice(IID_IDirect3DTnLHalDevice, BackBuffer, &D3DDevice))) if(FAILED(D3D->CreateDevice(IID_IDirect3DHALDevice, BackBuffer, &D3DDevice))) if(FAILED(D3D->CreateDevice(IID_IDirect3DMMXDevice, BackBuffer, &D3DDevice))) if(FAILED(Return = D3D->CreateDevice(IID_IDirect3DRGBDevice, BackBuffer, &D3DDevice))) return Return; // Report the error // Set up the viewport for the new screen size D3DVIEWPORT7 Viewport; Viewport.dwX = 0; Viewport.dwY = 0; Viewport.dwWidth = ScreenWidth; Viewport.dwHeight = ScreenHeight; Viewport.dvMinZ = 0.0f; Viewport.dvMaxZ = 1.0f; Return = D3DDevice->SetViewport(&Viewport); if(FAILED(Return)) return Return; // Set up a nice projection matrix D3DMATRIX PM(3, 0, 0, 0, 0, 4, 0, 0, 0, 0, 1, 1, 0, 0, -5, 0); // Apply the projection matrix Return = D3DDevice->SetTransform(D3DTRANSFORMSTATE_PROJECTION, &PM); if(FAILED(Return)) return Return; // Turn on some nice texture filtering Return = D3DDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE); if(FAILED(Return)) return Return; Return = D3DDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE); if(FAILED(Return)) return Return; Return = D3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE); if(FAILED(Return)) return Return; Return = D3DDevice->SetTextureStageState(0, D3DTSS_MINFILTER, D3DTFN_LINEAR); if(FAILED(Return)) return Return; Return = D3DDevice->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTFG_LINEAR); if(FAILED(Return)) return Return; // Enable z-buffering. Return = D3DDevice->SetRenderState(D3DRENDERSTATE_ZENABLE, D3DZB_USEW); if(FAILED(Return)) return Return; Return = D3DDevice->SetRenderState(D3DRENDERSTATE_ZFUNC, D3DCMP_LESSEQUAL); if(FAILED(Return)) return Return; // Enable Direct3D lighting Return = D3DDevice->SetRenderState(D3DRENDERSTATE_LIGHTING, TRUE); if(FAILED(Return)) return Return; Return = D3DDevice->SetRenderState(D3DRENDERSTATE_SPECULARENABLE, FALSE); if(FAILED(Return)) return Return; // Just to be safe, disable backface culling Return = D3DDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, D3DCULL_NONE); if(FAILED(Return)) return Return; // Turn on dithering Return = D3DDevice->SetRenderState(D3DRENDERSTATE_DITHERENABLE, TRUE); if(FAILED(Return)) return Return; // Do any freeform initialization if(IsFreeForm) { // Get a copy of the GDI surface ZeroMemory(&SD, sizeof(SD)); SD.dwSize = sizeof(SD); SD.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS; SD.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; SD.dwWidth = ScreenWidth; SD.dwHeight = ScreenHeight; Return = DirectDraw->CreateSurface(&SD, &GDIScreenShot, 0); if(FAILED(Return)) return(Return); HDC xdc; GDIScreenShot->GetDC(&xdc); StretchBlt(xdc, 0, 0, ScreenWidth, ScreenHeight, Screen, 0, 0, ScreenWidth, ScreenHeight, SRCCOPY); GDIScreenShot->ReleaseDC(xdc); // Clean up the GDI memory DeleteDC(Screen); DeleteObject(ScreenData); } // end if // Return success return(D3D_OK); } // end Direct3D::Init
Function * futamurize( const Function * orig_func, DenseMap<const Value*, Value*> &argmap, std::set<const unsigned char *> &constant_addresses_set ) { LLVMContext &context = getGlobalContext(); // Make a copy of the function, removing constant arguments Function * specialized_func = CloneFunction( orig_func, argmap ); specialized_func->setName( orig_func->getNameStr() + "_1" ); // add it to our module LLVM_Module->getFunctionList().push_back( specialized_func ); printf("\nspecialized_func = %p <%s>\n", specialized_func, specialized_func->getName().data()); //~ specialized_func->dump(); // Optimize it FunctionPassManager PM( LLVM_Module ); createStandardFunctionPasses( &PM, 3 ); PM.add(createScalarReplAggregatesPass()); // Break up aggregate allocas PM.add(createInstructionCombiningPass()); // Cleanup for scalarrepl. PM.add(createJumpThreadingPass()); // Thread jumps. PM.add(createCFGSimplificationPass()); // Merge & remove BBs PM.add(createInstructionCombiningPass()); // Combine silly seq's PM.add(createTailCallEliminationPass()); // Eliminate tail calls PM.add(createCFGSimplificationPass()); // Merge & remove BBs PM.add(createReassociatePass()); // Reassociate expressions PM.add(createLoopRotatePass()); // Rotate Loop PM.add(createLICMPass()); // Hoist loop invariants PM.add(createLoopUnswitchPass( false )); PM.add(createInstructionCombiningPass()); PM.add(createIndVarSimplifyPass()); // Canonicalize indvars PM.add(createLoopDeletionPass()); // Delete dead loops PM.add(createLoopUnroll2Pass()); // Unroll small loops PM.add(createInstructionCombiningPass()); // Clean up after the unroller PM.add(createGVNPass()); // Remove redundancies PM.add(createMemCpyOptPass()); // Remove memcpy / form memset PM.add(createSCCPPass()); // Constant prop with SCCP PM.add(createPromoteMemoryToRegisterPass()); PM.add(createConstantPropagationPass()); PM.add(createDeadStoreEliminationPass()); PM.add(createAggressiveDCEPass()); PM.add(new MemoryDependenceAnalysis()); //~ PM.add(createAAEvalPass()); const PassInfo * pinfo = Pass::lookupPassInfo( "print-alias-sets" ); if( !pinfo ) { printf( "print-alias-sets not found\n" ); exit(-1); } PM.add( pinfo->createPass() ); FunctionPassManager PM_Inline( LLVM_Module ); PM_Inline.add(createSingleFunctionInliningPass()); bool Changed = false; int iterations = 2; int inline_iterations = 6; do { Changed = false; // first do some optimizations PM.doInitialization(); PM.run( *specialized_func ); PM.doFinalization(); // Load from Constant Memory detection const TargetData *TD = LLVM_EE->getTargetData(); for (inst_iterator I = inst_begin(specialized_func), E = inst_end(specialized_func); I != E; ++I) { Instruction * inst = (Instruction *) &*I; // get all Load instructions LoadInst * load = dyn_cast<LoadInst>( inst ); if( !load ) continue; if( load->isVolatile() ) continue; if (load->use_empty()) continue; // Don't muck with dead instructions... // get the address loaded by load instruction Value *ptr_value = load->getPointerOperand(); // we're only interested in constant addresses ConstantExpr * ptr_constant_expr = dyn_cast<ConstantExpr>( ptr_value ); if( !ptr_constant_expr ) continue; ptr_constant_expr->dump(); // compute real address of constant pointer expression Constant * ptr_constant = ConstantFoldConstantExpression( ptr_constant_expr, TD ); if( !ptr_constant ) continue; ptr_constant->dump(); // convert to int constant ConstantInt *int_constant = dyn_cast<ConstantInt>( ConstantExpr::getPtrToInt( ptr_constant, Type::getInt64Ty( context ))); if( !int_constant ) continue; int_constant->dump(); // get data size int data_length = TD->getTypeAllocSize( load->getType() ); ptr_value->getType()->dump(); // get real address (at last !) const unsigned char * c_ptr = (const unsigned char *) int_constant->getLimitedValue(); printf( "%ld %d %d\n", c_ptr, constant_addresses_set.count( c_ptr ), data_length ); // check what's in this address int isconst = 1; for( int offset=0; offset<data_length; offset++ ) isconst &= constant_addresses_set.count( c_ptr + offset ); if( !isconst ) continue; printf( "It is constant.\n" ); // make a LLVM const with the data Constant *new_constant = NULL; switch( data_length ) { case 1: new_constant = ConstantInt::get( Type::getInt8Ty( context ), *(uint8_t*)c_ptr, false /* signed */ ); break; case 2: new_constant = ConstantInt::get( Type::getInt16Ty( context ), *(uint16_t*)c_ptr, false /* signed */ ); break; case 4: new_constant = ConstantInt::get( Type::getInt32Ty( context ), *(uint32_t*)c_ptr, false /* signed */ ); break; case 8: new_constant = ConstantInt::get( Type::getInt64Ty( context ), *(uint64_t*)c_ptr, false /* signed */ ); break; default: { StringRef const_data ( (const char *) c_ptr, data_length ); new_constant = ConstantArray::get( context, const_data, false /* dont add terminating null */ ); } } if( !new_constant ) continue; new_constant->dump(); //~ // get the type that is loaded const Type *Ty = load->getType(); // do we need a cast ? if( load->getType() != new_constant->getType() ) { new_constant = ConstantExpr::getBitCast( new_constant, Ty ); new_constant->dump(); } // zap the load and replace with constant address load->replaceAllUsesWith( new_constant ); printf( "\nREPLACED :...\n" ); load->dump(); new_constant->dump(); Changed = true; } if( Changed ) continue; // re-optimize and do another pass of constant load elimination // if we can't do anything else, do an inlining pass if( inline_iterations > 0 ) { inline_iterations --; PM_Inline.doInitialization(); Changed |= PM_Inline.run( *specialized_func ); PM_Inline.doFinalization(); //~ for( int i=0; i<3; i++ ) { PM.doInitialization(); Changed |= PM.run( *specialized_func ); PM.doFinalization(); } } if( iterations>0 && !Changed ) iterations--; } while( Changed || iterations>0 ); return specialized_func; }