///////////////////////////////////////////for client
//start main loop
public void mainflow()
{
if (shutdownval)
{
Environment.Exit(0);
}
settings.checkTimeSync(); //update changed time settings
//internal sync
if (settings.timeSync && !controller.wrong && !pause) //skip when xtu settings bad, or user request
{
controller.XTUdaemon(settings, checker);
//1. check config
controller.generateCLKlist(settings, checker); //before batchCheck
settings.batchCheckFiles(); //no need to save io here
if (settings.checkPowerCFGFlag)
{
controller.initPowerCFG(settings);
controller.forceApply = true; //just in case
}
//2. apply settings(add app if dont exist)
var currfg = checker.detectFgProc(settings);
checker.autoCheckInsert(currfg, settings, controller);
//controller.setProcNice(currfg, settings);
controller.setPower(currfg, settings);
//3. check throttle
/*
*
* per profile scheduling.
*
* store intermediate values on settingsmanager.
*
* on throttle:
* cpuload 80%(tweakable)
* -get median upto throttleSync(tweakable)
*
* if app on the same profile throttles:
* profile gets modified affecting other relevant apps.
*
* if app is not in any profile:
* monitor performance for throttleSync(tweakable) cycles and assign to closest one.
*
*/
/*current app info
* 1. skip if its not in list
* 2. which throttle mode
*/
//reset timers (except newlist does it internally)
if (prev_currfg != null)
{
if (currfg.Id != prev_currfg.Id)
{
settings.resetThrottleSync();
settings.resetResurSync();
}
}
prev_currfg = currfg;
//current profile:
int currprof = controller.checkInList(currfg, settings);
//if app has a profile:
if (currprof != -1)
{
if (checker.isCurrentlyThrottling(settings, controller))
{
int mode = settings.throttleMode; //save mode
settings.throttleMode = 0; //reset
//median limit
int limit = (int)settings.newlist_median.configList["newlist_median"]; //ex) 50
int listcount = settings.generatedCLK.configList.Count(); //ex) 12
int indexlimit = listcount - listcount * limit / 100; //ex) 6
//new clk value for cpu throttle (newclk)
var gclklist = checker.sortedCLKlist(settings);
int newindex = gclklist.IndexOf(controller.getCLK(false));
if (newindex > indexlimit)
{
newindex--; //ensure 0 is the end(noindex is -1)
}
int newclk = gclklist.ElementAt(newindex); //clk value goes in
//new xtu value for gpu throttle (newxtu)
float newxtu = controller.getXTU();
if (newxtu > controller.getBaseXTU(settings))
{
newxtu -= 0.5f;
}
switch (mode)
{
case 0: break;
case 1: //cpu
settings.programs_running_cfg_cpu.appendChanges(currprof, newclk);
break;
case 2: //gpu
settings.programs_running_cfg_xtu.appendChanges(currprof, newxtu);
break;
}
}
if (checker.isViableForResurrect(settings, controller))
{
int mode = settings.resurrectMode;
settings.resurrectMode = 0;
//median limit
int limit = (int)settings.newlist_median.configList["newlist_median"]; //ex) 50
int listcount = settings.generatedCLK.configList.Count(); //ex) 12
int indexlimit = listcount - listcount * limit / 100; //ex) 6
string name = controller.checkNameInList(currfg, settings);
switch (mode)
{
case 0: break;
case 1:
if (currprof > 0)
{
settings.special_programs.appendChanges(name, currprof - 1);
}
break;
case 2:
if (currprof < indexlimit)
{
settings.special_programs.appendChanges(name, currprof + 1);
}
break;
}
}
}
}
settings.updateTimeSync();
checker.resettick();
}
//assume cpu is clk 100
public void autoCheckInsert(Process proc, SettingsManager sm, TweakerController ts)
{
sm.IPClocked = true;
if (ts.checkInList(proc, sm) != -1)
{
return; //its in the list
}
//different process!
if (temp != null)
{
if (temp.Id != proc.Id)
{
newlist_high_acc.Clear();
newlist_low_acc.Clear();
sm.resetNewlistSync();
newlistcheck = 0;
}
}
//insert proc
temp = proc;
//launch timer
sm.startNewlistSync();
//default cpu speed is always MaxPWR
int currpwr = autofilterPWR(getPWR());
int load = getLoad() * currpwr / getTurboPWR(); //include circumstance of throttling
if (load > 100)
{
load = 100; //oob
}
int throttle_median = (int)sm.throttle_median.configList["throttle_median"];
int upperlimit = (int)sm.processor_guid_tweak.configList["06cadf0e-64ed-448a-8927-ce7bf90eb35d"];
//capture high load
if (load >= throttle_median)
{
//int hload = (load - throttle_median) * 100 / (100 - throttle_median);
int hload = load;
log.WriteLog("newlist accumulation pwr:" + currpwr + " high load:" + hload);
newlist_high_acc.Add(hload);
}
//capture low load
else
{
int lload = load * 100 / (throttle_median - 1);
log.WriteLog("newlist accumulation pwr:" + currpwr + " low load:" + lload);
newlist_low_acc.Add(lload);
}
//if time
if (sm.checkNewlistSync())
{
/*
* get avg.
* heavily modified version of exponential moving average(EMA)
* use ignoreFlag to ignore repeating high loads
* for games with high load on loading time and low load on gameplay
*/
//ema for high load
float havg = 100.0f;
try { havg = newlist_high_acc[0]; }
catch { }
float hsum = 0.0f;
for (int i = 1; i < newlist_high_acc.Count(); i++)
{
float next = newlist_high_acc[i];
hsum = next + havg + 1.0f; //prevent divbyzero
havg = havg * (1.0f - next / hsum) + next * (next / hsum);
}
//ema for low load
float lavg = 0.0f;
try { lavg = newlist_low_acc[0]; }
catch { }
float lsum = 0.0f;
for (int i = 1; i < newlist_low_acc.Count(); i++)
{
float next = newlist_low_acc[i];
lsum = next + lavg + 1.0f; //prevent divbyzero
lavg = lavg * (1.0f - next / lsum) + next * (next / lsum);
}
log.WriteLog("EMA result low:" + (int)lavg + " high:" + (int)havg);
int medload = 100; //pcsx2
if (havg > lavg)
{
medload = (int)lavg * (throttle_median - 1) / 100; //dirt rally 2.0
}
//anything over throttle_median is CPU heavy and needs immediate attention!
newlist_high_acc.Clear(); //clear
newlist_low_acc.Clear(); //clear
//average pwr(clockspeed)
//ex) 3100mhz * 3(load) / 100 = 93mhz
int target = getTurboPWR() * medload / 100;
//find index of low limit(newlist median)
int index = 0;
int limit = (int)sm.newlist_median.configList["newlist_median"]; //ex) 50
int listcount = sm.generatedCLK.configList.Count(); //ex) 12
int indexlimit = listcount * limit / 100; //ex) 6
//get low limit through sorted clk
foreach (int val in sortedCLKlist(sm))
{
if (index < indexlimit)
{
index++;
}
else
{
limit = val;
break;
}
}
//convert low limit to pwr
int pwr = autofilterPWR((int)sm.generatedCLK.configList[limit]);
//find index for pwr
//with low limit
index = sm.generatedCLK.configList.Count();
foreach (int val in sortedPWRlist(sm))
{
int val2 = autofilterPWR(val);
if (val2 > target && val2 >= pwr)
{
break;
}
else
{
index--;
}
}
//insert profile
sm.special_programs.appendChanges(proc.ProcessName, index);
}
sm.IPClocked = false;
}