Exemple #1
0
//---------------------------------------------------------------------------
int main(void)
{
    Kernel_Init();

    Thread_Init( &stMainThread,
                 aucMainStack,
                 MAIN_STACK_SIZE,
                 1,
                 (ThreadEntry_t)AppMain,
                 NULL );

    Thread_Init( &stIdleThread,
                 aucIdleStack,
                 MAIN_STACK_SIZE,
                 0,
                 (ThreadEntry_t)IdleMain,
                 NULL );

    Thread_Start( &stMainThread );
    Thread_Start( &stIdleThread );

    Driver_SetName( (Driver_t*) &stUART, "/dev/tty");
    ATMegaUART_Init( &stUART );
    
    DriverList_Add( (Driver_t*)&stUART );
    
    Kernel_Start();
}
Exemple #2
0
//---------------------------------------------------------------------------
int main(void)
{
    // See the annotations in lab1.
    Kernel_Init();

    // In this exercise, we create two threads at the same priority level.
    // As a result, the CPU will automatically swap between these threads
    // at runtime to ensure that each get a chance to execute.

    Thread_Init( &stApp1Thread, awApp1Stack,  APP1_STACK_SIZE,  1, App1Main,  0);
    Thread_Init( &stApp2Thread, awApp2Stack,  APP2_STACK_SIZE,  1, App2Main,  0);

    // Set the threads up so that Thread 1 can get 4ms of CPU time uninterrupted,
    // but Thread 2 can get 8ms of CPU time uninterrupted.  This means that
    // in an ideal situation, Thread 2 will get to do twice as much work as
    // Thread 1 - even though they share the same scheduling priority.

    // Note that if SetQuantum() isn't called on a thread, a default value
    // is set such that each thread gets equal timeslicing in the same
    // priority group by default.  You can play around with these values and
    // observe how it affects the execution of both threads.

    Thread_SetQuantum( &stApp1Thread, 4 );
    Thread_SetQuantum( &stApp2Thread, 8 );

    Thread_Start( &stApp1Thread );
    Thread_Start( &stApp2Thread );

    Kernel_Start();

    return 0;
}
Exemple #3
0
/**
 * @brief
 */
static void Frame(const uint32_t msec) {

	Cbuf_Execute();

	if (threads->modified) {
		threads->modified = false;

		Thread_Shutdown();
		Thread_Init(threads->integer);
	}

	if (game->modified) {
		game->modified = false;

		Fs_SetGame(game->string);

		if (Fs_Exists("autoexec.cfg")) {
			Cbuf_AddText("exec autoexec.cfg\n");
			Cbuf_Execute();
		}
	}

	Sv_Frame(msec);

	Cl_Frame(msec);
}
Exemple #4
0
/*
 * @brief Setup fixture.
 */
void setup(void) {

    Mem_Init();

    Thread_Init(2);

    memset(&cs, 0, sizeof(cs));
}
Exemple #5
0
//---------------------------------------------------------------------------
int main(void)
{
    // See the annotations in previous labs for details on init.
    Kernel_Init();

    Thread_Init( &stApp1Thread, awApp1Stack,  APP1_STACK_SIZE,  1, App1Main,  0);
    Thread_Init( &stApp2Thread, awApp2Stack,  APP2_STACK_SIZE,  1, App2Main,  0);

    Thread_Start( &stApp1Thread );
    Thread_Start( &stApp2Thread );
	
    EventFlag_Init( &stFlags );
    
    Kernel_Start();

    return 0;
}
Exemple #6
0
//---------------------------------------------------------------------------
int main(void)
{
    // See the annotations in previous labs for details on init.
    Kernel_Init();

	Thread_Init( &stApp1Thread, awApp1Stack,  APP1_STACK_SIZE,  1, App1Main,  0);
    Thread_Init( &stApp2Thread, awApp2Stack,  APP2_STACK_SIZE,  1, App2Main,  0);

    Thread_Start( &stApp1Thread );
    Thread_Start( &stApp2Thread );

    // Initialize the mutex used in this example.
	Mutex_Init( &stMyMutex );    

    Kernel_Start();

    return 0;
}
Exemple #7
0
IoObject *IoThread_threadCount(IoObject *self, IoObject *locals, IoMessage *m)
{
	Thread_Init();
	List *threads;
	size_t count;

	threads = Thread_Threads();
	count = List_size(threads);
	List_free(threads);

	return IONUMBER(count);
}
static int
NsThread_Init (Tcl_Interp *interp, void *cd)
{
    struct mydata *md = (struct mydata*)cd;
    int ret = Thread_Init(interp);

    if (ret != TCL_OK) {
        Ns_Log(Warning, "can't load module %s: %s", md->modname,
               Tcl_GetStringResult(interp));
        return TCL_ERROR;
    }
    Tcl_SetAssocData(interp, "thread:nsd", NULL, (ClientData)md);

    return TCL_OK;
}
Exemple #9
0
/**
 ****************************************************
 * \fn void TPOS_Init(void) 
 ****************************************************
 */
