disk io works using cache - also pid cache cleanup and pid cache dump

This commit is contained in:
nira11 committed 2013-09-15 12:00:23 +00:00
1 parent f2ba707d9f
commit 07b221a253
20 files changed
+409 -43

No files matched your search

+5 -7
View File
@@ -754,8 +754,8 @@ int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
return SIGAR_OK;
}
int sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_disk_io_t *proc_disk_io)
int sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_cumulative_disk_io_t *cumulative_proc_disk_io)
{
int status = sigar_getprocs(sigar, pid);
struct procsinfo64 *pinfo = sigar->pinfo;
@@ -763,13 +763,11 @@ int sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
if (status != SIGAR_OK) {
return status;
}
proc_disk_io->bytes_read = SIGAR_FIELD_NOTIMPL;
proc_disk_io->bytes_written = SIGAR_FIELD_NOTIMPL;
proc_disk_io->bytes_total = pinfo->pi_ioch;
cumulative_proc_disk_io->bytes_read = SIGAR_FIELD_NOTIMPL;
cumulative_proc_disk_io->bytes_written = SIGAR_FIELD_NOTIMPL;
cumulative_proc_disk_io->bytes_total = pinfo->pi_ioch;
return SIGAR_OK;
}
+2 -2
View File
@@ -1241,8 +1241,8 @@ int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
return SIGAR_OK;
}
int sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_disk_io_t *proc_disk_io)
int sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_cumulative_disk_io_t *proc_cumulative_disk_io)
{
return SIGAR_ENOTIMPL;
}
+5 -5
View File
@@ -307,8 +307,8 @@ int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
return SIGAR_OK;
}
int sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_disk_io_t *proc_disk_io)
int sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_cumulative_disk_io_t *proc_cumulative_disk_io)
{
int status = sigar_pstat_getproc(sigar, pid);
@@ -317,9 +317,9 @@ int sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
if (status != SIGAR_OK) {
return status;
}
proc_disk_io->bytes_read = SIGAR_FIELD_NOTIMPL;
proc_disk_io->bytes_written = SIGAR_FIELD_NOTIMPL;
proc_disk_io->bytes_total = pinfo->pst_ioch;
proc_cumulative_disk_io->bytes_read = SIGAR_FIELD_NOTIMPL;
proc_cumulative_disk_io->bytes_written = SIGAR_FIELD_NOTIMPL;
proc_cumulative_disk_io->bytes_total = pinfo->pst_ioch;
return SIGAR_OK;
+6 -6
View File
@@ -778,10 +778,10 @@ SIGAR_INLINE sigar_uint64_t get_named_proc_token(char *buffer,
return sigar_strtoul(ptr);
}
int sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_disk_io_t *proc_disk_io)
int sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_cumulative_disk_io_t *proc_cumulative_disk_io)
{
char buffer[BUFSIZ], *ptr=buffer;
char buffer[BUFSIZ];
int status = SIGAR_PROC_FILE2STR(buffer, pid, "/io");
@@ -789,9 +789,9 @@ int sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
return status;
}
proc_disk_io->bytes_read = get_named_proc_token(buffer, "\nread_bytes");
proc_disk_io->bytes_written = get_named_proc_token(buffer, "\nwrite_bytes");
proc_disk_io->bytes_total = proc_disk_io->bytes_read + proc_disk_io->bytes_written;
proc_cumulative_disk_io->bytes_read = get_named_proc_token(buffer, "\nread_bytes");
proc_cumulative_disk_io->bytes_written = get_named_proc_token(buffer, "\nwrite_bytes");
proc_cumulative_disk_io->bytes_total = proc_cumulative_disk_io->bytes_read + proc_cumulative_disk_io->bytes_written;
return SIGAR_OK;
}
+6 -6
View File
@@ -407,7 +407,7 @@ int sigar_cpu_get(sigar_t *sigar, sigar_cpu_t *cpu)
cpu->idle += xcpu->idle;
cpu->nice += xcpu->nice;
cpu->wait += xcpu->wait;
cpu->total = xcpu->total;
cpu->total += xcpu->total;
}
return SIGAR_OK;
@@ -719,17 +719,17 @@ int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
return SIGAR_OK;
}
int sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_disk_io_t *proc_disk_io)
int sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_cumulative_disk_io_t *proc_cumulative_disk_io)
{
prusage_t usage;
int status;
if ((status = sigar_proc_usage_get(sigar, &usage, pid)) != SIGAR_OK) {
return status;
}
proc_disk_io->bytes_read = SIGAR_FIELD_NOTIMPL;
proc_disk_io->bytes_written = SIGAR_FIELD_NOTIMPL;
proc_disk_io->bytes_total = usage.pr_ioch;
proc_cumulative_disk_io->bytes_read = SIGAR_FIELD_NOTIMPL;
proc_cumulative_disk_io->bytes_written = SIGAR_FIELD_NOTIMPL;
proc_cumulative_disk_io->bytes_total = usage.pr_ioch;
return SIGAR_OK;
}
+5 -5
View File
@@ -1214,8 +1214,8 @@ SIGAR_DECLARE(int) sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_disk_io_t *proc_disk_io)
SIGAR_DECLARE(int) sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_cumulative_disk_io_t *proc_cumulative_disk_io)
{
int status = get_proc_info(sigar, pid);
sigar_win32_pinfo_t *pinfo = &sigar->pinfo;
@@ -1224,9 +1224,9 @@ SIGAR_DECLARE(int) sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
return status;
}
proc_disk_io->bytes_read = pinfo->bytes_read;
proc_disk_io->bytes_written = pinfo->bytes_written;
proc_disk_io->bytes_total = proc_disk_io->bytes_read + proc_disk_io->bytes_written;
proc_cumulative_disk_io->bytes_read = pinfo->bytes_read;
proc_cumulative_disk_io->bytes_written = pinfo->bytes_written;
proc_cumulative_disk_io->bytes_total = proc_cumulative_disk_io->bytes_read + proc_cumulative_disk_io->bytes_written;
return SIGAR_OK;
}
+105 -1
View File
@@ -64,6 +64,7 @@ SIGAR_DECLARE(int) sigar_open(sigar_t **sigar)
(*sigar)->net_listen = NULL;
(*sigar)->net_services_tcp = NULL;
(*sigar)->net_services_udp = NULL;
(*sigar)->proc_io = NULL;
}
return status;
@@ -96,6 +97,11 @@ SIGAR_DECLARE(int) sigar_close(sigar_t *sigar)
if (sigar->net_services_udp) {
sigar_cache_destroy(sigar->net_services_udp);
}
if (sigar->proc_io) {
sigar_cache_destroy(sigar->proc_io);
}
return sigar_os_close(sigar);
}
@@ -123,7 +129,7 @@ SIGAR_DECLARE(int) sigar_proc_cpu_get(sigar_t *sigar, sigar_pid_t pid,
int status;
if (!sigar->proc_cpu) {
sigar->proc_cpu = sigar_cache_new(128);
sigar->proc_cpu = sigar_expired_cache_new(128, PID_CACHE_CLEANUP_PERIOD, PID_CACHE_ENTRY_EXPIRE_PERIOD);
}
entry = sigar_cache_get(sigar->proc_cpu, pid);
@@ -172,6 +178,104 @@ SIGAR_DECLARE(int) sigar_proc_cpu_get(sigar_t *sigar, sigar_pid_t pid,
return SIGAR_OK;
}
void copy_cached_disk_io_into_disk_io( sigar_cached_proc_disk_io_t *cached, sigar_proc_disk_io_t *proc_disk_io) {
proc_disk_io->bytes_read = cached->bytes_read_diff;
proc_disk_io->bytes_written = cached->bytes_written_diff;
proc_disk_io->bytes_total = cached->bytes_total_diff;
}
sigar_uint64_t get_io_diff(sigar_uint64_t current_value, sigar_uint64_t prev_value, sigar_uint64_t time_diff) {
if ( current_value == SIGAR_FIELD_NOTIMPL ) {
return SIGAR_FIELD_NOTIMPL;
}
double io_diff = (( current_value - prev_value)/(double)time_diff)*SIGAR_MSEC;
sigar_uint64_t int_io_diff = (sigar_uint64_t)io_diff;
if (int_io_diff >=0) {
return int_io_diff;
}
return 0;
}
void calculate_io_diff(sigar_proc_cumulative_disk_io_t * proc_disk_io, sigar_cached_proc_disk_io_t *cached, sigar_uint64_t time_diff, int is_first_time) {
/*calculate avg diff /read/write/total per second*/
if (!is_first_time) {
cached->bytes_written_diff = get_io_diff(proc_disk_io->bytes_written, cached->bytes_written, time_diff);
cached->bytes_read_diff = get_io_diff(proc_disk_io->bytes_read, cached->bytes_read, time_diff);
cached->bytes_total_diff = get_io_diff(proc_disk_io->bytes_total, cached->bytes_total, time_diff);
}
else {
cached->bytes_total_diff = cached->bytes_read_diff = cached->bytes_written_diff = 0.0;
}
// now put in cache the current cumulative values
cached->bytes_written = proc_disk_io->bytes_written;
cached->bytes_read = proc_disk_io->bytes_read;
cached->bytes_total = proc_disk_io->bytes_total;
}
SIGAR_DECLARE(int) sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_disk_io_t *proc_disk_io)
{
sigar_cache_entry_t *entry;
sigar_cached_proc_disk_io_t *prev;
sigar_proc_cumulative_disk_io_t cumulative_proc_disk_io;
sigar_uint64_t time_now = sigar_time_now_millis();
sigar_uint64_t time_diff;
int status;
if (!sigar->proc_io) {
sigar->proc_io = sigar_expired_cache_new(128, PID_CACHE_CLEANUP_PERIOD, PID_CACHE_ENTRY_EXPIRE_PERIOD);
}
entry = sigar_cache_get(sigar->proc_io, pid);
if (entry->value) {
prev = (sigar_cached_proc_disk_io_t *)entry->value;
}
else {
prev = entry->value = malloc(sizeof(*prev));
SIGAR_ZERO(prev);
}
int is_first_time = (prev->last_time == 0);
time_diff = time_now - prev->last_time;
if (time_diff < 1000) {
/* we were just called within < 1 second ago. */
copy_cached_disk_io_into_disk_io(prev, proc_disk_io);
if (time_diff < 0) {
// something is wrong at least from now on the time will be ok
prev->last_time = time_now;
}
return SIGAR_OK;
}
prev->last_time = time_now;
status =
sigar_proc_cumulative_disk_io_get(sigar, pid,
&cumulative_proc_disk_io);
if (status != SIGAR_OK) {
return status;
}
calculate_io_diff(&cumulative_proc_disk_io, prev, time_diff, is_first_time);
copy_cached_disk_io_into_disk_io(prev, proc_disk_io);
return SIGAR_OK;
}
void get_cache_info(sigar_cache_t * cache, char * name){
if (cache == NULL) {
return;
}
printf("******** %s *********\n", name);
sigar_cache_dump(cache);
}
SIGAR_DECLARE(int) sigar_dump_pid_cache_get(sigar_t *sigar, sigar_dump_pid_cache_t *info) {
get_cache_info(sigar->proc_cpu, "proc cpu cache");
get_cache_info(sigar->proc_io, "proc io cache");
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_proc_stat_get(sigar_t *sigar,
sigar_proc_stat_t *procstat)
+78 -7
View File
@@ -35,7 +35,7 @@ static void free_value(void *ptr)
free(ptr);
}
sigar_cache_t *sigar_cache_new(int size)
sigar_cache_t *sigar_expired_cache_new(int size, sigar_uint64_t cleanup_period_millis, sigar_uint64_t entry_expire_period)
{
sigar_cache_t *table = malloc(sizeof(*table));
table->count = 0;
@@ -43,16 +43,27 @@ sigar_cache_t *sigar_cache_new(int size)
table->entries = malloc(ENTRIES_SIZE(size));
memset(table->entries, '\0', ENTRIES_SIZE(size));
table->free_value = free_value;
table->cleanup_period_millis = cleanup_period_millis;
table->last_cleanup_time = sigar_time_now_millis();
table->entry_expire_period = entry_expire_period;
return table;
}
#ifdef DEBUG_CACHE
sigar_cache_t *sigar_cache_new(int size)
{
return sigar_expired_cache_new(size, SIGAR_FIELD_NOTIMPL, SIGAR_FIELD_NOTIMPL);
}
/*#ifdef DEBUG_CACHE*/
/* see how well entries are distributed */
static void sigar_cache_dump(sigar_cache_t *table)
void sigar_cache_dump(sigar_cache_t *table)
{
int i;
sigar_cache_entry_t **entries = table->entries;
printf("table size %lu\n", (long)table->size);
printf("table count %lu\n", (long)table->count);
for (i=0; i<table->size; i++) {
sigar_cache_entry_t *entry = *entries++;
@@ -68,12 +79,12 @@ static void sigar_cache_dump(sigar_cache_t *table)
printf("\n");
fflush(stdout);
}
#endif
/*#endif*/
static void sigar_cache_rehash(sigar_cache_t *table)
{
int i;
unsigned int new_size = table->size * 2 + 1;
unsigned int new_size = table->count * 2 + 1;
sigar_cache_entry_t **entries = table->entries;
sigar_cache_entry_t **new_entries =
malloc(ENTRIES_SIZE(new_size));
@@ -101,16 +112,73 @@ static void sigar_cache_rehash(sigar_cache_t *table)
#define SIGAR_CACHE_IX(t, k) \
t->entries + (k % t->size)
void sigar_perform_cleanup_if_necessary(sigar_cache_t *table) {
if (table->cleanup_period_millis == SIGAR_FIELD_NOTIMPL) {
/* no cleanup for this cache) */
}
sigar_uint64_t current_time = sigar_time_now_millis();
if ((current_time - table->last_cleanup_time) < table->cleanup_period_millis) {
/* not enough time has passed since last cleanup */
return;
}
/* performing cleanup */
int i;
sigar_cache_entry_t **entries = table->entries;
table->last_cleanup_time = current_time;
for (i=0; i<table->size; i++) {
sigar_cache_entry_t *entry, *ptr, *entry_prev=NULL, **entry_in_table;
entry_in_table = entries;
entry = *entries++;
while (entry) {
ptr = entry->next;
sigar_uint64_t period_with_no_access = current_time - entry->last_access_time;
if (table->entry_expire_period < period_with_no_access) {
/* no one acess this entry for too long - we can delete it */
if (entry->value) {
table->free_value(entry->value);
}
free(entry);
table->count--;
if (entry_prev != NULL) {
entry_prev->next = ptr;
}
else {
/* removing first entry - head of list should point to next entry */
*entry_in_table = ptr;
}
}
else {
/* entry not expired - advance entry_prev to current entry*/
entry_prev = entry;
}
entry = ptr;
}
}
if (table->count < (table->size/4)) {
/* hash table (the array size) too big for the amount of values it contains perform rehash */
sigar_cache_rehash(table);
}
}
sigar_cache_entry_t *sigar_cache_find(sigar_cache_t *table,
sigar_uint64_t key)
{
sigar_cache_entry_t *entry, **ptr;
sigar_perform_cleanup_if_necessary(table);
for (ptr = SIGAR_CACHE_IX(table, key), entry = *ptr;
entry;
ptr = &entry->next, entry = *ptr)
{
if (entry->id == key) {
entry->last_access_time = sigar_time_now_millis();
return entry;
}
}
@@ -123,17 +191,19 @@ sigar_cache_entry_t *sigar_cache_get(sigar_cache_t *table,
sigar_uint64_t key)
{
sigar_cache_entry_t *entry, **ptr;
sigar_perform_cleanup_if_necessary(table);
for (ptr = SIGAR_CACHE_IX(table, key), entry = *ptr;
entry;
ptr = &entry->next, entry = *ptr)
{
if (entry->id == key) {
entry->last_access_time = sigar_time_now_millis();
return entry;
}
}
if (table->count++ > table->size) {
if (++table->count > table->size) {
sigar_cache_rehash(table);
for (ptr = SIGAR_CACHE_IX(table, key), entry = *ptr;
@@ -147,6 +217,7 @@ sigar_cache_entry_t *sigar_cache_get(sigar_cache_t *table,
entry->id = key;
entry->value = NULL;
entry->next = NULL;
entry->last_access_time = sigar_time_now_millis();
return entry;
}
+9
View File
@@ -1338,6 +1338,14 @@ static ptql_lookup_t PTQL_Cpu[] = {
{ NULL }
};
static ptql_lookup_t PTQL_Disk_IO[] = {
{ "BytesRead", PTQL_LOOKUP_ENTRY(proc_disk_io, bytes_read, UI64) },
{ "BytesWritten", PTQL_LOOKUP_ENTRY(proc_disk_io, bytes_written, UI64) },
{ "BytesTotal", PTQL_LOOKUP_ENTRY(proc_disk_io, bytes_total, UI64) },
{ NULL }
};
static ptql_lookup_t PTQL_CredName[] = {
{ "User", PTQL_LOOKUP_ENTRY(proc_cred_name, user, STR) },
{ "Group", PTQL_LOOKUP_ENTRY(proc_cred_name, group, STR) },
@@ -1424,6 +1432,7 @@ static ptql_entry_t ptql_map[] = {
{ "Port", PTQL_Port },
{ "Pid", PTQL_Pid },
{ "Service", PTQL_Service },
{ "Disk_IO", PTQL_Disk_IO },
{ NULL }
};