luke
/
ngspice
mirror of https://git.code.sf.net/p/ngspice/ngspice
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ngspice/src/frontend/resource.c

711 lines
19 KiB
C
Raw Blame History

/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1985 Wayne A. Christopher, U. C. Berkeley CAD Group
**********/
/*
* Resource-related routines.
*
* New operation systems information options added:
* Windows 2000 and newer: Use GlobalMemoryStatusEx and GetProcessMemoryInfo
* LINUX (and maybe some others): Use the /proc virtual file information system
* Others: Use original code with sbrk(0) and some "ugly hacks"
*/
#include "ngspice/ngspice.h"
#include "ngspice/cpdefs.h"
#include "ngspice/ftedefs.h"
#include "circuits.h"
#include "quote.h"
#include "resource.h"
#include "variable.h"
#include "ngspice/cktdefs.h"
#include <inttypes.h>
#include "../misc/misc_time.h" /* timediff */
#ifdef XSPICE
/* gtri - add - 12/12/90 - wbk - include ipc stuff */
#include "ngspice/ipctiein.h"
/* gtri - end - 12/12/90 */
#endif
/* We might compile for Windows, but only as a console application (e.g. tcl) */
#if defined(HAS_WINGUI) || defined(__MINGW32__) || defined(_MSC_VER)
#define HAVE_WIN32
#endif
#ifdef HAVE_WIN32
#define WIN32_LEAN_AND_MEAN
#ifdef __MINGW32__ /* access to GlobalMemoryStatusEx in winbase.h:1558 */
#define WINVER 0x0500
#endif
/*
* The ngspice.h file included above defines BOOLEAN (via bool.h) and this
* clashes with the definition obtained from windows.h (via winnt.h).
* However, BOOLEAN is not used by this file so we can work round this problem
* by undefining BOOLEAN before including windows.h
* SJB - April 2005
*/
#undef BOOLEAN
#include <windows.h>
/* At least Windows 2000 is needed
* Undefine _WIN32_WINNT 0x0500 if you want to compile under Windows ME
* and older (not tested under Windows ME or 98!)
*/
#if defined(__MINGW32__) || (_MSC_VER > 1200) /* Exclude VC++ 6.0 from using the psapi */
#include <psapi.h>
#endif
#endif /* HAVE_WIN32 */
/* Uncheck the following definition if you want to get the old usage information
#undef HAVE__PROC_MEMINFO
*/
static void printres(char *name);
static void fprintmem(FILE *stream, unsigned long long memory);
#if defined(HAVE_WIN32) || defined(HAVE__PROC_MEMINFO)
static int get_procm(struct proc_mem *memall);
static int get_sysmem(struct sys_mem *memall);
struct sys_mem mem_t, mem_t_act;
struct proc_mem mem_ng, mem_ng_act;
#else
static RETSIGTYPE fault(void);
static void *baseaddr(void);
#endif
char *startdata;
char *enddata;
void
init_rlimits(void)
{
# if defined(HAVE_WIN32) || defined(HAVE__PROC_MEMINFO)
get_procm(&mem_ng);
get_sysmem(&mem_t);
# else
startdata = (char *) baseaddr();
enddata = sbrk(0);
# endif
}
void
init_time(void)
{
#ifdef HAVE_GETRUSAGE
#else
# ifdef HAVE_TIMES
# else
# ifdef HAVE_FTIME
ftime(&timebegin);
# endif
# endif
#endif
}
void
com_rusage(wordlist *wl)
{
char *copyword;
/* Fill in the SPICE accounting structure... */
if (wl && (eq(wl->wl_word, "everything") || eq(wl->wl_word, "all"))) {
printres(NULL);
} else if (wl) {
for (; wl; wl = wl->wl_next) {
/* printres(cp_unquote(wl->wl_word)); DG: bad, memory leak*/
copyword = cp_unquote(wl->wl_word);/*DG*/
printres(copyword);
tfree(copyword);
if (wl->wl_next)
(void) putc('\n', cp_out);
}
} else {
printres("cputime");
(void) putc('\n', cp_out);
printres("totalcputime");
(void) putc('\n', cp_out);
printres("space");
}
}
/* Find out if the user is approaching his maximum data size.
If usage is withing 90% of total available then a warning message is sent
to the error stream (cp_err) */
void
ft_ckspace(void)
{
unsigned long long usage, limit;
#if defined(HAVE_WIN32) || defined(HAVE__PROC_MEMINFO)
get_procm(&mem_ng_act);
usage = mem_ng_act.size;
limit = mem_t.free;
#else
static size_t old_usage = 0;
char *hi;
#ifdef HAVE_GETRLIMIT
struct rlimit rld;
getrlimit(RLIMIT_DATA, &rld);
if (rld.rlim_cur == RLIM_INFINITY)
return;
limit = rld.rlim_cur - (enddata - startdata); /* rlim_max not used */
#else /* HAVE_GETRLIMIT */
/* SYSVRLIMIT */
limit = ulimit(3, 0L) - (enddata - startdata);
#endif /* HAVE_GETRLIMIT */
hi = sbrk(0);
usage = (size_t) (hi - enddata);
if (usage <= old_usage)
return;
old_usage = usage;
#endif /* not HAS_WINGUI */
if ((double)usage > (double)limit * 0.9) {
fprintf(cp_err, "Warning - approaching max data size: ");
fprintf(cp_err, "current size = ");
fprintmem(cp_err, usage);
fprintf(cp_err, ", limit = ");
fprintmem(cp_err, limit);
fprintf(cp_err, "\n");
}
}
/* Print out one piece of resource usage information. */
static void
printres(char *name)
{
#ifdef CIDER
char *paramname = NULL;
#endif
bool yy = FALSE;
static long lastsec = 0, lastusec = 0;
struct variable *v, *vfree = NULL;
char *cpu_elapsed;
if (!name || eq(name, "totalcputime") || eq(name, "cputime")) {
int total, totalu;
#ifdef ipsc
# define NO_RUDATA
#else
# ifdef HAVE_GETRUSAGE
int ret;
struct rusage ruse;
memset(&ruse, 0, sizeof(ruse));
ret = getrusage(RUSAGE_SELF, &ruse);
if (ret == -1)
perror("getrusage(): ");
total = ruse.ru_utime.tv_sec + ruse.ru_stime.tv_sec;
totalu = (ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec) / 1000;
cpu_elapsed = "CPU";
# else
# ifdef HAVE_TIMES
struct tms ruse;
realt = times(&ruse);
total = (ruse.tms_utime + ruse.tms_stime)/ HZ;
totalu = (ruse.tms_utime + ruse.tms_utime) * 1000 / HZ;
cpu_elapsed = "CPU";
# else
# ifdef HAVE_FTIME
struct timeb timenow;
/* int sec, msec; sjb */
ftime(&timenow);
timediff(&timenow, &timebegin, &total, &totalu);
/* totalu /= 1000; hvogt */
cpu_elapsed = "elapsed";
# else
# define NO_RUDATA
# endif
# endif
# endif
#endif
#ifndef NO_RUDATA
if (!name || eq(name, "totalcputime")) {
total += totalu / 1000;
totalu %= 1000;
fprintf(cp_out, "Total %s time: %u.%03u seconds.\n",
cpu_elapsed, total, totalu);
}
if (!name || eq(name, "cputime")) {
lastusec = totalu - lastusec;
lastsec = total - lastsec;
while (lastusec < 0) {
lastusec += 1000;
lastsec -= 1;
}
while (lastusec > 1000) {
lastusec -= 1000;
lastsec += 1;
}
#ifndef HAVE_WIN32
fprintf(cp_out, "%s time since last call: %lu.%03lu seconds.\n",
cpu_elapsed, lastsec, lastusec);
#endif
lastsec = total;
lastusec = totalu;
}
#ifdef XSPICE
/* gtri - add - 12/12/90 - wbk - record cpu time used for ipc */
g_ipc.cpu_time = (double) lastusec;
g_ipc.cpu_time /= 1.0e6;
g_ipc.cpu_time += (double) lastsec;
/* gtri - end - 12/12/90 */
#endif
yy = TRUE;
#else
if (!name || eq(name, "totalcputime"))
fprintf(cp_out, "Total CPU time: ??.??? seconds.\n");
if (!name || eq(name, "cputime"))
fprintf(cp_out, "CPU time since last call: ??.??? seconds.\n");
yy = TRUE;
#endif
}
if (!name || eq(name, "space")) {
#ifdef ipsc
size_t usage = 0, limit = 0;
NXINFO cur = nxinfo, start = nxinfo_snap;
usage = cur.dataend - cur.datastart;
limit = start.availmem;
#else /* ipsc */
# ifdef HAVE_GETRLIMIT
size_t usage = 0, limit = 0;
struct rlimit rld;
char *hi;
getrlimit(RLIMIT_DATA, &rld);
limit = rld.rlim_cur - (size_t)(enddata - startdata);
hi = (char*) sbrk(0);
usage = (size_t) (hi - enddata);
# else /* HAVE_GETRLIMIT */
# ifdef HAVE_ULIMIT
size_t usage = 0, limit = 0;
char *hi;
limit = ulimit(3, 0L) - (size_t)(enddata - startdata);
hi = sbrk(0);
usage = (size_t) (hi - enddata);
# endif /* HAVE_ULIMIT */
# endif /* HAVE_GETRLIMIT */
#endif /* ipsc */
#if defined(HAVE_WIN32) || defined(HAVE__PROC_MEMINFO)
get_procm(&mem_ng_act);
get_sysmem(&mem_t_act);
/* get_sysmem returns bytes */
fprintf(cp_out, "Total DRAM available = ");
fprintmem(cp_out, mem_t_act.size);
fprintf(cp_out, ".\n");
fprintf(cp_out, "DRAM currently available = ");
fprintmem(cp_out, mem_t_act.free);
fprintf(cp_out, ".\n");
/* get_procm returns Kilobytes */
fprintf(cp_out, "Total ngspice program size = ");
fprintmem(cp_out, mem_ng_act.size*1024);
fprintf(cp_out, ".\n");
#if defined(HAVE__PROC_MEMINFO)
fprintf(cp_out, "Resident set size = ");
fprintmem(cp_out, mem_ng_act.resident*1024);
fprintf(cp_out, ".\n");
fprintf(cp_out, "Shared ngspice pages = ");
fprintmem(cp_out, mem_ng_act.shared*1024);
fprintf(cp_out, ".\n");
fprintf(cp_out, "Text (code) pages = ");
fprintmem(cp_out, mem_ng_act.trs*1024);
fprintf(cp_out, ".\n");
fprintf(cp_out, "Stack = ");
fprintmem(cp_out, mem_ng_act.drs*1024);
fprintf(cp_out, ".\n");
fprintf(cp_out, "Library pages = ");
fprintmem(cp_out, mem_ng_act.lrs*1024);
fprintf(cp_out, ".\n");
/* not used
fprintf(cp_out, "Dirty pages = ");
fprintmem(cp_out, all_memory.dt * 1024);
fprintf(cp_out, ".\n"); */
#endif /* HAVE__PROC_MEMINFO */
#else /* HAS_WINGUI or HAVE__PROC_MEMINFO */
fprintf(cp_out, "Current dynamic memory usage = ");
fprintmem(cp_out, usage);
fprintf(cp_out, ",\n");
fprintf(cp_out, "Dynamic memory limit = ");
fprintmem(cp_out, limit);
fprintf(cp_out, ".\n");
#endif
yy = TRUE;
}
if (!name || eq(name, "faults")) {
#ifdef HAVE_GETRUSAGE
int ret;
struct rusage ruse;
memset(&ruse, 0, sizeof(ruse));
ret = getrusage(RUSAGE_SELF, &ruse);
if (ret == -1)
perror("getrusage(): ");
fprintf(cp_out,
"%lu page faults, %lu vol + %lu invol = %lu context switches.\n",
ruse.ru_majflt, ruse.ru_nvcsw, ruse.ru_nivcsw,
ruse.ru_nvcsw + ruse.ru_nivcsw);
yy = TRUE;
#endif
}
/* PN Now get all the frontend resource stuff */
if (ft_curckt) {
if (name && eq(name, "task"))
vfree = v = ft_getstat(ft_curckt, NULL);
else
vfree = v = ft_getstat(ft_curckt, name);
if (name && v) {
fprintf(cp_out, "%s= ", v->va_name);
wl_print(cp_varwl(v), cp_out);
(void)putc('\n', cp_out);
yy = TRUE;
} else if (v) {
(void) putc('\n', cp_out);
while (v) {
wordlist *wlpr = cp_varwl(v);
fprintf(cp_out, "%s = ", v->va_name);
wl_print(wlpr, cp_out);
wl_free(wlpr);
(void) putc('\n', cp_out);
v = v->va_next;
}
yy = TRUE;
}
}
if (vfree)
free_struct_variable(vfree);
/* Now get all the spice resource stuff. */
if (ft_curckt && ft_curckt->ci_ckt) {
#ifdef CIDER
/* begin cider integration */
if (!name || eq(name, "circuit") || eq(name, "task"))
paramname = NULL;
else
paramname = name;
vfree = v = if_getstat(ft_curckt->ci_ckt, paramname);
if (paramname && v) {
/* end cider integration */
#else /* ~CIDER */
if (name && eq(name, "task"))
vfree = v = if_getstat(ft_curckt->ci_ckt, NULL);
else
vfree = v = if_getstat(ft_curckt->ci_ckt, name);
if (name && v) {
#endif
fprintf(cp_out, "%s = ", v->va_name);
wl_print(cp_varwl(v), cp_out);
(void) putc('\n', cp_out);
yy = TRUE;
} else if (v) {
(void) putc('\n', cp_out);
while (v) {
wordlist *wlpr = cp_varwl(v);
fprintf(cp_out, "%s = ", v->va_name);
wl_print(wlpr, cp_out);
wl_free(wlpr);
(void) putc('\n', cp_out);
v = v->va_next;
}
yy = TRUE;
}
#ifdef CIDER
/* begin cider integration */
/* Now print out interesting stuff about numerical devices. */
if (!name || eq(name, "devices")) {
(void) NDEVacct(ft_curckt->ci_ckt, cp_out);
yy = TRUE;
}
/* end cider integration */
#endif
}
if (!yy) {
fprintf(cp_err, "Note: no resource usage information for '%s',\n", name);
fprintf(cp_err, "\tor no active circuit available\n");
}
if (vfree)
free_struct_variable(vfree);
}
/* Print to stream the given memory size in a human friendly format */
static void
fprintmem(FILE *stream, unsigned long long memory) {
if (memory > 1048576)
fprintf(stream, "%8.6f MB", (double)memory / 1048576.);
else if (memory > 1024)
fprintf(stream, "%5.3f kB", (double)memory / 1024.);
else
fprintf(stream, "%llu bytes", memory);
}
#if defined(HAVE_WIN32) || defined(HAVE__PROC_MEMINFO)
static int get_procm(struct proc_mem *memall) {
#if defined(_MSC_VER) || defined(__MINGW32__)
#if (_WIN32_WINNT >= 0x0500) && defined(HAS_WINGUI)
/* Use Windows API function to obtain size of memory - more accurate */
HANDLE hProcess;
PROCESS_MEMORY_COUNTERS pmc;
DWORD procid = GetCurrentProcessId();
hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
FALSE, procid);
if (NULL == hProcess)
return 0;
/* psapi library required */
if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc))) {
memall->size = pmc.WorkingSetSize/1024;
memall->resident = pmc.QuotaNonPagedPoolUsage/1024;
memall->trs = pmc.QuotaPagedPoolUsage/1024;
} else {
CloseHandle(hProcess);
return 0;
}
CloseHandle(hProcess);
#else
/* Use Windows GlobalMemoryStatus or /proc/memory to obtain size of memory - not accurate */
get_sysmem(&mem_t_act); /* size is the difference between free memory at start time and now */
if (mem_t.free > mem_t_act.free) /* it can happen that that ngspice is */
memall->size = (mem_t.free - mem_t_act.free)/1024; /* to small compared to os memory usage */
else
memall->size = 0; /* sure, it is more */
memall->resident = 0;
memall->trs = 0;
#endif /* _WIN32_WINNT 0x0500 && HAS_WINGUI */
#else
/* Use Linux/UNIX /proc/<pid>/statm file information */
FILE *fp;
char buffer[1024], fibuf[100];
size_t bytes_read;
(void) sprintf(fibuf, "/proc/%d/statm", getpid());
if ((fp = fopen(fibuf, "r")) == NULL) {
perror("fopen(\"/proc/%d/statm\")");
return 0;
}
bytes_read = fread(buffer, 1, sizeof(buffer), fp);
fclose(fp);
if (bytes_read == 0 || bytes_read == sizeof(buffer))
return 0;
buffer[bytes_read] = '\0';
sscanf(buffer, "%llu %llu %llu %llu %llu %llu %llu", &memall->size, &memall->resident, &memall->shared, &memall->trs, &memall->drs, &memall->lrs, &memall->dt);
#endif
return 1;
}
static int
get_sysmem(struct sys_mem *memall)
{
#ifdef HAVE_WIN32
#if (_WIN32_WINNT >= 0x0500)
MEMORYSTATUSEX ms;
ms.dwLength = sizeof(MEMORYSTATUSEX);
GlobalMemoryStatusEx(&ms);
memall->size = ms.ullTotalPhys;
memall->free = ms.ullAvailPhys;
memall->swap_t = ms.ullTotalPageFile;
memall->swap_f = ms.ullAvailPageFile;
#else
MEMORYSTATUS ms;
ms.dwLength = sizeof(MEMORYSTATUS);
GlobalMemoryStatus(&ms);
memall->size = ms.dwTotalPhys;
memall->free = ms.dwAvailPhys;
memall->swap_t = ms.dwTotalPageFile;
memall->swap_f = ms.dwAvailPageFile;
#endif /*_WIN32_WINNT 0x0500*/
#else
FILE *fp;
char buffer[2048];
size_t bytes_read;
char *match;
unsigned long long mem_got;
if ((fp = fopen("/proc/meminfo", "r")) == NULL) {
perror("fopen(\"/proc/meminfo\")");
return 0;
}
bytes_read = fread(buffer, 1, sizeof(buffer), fp);
fclose(fp);
if (bytes_read == 0 || bytes_read == sizeof(buffer))
return 0;
buffer[bytes_read] = '\0';
/* Search for string "MemTotal" */
match = strstr(buffer, "MemTotal");
if (match == NULL) /* not found */
return 0;
sscanf(match, "MemTotal: %llu", &mem_got);
memall->size = mem_got*1024; /* 1MB = 1024KB */
/* Search for string "MemFree" */
match = strstr(buffer, "MemFree");
if (match == NULL) /* not found */
return 0;
sscanf(match, "MemFree: %llu", &mem_got);
memall->free = mem_got*1024; /* 1MB = 1024KB */
/* Search for string "SwapTotal" */
match = strstr(buffer, "SwapTotal");
if (match == NULL) /* not found */
return 0;
sscanf(match, "SwapTotal: %llu", &mem_got);
memall->swap_t = mem_got*1024; /* 1MB = 1024KB */
/* Search for string "SwapFree" */
match = strstr(buffer, "SwapFree");
if (match == NULL) /* not found */
return 0;
sscanf(match, "SwapFree: %llu", &mem_got);
memall->swap_f = mem_got*1024; /* 1MB = 1024KB */
#endif
return 1;
}
#else
#include <signal.h>
#include <setjmp.h>
/*
* baseaddr() returns the base address of the data segment on most Unix
* systems. It's an ugly hack for info that should be provided by the OS.
*/
/* Does anyone use a pagesize < 256 bytes?? I'll bet not;
* too small doesn't hurt
*/
#define LOG2_PAGESIZE 8
static JMP_BUF env;
static RETSIGTYPE
fault(void)
{
signal(SIGSEGV, (SIGNAL_FUNCTION) fault); /* SysV style */
LONGJMP(env, 1);
}
static void *
baseaddr(void)
{
#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(HAVE_WIN32) || defined(__APPLE__)
return 0;
#else
char *low, *high, *at;
long x;
RETSIGTYPE (*orig_signal)();
if (getenv("SPICE_NO_DATASEG_CHECK"))
return 0;
low = 0;
high = (char *) ((unsigned long) sbrk(0) & ~((1 << LOG2_PAGESIZE) - 1));
orig_signal = signal(SIGSEGV, (SIGNAL_FUNCTION) fault);
for (;;) {
at = (char *) ((((long)low >> LOG2_PAGESIZE) +
((long)high >> LOG2_PAGESIZE))
<< (LOG2_PAGESIZE - 1));
if (at == low || at == high)
break;
if (SETJMP(env, 1)) {
low = at;
continue;
} else {
x = *at;
}
if (SETJMP(env, 1)) {
low = at;
continue;
} else {
*at = x;
}
high = at;
}
(void) signal(SIGSEGV, (SIGNAL_FUNCTION) orig_signal);
return (void *) high;
#endif
}
#endif
# ifdef notdef
main()
{
printf("testing\n");
printf("baseaddr: %#8x topaddr: %#8x\n", baseaddr(), sbrk(0));
}
# endif
Reference in New Issue View Git Blame Copy Permalink