void 
TPOS_Init(void) 
{
	Thread *th;
	uint16_t i;

	Thread_Current()->next = NULL;
	EV_Init(&Thread_Current()->wakeEvent,TPos_ThreadWake,Thread_Current());
	for(i = 1; i < THREAD_POOL_SIZE; i++) {
		th = Thread_Alloc();		
		Thread_Init(th,EV_Loop);
		th->next = unusedqHead;		
		unusedqHead = th;
		EV_Init(&th->wakeEvent,TPos_ThreadWake,th);
	}
	Mutex_Init(&testRSema);
}
Exemple #10
0
/*******************************************************************************
  函数名:  	main
功能说明:	主函数
	参数:  	无
  返回值:  	无
*******************************************************************************/
int main(void)
{
	Thread_Init();
	SysHard_Init();		//系统相关硬件初始化
	WDG_Init(5,2000);
	FIFOInit();			//初始化队列缓冲区
	Instruct_Init();
	DeviceResetCheck_Init();
	Test_Init();
	Unit_Init();
		            
	while(1)
	{
		Process_FIFOData(&rcv433fifo, &rcv_433); 		//处理接收FIFO	
		Process_FIFOData(&rcv433_shortfifo, &rcv_433short); 		//处理接收FIFO		
		Thread_Process();
	}
}
/*******************************************************************************
  函数名:  	main
  功能说明:	主函数
  参    数:  	无
  返回值:  	无
*******************************************************************************/
int main(void)
{
	Key_Init();
	KeyLowPowerHandle();
	Thread_Init();	
 	SysHard_Init();		//系统相关硬件初始化        
	FIFOInit();			//初始化队列缓冲区
	Instruct_Init();
	DeviceResetCheck_Init();
	Test_Init();
	Unit_Init();
	KeyTimer_Init();
	
	while(1)
	{
		Process_FIFOData(&rcv433fifo, &rcv_433); 		//处理接收FIFO	
		Thread_Process();      
	}
}
Exemple #12
0
IoThread *IoThread_proto(void *state)
{
	IoThread *self = IoObject_new(state);
	IoObject_tag_(self, IoThread_newTag(state));

	IoState_registerProtoWithFunc_(state, self, IoThread_proto);

	{
		IoMethodTable methodTable[] = {
		{"threadCount", IoThread_threadCount},
		{"createThread", IoThread_createThread},
		//{"endCurrentThread", IoThread_endCurrentThread},
		{NULL, NULL},
		};
		IoObject_addMethodTable_(self, methodTable);
	}

	Thread_Init();

	return self;
}
Exemple #13
0
IoObject *IoThread_createThread(IoObject *self, IoObject *locals, IoMessage *m)
{
	IoSeq *s = IoMessage_locals_seqArgAt_(m, locals, 0);
	IoState *newState = IoState_new();
	Thread *t;

	Thread_Init();

	t = Thread_new();

	IoThreadInfo *ti = IoThreadInfo_new();
	IoThreadInfo_setState_(ti, newState);
	IoThreadInfo_setThread_(ti, t);
	IoThreadInfo_setEvalString_(ti, CSTRING(s));

	Thread_setFunc_(t, IoThread_BeginThread);
	Thread_setFuncArg_(t, (void *)ti);
	Thread_start(t);

	return self;
}
Exemple #14
0
//---------------------------------------------------------------------------
static void Thread_Profiling()
{
    K_USHORT i;
    
    for (i = 0; i < 100; i++)
    {
        // Profile the amount of time it takes to initialize a representative
        // test Thread_t, simulating an "average" system Thread_t.  Create the
        // Thread_t at a higher priority than the current Thread_t.
        ProfileTimer_Start( &stThreadInitTimer );
        Thread_Init( &stTestThread1, aucTestStack1, TEST_STACK1_SIZE, 2, (ThreadEntry_t)Thread_ProfilingThread, NULL);
        ProfileTimer_Stop( &stThreadInitTimer );
        
        // Profile the time it takes from calling "start" to the time when the
        // Thread_t becomes active
        ProfileTimer_Start( &stThreadStartTimer );
        
        Thread_Start( &stTestThread1 ); //-- Switch to the test Thread_t --
        
        // Stop the Thread_t-exit profiling timer, which was started from the
        // test Thread_t
        ProfileTimer_Stop( &stThreadExitTimer );
    }
    
    Scheduler_SetScheduler(0);
    for (i = 0; i < 100; i++)
    {
        // Context switch profiling - this is equivalent to what's actually
        // done within the AVR-implementation.
        ProfileTimer_Start( &stContextSwitchTimer );
        {
            Thread_SaveContext();
            g_pstNext = g_pstCurrent;
            Thread_RestoreContext();
        }
        ProfileTimer_Stop( &stContextSwitchTimer );
    }
    Scheduler_SetScheduler(1);
}
Exemple #15
0
int Libsqlite_Init( Tcl_Interp *interp) {
#ifdef TCL_THREADS
  if (Thread_Init(interp) == TCL_ERROR) {
    return TCL_ERROR;
  }
#endif
  Sqlite_Init(interp);
#ifdef SQLITE_TEST
  {
    extern int Sqlitetest1_Init(Tcl_Interp*);
    extern int Sqlitetest2_Init(Tcl_Interp*);
    extern int Sqlitetest3_Init(Tcl_Interp*);
    extern int Md5_Init(Tcl_Interp*);
    Sqlitetest1_Init(interp);
    Sqlitetest2_Init(interp);
    Sqlitetest3_Init(interp);
    Md5_Init(interp);
    Tcl_StaticPackage(interp, "sqlite", Libsqlite_Init, Libsqlite_Init);
  }
#endif
  return TCL_OK;
}
Exemple #16
0
//---------------------------------------------------------------------------
static void Semaphore_Profiling()
{
    Semaphore_t stSem;

    K_USHORT i;
    
    for (i = 0; i < 100; i++)
    {
        ProfileTimer_Start( &stSemInitTimer );
        Semaphore_Init( &stSem, 0, 1000);
        ProfileTimer_Stop( &stSemInitTimer );
    }

    for (i = 0; i < 100; i++)
    {        
        ProfileTimer_Start( &stSemPostTimer );
        Semaphore_Post( &stSem );
        ProfileTimer_Stop( &stSemPostTimer );
    }
    
    for (i = 0; i < 100; i++)
    {    
        ProfileTimer_Start( &stSemPendTimer );
        Semaphore_Pend( &stSem );
        ProfileTimer_Stop( &stSemPendTimer );
    }
    
    Semaphore_Init( &stSem, 0, 1);
    for (i = 0; i < 100; i++)
    {
        Thread_Init( &stTestThread1, aucTestStack1, TEST_STACK1_SIZE, 2, (ThreadEntry_t)Semaphore_Flyback, (void*)&stSem);
        Thread_Start( &stTestThread1 );
        
        Semaphore_Post( &stSem );
    }
    
    return;
}
Exemple #17
0
/*
** This routine runs first.  
*/
int main(int argc, char **argv){
  Tcl_Interp *interp;
  char *args;
  char buf[100];
  int tty;
  char TCLdir[20];
  char TKdir[20];
  char autopath[20];
  char sourceCmd[80];

#ifdef WITHOUT_TK
    Tcl_Obj *resultPtr;
    Tcl_Obj *commandPtr = NULL;
    char buffer[1000];
    int code, gotPartial, length;
    Tcl_Channel inChannel, outChannel, errChannel;
#endif

  /* Create a Tcl interpreter
  */
  Tcl_FindExecutable(argv[0]);
  interp = Tcl_CreateInterp();
  if( Tcl_PkgRequire(interp, "Tcl", TCL_VERSION, 1)==0 ){
    return 1;
  }
  args = Tcl_Merge(argc-1, (CONST84 char * CONST *)argv+1);
  Tcl_SetVar(interp, "argv", args, TCL_GLOBAL_ONLY);
  ckfree(args);
  sprintf(buf, "%d", argc-1);
  Tcl_SetVar(interp, "argc", buf, TCL_GLOBAL_ONLY);
  Tcl_SetVar(interp, "argv0", argv[0], TCL_GLOBAL_ONLY);
  tty = isatty(0);
  Tcl_SetVar(interp, "tcl_interactive", "0", TCL_GLOBAL_ONLY);

  /* We have to initialize the virtual filesystem before calling
  ** Tcl_Init().  Otherwise, Tcl_Init() will not be able to find
  ** its startup script files.
  */

  Zvfs_Init(interp);
  Tcl_SetVar(interp, "extname", "", TCL_GLOBAL_ONLY);
  Zvfs_Mount(interp, (char *)Tcl_GetNameOfExecutable(), "/");
  sprintf(TCLdir, "%s/tcl", mountPt);
  Tcl_SetVar2(interp, "env", "TCL_LIBRARY", TCLdir, TCL_GLOBAL_ONLY);
  sprintf(TKdir, "%s/tk", mountPt);
  Tcl_SetVar2(interp, "env", "TK_LIBRARY", TKdir, TCL_GLOBAL_ONLY);

  /* Initialize Tcl and Tk
  */
  if( Tcl_Init(interp) ) return TCL_ERROR;

  sprintf(autopath, " %s", TCLdir);
  Tcl_SetVar(interp, "auto_path", autopath, TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);
  Tcl_SetVar(interp, "tcl_libPath", TCLdir, TCL_GLOBAL_ONLY);

#ifdef WITHOUT_TK
  Tcl_SetVar(interp, "extname", "tclsh", TCL_GLOBAL_ONLY);
#else
  Tk_InitConsoleChannels(interp);
  if ( Tk_Init(interp) ) {
       return TCL_ERROR;
    }

  Tcl_StaticPackage(interp,"Tk", Tk_Init, 0);
  Tk_CreateConsoleWindow(interp);
#endif

  /* Start up all extensions.
  */
#if defined(__WIN32__)
  /* DRL - Do the standard Windows extentions */

  if (Registry_Init(interp) == TCL_ERROR) {
      return TCL_ERROR;
     }
  Tcl_StaticPackage(interp, "Registry", Registry_Init, 0);

  if (Dde_Init(interp) == TCL_ERROR) {
      return TCL_ERROR;
     }
  Tcl_StaticPackage(interp, "Dde", Dde_Init, 0);
#endif

#ifndef WITHOUT_TDOM
  if (Tdom_Init(interp) == TCL_ERROR) {
      return TCL_ERROR;
     }

  Tcl_StaticPackage(interp, "Tdom", Tdom_Init, Tdom_SafeInit);
#endif

#ifndef WITHOUT_TLS
  if (Tls_Init(interp) == TCL_ERROR) {
      return TCL_ERROR;
     }

  Tcl_StaticPackage(interp, "Tls", Tls_Init, Tls_SafeInit);
#endif

/*
#ifndef WITHOUT_MKZIPLIB
  if (Mkziplib_Init(interp) == TCL_ERROR) {
      return TCL_ERROR;
     }

  Tcl_StaticPackage(interp, "Mkziplib", Mkziplib_Init, Mkziplib_SafeInit);
#endif
*/

#ifndef WITHOUT_XOTCL
  if (Xotcl_Init(interp) == TCL_ERROR) {
      return TCL_ERROR;
     }

  Tcl_StaticPackage(interp, "Xotcl", Xotcl_Init, Xotcl_SafeInit);

/*  
  if (Xotclexpat_Init(interp) == TCL_ERROR) {
      return TCL_ERROR;
     }

  Tcl_StaticPackage(interp, "xotclexpat", Xotclexpat_Init, 0);
*/
/*  
  if (Xotclsdbm_Init(interp) == TCL_ERROR) {
      return TCL_ERROR;
  }
*/

//  Tcl_StaticPackage(interp, "xotclsdbm", Xotclsdbm_Init, Xotclsdbm_SafeInit);

/* 
  if (Xotclgdbm_Init(interp) == TCL_ERROR) {
      return TCL_ERROR;
     }
*/
//  Tcl_StaticPackage(interp, "xotclgdbm", Xotclgdbm_Init, Xotclgdbm_SafeInit);

#endif

#ifndef WITHOUT_TGDBM
  if (Tgdbm_Init(interp) == TCL_ERROR) {
      return TCL_ERROR;
     }

  Tcl_StaticPackage(interp, "Tgdbm", Tgdbm_Init, 0);
#endif

#ifndef WITHOUT_THREAD
  if (Thread_Init(interp) == TCL_ERROR) {
      return TCL_ERROR;
     }

  Tcl_StaticPackage(interp, "Thread", Thread_Init, 0);
#endif

#if !defined(WITHOUT_TK) && !defined(WITHOUT_WINICO) && (defined(__WIN32__) || defined(_WIN32))
  if (Winico_Init(interp) == TCL_ERROR) return TCL_ERROR;

  Tcl_StaticPackage(interp, "Winico", Winico_Init, Winico_SafeInit);
#endif

   /* Add some freeWrap commands */
  if (Freewrap_Init(interp) == TCL_ERROR) return TCL_ERROR;

  /* After all extensions are registered, start up the
  ** program by running freewrapCmds.tcl.
  */
    sprintf(sourceCmd, "source %s/freewrapCmds.tcl", mountPt);
    Tcl_Eval(interp, sourceCmd);

#ifndef WITHOUT_TK
    /*
     * Loop infinitely, waiting for commands to execute.  When there
     * are no windows left, Tk_MainLoop returns and we exit.
     */

    Tk_MainLoop();
    Tcl_DeleteInterp(interp);
    Tcl_Exit(0);
#else
    /*
     * Process commands from stdin until there's an end-of-file.  Note
     * that we need to fetch the standard channels again after every
     * eval, since they may have been changed.
     */
    commandPtr = Tcl_NewObj();
    Tcl_IncrRefCount(commandPtr);

    inChannel = Tcl_GetStdChannel(TCL_STDIN);
    outChannel = Tcl_GetStdChannel(TCL_STDOUT);
    gotPartial = 0;
    while (1) {
	if (tty) {
	    Tcl_Obj *promptCmdPtr;

	    promptCmdPtr = Tcl_GetVar2Ex(interp,
		    (gotPartial ? "tcl_prompt2" : "tcl_prompt1"),
		    NULL, TCL_GLOBAL_ONLY);
	    if (promptCmdPtr == NULL) {
                defaultPrompt:
		if (!gotPartial && outChannel) {
		    Tcl_WriteChars(outChannel, "% ", 2);
		}
	    } else {
		code = Tcl_EvalObjEx(interp, promptCmdPtr, 0);
		inChannel = Tcl_GetStdChannel(TCL_STDIN);
		outChannel = Tcl_GetStdChannel(TCL_STDOUT);
		errChannel = Tcl_GetStdChannel(TCL_STDERR);
		if (code != TCL_OK) {
		    if (errChannel) {
			Tcl_WriteObj(errChannel, Tcl_GetObjResult(interp));
			Tcl_WriteChars(errChannel, "\n", 1);
		    }
		    Tcl_AddErrorInfo(interp,
			    "\n    (script that generates prompt)");
		    goto defaultPrompt;
		}
	    }
	    if (outChannel) {
		Tcl_Flush(outChannel);
	    }
	}
	if (!inChannel) {
	    goto done;
	}
        length = Tcl_GetsObj(inChannel, commandPtr);
	if (length < 0) {
	    goto done;
	}
	if ((length == 0) && Tcl_Eof(inChannel) && (!gotPartial)) {
	    goto done;
	}

        /*
         * Add the newline removed by Tcl_GetsObj back to the string.
         */

	Tcl_AppendToObj(commandPtr, "\n", 1);
	if (!TclObjCommandComplete(commandPtr)) {
	    gotPartial = 1;
	    continue;
	}

	gotPartial = 0;
	code = Tcl_RecordAndEvalObj(interp, commandPtr, 0);
	inChannel = Tcl_GetStdChannel(TCL_STDIN);
	outChannel = Tcl_GetStdChannel(TCL_STDOUT);
	errChannel = Tcl_GetStdChannel(TCL_STDERR);
	Tcl_DecrRefCount(commandPtr);
	commandPtr = Tcl_NewObj();
	Tcl_IncrRefCount(commandPtr);
	if (code != TCL_OK) {
	    if (errChannel) {
		Tcl_WriteObj(errChannel, Tcl_GetObjResult(interp));
		Tcl_WriteChars(errChannel, "\n", 1);
	    }
	} else if (tty) {
	    resultPtr = Tcl_GetObjResult(interp);
	    Tcl_GetStringFromObj(resultPtr, &length);
	    if ((length > 0) && outChannel) {
		Tcl_WriteObj(outChannel, resultPtr);
		Tcl_WriteChars(outChannel, "\n", 1);
	    }
	}
    }

    /*
     * Rather than calling exit, invoke the "exit" command so that
     * users can replace "exit" with some other command to do additional
     * cleanup on exit.  The Tcl_Eval call should never return.
     */

    done:
    if (commandPtr != NULL) {
	Tcl_DecrRefCount(commandPtr);
    }
    sprintf(buffer, "exit %d", 0);
    Tcl_Eval(interp, buffer);

#endif

  return TCL_OK;
}
Exemple #18
0
/*----------------------------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
	FILE* fp;
	int success;
	int state;
	int fin[2];
	int fout[2];
	pid_t pid;

	Parse_Arguments(argc, argv);

	success = Hardware_Init();
	if(success == false)
	{
		Hardware_Shutdown();
		fprintf(stderr,"Hardware_Init() failed, aborting.\n");
		return(-1);
	}

	if(success)
	{
		success = Pipes_Init();
	}
	else
	{
		Pipes_Shutdown();
		Hardware_Shutdown();
		fprintf(stderr,"Pipes_Init() failed, aborting.\n");
		return(-1);
	}

	if(success)
	{
		success = Object_Init();
	}
	else
	{
		Pipes_Shutdown();
		Object_Shutdown();
		Hardware_Shutdown();
		fprintf(stderr,"Object_Init() failed, aborting.\n");
		return(-1);
	}

	if(success)
	{
		success = Thread_Init();
	}
	else
	{
		Thread_Shutdown();
		Pipes_Shutdown();
		Object_Shutdown();
		Hardware_Shutdown();
		fprintf(stderr,"Thread_Init() failed, aborting.\n");
		return(-1);
	}

	while(grun)
	{
		usleep(10000);
	}

	Thread_Shutdown();

	Pipes_Shutdown();

	Object_Shutdown();

	Hardware_Shutdown();

	return(1);

}
Exemple #19
0
/*
====================
Host_Init
====================
*/
static void Host_Init (void)
{
	int i;
	const char* os;
	char vabuf[1024];

	if (COM_CheckParm("-profilegameonly"))
		Sys_AllowProfiling(false);

	// LordHavoc: quake never seeded the random number generator before... heh
	if (COM_CheckParm("-benchmark"))
		srand(0); // predictable random sequence for -benchmark
	else
		srand((unsigned int)time(NULL));

	// FIXME: this is evil, but possibly temporary
	// LordHavoc: doesn't seem very temporary...
	// LordHavoc: made this a saved cvar
// COMMANDLINEOPTION: Console: -developer enables warnings and other notices (RECOMMENDED for mod developers)
	if (COM_CheckParm("-developer"))
	{
		developer.value = developer.integer = 1;
		developer.string = "1";
	}

	if (COM_CheckParm("-developer2") || COM_CheckParm("-developer3"))
	{
		developer.value = developer.integer = 1;
		developer.string = "1";
		developer_extra.value = developer_extra.integer = 1;
		developer_extra.string = "1";
		developer_insane.value = developer_insane.integer = 1;
		developer_insane.string = "1";
		developer_memory.value = developer_memory.integer = 1;
		developer_memory.string = "1";
		developer_memorydebug.value = developer_memorydebug.integer = 1;
		developer_memorydebug.string = "1";
	}

	if (COM_CheckParm("-developer3"))
	{
		gl_paranoid.integer = 1;gl_paranoid.string = "1";
		gl_printcheckerror.integer = 1;gl_printcheckerror.string = "1";
	}

// COMMANDLINEOPTION: Console: -nostdout disables text output to the terminal the game was launched from
	if (COM_CheckParm("-nostdout"))
		sys_nostdout = 1;

	// used by everything
	Memory_Init();

	// initialize console command/cvar/alias/command execution systems
	Cmd_Init();

	// initialize memory subsystem cvars/commands
	Memory_Init_Commands();

	// initialize console and logging and its cvars/commands
	Con_Init();

	// initialize various cvars that could not be initialized earlier
	u8_Init();
	Curl_Init_Commands();
	Cmd_Init_Commands();
	Sys_Init_Commands();
	COM_Init_Commands();
	FS_Init_Commands();

	// initialize console window (only used by sys_win.c)
	Sys_InitConsole();

	// initialize the self-pack (must be before COM_InitGameType as it may add command line options)
	FS_Init_SelfPack();

	// detect gamemode from commandline options or executable name
	COM_InitGameType();

	// construct a version string for the corner of the console
	os = DP_OS_NAME;
	dpsnprintf (engineversion, sizeof (engineversion), "%s %s %s", gamename, os, buildstring);
	Con_Printf("%s\n", engineversion);

	// initialize process nice level
	Sys_InitProcessNice();

	// initialize ixtable
	Mathlib_Init();

	// initialize filesystem (including fs_basedir, fs_gamedir, -game, scr_screenshot_name)
	FS_Init();

	// register the cvars for session locking
	Host_InitSession();

	// must be after FS_Init
	Crypto_Init();
	Crypto_Init_Commands();

	NetConn_Init();
	Curl_Init();
	//PR_Init();
	//PR_Cmd_Init();
	PRVM_Init();
	Mod_Init();
	World_Init();
	SV_Init();
	V_Init(); // some cvars needed by server player physics (cl_rollangle etc)
	Host_InitCommands();
	Host_InitLocal();
	Host_ServerOptions();

	Thread_Init();

	if (cls.state == ca_dedicated)
		Cmd_AddCommand ("disconnect", CL_Disconnect_f, "disconnect from server (or disconnect all clients if running a server)");
	else
	{
		Con_DPrintf("Initializing client\n");

		R_Modules_Init();
		Palette_Init();
#ifdef CONFIG_MENU
		MR_Init_Commands();
#endif
		VID_Shared_Init();
		VID_Init();
		Render_Init();
		S_Init();
		CDAudio_Init();
		Key_Init();
		CL_Init();
	}

	// save off current state of aliases, commands and cvars for later restore if FS_GameDir_f is called
	// NOTE: menu commands are freed by Cmd_RestoreInitState
	Cmd_SaveInitState();

	// FIXME: put this into some neat design, but the menu should be allowed to crash
	// without crashing the whole game, so this should just be a short-time solution

	// here comes the not so critical stuff
	if (setjmp(host_abortframe)) {
		return;
	}

	Host_AddConfigText();
	Cbuf_Execute();

	// if stuffcmds wasn't run, then quake.rc is probably missing, use default
	if (!host_stuffcmdsrun)
	{
		Cbuf_AddText("exec default.cfg\nexec " CONFIGFILENAME "\nexec autoexec.cfg\nstuffcmds\n");
		Cbuf_Execute();
	}

	// put up the loading image so the user doesn't stare at a black screen...
	SCR_BeginLoadingPlaque(true);

#ifdef CONFIG_MENU
	if (cls.state != ca_dedicated)
	{
		MR_Init();
	}
#endif

	// check for special benchmark mode
// COMMANDLINEOPTION: Client: -benchmark <demoname> runs a timedemo and quits, results of any timedemo can be found in gamedir/benchmark.log (for example id1/benchmark.log)
	i = COM_CheckParm("-benchmark");
	if (i && i + 1 < com_argc)
	if (!sv.active && !cls.demoplayback && !cls.connect_trying)
	{
		Cbuf_AddText(va(vabuf, sizeof(vabuf), "timedemo %s\n", com_argv[i + 1]));
		Cbuf_Execute();
	}

	// check for special demo mode
// COMMANDLINEOPTION: Client: -demo <demoname> runs a playdemo and quits
	i = COM_CheckParm("-demo");
	if (i && i + 1 < com_argc)
	if (!sv.active && !cls.demoplayback && !cls.connect_trying)
	{
		Cbuf_AddText(va(vabuf, sizeof(vabuf), "playdemo %s\n", com_argv[i + 1]));
		Cbuf_Execute();
	}

// COMMANDLINEOPTION: Client: -capturedemo <demoname> captures a playdemo and quits
	i = COM_CheckParm("-capturedemo");
	if (i && i + 1 < com_argc)
	if (!sv.active && !cls.demoplayback && !cls.connect_trying)
	{
		Cbuf_AddText(va(vabuf, sizeof(vabuf), "playdemo %s\ncl_capturevideo 1\n", com_argv[i + 1]));
		Cbuf_Execute();
	}

	if (cls.state == ca_dedicated || COM_CheckParm("-listen"))
	if (!sv.active && !cls.demoplayback && !cls.connect_trying)
	{
		Cbuf_AddText("startmap_dm\n");
		Cbuf_Execute();
	}

	if (!sv.active && !cls.demoplayback && !cls.connect_trying)
	{
#ifdef CONFIG_MENU
		Cbuf_AddText("togglemenu 1\n");
#endif
		Cbuf_Execute();
	}

	Con_DPrint("========Initialized=========\n");

	//Host_StartVideo();

	if (cls.state != ca_dedicated)
		SV_StartThread();
}
Exemple #20
0
/**
 * @brief
 */
