alarm.c

一个内存数据库的源代码这是服务器端还有客户端

#line 83 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/alarm.mx"
#include "mal_config.h"
#include "alarm.h"
#include <time.h>

#ifdef WIN32
#ifndef LIBALARM
#define alarm_export extern __declspec(dllimport)
#else
#define alarm_export extern __declspec(dllexport)
#endif
#else
#define alarm_export extern
#endif

alarm_export str ALARMprelude(void);
alarm_export str ALARMepilogue(void);
alarm_export str ALARMusec(lng *ret);
alarm_export str ALARMsleep(int *res, int *secs);
alarm_export str ALARMsetalarm(int *res, int *secs, str *action);
alarm_export str ALARMtimers(int *res);
alarm_export str ALARMctime(str *res);
alarm_export str ALARMepoch(int *res);
alarm_export str ALARMtime(int *res);

static monet_timer_t timer[MAXtimer];
static int timerTop = 0;



#line 116 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/alarm.mx"
#ifdef SIGALRM
void
CLKinitTimer(int sec, int usec)
{
	int i = sec - time(0);

	(void) usec;
	TRGDEBUG THRprintf(GDKout, "#CLKinitTimer: set timer to %d secs \n", i);

	alarm(i);
}
#endif


#line 132 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/alarm.mx"
#ifdef SIGALRM
void
CLKalarm(time_t t, str action)
{
	int j;
	int k;

	TRGDEBUG THRprintf(GDKout, "#CLKalarm: push " LLFMT "\n", (lng) t);

	if (timerTop == MAXtimer) {
		GDKerror("CLKalarm: timer stack overflow\n");
		return;
	}
	for (j = 0; j < timerTop; j++) {
		if (timer[j].alarm_time > t)
			break;
	}
	for (k = timerTop; k > j; k--) {
		timer[k] = timer[k - 1];
	}
	timer[k].alarm_time = t;
	if (action) {
		timer[k].action = GDKstrdup(action);
	} else {
		timer[k].action = 0;
		MT_init_sema(timer[k].sema, 0);
	}
	if (k == timerTop++) {
		CLKinitTimer(t, 0);	/* set it sooner */
	}
}
#endif


#line 168 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/alarm.mx"
#ifdef SIGALRM
/* HACK to pacify compiler */
#if (defined(__INTEL_COMPILER) && (SIZEOF_VOID_P > SIZEOF_INT))
#undef  SIG_ERR			/*((__sighandler_t)-1 ) */
#define SIG_ERR   ((__sighandler_t)-1L)
#endif
static RETSIGTYPE
CLKsignal(int nr)
{
	/* int restype; */
	int k = timerTop;
	int t;

	(void) nr;

	if (signal(SIGALRM, CLKsignal) == SIG_ERR) {
		GDKsyserror("CLKsignal: call failed\n");
	}
	TRGDEBUG THRprintf(GDKout, "#alarm signal (timeTop=%d)\n", timerTop);

	if (timerTop == 0) {
		return;
	}
	t = time(0);
	while (k-- && t >= timer[k].alarm_time) {
		if (timer[k].action) {
			TRGDEBUG THRprintf(GDKout, "#eval(%s)\n", timer[k].action);

			/* monet_eval(timer[k].action, &restype); */
			GDKfree(timer[k].action);
		} else {
			MT_up_sema(timer[k].sema, "CLKsignal");
		}
		timerTop--;
	}
	if (timerTop > 0) {
		CLKinitTimer(timer[timerTop - 1].alarm_time, 0);
	}
}
#endif

bat *
CLKprelude(void)
{
#ifdef SIGALRM
	(void) signal(SIGALRM, CLKsignal);
#endif
	return NULL;
}

void
CLKepilogue(void)
{
	int k;

#if (defined(SIGALRM) && defined(SIG_IGN))
/* HACK to pacify compiler */
#if (defined(__INTEL_COMPILER) && (SIZEOF_VOID_P > SIZEOF_INT))
#undef  SIG_IGN			/*((__sighandler_t)1 ) */
#define SIG_IGN   ((__sighandler_t)1L)
#endif
	(void) signal(SIGALRM, SIG_IGN);
#endif
	for (k = 0; k < timerTop; k++) {
		if (timer[k].action)
			GDKfree(timer[k].action);
	}
}


