WRes LoopThread_Create(CLoopThread *p)
{
p->stop = 0;
RINOK(AutoResetEvent_CreateNotSignaled(&p->startEvent));
RINOK(AutoResetEvent_CreateNotSignaled(&p->finishedEvent));
return Thread_Create(&p->thread, LoopThreadFunc, p);
}
/*
* @brief Updates the r_view_t for the renderer. Origin, angles, etc are calculated.
* Scene population is then delegated (asynchronously) to the client game.
*/
void Cl_UpdateView(void) {
if (!cl.frame.valid && !r_view.update)
return; // not a valid frame, and no forced update
Cl_ClearView();
const cl_frame_t *frame = &cl.frames[(cl.frame.frame_num - 1) & PACKET_MASK];
const player_state_t *from = frame->frame_num == cl.frame.frame_num - 1 ? &frame->ps : &cl.frame.ps;
Cl_UpdateOrigin(from, &cl.frame.ps);
Cl_UpdateAngles(from, &cl.frame.ps);
Cl_UpdateViewSize();
cls.cgame->UpdateView(&cl.frame);
// set time
r_view.time = cl.time;
// set area bits to mark visible leafs
r_view.area_bits = cl.frame.area_bits;
// create the thread which populates the view
r_view.thread = Thread_Create((ThreadRunFunc) cls.cgame->PopulateView, &cl.frame);
}
//START: ThreadStartsAfterStart
TEST(Thread, StartedThreadRunsBeforeItIsDestroyed)
{
thread = Thread_Create(threadEntry, 0);
Thread_Start(thread);
Thread_Destroy(thread);
CHECK(TRUE == threadRan);
}
TEST(Thread, Join)
{
void * result;
thread = Thread_Create(threadEntry, 0);
Thread_Start(thread);
Thread_Join(thread, &result);
Thread_Destroy(thread);
LONGS_EQUAL(42, *((int *)result));
}
int Server_Listen(struct Server * server)
{
printf("Server starting on port %d\n", server->port);
MessageHandler_Initialise();
ServerSocket_Construct(&server->sock);
ServerSocket_Bind(server->sock, server->port);
ServerSocket_Listen(server->sock);
Thread_Create(Server_AcceptConnections, server);
printf("Server started on port %d\n", server->port);
}
static void
TestSuite_RunParallel (TestSuite *suite) /* IN */
{
ParallelInfo *info;
Thread *threads;
Mutex mutex;
Test *test;
int count = 0;
int i;
ASSERT (suite);
Mutex_Init (&mutex);
for (test = suite->tests; test; test = test->next) {
count++;
}
threads = calloc (count, sizeof *threads);
Memory_Barrier ();
for (test = suite->tests, i = 0; test; test = test->next, i++) {
info = calloc (1, sizeof *info);
info->suite = suite;
info->test = test;
info->count = &count;
info->mutex = &mutex;
Thread_Create (&threads [i], TestSuite_ParallelWorker, info);
}
for (test = suite->tests, i = 0; test; test = test->next, i++) {
Thread_Join(threads [i]);
}
/*if (timeout < 0 || timeout > 600)
{
timeout = 60;
}
#ifdef _WIN32
Sleep (timeout * 1000);
#else
sleep (timeout);
#endif
*/
//fprintf (stderr, "Timed out, aborting!\n");
//abort ();
}
/*
* @brief Updates the r_view_t for the renderer. Origin, angles, etc are calculated.
* Scene population is then delegated to the client game.
*/
void Cl_UpdateView(void) {
if (!cl.frame.valid && !r_view.update)
return; // not a valid frame, and no forced update
// find the previous frame to interpolate from
cl_frame_t *prev = &cl.frames[(cl.frame.frame_num - 1) & PACKET_MASK];
if (prev->frame_num != cl.frame.frame_num - 1 || !prev->valid)
prev = &cl.frame; // previous frame was dropped or invalid
Cl_UpdateLerp(prev);
const player_state_t *ps = &cl.frame.ps;
const player_state_t *ops = &prev->ps;
if (ps != ops) { // see if we've teleported
vec3_t org, old_org, delta;
UnpackVector(ps->pm_state.origin, org);
UnpackVector(ops->pm_state.origin, old_org);
VectorSubtract(org, old_org, delta);
if (VectorLength(delta) > 256.0) {
ops = ps; // don't interpolate
}
}
Cl_ClearView();
Cl_UpdateOrigin(ps, ops);
Cl_UpdateAngles(ps, ops);
Cl_UpdateViewSize();
cls.cgame->UpdateView(&cl.frame);
// set time
r_view.time = cl.time;
// set area bits to mark visible leafs
r_view.area_bits = cl.frame.area_bits;
// create the thread which populates the view
r_view.thread = Thread_Create((ThreadRunFunc) cls.cgame->PopulateView, &cl.frame);
}
/*
* RunThreads
*/
static void RunThreads(void){
thread_t *t[64];
int i;
if(!threads->integer){
ThreadWork(0);
return;
}
lock = SDL_CreateMutex();
for(i = 0; i < threads->integer; i++)
t[i] = Thread_Create(ThreadWork, NULL);
for(i = 0; i < threads->integer; i++)
Thread_Wait(&t[i]);
SDL_DestroyMutex(lock);
lock = NULL;
}
static void
TestSuite_RunParallel (TestSuite *suite) /* IN */
{
ParallelInfo *info;
Thread *threads;
Mutex mutex;
Test *test;
int count = 0;
int i;
ASSERT (suite);
Mutex_Init (&mutex);
for (test = suite->tests; test; test = test->next) {
count++;
}
threads = (Thread *)calloc (count, sizeof *threads);
Memory_Barrier ();
for (test = suite->tests, i = 0; test; test = test->next, i++) {
info = (ParallelInfo *)calloc (1, sizeof *info);
info->suite = suite;
info->test = test;
info->count = &count;
info->mutex = &mutex;
Thread_Create (&threads [i], TestSuite_ParallelWorker, info);
}
#ifdef _WIN32
Sleep (30000);
#else
sleep (30);
#endif
_Print_StdErr ("Timed out, aborting!\n");
abort ();
}
static SRes MtSync_Create2(CMtSync *p, unsigned (MY_STD_CALL *startAddress)(void *), void *obj, UInt32 numBlocks)
{
if (p->wasCreated)
return SZ_OK;
RINOK_THREAD(CriticalSection_Init(&p->cs));
p->csWasInitialized = True;
RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->canStart));
RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->wasStarted));
RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->wasStopped));
RINOK_THREAD(Semaphore_Create(&p->freeSemaphore, numBlocks, numBlocks));
RINOK_THREAD(Semaphore_Create(&p->filledSemaphore, 0, numBlocks));
p->needStart = True;
RINOK_THREAD(Thread_Create(&p->thread, startAddress, obj));
p->wasCreated = True;
return SZ_OK;
}
/*
* @brief Main entry point for drawing the scene (world and entities).
*/
void R_DrawView(void) {
R_UpdateFrustum();
R_UpdateVis();
R_MarkBspSurfaces();
R_EnableFog(true);
R_DrawSkyBox();
// wait for the client to populate our lights array
Thread_Wait(&r_view.thread);
// now dispatch another thread to cull entities while we draw the world
r_view.thread = Thread_Create(R_CullEntities, NULL);
R_MarkLights();
const r_sorted_bsp_surfaces_t *surfs = r_model_state.world->bsp->sorted_surfaces;
R_DrawOpaqueBspSurfaces(&surfs->opaque);
R_DrawOpaqueWarpBspSurfaces(&surfs->opaque_warp);
R_DrawAlphaTestBspSurfaces(&surfs->alpha_test);
R_EnableBlend(true);
R_DrawBackBspSurfaces(&surfs->back);
R_DrawMaterialBspSurfaces(&surfs->material);
R_DrawFlareBspSurfaces(&surfs->flare);
R_EnableBlend(false);
R_DrawBspNormals();
// ensure the thread has finished culling entities
Thread_Wait(&r_view.thread);
// now dispatch another thread to update particles while we draw entities
r_view.thread = Thread_Create(R_UpdateParticles, NULL);
R_DrawEntities();
R_EnableBlend(true);
R_DrawBspLights();
R_DrawBlendBspSurfaces(&surfs->blend);
R_DrawBlendWarpBspSurfaces(&surfs->blend_warp);
// ensure the thread has finished updating particles
Thread_Wait(&r_view.thread);
R_DrawParticles();
R_EnableFog(false);
R_DrawCoronas();
R_DrawBspLeafs();
R_EnableBlend(false);
R_ResetArrayState();
}
/*
* @brief Main entry point for drawing the scene (world and entities).
*/
void R_DrawView(void) {
R_UpdateFrustum();
R_UpdateVis();
R_MarkBspSurfaces();
R_EnableFog(true);
R_DrawSkyBox();
// wait for the client to fully populate the scene
Thread_Wait(r_view.thread);
// dispatch threads to cull entities and sort elements while we draw the world
thread_t *cull_entities = Thread_Create(R_CullEntities, NULL);
thread_t *sort_elements = Thread_Create(R_SortElements, NULL);
R_MarkLights();
const r_sorted_bsp_surfaces_t *surfs = r_model_state.world->bsp->sorted_surfaces;
R_DrawOpaqueBspSurfaces(&surfs->opaque);
R_DrawOpaqueWarpBspSurfaces(&surfs->opaque_warp);
R_DrawAlphaTestBspSurfaces(&surfs->alpha_test);
R_EnableBlend(true);
R_DrawBackBspSurfaces(&surfs->back);
R_DrawMaterialBspSurfaces(&surfs->material);
R_DrawFlareBspSurfaces(&surfs->flare);
R_EnableBlend(false);
// wait for entity culling to complete
Thread_Wait(cull_entities);
R_DrawEntities();
R_EnableBlend(true);
// wait for element sorting to complete
Thread_Wait(sort_elements);
R_DrawElements();
R_EnableFog(false);
R_DrawDeveloperTools();
R_DrawCoronas();
R_EnableBlend(false);
R_ResetArrayState();
#if 0
vec3_t tmp;
VectorMA(r_view.origin, MAX_WORLD_DIST, r_view.forward, tmp);
cm_trace_t tr = Cl_Trace(r_view.origin, tmp, NULL, NULL, cl.client_num + 1, MASK_SOLID);
if (tr.fraction > 0.0 && tr.fraction < 1.0) {
Com_Print("%s: %d: %s\n", tr.surface->name, tr.plane.num, vtos(tr.plane.normal));
}
#endif
}
void Connection_StartListening(struct Connection * connection)
{
printf("Creating reader thread\n");
Thread_Create(Connection_Reader, connection);
}