static void Init(void) {

	SDL_Init(SDL_INIT_TIMER);

	Mem_Init();

	Cmd_Init();

	Cvar_Init();

	verbose = Cvar_Add("verbose", "0", 0, "Print verbose debugging information");

	dedicated = Cvar_Add("dedicated", "0", CVAR_NO_SET, "Run a dedicated server");
	if (strstr(Sys_ExecutablePath(), "-dedicated")) {
		Cvar_ForceSet("dedicated", "1");
	}

	if (dedicated->value) {
		Cvar_ForceSet("threads", "0");
	}

	game = Cvar_Add("game", DEFAULT_GAME, CVAR_LATCH | CVAR_SERVER_INFO, "The game module name");
	game->modified = g_strcmp0(game->string, DEFAULT_GAME);

	threads = Cvar_Add("threads", "0", CVAR_ARCHIVE, "Specifies the number of threads to create");
	threads->modified = false;

	time_demo = Cvar_Add("time_demo", "0", CVAR_LO_ONLY, "Benchmark and stress test");
	time_scale = Cvar_Add("time_scale", "1.0", CVAR_LO_ONLY, "Controls time lapse");

	const char *s = va("Quetoo %s %s %s", VERSION, __DATE__, BUILD_HOST);
	Cvar_Add("version", s, CVAR_SERVER_INFO | CVAR_NO_SET, NULL);

	quetoo.Debug = Debug;
	quetoo.Error = Error;
	quetoo.Print = Print;
	quetoo.Verbose = Verbose;
	quetoo.Warn = Warn;

	Fs_Init(true);

	Thread_Init(threads->integer);

	Con_Init();

	Cmd_Add("mem_stats", MemStats_f, CMD_SYSTEM, "Print memory stats");
	Cmd_Add("debug", Debug_f, CMD_SYSTEM, "Control debugging output");
	Cmd_Add("quit", Quit_f, CMD_SYSTEM, "Quit Quetoo");

	Netchan_Init();

	Sv_Init();

	Cl_Init();

	Com_Print("Quetoo %s %s %s initialized\n", VERSION, __DATE__, BUILD_HOST);

	// reset debug value since Cbuf may change it from Com's "all" init
	Com_SetDebug("0");

	// execute any +commands specified on the command line
	Cbuf_InsertFromDefer();
	Cbuf_Execute();

	// dedicated server, nothing specified, use Edge
	if (dedicated->value && !Com_WasInit(QUETOO_SERVER)) {
		Cbuf_AddText("map edge\n");
		Cbuf_Execute();
	}
}
Exemple #21
0
TEST_END

//===========================================================================
TEST(ut_quanta)
{
    K_ULONG ulAvg;
    K_ULONG ulMax;
    K_ULONG ulMin;
    K_ULONG ulRange;

    // Create three Thread_ts that only increment counters - similar to the
    // previous test.  However, modify the Thread_t quanta such that each Thread_t
    // will get a different proportion of the CPU cycles.
    Thread_Init( &stThread1, aucStack1, TEST_STACK_SIZE, 1, RR_EntryPoint, (void*)&ulRR1);
    Thread_Init( &stThread2, aucStack2, TEST_STACK_SIZE, 1, RR_EntryPoint, (void*)&ulRR2);
    Thread_Init( &stThread3, aucStack3, TEST_STACK_SIZE, 1, RR_EntryPoint, (void*)&ulRR3);

    ulRR1 = 0;
    ulRR2 = 0;
    ulRR3 = 0;

    // Adjust Thread_t priority before starting test Thread_ts to ensure
    // they all start at the same time (when we hit the 1 second sleep)
    Thread_SetPriority( Scheduler_GetCurrentThread(), 2);

    // Set a different execution quanta for each Thread_t
    Thread_SetQuantum( &stThread1, 3);
    Thread_SetQuantum( &stThread2, 6);
    Thread_SetQuantum( &stThread3, 9);

    Thread_Start( &stThread1 );
    Thread_Start( &stThread2 );
    Thread_Start( &stThread3 );

    Thread_Sleep(1800);

    // When the sleep ends, this will preempt the Thread_t in progress,
    // allowing us to stop them, and drop priority.
    Thread_Stop( &stThread1 );
    Thread_Stop( &stThread2 );
    Thread_Stop( &stThread3 );
    Thread_SetPriority( Scheduler_GetCurrentThread(), 1);

    // Test point - make sure that Q3 > Q2 > Q1
    EXPECT_GT( ulRR2, ulRR1 );
    EXPECT_GT( ulRR3, ulRR2 );

    // scale the counters relative to the largest value, and compare.
    ulRR1 *= 3;
    ulRR2 *= 3;
    ulRR2 = (ulRR2 + 1) / 2;

    // After scaling, they should be nearly identical (well, stose at least)
    if (ulRR1 > ulRR2)
    {
        ulMax = ulRR1;
    }
    else
    {
        ulMax = ulRR2;
    }
    if (ulMax < ulRR3)
    {
        ulMax = ulRR3;
    }

    if (ulRR1 < ulRR2)
    {
        ulMin = ulRR1;
    }
    else
    {
        ulMin = ulRR2;
    }
    if (ulMin > ulRR3)
    {
        ulMin = ulRR3;
    }
    ulRange = ulMax - ulMin;
    ulAvg = (ulRR1 + ulRR2 + ulRR3) / 3;

#if KERNEL_TIMERS_TICKLESS
    // Max-Min delta should not exceed 5% of average for this test
    EXPECT_LT( ulRange, ulAvg / 20);
#else
    // Max-Min delta should not exceed 20% of average for this test -- tick-based timers
    // are coarse, and prone to Thread_t preference due to phase.
    EXPECT_LT( ulRange, ulAvg / 5);
#endif


    // Make sure none of the component values are 0
    EXPECT_FAIL_EQUALS( ulRR1, 0 );
    EXPECT_FAIL_EQUALS( ulRR2, 0 );
    EXPECT_FAIL_EQUALS( ulRR3, 0 );
}