mirror of
https://github.com/urbit/shrub.git
synced 2024-12-22 18:31:44 +03:00
798 lines
14 KiB
C
798 lines
14 KiB
C
/* v/loop.c
|
|
**
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#include <setjmp.h>
|
|
#include <gmp.h>
|
|
#include <sigsegv.h>
|
|
#include <stdint.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <uv.h>
|
|
#include <errno.h>
|
|
#include <curses.h>
|
|
#include <termios.h>
|
|
#include <term.h>
|
|
|
|
#include "all.h"
|
|
#include "vere/vere.h"
|
|
|
|
#if 0
|
|
static jmp_buf Signal_buf;
|
|
#ifndef SIGSTKSZ
|
|
# define SIGSTKSZ 16384
|
|
#endif
|
|
static uint8_t Sigstk[SIGSTKSZ];
|
|
|
|
uint8_t u3_Critical;
|
|
|
|
typedef enum {
|
|
sig_none,
|
|
sig_overflow,
|
|
sig_interrupt,
|
|
sig_terminate,
|
|
sig_memory,
|
|
sig_assert,
|
|
sig_timer
|
|
} u3_kill;
|
|
|
|
volatile u3_kill Sigcause; // reasons for exception
|
|
|
|
static void _lo_cont(void *arg1, void *arg2, void *arg3)
|
|
{
|
|
(void)(arg1);
|
|
(void)(arg2);
|
|
(void)(arg3);
|
|
siglongjmp(Signal_buf, 1);
|
|
}
|
|
|
|
static void
|
|
_lo_signal_handle_over(int emergency, stackoverflow_context_t scp)
|
|
{
|
|
if ( u3_Critical ) {
|
|
// Careful not to grow the stack during critical sections.
|
|
//
|
|
write(2, "stack disaster\n", strlen("stack disaster" + 2));
|
|
abort();
|
|
}
|
|
|
|
#if 0
|
|
if ( 1 == emergency ) {
|
|
write(2, "stack emergency\n", strlen("stack emergency" + 2));
|
|
abort();
|
|
} else
|
|
#endif
|
|
{
|
|
Sigcause = sig_overflow;
|
|
sigsegv_leave_handler(_lo_cont, NULL, NULL, NULL);
|
|
}
|
|
}
|
|
|
|
static void
|
|
_lo_signal_handle_term(int x)
|
|
{
|
|
if ( !u3_Critical ) {
|
|
Sigcause = sig_terminate;
|
|
u3_Host.liv = c3n;
|
|
longjmp(Signal_buf, 1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
_lo_signal_handle_intr(int x)
|
|
{
|
|
if ( !u3_Critical ) {
|
|
Sigcause = sig_interrupt;
|
|
longjmp(Signal_buf, 1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
_lo_signal_handle_alrm(int x)
|
|
{
|
|
if ( !u3_Critical ) {
|
|
Sigcause = sig_timer;
|
|
longjmp(Signal_buf, 1);
|
|
}
|
|
}
|
|
|
|
/* _lo_signal_done():
|
|
*/
|
|
static void
|
|
_lo_signal_done()
|
|
{
|
|
// signal(SIGINT, SIG_IGN);
|
|
signal(SIGTERM, SIG_IGN);
|
|
signal(SIGVTALRM, SIG_IGN);
|
|
|
|
stackoverflow_deinstall_handler();
|
|
{
|
|
struct itimerval itm_u;
|
|
|
|
timerclear(&itm_u.it_interval);
|
|
timerclear(&itm_u.it_value);
|
|
|
|
setitimer(ITIMER_VIRTUAL, &itm_u, 0);
|
|
}
|
|
u3_unix_ef_move();
|
|
}
|
|
|
|
/* _lo_signal_deep(): start deep processing; set timer for sec_w or 0.
|
|
*/
|
|
static void
|
|
_lo_signal_deep(c3_w sec_w)
|
|
{
|
|
u3_unix_ef_hold();
|
|
|
|
stackoverflow_install_handler(_lo_signal_handle_over, Sigstk, SIGSTKSZ);
|
|
signal(SIGINT, _lo_signal_handle_intr);
|
|
signal(SIGTERM, _lo_signal_handle_term);
|
|
|
|
{
|
|
struct itimerval itm_u;
|
|
|
|
timerclear(&itm_u.it_interval);
|
|
itm_u.it_value.tv_sec = sec_w;
|
|
itm_u.it_value.tv_usec = 0;
|
|
|
|
setitimer(ITIMER_VIRTUAL, &itm_u, 0);
|
|
}
|
|
signal(SIGVTALRM, _lo_signal_handle_alrm);
|
|
}
|
|
#endif
|
|
|
|
/* u3_loop_signal_memory(): end computation for out-of-memory.
|
|
*/
|
|
void
|
|
u3_loop_signal_memory()
|
|
{
|
|
fprintf(stderr, "\r\nout of memory\r\n");
|
|
c3_assert(0);
|
|
|
|
#if 0
|
|
Sigcause = sig_memory;
|
|
longjmp(Signal_buf, 1);
|
|
#endif
|
|
}
|
|
|
|
/* _lo_init(): initialize I/O across the process.
|
|
*/
|
|
static void
|
|
_lo_init()
|
|
{
|
|
c3_l cod_l;
|
|
|
|
cod_l = u3a_lush(c3__unix);
|
|
u3_unix_io_init();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__ames);
|
|
u3_ames_io_init();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__term);
|
|
u3_term_io_init();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__http);
|
|
u3_http_io_init();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__cttp);
|
|
u3_cttp_io_init();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__save);
|
|
u3_save_io_init();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__behn);
|
|
u3_behn_io_init();
|
|
u3a_lop(cod_l);
|
|
}
|
|
|
|
/* _lo_talk(): bring up listeners across the process.
|
|
*/
|
|
static void
|
|
_lo_talk()
|
|
{
|
|
c3_l cod_l;
|
|
|
|
cod_l = u3a_lush(c3__unix);
|
|
u3_unix_io_talk();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__ames);
|
|
u3_ames_io_talk();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__http);
|
|
u3_http_io_talk();
|
|
u3a_lop(cod_l);
|
|
|
|
}
|
|
|
|
/* u3_lo_exit(): terminate I/O across the process.
|
|
*/
|
|
void
|
|
u3_lo_exit(void)
|
|
{
|
|
c3_l cod_l;
|
|
|
|
cod_l = u3a_lush(c3__unix);
|
|
u3_unix_io_exit();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__ames);
|
|
u3_ames_io_exit();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__term);
|
|
u3_term_io_exit();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__http);
|
|
u3_http_io_exit();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__cttp);
|
|
u3_cttp_io_exit();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__save);
|
|
u3_save_io_exit();
|
|
u3a_lop(cod_l);
|
|
|
|
cod_l = u3a_lush(c3__behn);
|
|
u3_behn_io_exit();
|
|
u3a_lop(cod_l);
|
|
|
|
if ( c3y == __(u3C.wag_w & u3o_trace) ) {
|
|
printf("saving trace file.\r\n");
|
|
u3t_trace_close();
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
/* _lo_how(): print how.
|
|
*/
|
|
static const c3_c*
|
|
_lo_how(u3_noun how)
|
|
{
|
|
switch ( how ) {
|
|
default: c3_assert(0); break;
|
|
|
|
case c3__ames: return "ames";
|
|
case c3__behn: return "behn";
|
|
case c3__term: return "cons";
|
|
case c3__htcn: return "http-conn";
|
|
case c3__htls: return "http-lisn";
|
|
case c3__save: return "save";
|
|
case c3__unix: return "unix";
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* u3_lo_bail(): clean up all event state.
|
|
*/
|
|
void
|
|
u3_lo_bail(void)
|
|
{
|
|
fflush(stdout);
|
|
u3_lo_exit();
|
|
|
|
exit(1);
|
|
}
|
|
|
|
/* _lo_tape(): dump a tape, old style. Don't do this.
|
|
*/
|
|
static void
|
|
_lo_tape(FILE* fil_u, u3_noun tep)
|
|
{
|
|
u3_noun tap = tep;
|
|
|
|
while ( u3_nul != tap ) {
|
|
c3_c car_c;
|
|
|
|
if ( u3h(tap) >= 127 ) {
|
|
car_c = '?';
|
|
} else car_c = u3h(tap);
|
|
|
|
putc(car_c, fil_u);
|
|
tap = u3t(tap);
|
|
}
|
|
u3z(tep);
|
|
}
|
|
|
|
/* _lo_wall(): dump a wall, old style. Don't do this.
|
|
*/
|
|
static void
|
|
_lo_wall(u3_noun wol)
|
|
{
|
|
FILE* fil_u = u3_term_io_hija();
|
|
u3_noun wal = wol;
|
|
|
|
while ( u3_nul != wal ) {
|
|
_lo_tape(fil_u, u3k(u3h(wal)));
|
|
|
|
putc(13, fil_u);
|
|
putc(10, fil_u);
|
|
|
|
wal = u3t(wal);
|
|
}
|
|
u3_term_io_loja(0);
|
|
u3z(wol);
|
|
}
|
|
|
|
/* u3_lo_tank(): dump single tank.
|
|
*/
|
|
void
|
|
u3_lo_tank(c3_l tab_l, u3_noun tac)
|
|
{
|
|
u3_lo_punt(tab_l, u3nc(tac, u3_nul));
|
|
}
|
|
|
|
/* u3_lo_punt(): dump tank list.
|
|
*/
|
|
void
|
|
u3_lo_punt(c3_l tab_l, u3_noun tac)
|
|
{
|
|
u3_noun blu = u3_term_get_blew(0);
|
|
c3_l col_l = u3h(blu);
|
|
u3_noun cat = tac;
|
|
|
|
// We are calling nock here, but hopefully need no protection.
|
|
//
|
|
while ( c3y == u3r_du(cat) ) {
|
|
u3_noun wol = u3dc("wash", u3nc(tab_l, col_l), u3k(u3h(cat)));
|
|
|
|
_lo_wall(wol);
|
|
cat = u3t(cat);
|
|
}
|
|
u3z(tac);
|
|
u3z(blu);
|
|
}
|
|
|
|
/* u3_lo_sway(): print trace.
|
|
*/
|
|
void
|
|
u3_lo_sway(c3_l tab_l, u3_noun tax)
|
|
{
|
|
u3_noun mok = u3dc("mook", 2, tax);
|
|
|
|
u3_lo_punt(tab_l, u3k(u3t(mok)));
|
|
u3z(mok);
|
|
}
|
|
|
|
/* _lo_time(): set time.
|
|
*/
|
|
static void
|
|
_lo_time(void)
|
|
{
|
|
struct timeval tim_tv;
|
|
|
|
gettimeofday(&tim_tv, 0);
|
|
u3v_time(u3_time_in_tv(&tim_tv));
|
|
}
|
|
|
|
/* u3_lo_open(): begin callback processing.
|
|
*/
|
|
void
|
|
u3_lo_open(void)
|
|
{
|
|
if ( u3C.wag_w & (u3o_debug_ram | u3o_check_corrupt) ) {
|
|
//
|
|
// Assumption: there are no noun roots outside u3A.
|
|
//
|
|
u3m_grab(u3_none);
|
|
}
|
|
#if 0
|
|
if ( u3C.wag_w & u3o_debug_cpu ) {
|
|
struct itimerval itm_u;
|
|
|
|
getitimer(ITIMER_VIRTUAL, &itm_u);
|
|
fprintf(stderr, "tv_sec %d, tv_usec %d, value %d/%d\r\n",
|
|
itm_u.it_interval.tv_sec,
|
|
itm_u.it_interval.tv_usec,
|
|
itm_u.it_value.tv_sec,
|
|
itm_u.it_interval.tv_usec);
|
|
}
|
|
#endif
|
|
_lo_time();
|
|
}
|
|
|
|
/* u3_lo_shut(): end callback processing.
|
|
*/
|
|
void
|
|
u3_lo_shut(c3_o inn)
|
|
{
|
|
// u3m_grab(u3_none);
|
|
|
|
// process actions
|
|
//
|
|
u3_raft_work();
|
|
|
|
// u3_lo_grab("lo_shut b", u3_none);
|
|
|
|
// update time
|
|
//
|
|
_lo_time();
|
|
|
|
// u3_lo_grab("lo_shut c", u3_none);
|
|
|
|
// for input operations, poll fs (XX not permanent)
|
|
// XX remove raty_lead guard
|
|
//
|
|
if ( c3y == inn ) {
|
|
u3_unix_ef_look(c3n);
|
|
u3_raft_work();
|
|
_lo_time();
|
|
}
|
|
|
|
// u3_lo_grab("lo_shut d", u3_none);
|
|
|
|
// clean shutdown
|
|
//
|
|
if ( c3n == u3_Host.liv ) {
|
|
// direct save and die
|
|
//
|
|
u3_raft_play();
|
|
// u3_lo_grab("lo_exit", u3_none);
|
|
// u3_loom_save(u3A->ent_d);
|
|
// u3_loom_exit();
|
|
u3t_damp();
|
|
u3_lo_exit();
|
|
|
|
// save a checkpoint before exiting
|
|
u3e_save();
|
|
exit(u3_Host.xit_i);
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
// _lo_bench_noop(): benchmark no-op events.
|
|
//
|
|
static void
|
|
_lo_bench_noop(c3_w num_w)
|
|
{
|
|
c3_w i_w;
|
|
|
|
for ( i_w = 0; i_w < num_w; i_w++ ) {
|
|
u3_reck_plan(u3A, u3nq(u3_blip, c3__term, 1, u3_nul),
|
|
u3nc(c3__noop, u3_nul));
|
|
}
|
|
|
|
u3_raft_work(u3A);
|
|
}
|
|
|
|
// _lo_bench_scot_p(): benchmark prettyprint.
|
|
//
|
|
static void
|
|
_lo_bench_scot_p(c3_w num_w)
|
|
{
|
|
c3_w i_w;
|
|
|
|
for ( i_w = 0; i_w < num_w; i_w++ ) {
|
|
u3_noun soc = u3dc("scot", 'p', u3k(u3A->now));
|
|
|
|
u3z(soc);
|
|
}
|
|
}
|
|
|
|
// _lo_bench_slay_p(): benchmark prettyprint.
|
|
//
|
|
static void
|
|
_lo_bench_slay_p(c3_w num_w)
|
|
{
|
|
c3_w i_w;
|
|
|
|
for ( i_w = 0; i_w < num_w; i_w++ ) {
|
|
u3_noun soc = u3dc("scot", 'p', u3k(u3A->now));
|
|
u3_noun dub = u3do("slay", soc);
|
|
|
|
u3z(dub);
|
|
}
|
|
}
|
|
|
|
// _lo_bench_scot_da(): benchmark prettyprint.
|
|
//
|
|
static void
|
|
_lo_bench_scot_da(c3_w num_w)
|
|
{
|
|
c3_w i_w;
|
|
|
|
for ( i_w = 0; i_w < num_w; i_w++ ) {
|
|
u3_noun soc = u3dc("scot", c3__da, u3k(u3A->now));
|
|
|
|
u3z(soc);
|
|
}
|
|
}
|
|
|
|
// _lo_bench_dec(): benchmark decrement.
|
|
//
|
|
static void
|
|
_lo_bench_dec(c3_w num_w)
|
|
{
|
|
c3_w i_w;
|
|
|
|
for ( i_w = 0; i_w < num_w; i_w++ ) {
|
|
u3_noun soc = u3do("dec", u3k(u3A->now));
|
|
|
|
u3z(soc);
|
|
}
|
|
}
|
|
|
|
// _lo_bench_scot_ud(): benchmark prettyprint.
|
|
//
|
|
static void
|
|
_lo_bench_scot_ud(c3_w num_w)
|
|
{
|
|
c3_w i_w;
|
|
|
|
for ( i_w = 0; i_w < num_w; i_w++ ) {
|
|
u3_noun soc = u3dc("scot", c3__ud, u3k(u3A->now));
|
|
|
|
u3z(soc);
|
|
}
|
|
}
|
|
|
|
// _lo_bench(): lo-tech profiling.
|
|
//
|
|
static void
|
|
_lo_bench(const c3_c* lab_c, void (*fun)(c3_w), c3_w num_w)
|
|
{
|
|
u3_noun old, new;
|
|
|
|
uL(fprintf(uH, "bench: %s: start...\n", lab_c));
|
|
u3_reck_time(u3A);
|
|
old = u3k(u3A->now);
|
|
|
|
fun(num_w);
|
|
|
|
u3_reck_time(u3A);
|
|
new = u3k(u3A->now);
|
|
{
|
|
c3_w tms_w = (c3_w)u3_time_gap_ms(old, new);
|
|
|
|
if ( tms_w > (10 * num_w) ) {
|
|
uL(fprintf(uH, "bench: %s*%d: %d ms, %d ms each.\n",
|
|
lab_c, num_w, tms_w, (tms_w / num_w)));
|
|
}
|
|
else {
|
|
uL(fprintf(uH, "bench: %s*%d: %d ms, %d us each.\n",
|
|
lab_c, num_w, tms_w, ((tms_w * 1000) / num_w)));
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* u3_lo_show(): generic noun print.
|
|
*/
|
|
void
|
|
u3_lo_show(c3_c* cap_c, u3_noun nun)
|
|
{
|
|
u3_noun pav = u3dc("pave", c3__noun, nun);
|
|
c3_c* txt_c = (c3_c*)u3r_tape(pav);
|
|
|
|
fprintf(stderr, "%s: %s\r\n", cap_c, txt_c);
|
|
u3z(pav);
|
|
free(txt_c);
|
|
}
|
|
|
|
static void
|
|
_lo_slow()
|
|
{
|
|
#if 0
|
|
_lo_bench("scot %p", _lo_bench_scot_p, 256);
|
|
_lo_bench("scot %da", _lo_bench_scot_da, 256);
|
|
_lo_bench("scot %ud", _lo_bench_scot_ud, 256);
|
|
_lo_bench("slay %p", _lo_bench_slay_p, 256);
|
|
_lo_bench("noop", _lo_bench_noop, 256);
|
|
#endif
|
|
}
|
|
|
|
/* u3_lo_loop(): begin main event loop.
|
|
*/
|
|
void
|
|
u3_lo_loop()
|
|
{
|
|
uv_loop_t* lup_u = uv_default_loop();
|
|
|
|
u3_Host.lup_u = lup_u;
|
|
|
|
signal(SIGPIPE, SIG_IGN); // pipe, schmipe
|
|
// signal(SIGIO, SIG_IGN); // linux is wont to produce for some reason
|
|
|
|
_lo_init();
|
|
|
|
u3_raft_init();
|
|
|
|
if ( _(u3_Host.ops_u.tex) ) {
|
|
u3t_boff();
|
|
u3t_damp();
|
|
u3_lo_exit();
|
|
|
|
fprintf(stderr, "dry run: exit\r\n");
|
|
exit(0);
|
|
}
|
|
else {
|
|
if ( c3n == u3_Host.ops_u.bat ) {
|
|
uv_run(u3L, UV_RUN_DEFAULT);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* u3_lo_lead(): actions on promotion to leader.
|
|
*/
|
|
void
|
|
u3_lo_lead(void)
|
|
{
|
|
// Further server configuration.
|
|
//
|
|
{
|
|
if ( c3n == u3_Host.ops_u.nuu ) {
|
|
u3_ames_ef_bake();
|
|
u3_behn_ef_bake();
|
|
}
|
|
|
|
u3_http_ef_bake();
|
|
}
|
|
|
|
_lo_talk();
|
|
{
|
|
u3_unix_ef_look(c3n);
|
|
u3v_plan(u3nt(u3_blip, c3__ames, u3_nul),
|
|
u3nc(c3__kick, u3k(u3A->now)));
|
|
}
|
|
|
|
#if 0
|
|
u3_loom_save(u3A->ent_d);
|
|
|
|
u3_Host.sav_u.ent_d = rec_u->ent_d;
|
|
#endif
|
|
|
|
if ( c3y == u3_Host.ops_u.nuu ) {
|
|
u3_term_ef_boil(1);
|
|
}
|
|
|
|
if ( c3y == u3_Host.ops_u.veb ) {
|
|
u3_term_ef_verb();
|
|
}
|
|
|
|
#if 1
|
|
_lo_slow();
|
|
#endif
|
|
}
|
|
|
|
#if 0
|
|
/* _lo_mark_reck(): mark a reck.
|
|
*/
|
|
static c3_w
|
|
_lo_mark_reck(u3_reck* rec_u)
|
|
{
|
|
c3_w siz_w = 0;
|
|
c3_w egg_w;
|
|
|
|
siz_w += u3m_mark_noun(rec_u->ken);
|
|
siz_w += u3m_mark_noun(rec_u->roc);
|
|
|
|
siz_w += u3m_mark_noun(rec_u->yot);
|
|
siz_w += u3m_mark_noun(rec_u->now);
|
|
siz_w += u3m_mark_noun(rec_u->wen);
|
|
siz_w += u3m_mark_noun(rec_u->sen);
|
|
siz_w += u3m_mark_noun(rec_u->own);
|
|
siz_w += u3m_mark_noun(rec_u->roe);
|
|
siz_w += u3m_mark_noun(rec_u->key);
|
|
|
|
{
|
|
u3_cart* egg_u;
|
|
|
|
egg_w = 0;
|
|
for ( egg_u = rec_u->ova.egg_u; egg_u; egg_u = egg_u->nex_u ) {
|
|
egg_w += u3m_mark_noun(egg_u->vir);
|
|
}
|
|
siz_w += egg_w;
|
|
}
|
|
#if 0
|
|
fprintf(stderr, "ken %d, roc %d, yot %d, roe %d, egg %d\r\n",
|
|
ken_w, roc_w, yot_w, roe_w, egg_w);
|
|
#endif
|
|
return siz_w;
|
|
}
|
|
|
|
/* _lo_mark(): mark the whole vere system.
|
|
*/
|
|
static c3_w
|
|
_lo_mark()
|
|
{
|
|
c3_w siz_w;
|
|
|
|
siz_w = u3m_mark_internal();
|
|
siz_w += _lo_mark_reck(u3_Host.arv_u);
|
|
|
|
return siz_w;
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
/* _lo_word(): print a word to the passed stream.
|
|
*/
|
|
static void
|
|
_lo_word(FILE* fil_u, c3_w wod_w)
|
|
{
|
|
u3_noun top = c3y;
|
|
|
|
if ( wod_w / (1000 * 1000 * 1000) ) {
|
|
fprintf(fil_u, "%u.", wod_w / (1000 * 1000 * 1000));
|
|
wod_w %= (1000 * 1000 * 1000);
|
|
top = c3n;
|
|
}
|
|
if ( wod_w / (1000 * 1000) ) {
|
|
fprintf(fil_u, ((top == c3y) ? "%u." : "%03u."),
|
|
wod_w / (1000 * 1000));
|
|
wod_w %= (1000 * 1000);
|
|
top = c3n;
|
|
}
|
|
if ( wod_w / 1000 ) {
|
|
fprintf(fil_u, ((top == c3y) ? "%u." : "%03u."), wod_w / 1000);
|
|
wod_w %= 1000;
|
|
top = c3n;
|
|
}
|
|
fprintf(fil_u, ((top == c3y) ? "%u" : "%03u"), wod_w);
|
|
}
|
|
|
|
/* u3_lo_grab(): garbage-collect the world, plus roots.
|
|
*/
|
|
void
|
|
u3_lo_grab(c3_c* cap_c, u3_noun som, ...)
|
|
{
|
|
c3_w siz_w, lec_w;
|
|
|
|
siz_w = _lo_mark();
|
|
{
|
|
va_list vap;
|
|
u3_noun tur;
|
|
|
|
va_start(vap, som);
|
|
|
|
if ( som != u3_none ) {
|
|
siz_w += u3m_mark_noun(som);
|
|
|
|
while ( u3_none != (tur = va_arg(vap, u3_noun)) ) {
|
|
siz_w += u3m_mark_noun(tur);
|
|
}
|
|
}
|
|
va_end(vap);
|
|
}
|
|
lec_w = u3m_sweep(siz_w);
|
|
|
|
// if ( lec_w || (c3y == u3_Flag_Verbose) )
|
|
if ( lec_w || !strcmp("init", cap_c) ) {
|
|
FILE* fil_u = uH;
|
|
fprintf(fil_u, "%s: gc: ", cap_c);
|
|
if ( lec_w ) {
|
|
_lo_word(fil_u, 4 * lec_w);
|
|
fprintf(fil_u, " bytes shed; ");
|
|
}
|
|
_lo_word(fil_u, 4 * siz_w);
|
|
uL(fprintf(fil_u, " bytes live\n"));
|
|
|
|
#if 0
|
|
if ( lec_w ) {
|
|
uL(fprintf(uH, "zero garbage tolerance!\n"));
|
|
u3_lo_exit();
|
|
c3_assert(0);
|
|
exit(1);
|
|
}
|
|
#endif
|
|
}
|
|
u3_wire_lan(u3_Wire) = c3y;
|
|
}
|
|
#endif
|