ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/libstatgrab/src/libstatgrab/memory_stats.c
(Generate patch)

Comparing projects/libstatgrab/src/libstatgrab/memory_stats.c (file contents):
Revision 1.27 by tdb, Wed Apr 7 21:08:40 2004 UTC vs.
Revision 1.32 by tdb, Sat Sep 24 13:29:22 2005 UTC

# Line 45 | Line 45
45   #include <sys/time.h>
46   #include <uvm/uvm.h>
47   #endif
48 + #ifdef HPUX
49 + #include <sys/param.h>
50 + #include <sys/pstat.h>
51 + #include <unistd.h>
52 + #endif
53 + #ifdef WIN32
54 + #include <windows.h>
55 + #include "win32.h"
56 + #endif
57  
58   sg_mem_stats *sg_get_mem_stats(){
59  
60          static sg_mem_stats mem_stat;
61  
62 + #ifdef HPUX
63 +        struct pst_static *pstat_static;
64 +        struct pst_dynamic pstat_dynamic;
65 +        long long pagesize;
66 + #endif
67   #ifdef SOLARIS
68          kstat_ctl_t *kc;
69          kstat_t *ksp;
# Line 74 | Line 88 | sg_mem_stats *sg_get_mem_stats(){
88   #if defined(NETBSD) || defined(OPENBSD)
89          struct uvmexp *uvm;
90   #endif
91 + #ifdef WIN32
92 +        MEMORYSTATUSEX memstats;
93 + #endif
94  
95 + #ifdef HPUX
96 +        if((pagesize=sysconf(_SC_PAGESIZE)) == -1){
97 +                sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
98 +                return NULL;
99 +        }
100 +
101 +        if (pstat_getdynamic(&pstat_dynamic, sizeof(pstat_dynamic), 1, 0) == -1) {
102 +                sg_set_error_with_errno(SG_ERROR_PSTAT, "pstat_dynamic");
103 +                return NULL;
104 +        }
105 +        pstat_static = sg_get_pstat_static();
106 +        if (pstat_static == NULL) {
107 +                return NULL;
108 +        }
109 +
110 +        /* FIXME Does this include swap? */
111 +        mem_stat.total = ((long long) pstat_static->physical_memory) * pagesize;
112 +        mem_stat.free = ((long long) pstat_dynamic.psd_free) * pagesize;
113 +        mem_stat.used = mem_stat.total - mem_stat.free;
114 + #endif
115   #ifdef SOLARIS
116          if((pagesize=sysconf(_SC_PAGESIZE)) == -1){
117 <                sg_set_error(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
117 >                sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
118                  return NULL;    
119          }
120  
121          if((totalmem=sysconf(_SC_PHYS_PAGES)) == -1){
122 <                sg_set_error(SG_ERROR_SYSCONF, "_SC_PHYS_PAGES");
122 >                sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PHYS_PAGES");
123                  return NULL;
124          }
125  
# Line 111 | Line 148 | sg_mem_stats *sg_get_mem_stats(){
148  
149   #if defined(LINUX) || defined(CYGWIN)
150          if ((f = fopen("/proc/meminfo", "r")) == NULL) {
151 <                sg_set_error(SG_ERROR_OPEN, "/proc/meminfo");
151 >                sg_set_error_with_errno(SG_ERROR_OPEN, "/proc/meminfo");
152                  return NULL;
153          }
154  
# Line 140 | Line 177 | sg_mem_stats *sg_get_mem_stats(){
177          mib[1] = HW_PHYSMEM;
178          size = sizeof physmem;
179          if (sysctl(mib, 2, &physmem, &size, NULL, 0) < 0) {
180 <                sg_set_error(SG_ERROR_SYSCTL, "CTL_HW.HW_PHYSMEM");
180 >                sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_HW.HW_PHYSMEM");
181                  return NULL;
182          }
183          mem_stat.total = physmem;
# Line 148 | Line 185 | sg_mem_stats *sg_get_mem_stats(){
185          /*returns pages*/
186          size = sizeof free_count;
187          if (sysctlbyname("vm.stats.vm.v_free_count", &free_count, &size, NULL, 0) < 0){
188 <                sg_set_error(SG_ERROR_SYSCTLBYNAME, "vm.stats.vm.v_free_count");
188 >                sg_set_error_with_errno(SG_ERROR_SYSCTLBYNAME,
189 >                                        "vm.stats.vm.v_free_count");
190                  return NULL;
191          }
192  
193          size = sizeof inactive_count;
194          if (sysctlbyname("vm.stats.vm.v_inactive_count", &inactive_count , &size, NULL, 0) < 0){
195 <                sg_set_error(SG_ERROR_SYSCTLBYNAME, "vm.stats.vm.v_inactive_count");
195 >                sg_set_error_with_errno(SG_ERROR_SYSCTLBYNAME,
196 >                                        "vm.stats.vm.v_inactive_count");
197                  return NULL;
198          }
199  
200          size = sizeof cache_count;
201          if (sysctlbyname("vm.stats.vm.v_cache_count", &cache_count, &size, NULL, 0) < 0){
202 <                sg_set_error(SG_ERROR_SYSCTLBYNAME, "vm.stats.vm.v_cache_count");
202 >                sg_set_error_with_errno(SG_ERROR_SYSCTLBYNAME,
203 >                                        "vm.stats.vm.v_cache_count");
204                  return NULL;
205          }
206  
# Line 168 | Line 208 | sg_mem_stats *sg_get_mem_stats(){
208           * After that I then need to multiple the anything that used vm.stats to
209           * get the system statistics by pagesize
210           */
211 <        if ((pagesize=getpagesize()) == -1){
172 <                sg_set_error(SG_ERROR_GETPAGESIZE, "NULL");
173 <                return NULL;
174 <        }
175 <
211 >        pagesize = getpagesize();
212          mem_stat.cache=cache_count*pagesize;
213  
214          /* Of couse nothing is ever that simple :) And I have inactive pages to
# Line 198 | Line 234 | sg_mem_stats *sg_get_mem_stats(){
234          mem_stat.used = mem_stat.total - mem_stat.free;
235   #endif
236  
237 + #ifdef WIN32
238 +        memstats.dwLength = sizeof(memstats);
239 +        if (!GlobalMemoryStatusEx(&memstats)) {
240 +                sg_set_error_with_errno(SG_ERROR_MEMSTATUS, NULL);
241 +                return NULL;
242 +        }
243 +        mem_stat.free = memstats.ullAvailPhys;
244 +        mem_stat.total = memstats.ullTotalPhys;
245 +        mem_stat.used = mem_stat.total - mem_stat.free;
246 +        if(read_counter_large(SG_WIN32_MEM_CACHE, &mem_stat.cache)) {
247 +                mem_stat.cache = 0;
248 +        }
249 + #endif
250          return &mem_stat;
251   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines