int main(int argc,char *argv[] )
{
int value = 0;
if(argc == 2)
value = atoi(argv[1]);
printf("value is :%d\n",value);
value = subcount(value,10);
printf("value is :%d\n",value);
¡¡return 0;
}
float get_energy()
{
static unsigned long int count = 0;
int prev = !curr;
/* Don't buffer data if redirected to a pipe */
//setbuf(stdout, NULL);
memset(&sys_stats[curr], 0, SYS_INFO_SIZE);
read_process_stats(curr);
read_cpufreq_stats(&sys_stats[curr]);
u32 delta_runtime = subcount(sys_stats[curr].runtime, sys_stats[prev].runtime);
float delta_cpu = (u64_subcount(sys_stats[curr].stats.utime, sys_stats[prev].stats.utime) + u64_subcount(sys_stats[curr].stats.stime, sys_stats[prev].stats.stime)) * (100.0f / delta_runtime);
u32 delta_itv = u64_subcount(sys_stats[curr].itv, sys_stats[prev].itv);
stm_time_t delta_timestamp = u64_subcount(sys_stats[curr].timestamp, sys_stats[prev].timestamp);
/* (avg cpu time) * (cpu power) * (run percent) / 100 */
double power = delta_cpu * sys_stats[curr].cpupower * (delta_runtime * 1.0f / delta_itv) / 100.0f;
if (power != power) // check not NaN
{
#ifdef POWER_DEBUG
DEBUG(stdout, "NaN result\n");
#endif
power = 0;
}
power_history[power_index].power = power;
power_history[power_index].delta = delta_timestamp;
/* timestamp set as last element to avoid critical raise in CPUEnergy */
power_history[power_index].timestamp = sys_stats[curr].timestamp;
#ifdef POWER_DEBUG
DEBUG(stdout, "[%lu - %d/%d] Power %f @ %llu for %f\n", count, power_index, RETENTION_SIZE, power_history[power_index].power, power_history[power_index].timestamp, power_history[power_index].delta / 1000000.0f);
#endif
if(count > 0 && !power) {
#ifdef POWER_ALERT
WARNING(stdout, "Power consumption read 0 W, the acquiring interval '%f msec' is too small. Start: %llu, End: %llu, delta: %f\n", (float)ACQUIRING_INTERVAL, sys_stats[prev].timestamp, sys_stats[curr].timestamp, delta_timestamp / 1000000.0);
#endif
} else {
power_index = NEXT_RETENTION_SIZE(power_index);
curr ^= 1;
}
count++;
return power;
}
/*
** calculate the system-activity during the last sample
*/
void
deviatsyst(struct sstat *cur, struct sstat *pre, struct sstat *dev)
{
register int i, j;
size_t size;
count_t *cdev, *ccur, *cpre;
if (cur->cpu.nrcpu != dev->cpu.nrcpu)
{
size = cur->cpu.nrcpu * sizeof(struct percpu);
dev->cpu.cpu = (struct percpu *)realloc(dev->cpu.cpu, size);
ptrverify(dev->cpu.cpu, "deviatsyst cpus [%ld]", (long)size);
}
if (cur->cpu.nrcpu > pre->cpu.nrcpu)
{
free(pre->cpu.cpu);
size = cur->cpu.nrcpu * sizeof(struct percpu);
pre->cpu.cpu = (struct percpu *)calloc(1, size);
ptrverify(pre->cpu.cpu, "deviatsyst precpus [%ld]", (long)size);
}
dev->cpu.nrcpu = cur->cpu.nrcpu;
dev->cpu.devint = subcount(cur->cpu.devint, pre->cpu.devint);
dev->cpu.csw = subcount(cur->cpu.csw, pre->cpu.csw);
dev->cpu.nprocs = subcount(cur->cpu.nprocs, pre->cpu.nprocs);
dev->cpu.all.stime = subcount(cur->cpu.all.stime, pre->cpu.all.stime);
dev->cpu.all.utime = subcount(cur->cpu.all.utime, pre->cpu.all.utime);
dev->cpu.all.ntime = subcount(cur->cpu.all.ntime, pre->cpu.all.ntime);
dev->cpu.all.itime = subcount(cur->cpu.all.itime, pre->cpu.all.itime);
dev->cpu.all.wtime = subcount(cur->cpu.all.wtime, pre->cpu.all.wtime);
dev->cpu.all.Itime = subcount(cur->cpu.all.Itime, pre->cpu.all.Itime);
dev->cpu.all.Stime = subcount(cur->cpu.all.Stime, pre->cpu.all.Stime);
dev->cpu.all.steal = subcount(cur->cpu.all.steal, pre->cpu.all.steal);
dev->cpu.all.guest = subcount(cur->cpu.all.guest, pre->cpu.all.guest);
for (i=0; i < dev->cpu.nrcpu; i++)
{
count_t ticks;
dev->cpu.cpu[i].cpunr = cur->cpu.cpu[i].cpunr;
dev->cpu.cpu[i].stime = subcount(cur->cpu.cpu[i].stime,
pre->cpu.cpu[i].stime);
dev->cpu.cpu[i].utime = subcount(cur->cpu.cpu[i].utime,
pre->cpu.cpu[i].utime);
dev->cpu.cpu[i].ntime = subcount(cur->cpu.cpu[i].ntime,
pre->cpu.cpu[i].ntime);
dev->cpu.cpu[i].itime = subcount(cur->cpu.cpu[i].itime,
pre->cpu.cpu[i].itime);
dev->cpu.cpu[i].wtime = subcount(cur->cpu.cpu[i].wtime,
pre->cpu.cpu[i].wtime);
dev->cpu.cpu[i].Itime = subcount(cur->cpu.cpu[i].Itime,
pre->cpu.cpu[i].Itime);
dev->cpu.cpu[i].Stime = subcount(cur->cpu.cpu[i].Stime,
pre->cpu.cpu[i].Stime);
dev->cpu.cpu[i].steal = subcount(cur->cpu.cpu[i].steal,
pre->cpu.cpu[i].steal);
dev->cpu.cpu[i].guest = subcount(cur->cpu.cpu[i].guest,
pre->cpu.cpu[i].guest);
ticks = cur->cpu.cpu[i].freqcnt.ticks;
dev->cpu.cpu[i].freqcnt.maxfreq =
cur->cpu.cpu[i].freqcnt.maxfreq;
dev->cpu.cpu[i].freqcnt.cnt = ticks ?
subcount(cur->cpu.cpu[i].freqcnt.cnt,
pre->cpu.cpu[i].freqcnt.cnt)
: cur->cpu.cpu[i].freqcnt.cnt;
dev->cpu.cpu[i].freqcnt.ticks = ticks ?
subcount(cur->cpu.cpu[i].freqcnt.ticks,
pre->cpu.cpu[i].freqcnt.ticks)
: cur->cpu.cpu[i].freqcnt.ticks;
}
dev->cpu.lavg1 = cur->cpu.lavg1;
dev->cpu.lavg5 = cur->cpu.lavg5;
dev->cpu.lavg15 = cur->cpu.lavg15;
dev->mem.physmem = cur->mem.physmem;
dev->mem.freemem = cur->mem.freemem;
dev->mem.buffermem = cur->mem.buffermem;
dev->mem.slabmem = cur->mem.slabmem;
dev->mem.slabreclaim = cur->mem.slabreclaim;
dev->mem.committed = cur->mem.committed;
dev->mem.commitlim = cur->mem.commitlim;
dev->mem.cachemem = cur->mem.cachemem;
dev->mem.cachedrt = cur->mem.cachedrt;
dev->mem.totswap = cur->mem.totswap;
dev->mem.freeswap = cur->mem.freeswap;
dev->mem.shmem = cur->mem.shmem;
dev->mem.shmrss = cur->mem.shmrss;
dev->mem.shmswp = cur->mem.shmswp;
dev->mem.tothugepage = cur->mem.tothugepage;
dev->mem.freehugepage = cur->mem.freehugepage;
dev->mem.hugepagesz = cur->mem.hugepagesz;
dev->mem.vmwballoon = cur->mem.vmwballoon;
dev->mem.swouts = subcount(cur->mem.swouts, pre->mem.swouts);
dev->mem.swins = subcount(cur->mem.swins, pre->mem.swins);
dev->mem.pgscans = subcount(cur->mem.pgscans, pre->mem.pgscans);
dev->mem.pgsteal = subcount(cur->mem.pgsteal, pre->mem.pgsteal);
dev->mem.allocstall = subcount(cur->mem.allocstall,
pre->mem.allocstall);
/*
** structures with network-related counters are considered
** as tables of frequency-counters that have to be subtracted;
** values that do not represent a frequency are corrected afterwards
*/
for (cdev = (count_t *)&dev->net.ipv4,
ccur = (count_t *)&cur->net.ipv4,
cpre = (count_t *)&pre->net.ipv4,
i = 0;
i < (sizeof dev->net.ipv4 / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
dev->net.ipv4.Forwarding = cur->net.ipv4.Forwarding;
dev->net.ipv4.DefaultTTL = cur->net.ipv4.DefaultTTL;
/* ------------- */
for (cdev = (count_t *)&dev->net.icmpv4,
ccur = (count_t *)&cur->net.icmpv4,
cpre = (count_t *)&pre->net.icmpv4,
i = 0;
i < (sizeof dev->net.icmpv4 / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
/* ------------- */
for (cdev = (count_t *)&dev->net.udpv4,
ccur = (count_t *)&cur->net.udpv4,
cpre = (count_t *)&pre->net.udpv4,
i = 0;
i < (sizeof dev->net.udpv4 / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
/* ------------- */
for (cdev = (count_t *)&dev->net.ipv6,
ccur = (count_t *)&cur->net.ipv6,
cpre = (count_t *)&pre->net.ipv6,
i = 0;
i < (sizeof dev->net.ipv6 / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
/* ------------- */
for (cdev = (count_t *)&dev->net.icmpv6,
ccur = (count_t *)&cur->net.icmpv6,
cpre = (count_t *)&pre->net.icmpv6,
i = 0;
i < (sizeof dev->net.icmpv6 / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
/* ------------- */
for (cdev = (count_t *)&dev->net.udpv6,
ccur = (count_t *)&cur->net.udpv6,
cpre = (count_t *)&pre->net.udpv6,
i = 0;
i < (sizeof dev->net.udpv6 / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
/* ------------- */
for (cdev = (count_t *)&dev->net.tcp,
ccur = (count_t *)&cur->net.tcp,
cpre = (count_t *)&pre->net.tcp,
i = 0;
i < (sizeof dev->net.tcp / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
dev->net.tcp.RtoAlgorithm = cur->net.tcp.RtoAlgorithm;
dev->net.tcp.RtoMin = cur->net.tcp.RtoMin;
dev->net.tcp.RtoMax = cur->net.tcp.RtoMax;
dev->net.tcp.MaxConn = cur->net.tcp.MaxConn;
dev->net.tcp.CurrEstab = cur->net.tcp.CurrEstab;
/*
** calculate deviations for interfaces
*/
if (cur->intf.nrintf != dev->intf.nrintf)
{
size = (cur->intf.nrintf + 1) * sizeof(struct perintf);
dev->intf.intf = (struct perintf *)realloc(dev->intf.intf, size);
ptrverify(dev->intf.intf, "deviatsyst intf [%ld]\n", (long)size);
}
if (pre->intf.nrintf < cur->intf.nrintf) /* first sample? */
{
struct ifprop ifprop;
free(pre->intf.intf);
size = (cur->intf.nrintf + 1) * sizeof(struct perintf);
pre->intf.intf = (struct perintf *)calloc(1, size);
ptrverify(pre->intf.intf, "deviatsyst preintf [%ld]\n", size);
for (i=0; cur->intf.intf[i].name[0]; i++)
{
strcpy(pre->intf.intf[i].name, cur->intf.intf[i].name);
strcpy(ifprop.name, cur->intf.intf[i].name);
getifprop(&ifprop);
pre->intf.intf[i].speed = ifprop.speed;
pre->intf.intf[i].duplex = ifprop.fullduplex;
}
pre->intf.intf[i].name[0] = '\0';
}
for (i=0; cur->intf.intf && cur->intf.intf[i].name[0]; i++)
{
/*
** check if an interface has been added or removed;
** in that case, skip further handling for this sample
*/
if (strcmp(cur->intf.intf[i].name, pre->intf.intf[i].name) != 0)
{
int j;
struct ifprop ifprop;
/*
** take care that interface properties are
** corrected for future samples
*/
initifprop(); /* refresh interface info */
for (j=0; cur->intf.intf[j].name[0]; j++)
{
strcpy(ifprop.name, cur->intf.intf[j].name);
getifprop(&ifprop);
cur->intf.intf[j].speed = ifprop.speed;
cur->intf.intf[j].duplex = ifprop.fullduplex;
}
break;
}
/*
** calculate interface deviations for this sample
*/
strcpy(dev->intf.intf[i].name, cur->intf.intf[i].name);
dev->intf.intf[i].rbyte = subcount(cur->intf.intf[i].rbyte,
pre->intf.intf[i].rbyte);
dev->intf.intf[i].rpack = subcount(cur->intf.intf[i].rpack,
pre->intf.intf[i].rpack);
dev->intf.intf[i].rerrs = subcount(cur->intf.intf[i].rerrs,
pre->intf.intf[i].rerrs);
dev->intf.intf[i].rdrop = subcount(cur->intf.intf[i].rdrop,
pre->intf.intf[i].rdrop);
dev->intf.intf[i].rfifo = subcount(cur->intf.intf[i].rfifo,
pre->intf.intf[i].rfifo);
dev->intf.intf[i].rframe= subcount(cur->intf.intf[i].rframe,
pre->intf.intf[i].rframe);
dev->intf.intf[i].rcompr= subcount(cur->intf.intf[i].rcompr,
pre->intf.intf[i].rcompr);
dev->intf.intf[i].rmultic=subcount(cur->intf.intf[i].rmultic,
pre->intf.intf[i].rmultic);
dev->intf.intf[i].sbyte = subcount(cur->intf.intf[i].sbyte,
pre->intf.intf[i].sbyte);
dev->intf.intf[i].spack = subcount(cur->intf.intf[i].spack,
pre->intf.intf[i].spack);
dev->intf.intf[i].serrs = subcount(cur->intf.intf[i].serrs,
pre->intf.intf[i].serrs);
dev->intf.intf[i].sdrop = subcount(cur->intf.intf[i].sdrop,
pre->intf.intf[i].sdrop);
dev->intf.intf[i].sfifo = subcount(cur->intf.intf[i].sfifo,
pre->intf.intf[i].sfifo);
dev->intf.intf[i].scollis= subcount(cur->intf.intf[i].scollis,
pre->intf.intf[i].scollis);
dev->intf.intf[i].scarrier= subcount(cur->intf.intf[i].scarrier,
pre->intf.intf[i].scarrier);
dev->intf.intf[i].scompr= subcount(cur->intf.intf[i].scompr,
pre->intf.intf[i].scompr);
dev->intf.intf[i].speed = pre->intf.intf[i].speed;
dev->intf.intf[i].duplex = pre->intf.intf[i].duplex;
/*
** save interface properties for next interval
*/
cur->intf.intf[i].speed = pre->intf.intf[i].speed;
cur->intf.intf[i].duplex = pre->intf.intf[i].duplex;
}
dev->intf.intf[i].name[0] = '\0';
dev->intf.nrintf = i;
/*
** calculate deviations for disks
*/
if (cur->dsk.ndsk != dev->dsk.ndsk)
{
size = (cur->dsk.ndsk + 1) * sizeof(struct perdsk);
dev->dsk.dsk = (struct perdsk *)realloc(dev->dsk.dsk, size);
ptrverify(dev->dsk.dsk, "deviatsyst disk [%ld]\n", (long)size);
}
for (i=j=0; cur->dsk.dsk && cur->dsk.dsk[i].name[0]; i++)
{
int realj = j;
/*
** check if disk has been added or removed since
** previous interval
*/
if (pre->dsk.dsk[j].name[0] == '\0' ||
strcmp(cur->dsk.dsk[i].name, pre->dsk.dsk[j].name) != 0)
{
for (j=0; pre->dsk.dsk[j].name[0]; j++)
{
if ( strcmp(cur->dsk.dsk[i].name,
pre->dsk.dsk[j].name) == 0)
break;
}
/*
** either the corresponding entry has been found
** in the case that a disk has been removed, or
** an empty entry has been found (all counters
** on zero) in the case that a disk has been added
** during the last sample
*/
}
strcpy(dev->dsk.dsk[i].name, cur->dsk.dsk[i].name);
dev->dsk.dsk[i].nread = subcount(cur->dsk.dsk[i].nread,
pre->dsk.dsk[j].nread);
dev->dsk.dsk[i].nwrite = subcount(cur->dsk.dsk[i].nwrite,
pre->dsk.dsk[j].nwrite);
dev->dsk.dsk[i].nrsect = subcount(cur->dsk.dsk[i].nrsect,
pre->dsk.dsk[j].nrsect);
dev->dsk.dsk[i].nwsect = subcount(cur->dsk.dsk[i].nwsect,
pre->dsk.dsk[j].nwsect);
dev->dsk.dsk[i].io_ms = subcount(cur->dsk.dsk[i].io_ms,
pre->dsk.dsk[j].io_ms);
dev->dsk.dsk[i].avque = subcount(cur->dsk.dsk[i].avque,
pre->dsk.dsk[j].avque);
/*
** determine new j
*/
if (pre->dsk.dsk[j].name[0] != '\0') // existing matching entry
j++;
else
j = realj; // empty entry: stick to old j
}
dev->dsk.dsk[i].name[0] = '\0';
dev->dsk.ndsk = i;
/*
** calculate deviations for multiple devices
*/
if (cur->dsk.nmdd != dev->dsk.nmdd)
{
size = (cur->dsk.nmdd + 1) * sizeof(struct perdsk);
dev->dsk.mdd = (struct perdsk *)realloc(dev->dsk.mdd, size);
ptrverify(dev->dsk.mdd, "deviatsyst mdd [%ld]\n", (long)size);
}
for (i=j=0; cur->dsk.mdd && cur->dsk.mdd[i].name[0]; i++)
{
int realj = j;
/*
** check if md has been added or removed since
** previous interval
*/
if (pre->dsk.mdd[j].name[0] == '\0' ||
strcmp(cur->dsk.mdd[i].name, pre->dsk.mdd[j].name) != 0)
{
for (j=0; pre->dsk.mdd[j].name[0]; j++)
{
if ( strcmp(cur->dsk.mdd[i].name,
pre->dsk.mdd[j].name) == 0)
break;
}
/*
** either the corresponding entry has been found
** in the case that a md has been removed, or
** an empty entry has been found (all counters
** on zero) in the case that a md has been added
** during the last sample
*/
}
strcpy(dev->dsk.mdd[i].name, cur->dsk.mdd[i].name);
dev->dsk.mdd[i].nread = subcount(cur->dsk.mdd[i].nread,
pre->dsk.mdd[j].nread);
dev->dsk.mdd[i].nwrite = subcount(cur->dsk.mdd[i].nwrite,
pre->dsk.mdd[j].nwrite);
dev->dsk.mdd[i].nrsect = subcount(cur->dsk.mdd[i].nrsect,
pre->dsk.mdd[j].nrsect);
dev->dsk.mdd[i].nwsect = subcount(cur->dsk.mdd[i].nwsect,
pre->dsk.mdd[j].nwsect);
dev->dsk.mdd[i].io_ms = subcount(cur->dsk.mdd[i].io_ms,
pre->dsk.mdd[j].io_ms);
dev->dsk.mdd[i].avque = subcount(cur->dsk.mdd[i].avque,
pre->dsk.mdd[j].avque);
/*
** determine new j
*/
if (pre->dsk.mdd[j].name[0] != '\0') // existing matching entry
j++;
else
j = realj; // empty entry: stick to old j
}
dev->dsk.mdd[i].name[0] = '\0';
dev->dsk.nmdd = i;
/*
** calculate deviations for LVM logical volumes
*/
if (cur->dsk.nlvm != dev->dsk.nlvm)
{
size = (cur->dsk.nlvm + 1) * sizeof(struct perdsk);
dev->dsk.lvm = (struct perdsk *)realloc(dev->dsk.lvm, size);
ptrverify(dev->dsk.lvm, "deviatsyst lvm [%ld]\n", (long)size);
}
for (i=j=0; cur->dsk.lvm && cur->dsk.lvm[i].name[0]; i++)
{
int realj = j;
/*
** check if logical volume has been added or removed since
** previous interval
*/
if (pre->dsk.lvm[j].name[0] == '\0' ||
strcmp(cur->dsk.lvm[i].name, pre->dsk.lvm[j].name) != 0)
{
for (j=0; pre->dsk.lvm[j].name[0]; j++)
{
if ( strcmp(cur->dsk.lvm[i].name,
pre->dsk.lvm[j].name) == 0)
break;
}
/*
** either the corresponding entry has been found
** in the case that a logical volume has been removed,
** or an empty entry has been found (all counters
** on zero) in the case that a logical volume has
** been added during the last sample
*/
}
strcpy(dev->dsk.lvm[i].name, cur->dsk.lvm[i].name);
dev->dsk.lvm[i].nread = subcount(cur->dsk.lvm[i].nread,
pre->dsk.lvm[j].nread);
dev->dsk.lvm[i].nwrite = subcount(cur->dsk.lvm[i].nwrite,
pre->dsk.lvm[j].nwrite);
dev->dsk.lvm[i].nrsect = subcount(cur->dsk.lvm[i].nrsect,
pre->dsk.lvm[j].nrsect);
dev->dsk.lvm[i].nwsect = subcount(cur->dsk.lvm[i].nwsect,
pre->dsk.lvm[j].nwsect);
dev->dsk.lvm[i].io_ms = subcount(cur->dsk.lvm[i].io_ms,
pre->dsk.lvm[j].io_ms);
dev->dsk.lvm[i].avque = subcount(cur->dsk.lvm[i].avque,
pre->dsk.lvm[j].avque);
/*
** determine new j
*/
if (pre->dsk.lvm[j].name[0] != '\0') // existing matching entry
j++;
else
j = realj; // empty entry: stick to old j
}
dev->dsk.lvm[i].name[0] = '\0';
dev->dsk.nlvm = i;
/*
** application-specific counters
*/
if (cur->www.uptime >= pre->www.uptime)
{
dev->www.accesses = subcount(cur->www.accesses,
pre->www.accesses);
dev->www.totkbytes = subcount(cur->www.totkbytes,
pre->www.totkbytes);
}
else
{
dev->www.accesses = cur->www.accesses;
dev->www.totkbytes = cur->www.totkbytes;
}
dev->www.bworkers = cur->www.bworkers;
dev->www.iworkers = cur->www.iworkers;
}
/*
** calculate the differences between the current sample and
** the previous sample for a task
*/
static void
calcdiff(struct tstat *devstat, struct tstat *curstat, struct tstat *prestat,
char newtask, count_t totusedcpu)
{
devstat->gen = curstat->gen;
if (newtask)
devstat->gen.excode |= ~(INT_MAX);
devstat->cpu.nice = curstat->cpu.nice;
devstat->cpu.prio = curstat->cpu.prio;
devstat->cpu.rtprio = curstat->cpu.rtprio;
devstat->cpu.policy = curstat->cpu.policy;
devstat->cpu.curcpu = curstat->cpu.curcpu;
devstat->cpu.stime =
subcount(curstat->cpu.stime, prestat->cpu.stime);
devstat->cpu.utime =
subcount(curstat->cpu.utime, prestat->cpu.utime);
/*
** particular kernel versions sometimes supply a smaller
** amount for consumed CPU-ticks than a previous sample;
** with unsigned calculations this results in 497 days of
** CPU-consumption so a sanity-check is needed here...
*/
if (devstat->cpu.stime > totusedcpu)
devstat->cpu.stime = 1;
if (devstat->cpu.utime > totusedcpu)
devstat->cpu.utime = 1;
/*
** do further calculations
*/
devstat->dsk.rio =
subcount(curstat->dsk.rio, prestat->dsk.rio);
devstat->dsk.rsz =
subcount(curstat->dsk.rsz, prestat->dsk.rsz);
devstat->dsk.wio =
subcount(curstat->dsk.wio, prestat->dsk.wio);
devstat->dsk.wsz =
subcount(curstat->dsk.wsz, prestat->dsk.wsz);
devstat->dsk.cwsz =
subcount(curstat->dsk.cwsz, prestat->dsk.cwsz);
devstat->mem.vexec = curstat->mem.vexec;
devstat->mem.vmem = curstat->mem.vmem;
devstat->mem.rmem = curstat->mem.rmem;
devstat->mem.pmem = curstat->mem.pmem;
devstat->mem.vgrow = curstat->mem.vmem - prestat->mem.vmem;
devstat->mem.rgrow = curstat->mem.rmem - prestat->mem.rmem;
devstat->mem.vdata = curstat->mem.vdata;
devstat->mem.vstack = curstat->mem.vstack;
devstat->mem.vlibs = curstat->mem.vlibs;
devstat->mem.vswap = curstat->mem.vswap;
devstat->mem.minflt =
subcount(curstat->mem.minflt, prestat->mem.minflt);
devstat->mem.majflt =
subcount(curstat->mem.majflt, prestat->mem.majflt);
/*
** network counters: due to an unload/load of the netatop module,
** previous counters might be larger than the current
*/
if (curstat->net.tcpsnd >= prestat->net.tcpsnd)
devstat->net.tcpsnd =
subcount(curstat->net.tcpsnd, prestat->net.tcpsnd);
else
devstat->net.tcpsnd = curstat->net.tcpsnd;
if (curstat->net.tcpssz >= prestat->net.tcpssz)
devstat->net.tcpssz =
subcount(curstat->net.tcpssz, prestat->net.tcpssz);
else
devstat->net.tcpssz = curstat->net.tcpssz;
if (curstat->net.tcprcv >= prestat->net.tcprcv)
devstat->net.tcprcv =
subcount(curstat->net.tcprcv, prestat->net.tcprcv);
else
devstat->net.tcprcv = curstat->net.tcprcv;
if (curstat->net.tcprsz >= prestat->net.tcprsz)
devstat->net.tcprsz =
subcount(curstat->net.tcprsz, prestat->net.tcprsz);
else
devstat->net.tcprsz = curstat->net.tcprsz;
if (curstat->net.udpsnd >= prestat->net.udpsnd)
devstat->net.udpsnd =
subcount(curstat->net.udpsnd, prestat->net.udpsnd);
else
devstat->net.udpsnd = curstat->net.udpsnd;
if (curstat->net.udpssz >= prestat->net.udpssz)
devstat->net.udpssz =
subcount(curstat->net.udpssz, prestat->net.udpssz);
else
devstat->net.udpssz = curstat->net.udpssz;
if (curstat->net.udprcv >= prestat->net.udprcv)
devstat->net.udprcv =
subcount(curstat->net.udprcv, prestat->net.udprcv);
else
devstat->net.udprcv = curstat->net.udprcv;
if (curstat->net.udprsz >= prestat->net.udprsz)
devstat->net.udprsz =
subcount(curstat->net.udprsz, prestat->net.udprsz);
else
devstat->net.udprsz = curstat->net.udprsz;
}