int
CMDsleep(int *secs)
{

	if (*secs < 0) {
		GDKerror("CMDsleep: negative delay\n");
		return GDK_FAIL;
	} else {
#ifdef __CYGWIN__
		/* CYGWIN cannot handle SIGALRM with sleep */
		lng t = GDKusec() + (*secs)*1000000;
		
		while (GDKusec() < t)
			;
#else
		MT_sleep_ms(*secs * 1000);
#endif
	}
	return GDK_SUCCEED;
}

int
CMDalarm(int *secs, str action)
{
	if (*secs < 0) {
		GDKerror("CMDalarm: negative delay\n");
		return GDK_FAIL;
	} else {
#ifndef SIGALRM
		(void)action;
		GDKerror("CMDalarm: not implemented\n");
		return GDK_FAIL;
#else
		CLKalarm(time(0) + *secs, action);
#endif
	}
	return GDK_SUCCEED;
}



#line 284 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/alarm.mx"
int
CMDtimers(BAT **retval)
{
	char buf[27];
	int k;

	*retval = BATnew(TYPE_str, TYPE_str, timerTop);
	if (*retval == NULL)
		return GDK_FAIL;
	BATroles(*retval, "alarm", "action");
	for (k = 0; k < timerTop; k++) {
		time_t t = timer[k].alarm_time;

#ifdef HAVE_CTIME_R3
		ctime_r(&t, buf, sizeof(buf));
#else
#ifdef HAVE_CTIME_R
		ctime_r(&t, buf);
#else
		strncpy(buf, ctime(&t), sizeof(buf));
#endif
#endif
		BUNins(*retval, buf, timer[k].action ? timer[k].action : "barrier", FALSE);
	}
	return GDK_SUCCEED;
}

int
CMDctime(str *retval)
{
	time_t t = time(0);

#ifdef HAVE_CTIME_R3
	char buf[26];

	*retval = GDKstrdup(ctime_r(&t, buf, sizeof(buf)));
#else
#ifdef HAVE_CTIME_R
	char buf[26];

	*retval = GDKstrdup(ctime_r(&t, buf));
#else
	*retval = GDKstrdup(ctime(&t));
#endif
#endif
	return GDK_SUCCEED;
}

int
CMDepoch(int *retval)		/* XXX should be lng */
{
	*retval = (int) time(0);
	return GDK_SUCCEED;
}

/* should return lng */
int
CMDusec(lng *retval)
{
	*retval = GDKusec();
	return GDK_SUCCEED;
}

int
CMDtime(int *retval)
{
	*retval = GDKms();
	return GDK_SUCCEED;
}



#line 357 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/alarm.mx"
#include "mal.h"
#include "mal_exception.h"

void
ALARMinitTimer(int sec, int usec)
{
	(void) sec;
	(void) usec;
#ifdef SIGALRM
	CLKinitTimer(sec, usec);
#endif
}

#ifdef SIGALRM
str
ALARMalarm(int t, str *action)
{
	CLKalarm(t, *action);
	return MAL_SUCCEED;
}
#endif

str
ALARMprelude()
{
#ifdef SIGALRM
	(void) signal(SIGALRM, (void (*)()) CLKsignal);
#endif
	return MAL_SUCCEED;
}

str
ALARMepilogue()
{
	CLKepilogue();
	return MAL_SUCCEED;
}

str
ALARMusec(lng *ret)
{
	CMDusec(ret);
	return MAL_SUCCEED;
}

str
ALARMsleep(int *res, int *secs)
{
	(void) res;		/* fool compilers */
	CMDsleep(secs);
	return MAL_SUCCEED;
}

str
ALARMsetalarm(int *res, int *secs, str *action)
{
	(void) res;
	(void) secs;
	(void) action;		/* foolc compiler */
	throw(MAL, "alarm.setalarm", "Not yet implemented");
}

str
ALARMtimers(int *res)
{
	(void) res;		/* fool compiler */
	throw(MAL, "alarm.timers", "Not yet implemented");
}

str
ALARMctime(str *res)
{
	CMDctime(res);
	return MAL_SUCCEED;
}

str
ALARMepoch(int *res)
{
	CMDepoch(res);
	return MAL_SUCCEED;
}

str
ALARMtime(int *res)
{
	CMDtime(res);
	return MAL_SUCCEED;
}



#line 448 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/alarm.mx"