From c791ba092d082a05d26dff3bbf666531f11c2b65 Mon Sep 17 00:00:00 2001 From: Florian Forster Date: Sun, 12 Jan 2014 12:12:26 +0100 Subject: [PATCH] memory plugin: Move calculation of the percentage to memory_submit(). This removed the need for a lot of duplicate calls. It also changes the naming schema to use the "percent" type rather than the "memory" type, putting the information that these are percentages into the type instance field. --- src/memory.c | 197 ++++++++++++++++++++++++----------------------------------- 1 file changed, 80 insertions(+), 117 deletions(-) diff --git a/src/memory.c b/src/memory.c index 160e1ee7..a4b21dab 100644 --- a/src/memory.c +++ b/src/memory.c @@ -84,7 +84,6 @@ static int pagesize; /* endif HAVE_LIBSTATGRAB */ #elif HAVE_PERFSTAT static int pagesize; -static perfstat_memory_total_t pmemory; /* endif HAVE_PERFSTAT */ #else # error "No applicable input method." @@ -156,21 +155,29 @@ static int memory_init (void) return (0); } /* int memory_init */ -static void memory_submit (const char *type_instance, gauge_t value) +static void memory_submit (const char *type_instance, gauge_t value, gauge_t total) { value_t values[1]; value_list_t vl = VALUE_LIST_INIT; - values[0].gauge = value; - vl.values = values; vl.values_len = 1; sstrncpy (vl.host, hostname_g, sizeof (vl.host)); sstrncpy (vl.plugin, "memory", sizeof (vl.plugin)); - sstrncpy (vl.type, "memory", sizeof (vl.type)); sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance)); - plugin_dispatch_values (&vl); + if (values_absolute) + { + values[0].gauge = value; + sstrncpy (vl.type, "memory", sizeof (vl.type)); + plugin_dispatch_values (&vl); + } + if (values_percentage) + { + values[0].gauge = 100.0 * value / total; + sstrncpy (vl.type, "percent", sizeof (vl.type)); + plugin_dispatch_values (&vl); + } } static int memory_read (void) @@ -224,20 +231,10 @@ static int memory_read (void) free = (gauge_t) (((uint64_t) vm_data.free_count) * ((uint64_t) pagesize)); total = wired + active + inactive + free; - if (values_absolute) - { - memory_submit ("wired", wired); - memory_submit ("active", active); - memory_submit ("inactive", inactive); - memory_submit ("free", free); - } - if (values_percentage) - { - memory_submit ("percent_wired", (gauge_t) ((float_t) wired) / total * 100); - memory_submit ("percent_active", (gauge_t) ((float_t) active) / total * 100); - memory_submit ("percent_inactive", (gauge_t) ((float_t) inactive / total * 100); - memory_submit ("percent_free", (gauge_t) ((float_t) free / total * 100); - } + memory_submit ("wired", wired, total); + memory_submit ("active", active, total); + memory_submit ("inactive", inactive, total); + memory_submit ("free", free, total); /* #endif HAVE_HOST_STATISTICS */ #elif HAVE_SYSCTLBYNAME @@ -262,6 +259,7 @@ static int memory_read (void) NULL }; double sysctl_vals[8]; + gauge_t total; int i; @@ -287,23 +285,12 @@ static int memory_read (void) if (!isnan (sysctl_vals[i])) sysctl_vals[i] *= sysctl_vals[0]; - if (values_absolute) - { - memory_submit ("free", sysctl_vals[2]); - memory_submit ("wired", sysctl_vals[3]); - memory_submit ("active", sysctl_vals[4]); - memory_submit ("inactive", sysctl_vals[5]); - memory_submit ("cache", sysctl_vals[6]); - } - if (values_percentage) - { - double total = sysctl_vals[2] + sysctl_vals[3] + sysctl_vals[4] + sysctl_vals[5] + sysctl_vals[6]; - memory_submit ("percent_free", (gauge_t) ((float_t) sysctl_vals[2]) / total * 100); - memory_submit ("percent_wired", (gauge_t) ((float_t) sysctl_vals[3]) / total * 100); - memory_submit ("percent_active", (gauge_t) ((float_t) sysctl_vals[4]) / total * 100); - memory_submit ("percent_inactive", (gauge_t) ((float_t) sysctl_vals[5]) / total * 100); - memory_submit ("percent_cache", (gauge_t) ((float_t) sysctl_vals[6]) / total * 100); - } + total = sysctl_vals[2] + sysctl_vals[3] + sysctl_vals[4] + sysctl_vals[5] + sysctl_vals[6]; + memory_submit ("free", sysctl_vals[2], total); + memory_submit ("wired", sysctl_vals[3], total); + memory_submit ("active", sysctl_vals[4], total); + memory_submit ("inactive", sysctl_vals[5], total); + memory_submit ("cache", sysctl_vals[6], total); /* #endif HAVE_SYSCTLBYNAME */ #elif KERNEL_LINUX @@ -357,24 +344,14 @@ static int memory_read (void) sstrerror (errno, errbuf, sizeof (errbuf))); } - if (mem_total >= (mem_free + mem_buffered + mem_cached)) - { - mem_used = mem_total - (mem_free + mem_buffered + mem_cached); - if (values_absolute) - { - memory_submit ("used", mem_used); - memory_submit ("buffered", mem_buffered); - memory_submit ("cached", mem_cached); - memory_submit ("free", mem_free); - } - if (values_percentage) - { - memory_submit ("percent_used", (gauge_t) ((float_t) mem_used) / mem_total * 100); - memory_submit ("percent_buffered", (gauge_t) ((float_t) mem_buffered) / mem_total * 100); - memory_submit ("percent_cached", (gauge_t) ((float_t) mem_cached) / mem_total * 100); - memory_submit ("percent_free", (gauge_t) ((float_t) mem_free) / mem_total * 100); - } - } + if (mem_total < (mem_free + mem_buffered + mem_cached)) + return (0); + + mem_used = mem_total - (mem_free + mem_buffered + mem_cached); + memory_submit ("used", (gauge_t) mem_used, (gauge_t) mem_total); + memory_submit ("buffered", (gauge_t) mem_buffered, (gauge_t) mem_total); + memory_submit ("cached", (gauge_t) mem_cached, (gauge_t) mem_total); + memory_submit ("free", (gauge_t) mem_free, (gauge_t) mem_total); /* #endif KERNEL_LINUX */ #elif HAVE_LIBKSTAT @@ -385,6 +362,7 @@ static int memory_read (void) long long mem_lock; long long mem_kern; long long mem_unus; + long long mem_total; long long pp_kernel; long long physmem; @@ -429,7 +407,7 @@ static int memory_read (void) } /* mem_kern is accounted for in mem_lock */ - if ( pp_kernel < mem_lock ) + if (pp_kernel < mem_lock) { mem_kern = pp_kernel; mem_lock -= pp_kernel; @@ -445,29 +423,22 @@ static int memory_read (void) mem_lock *= pagesize; /* some? ;) */ mem_kern *= pagesize; /* it's 2011 RAM is cheap */ mem_unus *= pagesize; + mem_total = mem_used + mem_free + mem_lock + mem_kern + mem_unus; - if (values_absolute) - { - memory_submit ("used", mem_used); - memory_submit ("free", mem_free); - memory_submit ("locked", mem_lock); - memory_submit ("kernel", mem_kern); - memory_submit ("unusable", mem_unus); - } - if (values_percentage) - { - memory_submit ("percent_used", (gauge_t) ((float_t) mem_used) / (mem_used + mem_free + mem_lock + mem_kern + mem_unus) * 100); - memory_submit ("percent_free", (gauge_t) ((float_t) mem_free) / (mem_used + mem_free + mem_lock + mem_kern + mem_unus) * 100); - memory_submit ("percent_locked", (gauge_t) ((float_t) mem_lock) / (mem_used + mem_free + mem_lock + mem_kern + mem_unus) * 100); - memory_submit ("percent_kernel", (gauge_t) ((float_t) mem_kern) / (mem_used + mem_free + mem_lock + mem_kern + mem_unus) * 100); - memory_submit ("percent_unusable", (gauge_t) ((float_t) mem_unus) / (mem_used + mem_free + mem_lock + mem_kern + mem_unus) * 100); - - } + memory_submit ("used", (gauge_t) mem_used, (gauge_t) mem_total); + memory_submit ("free", (gauge_t) mem_free, (gauge_t) mem_total); + memory_submit ("locked", (gauge_t) mem_lock, (gauge_t) mem_total); + memory_submit ("kernel", (gauge_t) mem_kern, (gauge_t) mem_total); + memory_submit ("unusable", (gauge_t) mem_unus, (gauge_t) mem_total); /* #endif HAVE_LIBKSTAT */ #elif HAVE_SYSCTL int mib[] = {CTL_VM, VM_METER}; struct vmtotal vmtotal; + gauge_t mem_active; + gauge_t mem_inactive; + gauge_t mem_free; + gauge_t mem_total; size_t size; memset (&vmtotal, 0, sizeof (vmtotal)); @@ -481,64 +452,56 @@ static int memory_read (void) } assert (pagesize > 0); - if (values_absolute) - { - memory_submit ("active", vmtotal.t_arm * pagesize); - memory_submit ("inactive", (vmtotal.t_rm - vmtotal.t_arm) * pagesize); - memory_submit ("free", vmtotal.t_free * pagesize); - } - if (values_percentage) - { - memory_submit ("percent_active", (gauge_t) ((float_t) vmtotal.t_arm) / (vmtotal.t_rm + vmtotal.t_free) * 100); - memory_submit ("percent_inactive", (gauge_t) ((float_t) (vmtotal.t_rm - vmtotal.t_arm) / (vmtotal.t_rm + vmtotal.t_free) * 100); - memory_submit ("percent_free", (gauge_t) ((float_t) vmtotal.t_free) / (vmtotal.t_rm + vmtotal.t_free) * 100); - } + mem_active = (gauge_t) (vmtotal.t_arm * pagesize); + mem_inactive = (gauge_t) ((vmtotal.t_rm - vmtotal.t_arm) * pagesize); + mem_free = (gauge_t) (vmtotal.t_free * pagesize); + mem_total = mem_active + mem_inactive + mem_free; + + memory_submit ("active", mem_active, mem_total); + memory_submit ("inactive", mem_inactive, mem_total); + memory_submit ("free", mem_free, mem_total); /* #endif HAVE_SYSCTL */ #elif HAVE_LIBSTATGRAB sg_mem_stats *ios; + gauge_t total; - if ((ios = sg_get_mem_stats ()) != NULL) - { - if (values_absolute) - { - memory_submit ("used", ios->used); - memory_submit ("cached", ios->cache); - memory_submit ("free", ios->free); - } - if (values_percentage) - { - memory_submit ("percent_used", (gauge_t) ((float_t) ios->used) / (ios->used + ios->cache + ios->free) * 100); - memory_submit ("percent_cached", (gauge_t) ((float_t) ios->cache) / (ios->used + ios->cache + ios->free) * 100); - memory_submit ("percent_free", (gauge_t) ((float_t) ios->free) / (ios->used + ios->cache + ios->free) * 100); - } - } + ios = sg_get_mem_stats (); + if (ios == NULL) + return (-1); + + total = (gauge_t) (ios->used + ios->cache + ios->free); + memory_submit ("used", (gauge_t) ios->used, total); + memory_submit ("cached", (gauge_t) ios->cache, total); + memory_submit ("free", (gauge_t) ios->free, total); /* #endif HAVE_LIBSTATGRAB */ #elif HAVE_PERFSTAT - if (perfstat_memory_total(NULL, &pmemory, sizeof(perfstat_memory_total_t), 1) < 0) + perfstat_memory_total_t pmemory; + + memset (&pmemory, 0, sizeof (pmemory)); + if (perfstat_memory_total(NULL, &pmemory, sizeof(pmemory), 1) < 0) { char errbuf[1024]; WARNING ("memory plugin: perfstat_memory_total failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } - if (values_absolute) - { - memory_submit ("used", pmemory.real_inuse * pagesize); - memory_submit ("free", pmemory.real_free * pagesize); - memory_submit ("cached", pmemory.numperm * pagesize); - memory_submit ("system", pmemory.real_system * pagesize); - memory_submit ("user", pmemory.real_process * pagesize); - } - if (values_percentage) - { - memory_submit ("percent_used", (gauge_t) ((float_t) pmemory.real_inuse) / pmemory.real_total * 100); - memory_submit ("percent_free", (gauge_t) ((float_t) pmemory.real_free) / pmemory.real_total * 100); - memory_submit ("percent_cached", (gauge_t) ((float_t) pmemory.numperm) / pmemory.real_total * 100); - memory_submit ("percent_system", (gauge_t) ((float_t) pmemory.real_system) / pmemory.real_total * 100); - memory_submit ("percent_user", (gauge_t) ((float_t) pmemory.real_process) / pmemory.real_total * 100); - } + + /* Unfortunately, the AIX documentation is not very clear on how these + * numbers relate to one another. The only thing is states explcitly + * is: + * real_total = real_process + real_free + numperm + real_system + * + * Another segmentation, which would be closer to the numbers reported + * by the "svmon" utility, would be: + * real_total = real_free + real_inuse + * real_inuse = "active" + real_pinned + numperm + */ + memory_submit ("free", pmemory.real_free * pagesize, pmemory.real_total * pagesize); + memory_submit ("cached", pmemory.numperm * pagesize, pmemory.real_total * pagesize); + memory_submit ("system", pmemory.real_system * pagesize, pmemory.real_total * pagesize); + memory_submit ("user", pmemory.real_process * pagesize, pmemory.real_total * pagesize); #endif /* HAVE_PERFSTAT */ return (0); -- 2.11.0