public DataNode()
{
time = 0;
pData = new ArrayList();
sData = null;
pEnergy = new Hashtable();
sEnergy = null;
}
private void addOrUpdateSystemCounters(SystemEnergy se)
{
try
{
int i;
if (sysCounters == null)
{
sysCounters = new PerformanceCounter[SYSTEM_COUNTER_NUM];
for (i = 0; i < SYSTEM_COUNTER_NUM; i++)
{
sysCounters[i] = new PerformanceCounter(PTOPW_CATEGORY, (String)counterNames[i], "_Total", false);
sysCounters[i].RawValue = 0;
}
}
i = 0;
sysCounters[i++].RawValue = (long)(se.totalActivePower() * 1000);//uw
sysCounters[i++].RawValue = (long)(se.cpuPower * 1000);//uw
sysCounters[i++].RawValue = (long)(se.memPower * 1000);//uw
sysCounters[i++].RawValue = (long)(se.diskPower * 1000);//uw
sysCounters[i++].RawValue = (long)(se.nicPower * 1000);//uw
}
catch (System.Exception ex)
{
throw new MyException(ex.Message, MyException.MSG_UPDATE_COUNTER_ERROR);
}
}
private void calButton_Click(object sender, EventArgs e)
{
if("".Equals(timeTextBox.Text.Trim()))
{
MessageBox.Show("Please input the time!", "Alert",
MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
return;
}
long time = 0;
try{
time = Convert.ToInt32(timeTextBox.Text);
}catch(Exception ex)
{
MessageBox.Show("Please input a correct time!","Alert",
MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
return;
}
clearView();
ArrayList al = dc.retrieveData(time * 1000);
Hashtable engList = new Hashtable();
SystemEnergy tse = new SystemEnergy();
//calculate
foreach(DataNode dn in al)
{
tse.cpuEng += dn.sEnergy.cpuEng;
tse.diskEng += dn.sEnergy.diskEng;
tse.memEng += dn.sEnergy.memEng;
tse.nicEng += dn.sEnergy.nicEng;
foreach(ProcessEnergy pe in dn.pEnergy.Values)
{
ProcessEnergy tpe = null;
if(engList.ContainsKey(pe.GetID()))
{
tpe = (ProcessEnergy)engList[pe.GetID()];
}
else
{
tpe = new ProcessEnergy();
tpe.no = pe.no;
tpe.name = pe.name;
engList.Add(pe.no, tpe);
}
tpe.cpuEng += pe.cpuEng;
tpe.diskEng += pe.diskEng;
tpe.memEng += pe.memEng;
tpe.nicEng += pe.nicEng;
}
}
//display
cpuEnergyLabel.Text = string.Format(DOUBLE_FORMAT, tse.cpuEng);
memEnergyLabel.Text = string.Format(DOUBLE_FORMAT, tse.memEng);
diskEnergyLabel.Text = string.Format(DOUBLE_FORMAT, tse.diskEng);
wnicEnergyLabel.Text = string.Format(DOUBLE_FORMAT, tse.nicEng);
ArrayList list = new ArrayList(engList.Values);
if (list.Count == 0) return;
list.Sort(compare);
foreach (ProcessEnergy eng in list)
{
Object[] objs = new Object[8];
double total = eng.cpuEng + eng.memEng + eng.diskEng + eng.nicEng;
objs[1] = NonEmptyString(string.Format(DOUBLE_FORMAT, total));
objs[2] = NonEmptyString(string.Format(DOUBLE_FORMAT, eng.cpuEng));
objs[3] = NonEmptyString(string.Format(DOUBLE_FORMAT, eng.memEng));
objs[4] = NonEmptyString(string.Format(DOUBLE_FORMAT, eng.diskEng));
objs[5] = NonEmptyString(string.Format(DOUBLE_FORMAT, eng.nicEng));
objs[0] = NonEmptyString(eng.name);
processDataGridView.Rows.Add(objs);
}
}
public void systemEnergy(SystemInfo info, SystemEnergy se)
{
MaxFrequency = info.pro.MaxClockSpeed;
DiskEnergy(info.percentDiskIdleTime, info.percentDiskReadTime,
info.percentDiskWriteTime, info.timeInterval, se);
NICEnergy(info.nrecv, info.nsend, info.timeInterval, se);
MemoryEnergy(info.memRead, info.memWrite, info.memCopy, info.timeInterval,info.pageSize, se);
CPUEnergy(info.cpuFrequency, info.cpuTime, info.timeInterval, info.pro.NumberOfCores, se);
}
public void processEnergy(ProcessInfo info, SystemEnergy se, SystemInfo sinfo,ProcessEnergy pe)
{
pCPUEnergy(info, pe, sinfo, se);
pNICEnergy(info, pe, se, sinfo);
pDiskEnergy(info, pe, se, sinfo);
pMemoryEnergy(info, pe, se, sinfo);
}
void pNICEnergy(ProcessInfo pinfo, ProcessEnergy peng, SystemEnergy seng, SystemInfo sinfo)
{
if(pinfo.networkActive && sinfo.NetActiveProcessNum > 0)
{
peng.nicEng = seng.nicEng / sinfo.NetActiveProcessNum;
}
else{
peng.nicEng = 0;
}
peng.nicPower = peng.nicEng * 1000 / sinfo.timeInterval;
}
void pMemoryEnergy(ProcessInfo pinfo, ProcessEnergy peng, SystemEnergy seng, SystemInfo sinfo)
{
peng.memEng = seng.memEng *
((pinfo.dwrite + pinfo.dread) * 1.0 / (sinfo.diskRead + sinfo.diskWrite));
peng.memPower = peng.memEng * 1000 / sinfo.timeInterval;
}
void pCPUEnergy(ProcessInfo info, ProcessEnergy pe, SystemInfo sinfo, SystemEnergy se)
{
pe.cpuEng = se.cpuEng * info.cpuTime / (sinfo.cpuTime);
pe.cpuPower = pe.cpuEng * 1000 / sinfo.timeInterval;
}
//ms
void NICEnergy(double drecv, double dsend, double interval, SystemEnergy se)
{
if((drecv + dsend) == 0)
{
se.nicEng = WirelessNICIdlePower * interval / 1000;
}
else
{
se.nicEng = ((drecv / (drecv + dsend) * WirelessReceivePower)
+ (dsend / (drecv + dsend) * WirelessTransmitPower))
* interval / 1000;
}
se.nicPower = se.nicEng / (interval / 1000);
}
void MemoryEnergy(double memread, double memwrite, double memcopy,double interval, int pagesize, SystemEnergy se)
{
double indata = ((memread * interval/1000) * pagesize)/1024;//MB, memory write
double outdata = ((memwrite * interval/1000) * pagesize)/1024;//MB, memory read
double copydata = ((memcopy * interval / 1000) * pagesize);//MB, memory read
double t = (indata / MemReadSpeed + outdata / MemWriteSpeed + copydata / MemCopySpeed)*1000;//ms
double idlet = interval - t;
if (t > interval)//may happen
{
t = interval;
idlet = 0;
}
se.memEng = ((t * MemWritePower) + (idlet * MemIdlePower)) / 1000;//joule
se.memPower = se.memEng / (interval/1000);//watt
}
//ms
void DiskEnergy(UInt64 idle, UInt64 read, UInt64 write, double interval, SystemEnergy se)
{
se.diskEng = (((read*DiskReadPower)
+ (write*DiskWritePower) + (idle*DiskIdlePower)) * 1.0 /(idle + read + write)) * interval/1000;
se.diskPower = se.diskEng * 1000 / interval;
}
void CPUEnergy(double CurrentFrequency, double cpuTime, double Interval, uint coreNum, SystemEnergy se)
{
se.cpuEng = (MinCPUPower*Interval/1000) +
alpha * (
(MaxCPUPower - MinCPUPower) * (CurrentFrequency / MaxFrequency) * cpuTime / coreNum / 1000
);
se.cpuPower = se.cpuEng * 1000 / Interval;
}
