static void prstats(Agraph_t * g, int verbose)
{
#ifdef HAVE_VMALLOC
Vmstat_t ss, *s;
vmstat(g->cmn->heap, &ss);
s = &ss;
if (verbose)
fprintf(stderr,
"n_busy %d n_free %d s_busy %d s_free %d m_busy %d m_free %d n_seg %d extent %d\n",
s->n_busy, s->n_free, s->s_busy, s->s_free, s->m_busy,
s->m_free, s->n_seg, s->extent);
else
fprintf(stderr, "%d (%d,%d)\n", s->extent, s->s_busy, s->s_free);
#endif
}
static int
nomalloc(Vmalloc_t* region, int type, void* obj, Vmdisc_t* disc)
{
Vmstat_t st;
NoP(disc);
switch (type)
{
case VM_BADADDR:
error(ERROR_SYSTEM|3, "invalid pointer %p passed to free or realloc", obj);
return(-1);
case VM_NOMEM:
vmstat(region, &st);
error(ERROR_SYSTEM|3, "storage allocator out of space on %lu byte request ( region %lu segments %lu busy %lu:%lu:%lu free %lu:%lu:%lu )", (size_t)obj, st.extent, st.n_seg, st.n_busy, st.s_busy, st.m_busy, st.n_free, st.s_free, st.m_free);
return(-1);
}
return(0);
}
unsigned char *var_extensible_vmstat (struct variable *vp,
oid * name,
size_t * length, int exact, size_t * var_len, WriteMethod ** write_method)
{
static long long_ret;
static char errmsg[300];
long_ret = 0; /* set to 0 as default */
if (header_generic (vp, name, length, exact, var_len, write_method))
return (NULL);
switch (vp->magic)
{
case MIBINDEX:
long_ret = 1;
return ((u_char *) (&long_ret));
case ERRORNAME: /* dummy name */
sprintf (errmsg, "systemStats");
*var_len = strlen (errmsg);
return ((u_char *) (errmsg));
case SWAPIN:
long_ret = vmstat (swapin) & MAX_INT32;
return ((u_char *) (&long_ret));
case SWAPOUT:
long_ret = vmstat (swapout) & MAX_INT32;
return ((u_char *) (&long_ret));
case RAWSWAPIN:
long_ret = vmstat (rawswapin) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case RAWSWAPOUT:
long_ret = vmstat (rawswapout) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case IOSENT:
long_ret = vmstat (iosent) & MAX_INT32;
return ((u_char *) (&long_ret));
case IORECEIVE:
long_ret = vmstat (ioreceive) & MAX_INT32;
return ((u_char *) (&long_ret));
case IORAWSENT:
long_ret = vmstat (rawiosent) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case IORAWRECEIVE:
long_ret = vmstat (rawioreceive) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case SYSINTERRUPTS:
long_ret = vmstat (sysinterrupts) & MAX_INT32;
return ((u_char *) (&long_ret));
case SYSCONTEXT:
long_ret = vmstat (syscontext) & MAX_INT32;
return ((u_char *) (&long_ret));
case CPUUSER:
long_ret = vmstat (cpuuser) & MAX_INT32;
return ((u_char *) (&long_ret));
case CPUSYSTEM:
long_ret = vmstat (cpusystem) & MAX_INT32;
return ((u_char *) (&long_ret));
case CPUIDLE:
long_ret = vmstat (cpuidle) & MAX_INT32;
return ((u_char *) (&long_ret));
case CPURAWUSER:
long_ret = vmstat (cpurawuser) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case CPURAWNICE:
long_ret = vmstat (cpurawnice) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case CPURAWSYSTEM:
long_ret = (vmstat (cpurawsystem) + vmstat (cpurawinter) + vmstat (cpurawsoft)) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case CPURAWKERNEL:
long_ret = vmstat (cpurawsystem) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case CPURAWIDLE:
long_ret = vmstat (cpurawidle) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case SYSRAWINTERRUPTS:
long_ret = vmstat (rawinterrupts) & MAX_COUNTER;
return (u_char *) & long_ret;
case SYSRAWCONTEXT:
long_ret = vmstat (rawcontext) & MAX_COUNTER;
return (u_char *) & long_ret;
case CPURAWWAIT:
if (!has_cpu_26)
return NULL;
long_ret = vmstat (cpurawwait) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case CPURAWINTR:
if (!has_cpu_26)
return NULL;
long_ret = vmstat (cpurawinter) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case CPURAWSOFTIRQ:
if (!has_cpu_26)
return NULL;
long_ret = vmstat (cpurawsoft) & MAX_COUNTER;
return ((u_char *) (&long_ret));
/*
* reserved for future use
*/
/*
* case ERRORFLAG:
* return((u_char *) (&long_ret));
* case ERRORMSG:
* return((u_char *) (&long_ret));
*/
default:
snmp_log (LOG_ERR, "vmstat.c: don't know how to handle %d request\n", vp->magic);
}
return NULL;
}
tmain()
{
Obj_t *o, *next;
Void_t *huge;
size_t hugesz;
Vmstat_t sb;
ssize_t k, p;
srandom(0);
hugesz = Z_HUGE; /* one huge block to be resized occasionally */
if(!(huge = vmalloc(Vmregion, hugesz)) )
terror("Can't allocate block");
for(k = 0; k < N_OBJ; ++k)
{
/* free/resize all on this list */
for(o = List[k]; o; o = next)
{ next = o->next;
if((RAND()%2) == 0 ) /* flip a coin to see if freeing */
vmfree(Vmregion, o->obj);
else /* resizing */
{ o->size = ALLOCSIZE();
if(!(o->obj = vmresize(Vmregion,o->obj,o->size,VM_RSMOVE)) )
terror("Vmresize failed");
TIME(p, k, o->size); /* add to a future list */
o->next = List[p]; List[p] = o;
}
}
if(COMPACT(k)) /* global compaction */
{ if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Arena: busy=(%u,%u) free=(%u,%u) extent=%u #segs=%d",
sb.n_busy,sb.s_busy, sb.n_free,sb.s_free,
sb.extent, sb.n_seg);
if(vmcompact(Vmregion) < 0 )
terror("Vmcompact failed");
if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Compact: busy=(%u,%u) free=(%u,%u) extent=%u #segs=%d",
sb.n_busy,sb.s_busy, sb.n_free,sb.s_free,
sb.extent, sb.n_seg);
}
if(RESIZE(k)) /* make the huge block bigger */
{ hugesz += Z_HUGE;
if(!(huge = vmresize(Vmregion, huge, hugesz, VM_RSMOVE)) )
terror("Bad resize of huge block");
}
o = Obj+k; /* allocate a new block */
o->size = ALLOCSIZE();
if(!(o->obj = vmalloc(Vmregion, o->size)) )
terror("Vmalloc failed");
TIME(p, k, o->size);
o->next = List[p]; List[p] = o;
}
if(vmdbcheck(Vmregion) < 0)
terror("Corrupted region");
if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Full: Busy=(%u,%u) Free=(%u,%u) Extent=%u #segs=%d\n",
sb.n_busy, sb.s_busy, sb.n_free, sb.s_free, sb.extent, sb.n_seg);
if(vmcompact(Vmregion) < 0 )
terror("Vmcompact failed");
if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Compact: Busy=(%u,%u) Free=(%u,%u) Extent=%u #segs=%d\n",
sb.n_busy, sb.s_busy, sb.n_free, sb.s_free, sb.extent, sb.n_seg);
/* now free all left-overs */
for(o = List[N_OBJ]; o; o = o->next)
vmfree(Vmregion,o->obj);
vmfree(Vmregion,huge);
if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Free: Busy=(%u,%u) Free=(%u,%u) Extent=%u #segs=%d\n",
sb.n_busy, sb.s_busy, sb.n_free, sb.s_free, sb.extent, sb.n_seg);
if(vmcompact(Vmregion) < 0 )
terror("Vmcompact failed2");
if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Compact: Busy=(%u,%u) Free=(%u,%u) Extent=%u #segs=%d\n",
sb.n_busy, sb.s_busy, sb.n_free, sb.s_free, sb.extent, sb.n_seg);
if(!(huge = vmalloc(Vmregion, 10)))
terror("Vmalloc failed");
if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Small: Busy=(%u,%u) Free=(%u,%u) Extent=%u #segs=%d\n",
sb.n_busy, sb.s_busy, sb.n_free, sb.s_free, sb.extent, sb.n_seg);
texit(0);
}
void
finish(int n)
{
Rule_t* r;
int i;
/*
* old error intercept
*/
if (!state.hold && (r = internal.error) && (r->property & (P_target|P_functional)) == P_target)
{
state.hold = null;
if (n && error_info.errors && !state.compileonly && !state.interrupt)
{
if (r->status == NOTYET)
maketop(r, P_dontcare|P_foreground, NiL);
state.hold = 0;
if (r->status == EXISTS)
{
r->status = NOTYET;
return;
}
}
}
/*
* children exit without cleanup
*/
if (getpid() != state.pid)
_exit(n);
unparse(0);
switch (state.finish)
{
case 0:
/*
* disable listing and wait for any jobs to finish
*/
state.finish++;
alarm(0);
state.list = 0;
message((-1, "%s cleanup", state.interrupt ? "interrupt" : n > 0 ? "error" : "normal"));
complete(NiL, NiL, NiL, 0);
/*FALLTHROUGH*/
case 1:
/*
* make the done trap
*/
state.finish++;
if (!state.compileonly && (r = getrule(external.done)))
maketop(r, P_dontcare, NiL);
/*FALLTHROUGH*/
case 2:
/*
* make the makedone trap
*/
state.finish++;
if (!state.compileonly && (r = getrule(external.makedone)))
maketop(r, P_dontcare, NiL);
/*FALLTHROUGH*/
case 3:
/*
* wait for any job(s) to finish
*/
state.finish++;
complete(NiL, NiL, NiL, 0);
/*FALLTHROUGH*/
case 4:
/*
* put all jobs in foreground and save state
*/
state.finish++;
state.jobs = 0;
savestate();
/*FALLTHROUGH*/
case 5:
/*
* clean up temporaries
*/
state.finish++;
remtmp(1);
/*FALLTHROUGH*/
case 6:
/*
* drop the coshell
*/
state.finish++;
drop();
/*FALLTHROUGH*/
case 7:
/*
* dump
*/
state.finish++;
if (state.test & 0x00002000)
{
Vmstat_t vs;
vmstat(Vmheap, &vs);
error(0, "vm region %zu segments %zu busy %zu:%zu free %zu:%zu", vs.extent, vs.n_seg, vs.n_busy, vs.s_busy, vs.n_free, vs.s_free);
}
dump(sfstdout, error_info.trace <= -14);
/*FALLTHROUGH*/
case 8:
/*
* final output
*/
state.finish++;
if (state.errors && state.keepgoing && !n)
n = 1;
if (state.mam.out)
{
if (state.mam.regress)
sfprintf(state.mam.out, "%sinfo finish regression\n", state.mam.label);
else if (state.mam.dynamic || *state.mam.label)
sfprintf(state.mam.out, "%sinfo finish %lu %d\n", state.mam.label, CURTIME, n);
}
for (i = 0; i < elementsof(state.io); i++)
if (state.io[i] != sfstdin && state.io[i] != sfstdout && state.io[i] != sfstderr)
sfclose(state.io[i]);
if (state.errors && state.keepgoing)
error(2, "*** %d action%s failed", state.errors, state.errors == 1 ? null : "s");
message((-1, "%s exit", state.interrupt ? "interrupt" : n ? "error" : "normal"));
break;
}
if (state.interrupt)
{
n = 3;
signal(state.interrupt, SIG_DFL);
kill(getpid(), state.interrupt);
pause();
}
exit(n);
}
tmain()
{
int i, rv;
void *status;
char *objs[N_THREAD];
pthread_t thread[N_THREAD];
int nthreads = N_THREAD;
int iterations = ITERATIONS;
int objsize = OBJSIZE;
int repetitions = REPETITIONS;
#ifdef VMALLOC
Vmstat_t vmst;
#endif
tresource(-1, 0);
while(argc > 1)
{ if(argv[1][0] == '-' && argv[1][1] == 't')
nthreads = atoi(argv[1]+2);
else if(argv[1][0] == '-' && argv[1][1] == 'i')
iterations = atoi(argv[1]+2);
else if(argv[1][0] == '-' && argv[1][1] == 'r')
repetitions = atoi(argv[1]+2);
else if(argv[1][0] == '-' && argv[1][1] == 'z')
objsize = atoi(argv[1]+2);
argc--; argv++;
}
if(nthreads <= 0 || nthreads > N_THREAD)
terror("nthreads=%d must be in 1..%d", nthreads, N_THREAD);
if(repetitions < nthreads)
repetitions = 0;
tinfo("nthreads=%d iterations=%d objsize=%d repetitions=%d",
nthreads, iterations, objsize, repetitions );
for(i = 0; i < nthreads; ++i)
if(!(objs[i] = (char*)malloc(objsize)) )
terror("Can't allocate objs[%d]", i);
for(i = 0; i < nthreads; ++i)
{ Worker_t *w = (Worker_t*)malloc(sizeof(Worker_t));
w->object = objs[i];
w->objsize = objsize;
w->iterations = iterations;
w->repetitions = repetitions/nthreads;
if((rv = pthread_create(&thread[i], NULL, worker, (void*)w)) != 0)
terror("Failed to create thread %d", i);
}
for(i = 0; i < nthreads; ++i)
if((rv = pthread_join(thread[i], &status)) != 0)
terror("Failed waiting for thread %d", i);
tresource(0, 0);
#ifdef VMALLOC
vmstat(0, &vmst);
twarn(vmst.mesg);
#endif
texit(0);
}
