ExecutionEngine * JIT_to_ExecutionEngine (Module * m) { InitializeNativeTarget(); InitializeNativeTargetAsmPrinter(); InitializeNativeTargetAsmParser(); PassRegistry * Registry = PassRegistry::getPassRegistry(); initializeCore(*Registry); initializeCodeGen(*Registry); initializeLowerIntrinsicsPass(*Registry); std::string errMessage; EngineBuilder builder{std::unique_ptr<Module>(m)}; builder.setErrorStr(&errMessage); builder.setMCPU(sys::getHostCPUName()); TargetOptions opts = InitTargetOptionsFromCodeGenFlags(); builder.setTargetOptions(opts); CodeGenOpt::Level optLevel = CodeGenOpt::Level::None; switch (OptLevel) { case '0': optLevel = CodeGenOpt::None; break; case '1': optLevel = CodeGenOpt::Less; break; case '2': optLevel = CodeGenOpt::Default; break; case '3': optLevel = CodeGenOpt::Aggressive; break; default: errs() << OptLevel << " is an invalid optimization level.\n"; } builder.setOptLevel(optLevel); if ((strncmp(lGetSystemISA(), "avx2", 4) == 0)) { std::vector<std::string> attrs; attrs.push_back("avx2"); builder.setMAttrs(attrs); } // builder.selectTarget(); if (LLVM_UNLIKELY(DumpGeneratedIR)) { if (IROutputFilename.empty()) { m->dump(); } else { std::error_code error; llvm::raw_fd_ostream out(IROutputFilename, error, sys::fs::OpenFlags::F_None); m->print(out, nullptr); } } ExecutionEngine * engine = builder.create(); ICGrepObjectCache * cache = nullptr; if (engine == nullptr) { throw std::runtime_error("Could not create ExecutionEngine: " + errMessage); } if (EnableObjectCache) { if (ObjectCacheDir.empty()) // Default is $HOME/.cache/icgrep cache = new ICGrepObjectCache(); else cache = new ICGrepObjectCache(ObjectCacheDir); engine->setObjectCache(cache); } return engine; }
int main (int argc,const char **argv) { int argvStep; unsigned int currentNode; unsigned int currentCore; Processor *processor; PState ps(0); bool autoRecall=false; int autoRecallTimer=60; CfgManager *cfgInstance; int errorLine; Scaler *scaler; int rv; int parsed = 0; int parsed_set = 0; printf ("TurionPowerControl %s (%s) %s\n", _VERSION, _SOURCE_VERSION, _TARGET_OS); printf ("Turion Power States Optimization and Control - by blackshard\n\n"); if (argc<2) { printUsage(argv[0]); return 0; } if (initializeCore() == false) { return -1; } processor=getSupportedProcessor (); if (processor==NULL) { printf ("No supported processor detected, sorry.\n"); return -2; } //Initializes currentNode and currentCore currentNode=processor->ALL_NODES; currentCore=processor->ALL_CORES; //Initializes the scaler based on the processor found in the system scaler=new Scaler (processor); for (argvStep = 1; ; argvStep++) { if (argvStep == argc) { if (!autoRecall) break; //Autorecall feature set argvStep back to 1 when it reaches end printf("Autorecall activated. Timeout: %d seconds\n", autoRecallTimer); Sleep(autoRecallTimer * 1000); printf("Autorecalling...\n"); argvStep = 1; } //Reinitializes the processor object for active node and core in the system processor->setNode(currentNode); processor->setCore(currentCore); //printf ("Parsing argument %d %s\n",argvStep,argv[argvStep]); if (parsed_set) { printf("ERROR: -set can only be used exclusively\n"); break; } parsed++; //List power states action if (strcmp(argv[argvStep], "-l") == 0) { processorStatus (processor); continue; } //Set the current operational node if (strcmp(argv[argvStep], "-node") == 0) { unsigned int thisNode; const char *arg = argv[argvStep + 1]; if (arg == NULL) { printf("-node requires an argument\n"); break; } if (strcmp(arg, "all") != 0) { if (requireUnsignedInteger(argc, argv, argvStep + 1, &thisNode)) { printf("ERROR: invalid -node -- %s\n", arg); break; } if (thisNode >= processor->getProcessorNodes()) { printf("ERROR: node must be in 0-%u range\n", processor->getProcessorNodes() - 1); break; } currentNode = thisNode; } else { currentNode = processor->ALL_NODES; } argvStep++; continue; } //Set the current operational core if (strcmp(argv[argvStep], "-core") == 0) { unsigned int thisCore; const char *arg = argv[argvStep + 1]; if (arg == NULL) { printf("ERROR: -core requires an argument\n"); break; } if (strcmp(arg, "all") != 0) { if (requireUnsignedInteger(argc, argv, argvStep + 1, &thisCore)) { printf("ERROR: invalid -core -- %s\n", arg); break; } if (thisCore >= processor->getProcessorCores()) { printf("ERROR: core must be in 0-%u range\n", processor->getProcessorCores() - 1); break; } currentCore = thisCore; } else { currentCore = processor->ALL_CORES; } argvStep++; continue; } rv = parseSingleSetSubcommand(processor, argc, argv, argvStep, 1, &ps); if (rv >= 0) { printf("\n"); argvStep = rv - 1; continue; } if (rv == PARSE_WRONG_FORMAT) { break; } if (strcmp(argv[argvStep], "-nbvid") == 0) { unsigned int nbvid; if (argv[argvStep + 1] == NULL) { printf ("ERROR: -nbvid requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &nbvid)) { printf("ERROR: invalid NBVid -- %s\n", argv[argvStep + 1]); break; } if (processor->getProcessorIdentifier() == PROCESSOR_10H_FAMILY) { processor->setNBVid (ps, nbvid); print_stat(processor, ps, "nbvid", nbvid, PRINT_STAT_FLAG_NODE | PRINT_STAT_FLAG_PSTATE); if (processor->getNBVid(ps) != nbvid) printf(" (actual: %d)", processor->getNBVid(ps)); printf("\n\n"); } else { processor->setNBVid (nbvid); print_stat(processor, ps, "nbvid", nbvid, PRINT_STAT_FLAG_NODE); if (processor->getNBVid() != nbvid) printf(" (actual: %d)", processor->getNBVid()); printf("\n\n"); } argvStep = argvStep + 1; continue; } if (strcmp(argv[argvStep], "-nbdid") == 0) { if (processor->getProcessorIdentifier() == PROCESSOR_10H_FAMILY) { unsigned int nbdid; if (argv[argvStep + 1] == NULL) { printf("ERROR: -nbdid requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &nbdid)) { printf("ERROR: invalid NBDid -- %s\n", argv[argvStep + 1]); break; } processor->setNBDid (ps, nbdid); print_stat(processor, ps, "nbdid", nbdid, PRINT_STAT_FLAG_NODE | PRINT_STAT_FLAG_PSTATE); if (processor->getNBDid(ps) != nbdid) printf(" (actual: %d)", processor->getNBDid(ps)); printf("\n\n"); argvStep = argvStep + 1; } else { printf("ERROR: -nbdid is only supported on family 10h processors\n"); break; } continue; } if (strcmp(argv[argvStep], "-nbfid") == 0) { unsigned int nbfid; if (argv[argvStep + 1] == NULL) { printf ("ERROR: -nbfid requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &nbfid)) { printf("ERROR: invalid NBFid -- %s\n", argv[argvStep + 1]); break; } processor->setNBFid(nbfid); print_stat(processor, ps, "nbfid", nbfid, PRINT_STAT_FLAG_NODE); if (processor->getNBFid() != nbfid) printf(" (actual: %d)", processor->getNBFid()); printf("\n\n"); argvStep += 1; continue; } /* * Following section will set a new frequency for selected pstate/core/node */ if (strcmp(argv[argvStep], "-nbfreq") == 0 || strcmp(argv[argvStep], "-nbf") == 0 || strcmp(argv[argvStep], "-nbfrequency") == 0) { unsigned int nbfrequency; if (argv[argvStep + 1] == NULL) { printf("ERROR: %s requires an argument\n", argv[argvStep]); return -1; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &nbfrequency)) { printf("ERROR: invalid nbfrequency -- %s\n", argv[argvStep + 1]); return -1; } if (processor->getProcessorIdentifier() == PROCESSOR_10H_FAMILY) { processor->setNBFrequency(ps, nbfrequency); print_stat(processor, ps, "nbfrequency", nbfrequency, PRINT_STAT_FLAG_NODE | PRINT_STAT_FLAG_PSTATE); if (processor->getNBFrequency(ps) != nbfrequency) printf(" (actual: %d)", processor->getNBFrequency(ps)); printf("\n\n"); } else { processor->setNBFrequency(nbfrequency); print_stat(processor, ps, "nbfrequency", nbfrequency, PRINT_STAT_FLAG_NODE); if (processor->getNBFrequency() != nbfrequency) printf(" (actual: %d)", processor->getNBFrequency()); printf("\n\n"); } argvStep++; continue; } //Enables a specified PState for current cores and current nodes if (strcmp(argv[argvStep], "-en") == 0) { unsigned int pstate; if (argv[argvStep + 1] == NULL) { printf ("ERROR: -en requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &pstate)) { printf("ERROR: -en: invalid P-state -- %s\n", argv[argvStep + 1]); break; } if (pstate >= processor->getPowerStates()) { printf("ERROR: -en: P-state must be in 0-%u range\n", processor->getPowerStates() - 1); break; } processor->pStateEnable(pstate); argvStep++; continue; } //Disables a specified PState for current cores and current nodes if (strcmp(argv[argvStep], "-di") == 0) { unsigned int pstate; if (argv[argvStep + 1] == NULL) { printf ("ERROR: -di requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &pstate)) { printf("ERROR: -di: invalid P-state -- %s\n", argv[argvStep + 1]); break; } if (pstate >= processor->getPowerStates()) { printf("ERROR: -di: P-state must be in 0-%u range\n", processor->getPowerStates() - 1); break; } processor->pStateDisable(pstate); argvStep++; continue; } //Set maximum PState for current nodes if (strcmp(argv[argvStep], "-psmax") == 0) { unsigned int pstate; if (argv[argvStep + 1] == NULL) { printf ("ERROR: -psmax requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &pstate)) { printf("ERROR: invalid P-state -- %s\n", argv[argvStep + 1]); break; } if (pstate >= processor->getPowerStates()) { printf("ERROR: P-state must be in 0-%u range\n", processor->getPowerStates() - 1); break; } processor->setMaximumPState(pstate); argvStep++; continue; } //Force transition to a pstate for current cores and current nodes if (strcmp(argv[argvStep], "-fo") == 0) { unsigned int pstate; if (argv[argvStep + 1] == NULL) { printf ("ERROR: -fo requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &pstate)) { printf("ERROR: -fo: invalid P-state -- %s\n", argv[argvStep + 1]); break; } if (pstate >= processor->getPowerStates() - processor->getBoostStates()) { printf("ERROR: -fo: P-state (software P-state) must be in 0-%u range\n", processor->getPowerStates() - processor->getBoostStates() - 1); break; } processor->forcePState(pstate); argvStep++; continue; } if (strcmp(argv[argvStep], "-bst") == 0) { unsigned int numBoostStates; if (argv[argvStep + 1] == NULL) { printf ("ERROR: -bst requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &numBoostStates)) { printf("ERROR: invalid numBoostStates -- %s\n", argv[argvStep + 1]); break; } processor->setNumBoostStates(numBoostStates); argvStep++; continue; } //Show temperature table if (strcmp(argv[argvStep], "-temp") == 0) { processorTempStatus(processor); continue; } //Set vsSlamTime for current nodes if (strcmp(argv[argvStep], "-slamtime") == 0) { unsigned int slamtime; if (argv[argvStep + 1] == NULL) { printf ("ERROR: -slamtime requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &slamtime)) { printf("ERROR: invalid slamtime -- %s\n", argv[argvStep + 1]); break; } processor->setSlamTime(slamtime); argvStep++; continue; } //Set vsAltVIDSlamTime for current nodes if (strcmp(argv[argvStep], "-altvidslamtime") == 0) { unsigned int altvidslamtime; if (argv[argvStep + 1] == NULL) { printf ("ERROR: -altvidslamtime requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &altvidslamtime)) { printf("ERROR: invalid altvidslamtime -- %s\n", argv[argvStep + 1]); break; } processor->setAltVidSlamTime(altvidslamtime); argvStep++; continue; } //Set Ramp time for StepUpTime for current nodes if (strcmp(argv[argvStep], "-rampuptime") == 0) { unsigned int rampuptime; if (argv[argvStep + 1] == NULL) { printf ("ERROR: -rampuptime requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &rampuptime)) { printf("ERROR: invalid rampuptime -- %s\n", argv[argvStep + 1]); break; } processor->setStepUpRampTime(rampuptime); argvStep++; continue; } //Set Ramp time for StepDownTime for current nodes if (strcmp(argv[argvStep], "-rampdowntime") == 0) { unsigned int rampdowntime; if (argv[argvStep + 1] == NULL) { printf ("ERROR: -rampdowntime requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &rampdowntime)) { printf("ERROR: invalid rampdowntime -- %s\n", argv[argvStep + 1]); break; } processor->setStepDownRampTime(rampdowntime); argvStep++; continue; } if (strcmp(argv[argvStep], "-gettdp") == 0) { processor->getTDP(); continue; } //Show information about per-family specifications if (strcmp(argv[argvStep], "-spec") == 0) { processor->showFamilySpecs(); continue; } //Show information about DRAM timing register if (strcmp(argv[argvStep], "-dram") == 0) { processor->showDramTimings(); continue; } //Show information about HTC registers status if (strcmp(argv[argvStep], "-htc") == 0) { processor->showHTC(); continue; } //Enables HTC Features for current nodes if (strcmp(argv[argvStep], "-htcenable") == 0) { processor->HTCEnable(); continue; } //Disables HTC Features for current nodes if (strcmp(argv[argvStep], "-htcdisable") == 0) { processor->HTCDisable(); continue; } //Set HTC temperature limit for current nodes if (strcmp(argv[argvStep], "-htctemplimit") == 0) { unsigned int htctemplimit; if (argv[argvStep + 1] == NULL) { printf("ERROR: -htctemplimit requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &htctemplimit)) { printf("ERROR: invalid htctemplimit -- %s\n", argv[argvStep + 1]); break; } processor->HTCsetTempLimit(htctemplimit); argvStep++; continue; } //Set HTC hysteresis limit for current nodes if (strcmp(argv[argvStep], "-htchystlimit") == 0) { unsigned int htchystlimit; if (argv[argvStep + 1] == NULL) { printf("ERROR: -htchystlimit requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &htchystlimit)) { printf("ERROR: invalid htchystlimit -- %s\n", argv[argvStep + 1]); break; } processor->HTCsetHystLimit(htchystlimit); argvStep++; continue; } //Set AltVID for current nodes if (strcmp(argv[argvStep], "-altvid") == 0) { unsigned int altvid; if (argv[argvStep + 1] == NULL) { printf("ERROR: -altvid requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &altvid)) { printf("ERROR: invalid altvid -- %s\n", argv[argvStep + 1]); break; } processor->setAltVid(altvid); argvStep++; continue; } //Show information about Hypertransport registers if (strcmp(argv[argvStep], "-htstatus") == 0) { processor->showHTLink(); continue; } //Set Hypertransport Link frequency for current nodes if (strcmp(argv[argvStep], "-htset") == 0) { unsigned int reg; unsigned int value; if ((argv[argvStep + 1] == NULL) || (argv[argvStep + 2] == NULL)) { printf("ERROR: -htset requires two arguments (register, value)\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, ®)) { printf("ERROR: invalid register -- %s\n", argv[argvStep + 1]); break; } if (requireUnsignedInteger(argc, argv, argvStep + 2, &value)) { printf("ERROR: invalid value -- %s\n", argv[argvStep + 2]); break; } processor->setHTLinkSpeed(reg, value); argvStep += 2; continue; } //Enables PSI_L bit for current nodes if (strcmp(argv[argvStep], "-psienable") == 0) { processor->setPsiEnabled (true); continue; } //Disables PSI_L bit for current nodes if (strcmp(argv[argvStep], "-psidisable") == 0) { processor->setPsiEnabled (false); continue; } //Set PSI_L bit threshold for current nodes if (strcmp(argv[argvStep], "-psithreshold") == 0) { unsigned int psithreshold; if (argv[argvStep + 1] == NULL) { printf("ERROR: -psithreshold requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &psithreshold)) { printf("ERROR: invalid psithreshold -- %s\n", argv[argvStep + 1]); break; } if (processor->getPsiEnabled() == true) { printf("ERROR: PSI enabled; disable PSI before changing PSI threshold\n"); break; } printf("WARNING: changing PSI threshold may cause permanent damage to your hardware!\n\n"); processor->setPsiThreshold(psithreshold); argvStep++; continue; } //Set C1E enabled on current nodes and current cores if (strcmp(argv[argvStep], "-c1eenable") == 0) { processor->setC1EStatus(true); continue; } //Set C1E disabled on current nodes and current cores if (strcmp(argv[argvStep], "-c1edisable") == 0) { processor->setC1EStatus(false); continue; } //Set Boost state to enabled for supported processors if (strcmp(argv[argvStep], "-boostenable") == 0) { processor->setBoost(true); continue; } //Set Boost state to disabled for supported processors if (strcmp(argv[argvStep], "-boostdisable") == 0) { processor->setBoost(false); continue; } //Goes in temperature monitoring if (strcmp(argv[argvStep], "-mtemp") == 0) { processorTempMonitoring(processor); continue; } //Goes into Check Mode and controls very fastly if a transition to a wrong pstate happens if (strcmp(argv[argvStep], "-CM") == 0) { processor->checkMode(); continue; } //Allow cyclic parameter auto recall if (strcmp(argv[argvStep], "-autorecall") == 0) { if (autoRecall == false) { autoRecall = true; autoRecallTimer = 60; } continue; } //Get general info about Performance counters if (strcmp(argv[argvStep], "-pcgetinfo") == 0) { processor->perfCounterGetInfo(); continue; } //Get Performance counter value about a specific performance counter if (strcmp(argv[argvStep], "-pcgetvalue") == 0) { unsigned int counter; if (argv[argvStep + 1] == NULL) { printf("ERROR: -pcgetvalue requires an argument\n"); break; } if (requireUnsignedInteger(argc, argv, argvStep + 1, &counter)) { printf("ERROR: invalid counter -- %s\n", argv[argvStep + 1]); break; } processor->perfCounterGetValue(counter); argvStep++; continue; } //Costantly monitors Performance counter value about a specific performance counter if (strcmp(argv[argvStep], "-pcmonitor") == 0) { printf("ERROR: -pcmonitor is currently not implemented\n"); break; } //Handle -set switch. That is a user friendly way to set up a pstate or a pstate/core //with frequency value and voltage value. if (strcmp(argv[argvStep], "-set") == 0) { parsed_set++; if (parsed - parsed_set) { printf("ERROR: -set can only be used exclusively\n"); break; } printf("WARNING: -set is deprecated and will be removed in future versions.\n"); printf(" Please consider using standalone versions of your sub-commands.\n"); printf(" Consult the documentation for details.\n\n"); if ((argvStep = parseSetCommand(processor, argc, argv, argvStep + 1)) == PARSE_WRONG_FORMAT) break; printf ("*** -set parsing completed\n"); argvStep--; continue; } //Costantly monitors CPU Usage if (strcmp(argv[argvStep], "-perf-cpuusage") == 0) { processor->perfMonitorCPUUsage (); continue; } //Costantly monitors FPU Usage if (strcmp(argv[argvStep], "-perf-fpuusage") == 0) { processor->perfMonitorFPUUsage (); continue; } //Constantly monitors Data Cache Misaligned Accesses if (strcmp(argv[argvStep], "-perf-dcma") == 0) { processor->perfMonitorDCMA(); continue; } //Open a configuration file if (strcmp(argv[argvStep], "-cfgfile") == 0) { cfgInstance=new CfgManager (processor, scaler); if (cfgInstance->openCfgFile ((char *)argv[argvStep+1])) { printf ("Error: invalid configuration file\n"); free (cfgInstance); break; } errorLine=cfgInstance->parseCfgFile (); if (errorLine!=0) { printf ("Error: invalid configuration identifier at row %d\n",errorLine); free (cfgInstance); break; } free (cfgInstance); argvStep++; continue; } if (strcmp(argv[argvStep], "-scaler") == 0) { printf ("Scaler is not active in this version.\n"); scaler->beginScaling (); continue; } printf("ERROR: invalid argument -- %s\n", argv[argvStep]); break; } free (processor); deinitializeCore(); if (argvStep == argc) { printf ("Done.\n"); return 0; } return -1; }