//Takes one argument the number of queues to use.
//case 1) 2 queues = ULE
//case 2) #>2 queues = 4BSD
int main(int argc, char *argv[]){
//gets the start time
struct timeval startC;
gettimeofday(&startC, NULL);
//creates intial PCB array
procBlock = malloc( sizeof(procInfo));
//checks for args
if(argc > 1 && atoi(argv[1]) >1){
numQueue = atoi(argv[1]);
queueS = malloc( sizeof(qNode)* numQueue);
queueE = malloc( sizeof(qNode) * numQueue);
//runs simulate
Simulate(NUMROUNDS, TIMESLICE);
}else{
printf("Didn't supply the number of queues to create aborting or supplied with only one queue \n");
exit(1);
}
//grabs the ending time
struct timeval endC;
gettimeofday(&endC, NULL);
//data prints
printf("Time program ran for is %ld ms\n",((endC.tv_sec * 1000 + endC.tv_usec/1000) - (startC.tv_sec * 1000 + startC.tv_usec/1000)));
int i;
for(i =0; i < numProc; i++){
if( procBlock[i]->readyTimes.numProc>0){
printf(" Process with ID %d was in the ready queue with an average of %f ms, max of %ld ms, and a min of %ld ms\n",
procBlock[i]->ppid,
((double)(procBlock[i]->readyTimes.avg))/procBlock[i]->readyTimes.numProc,
(procBlock[i]->readyTimes.max),
(procBlock[i]->readyTimes.min));
if(procBlock[i] ->ioTimes.numProc > 0){
printf(" it spent an average of %f ms, max of %ld ms, and min of %ld ms on IO responsiveness\n",
((double)(procBlock[i]->ioTimes.avg))/procBlock[i]->ioTimes.numProc,
(procBlock[i]->ioTimes.max),
(procBlock[i]->ioTimes.min));
} else {
printf(" process didn't do any IO waiting\n");
}
} else {
printf(" Process with PID %d was never dispatched\n", procBlock[i]->ppid);
}
}
printf("Time program spent on scheduler overheads is %ld ms\n", ((endC.tv_sec * 1000 + endC.tv_usec/1000) - (startC.tv_sec * 1000 + startC.tv_usec/1000)) -overhead);
exit(0);
}
//
// Image::Notify
//
void Image::Notify(U32 crc)
{
switch (crc)
{
case 0xC3AC47E6: // "Render::PostIFace2"
{
F32 curr = Simulate();
// Calculate screen rectangle
const ClipRect &rc = cineViewPort;
ClipRect newRc;
if (absolute)
{
if (absPos.x < 0)
{
newRc.p0.x = rc.p1.x - absSize.x + absPos.x;
}
else
{
newRc.p0.x = rc.p0.x + absPos.x;
}
if (absPos.y < 0)
{
newRc.p0.y = rc.p1.y - absSize.y + absPos.y;
}
else
{
newRc.p0.y = rc.p0.y + absPos.y;
}
newRc.p1 = newRc.p0 + absSize;
}
else
{
newRc.p0.x = rc.p0.x + Utils::FtoL(pos.x * F32(rc.Width()));
newRc.p0.y = rc.p0.y + Utils::FtoL(pos.y * F32(rc.Height()));
newRc.p1.x = rc.p0.x + Utils::FtoL((pos.x + size.x) * F32(rc.Width()));
newRc.p1.y = rc.p0.y + Utils::FtoL((pos.y + size.y) * F32(rc.Height()));
}
IFace::RenderRectangle(newRc, clr, &texture, curr * IFace::data.alphaScale);
return;
}
}
}
int main(int argc, char** argv) {
if(argc == 3){
/*Set function pointers to appropriate algorithm */
if (strcmp(argv[1], "-4bsd") == 0){
initbsd();
__ready = &bsd_ready;
__dispatch = &bsd_dispatch;
__wait = &bsd_wait;
__terminate = &bsd_terminate;
__newprocess = &bsd_newproc;
} else if(strcmp(argv[1], "-ule") == 0){
initule();
__ready = &ule_ready;
__dispatch = &ule_dispatch;
__wait = &ule_wait;
__terminate = &ule_terminate;
__newprocess = &ule_newproc;
} else{
usage();
exit(EXIT_FAILURE);
}
timeslice = atoi(argv[2]);
} else{
usage();
exit(EXIT_FAILURE);
}
gettimeofday(&time_start, NULL);
init_termq();
printf("Running Simulation with timeslice=%d for %d rounds...\n", timeslice, ROUNDS);
/* Simulate for 1000 rounds */
Simulate(ROUNDS, timeslice);
print_stats(termq);
return 0;
}
void Application::Update()
{
SDL_Event event;
while (SDL_PollEvent(&event))
{
if (event.type == SDL_EventType::SDL_QUIT)
{
_running = false;
}
}
_input.Update();
if (_input.KeyPressed(SDL_SCANCODE_SPACE)) { _updateScene = !_updateScene; }
if (_input.KeyPressed(SDL_SCANCODE_G)) { _useDeferredShading = !_useDeferredShading; }
if (_input.KeyPressed(SDL_SCANCODE_T)) { _showTangents = !_showTangents; }
if (_input.KeyPressed(SDL_SCANCODE_R)) { _renderer.sortEnabled = !_renderer.sortEnabled; }
if (_input.KeyPressed(SDL_SCANCODE_F))
{
//Toggle shadow maps
for (size_t i = 0; i < _lights.size(); i++)
{
if (_lights[i].shadowMap == nullptr) { _lights[i].shadowMap = &_shadowMaps[i]; }
else { _lights[i].shadowMap = nullptr; }
}
}
if (_input.KeyPressed(SDL_SCANCODE_MINUS)) { _renderer.ignoreCount++; }
if (_input.KeyPressed(SDL_SCANCODE_EQUALS)) { _renderer.ignoreCount = Math::Max(_renderer.ignoreCount - 1, 0); }
//std::cout << "Ignoring: " << _renderer.ignoreCount << std::endl;
Simulate();
RenderShadowMaps();
if (_useDeferredShading)
{
RenderDeferred();
}
else
{
RenderForward();
}
SDL_GL_SwapWindow(_window);
}
//
// Simulation
//
void Mesh::Notify(U32 crc)
{
switch (crc)
{
case 0xEF30A860: // "Render::PostObject"
{
Simulate();
if (root && !done)
{
Matrix mat = Vid::CurCamera().WorldMatrix();
Vector vect;
mat.Transform( vect, offset);
mat.posit = vect;
root->Render( mat);
}
return;
}
}
}
//
// Simulation
//
void Text::Notify(U32 crc)
{
switch (crc)
{
case 0xC3AC47E6: // "Render::PostIFace2"
{
F32 curr = Simulate();
// Draw the text
if (text)
{
S32 width = font->Width(text, len);
S32 height = font->Height();
S32 xpos = Max<S32>(Utils::FtoL(F32(Vid::backBmp.Width() - width) * x), 0);
S32 ypos = Max<S32>(Utils::FtoL(F32(Vid::backBmp.Height() - height) * y), 0);
font->Draw(xpos, ypos, text, len, clr, NULL, curr);
}
return;
}
}
}
void World::TickAndRender()
{
Simulate(_simulateOn);
// Setup the camera matrix.
theCamera.Render();
DrawRenderables();
// Give the GameManager a chance to draw something.
if (_gameManager)
_gameManager->Render();
//Render debug information
theSpatialGraph.Render();
DrawDebugItems();
//Draw developer console
_console->Render();
}
int main(int argc, char *argv[])
{
ConfigMap cmap;
if (ParseCmdLine(argc, argv, cmap) != OK)
{
exit(0);
}
auto queue = makeQueue<Process>();
uint64_t seconds = Utils::getTimeStamp();
uint64_t stopTS = Utils::getTimeStamp() + (boost::get<uint64_t>(cmap["sim_time"]) * MILLISECONS_IN_A_SECOND);
auto t1 = Utils::Time();
auto algorithm = bindSimulator(getAlgorithmByString(boost::get<std::string>(cmap["algorithm"])));
auto pg = ProcessGenerator::createGenerator(queue);
std::this_thread::sleep_for(std::chrono::seconds(1));
algorithm.Simulate(queue);
while (seconds <= stopTS)
{
seconds = Utils::getTimeStamp();
}
algorithm.Stop();
pg->Stop();
auto t2 = Utils::Time();
ShowStats(algorithm.getStats(), boost::get<std::string>(cmap["algorithm"]));
std::cout << "Executing stuff for " << Utils::Diff(t1, t2) / MICROSECONS_IN_A_SECOND << " seconds" << std::endl;
return 0;
}
int main(int argc, char *argv[])
{
int n, G;
int rank, p;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &p);
printf("my rank = %d\n", rank);
printf("Rank = %d: number of processes = %d\n", rank, p);
if(argc == 3)
{
n = argv[1];
G = argv[2];
}
else
get_input(&n, &G);
Simulate(n, G, GenerateInitialGoL(n));
MPI_Finalize();
}
void iPhysicsWorld::Update(float afTimeStep)
{
//Clear all contact points.
mvContactPoints.clear();
////////////////////////////////////
//Update controllers
tPhysicsControllerListIt CtrlIt = mlstControllers.begin();
for(; CtrlIt != mlstControllers.end(); ++CtrlIt)
{
iPhysicsController *pCtrl = *CtrlIt;
pCtrl->Update(afTimeStep);
}
////////////////////////////////////
//Update character bodies
unsigned int lTime = GetApplicationTime();
tCharacterBodyListIt CharIt = mlstCharBodies.begin();
for(; CharIt != mlstCharBodies.end(); ++CharIt)
{
iCharacterBody *pBody = *CharIt;
//for(int i=0; i<20; ++i)
{
pBody->Update(afTimeStep);//20.0f);
}
}
//LogUpdate(" Updating chars took %d ms\n",mpWorld3D->GetSystem()->GetLowLevel()->GetTime() - lTime);
////////////////////////////////////
//Update the rigid bodies before simulation.
tPhysicsBodyListIt BodyIt = mlstBodies.begin();
for(; BodyIt != mlstBodies.end(); ++BodyIt)
{
iPhysicsBody *pBody = *BodyIt;
pBody->UpdateBeforeSimulate(afTimeStep);
}
////////////////////////////////////
//Simulate the physics
lTime = GetApplicationTime();
Simulate(afTimeStep);
//LogUpdate(" Updating lowlevel physics took %d ms\n",mpWorld3D->GetSystem()->GetLowLevel()->GetTime() - lTime);
////////////////////////////////////
//Update the joints after simulation.
tPhysicsJointListIt JointIt = mlstJoints.begin();
for(; JointIt != mlstJoints.end(); )
{
iPhysicsJoint *pJoint = *JointIt;
pJoint->OnPhysicsUpdate();
if(pJoint->CheckBreakage())
{
JointIt = mlstJoints.erase(JointIt);
hplDelete(pJoint);
}
else
{
++JointIt;
}
}
////////////////////////////////////
//Update the rigid bodies after simulation.
BodyIt = mlstBodies.begin();
for(; BodyIt != mlstBodies.end(); ++BodyIt)
{
iPhysicsBody *pBody = *BodyIt;
pBody->UpdateAfterSimulate(afTimeStep);
}
}
void RunTest(const std::string& rOutputDirName,
const std::string& rModelName,
const std::vector<std::string>& rArgs,
bool testLookupTables=false,
double tableTestV=-1000)
{
// Copy CellML file (and .out if present) into output dir
OutputFileHandler handler(rOutputDirName, true);
FileFinder cellml_file("heart/test/data/cellml/" + rModelName + ".cellml", RelativeTo::ChasteSourceRoot);
handler.CopyFileTo(cellml_file);
FileFinder out_file("heart/test/data/cellml/" + rModelName + ".out", RelativeTo::ChasteSourceRoot);
if (out_file.Exists())
{
handler.CopyFileTo(out_file);
}
// Create options file
std::vector<std::string> args(rArgs);
// args.push_back("--profile");
CellMLToSharedLibraryConverter converter(true);
if (!args.empty())
{
converter.CreateOptionsFile(handler, rModelName, args);
}
// Do the conversion
FileFinder copied_file(rOutputDirName + "/" + rModelName + ".cellml", RelativeTo::ChasteTestOutput);
DynamicCellModelLoaderPtr p_loader = converter.Convert(copied_file);
// Apply a stimulus of -40 uA/cm^2 - should work for all models
boost::shared_ptr<AbstractCardiacCellInterface> p_cell(CreateCellWithStandardStimulus(*p_loader, -40.0));
// Check that the default stimulus units are correct
if (p_cell->HasCellMLDefaultStimulus())
{
// Record the existing stimulus and re-apply it at the end
boost::shared_ptr<AbstractStimulusFunction> original_stim = p_cell->GetStimulusFunction();
// Tell the cell to use the default stimulus and retrieve it
boost::shared_ptr<RegularStimulus> p_reg_stim = p_cell->UseCellMLDefaultStimulus();
if (rModelName!="aslanidi_model_2009") // Even before recent changes aslanidi model has stimulus of -400 !
{
// Stimulus magnitude should be approximately between -5 and -81 uA/cm^2
TS_ASSERT_LESS_THAN(p_reg_stim->GetMagnitude(),-5);
TS_ASSERT_LESS_THAN(-81,p_reg_stim->GetMagnitude());
}
// Stimulus duration should be approximately between 0.1 and 5 ms.
TS_ASSERT_LESS_THAN(p_reg_stim->GetDuration(),6.01);
TS_ASSERT_LESS_THAN(0.1,p_reg_stim->GetDuration());
// Stimulus period should be approximately between 70 (for bondarenko - seems fast! - would expect 8-10 beats per second for mouse) and 2000ms.
TS_ASSERT_LESS_THAN(p_reg_stim->GetPeriod(),2000);
TS_ASSERT_LESS_THAN(70,p_reg_stim->GetPeriod());
p_cell->SetIntracellularStimulusFunction(original_stim);
}
// Check lookup tables exist if they should
if (testLookupTables && rModelName != "hodgkin_huxley_squid_axon_model_1952_modified")
{
double v = p_cell->GetVoltage();
p_cell->SetVoltage(tableTestV);
TS_ASSERT_THROWS_CONTAINS(p_cell->GetIIonic(), "outside lookup table range");
p_cell->SetVoltage(v);
}
Simulate(rOutputDirName, rModelName, p_cell);
}
int main (int argc, char*argv[])
{
char *MCctlf=NULL, outf[512]="evolver.out", treefile[512]="mcmc.txt", mastertreefile[512]="\0";
int i, option=-1, ntree=1,rooted, BD=0, gotoption=0, pick1tree=-1;
double bfactor=1, birth=-1,death=-1,sample=-1,mut=-1, *space;
FILE *fout=gfopen(outf,"w");
printf("EVOLVER in %s\n", pamlVerStr);
com.alpha=0; com.cleandata=1; com.model=0; com.NSsites=0;
if(argc>1) {
gotoption=1; sscanf(argv[1], "%d", &option);
}
if(argc==1)
printf("Results for options 1-4 & 8 go into %s\n",outf);
else if(option!=5 && option!=6 && option!=7 && option!=9) {
puts("Usage: \n\tevolver \n\tevolver option# MyDataFile"); exit(-1);
}
if(option>=4 && option<=6)
MCctlf = argv[2];
else if(option==9) {
strcpy(treefile, argv[2]);
if(argc>3) strcpy(mastertreefile, argv[3]);
if(argc>4) sscanf(argv[4], "%d", &pick1tree);
}
#if defined (CodonNSbranches)
option=6; com.model=1;
MCctlf = (argc==3 ? argv[2] : "MCcodonNSbranches.dat");
gotoption = 1;
#elif defined (CodonNSsites)
option=6; com.NSsites=3;
MCctlf = (argc==3 ? argv[2] : "MCcodonNSsites.dat");
gotoption = 1;
#elif defined (CodonNSbranchsites)
option=6; com.model=1; com.NSsites=3;
MCctlf = (argc==3 ? argv[2] : "MCcodonNSbranchsites.dat");
gotoption = 1;
#endif
if(!gotoption) {
for(; ;) {
fflush(fout);
printf("\n\t(1) Get random UNROOTED trees?\n");
printf("\t(2) Get random ROOTED trees?\n");
printf("\t(3) List all UNROOTED trees?\n");
printf("\t(4) List all ROOTED trees?\n");
printf("\t(5) Simulate nucleotide data sets (use %s)?\n",MCctlf0[0]);
printf("\t(6) Simulate codon data sets (use %s)?\n",MCctlf0[1]);
printf("\t(7) Simulate amino acid data sets (use %s)?\n",MCctlf0[2]);
printf("\t(8) Calculate identical bi-partitions between trees?\n");
printf("\t(9) Calculate clade support values (evolver 9 treefile mastertreefile <pick1tree>)?\n");
printf("\t(11) Label clades?\n");
printf("\t(0) Quit?\n");
option = 9;
scanf("%d", &option);
if(option==0) exit(0);
if(option>=5 && option<=7) break;
if(option<5) {
printf ("No. of species: ");
scanf ("%d", &com.ns);
}
if(com.ns>NS) error2 ("Too many species. Raise NS.");
if((space=(double*)malloc(10000*sizeof(double)))==NULL) error2("oom");
rooted = !(option%2);
if(option<3) {
printf("\nnumber of trees & random number seed? ");
scanf("%d%d", &ntree, &i);
SetSeed(i, 1);
printf ("Want branch lengths from the birth-death process (0/1)? ");
scanf ("%d", &BD);
}
if(option<=4) {
if(com.ns<3) error2("no need to do this?");
i = (com.ns*2-1)*sizeof(struct TREEN);
if((nodes=(struct TREEN*)malloc(i)) == NULL)
error2("oom");
}
switch (option) {
case(1): /* random UNROOTED trees */
case(2): /* random ROOTED trees */
/* default names */
if(com.ns<=52)
for(i=0; i<com.ns; i++) sprintf(com.spname[i], "%c", (i<26 ? 'A'+i : 'a'+i-26));
else
for(i=0; i<com.ns; i++) sprintf(com.spname[i], "S%d", i+1);
if(BD) {
printf ("\nbirth rate, death rate, sampling fraction, and ");
printf ("mutation rate (tree height)?\n");
scanf ("%lf%lf%lf%lf", &birth, &death, &sample, &mut);
}
for(i=0;i<ntree;i++) {
RandomLHistory (rooted, space);
if(BD)
BranchLengthBD (1, birth, death, sample, mut);
if(com.ns<20&&ntree<10) { OutTreeN(F0, 0, BD); puts("\n"); }
OutTreeN(fout, 1, BD); FPN(fout);
}
/*
for (i=0; i<com.ns-2-!rooted; i++)
Ib[i] = (int)((3.+i)*rndu());
MakeTreeIb (com.ns, Ib, rooted);
*/
break;
case(3):
case(4):
ListTrees(fout, com.ns, rooted);
break;
case(8): TreeDistances(fout); break;
case(9):
printf("tree file names? ");
scanf("%s%s", treefile, mastertreefile);
break;
case(10): between_f_and_x(); break;
case(11): LabelClades(fout); break;
default: exit(0);
}
}
}
if(option>=5 && option<=7) {
com.seqtype = option-5; /* 0, 1, 2 for bases, codons, & amino acids */
Simulate(MCctlf ? MCctlf : MCctlf0[option-5]);
}
else if(option==9) {
CladeSupport(fout, treefile, mastertreefile, pick1tree);
/* CladeMrBayesProbabilities("/papers/BPPJC3sB/Karol.trees"); */
}
return(0);
}
static void simLoop (int pause)
{
Simulate(pause);
}
void World::Tick()
{
Simulate(_simulateOn);
}
bool ESoundSource::Load(IReader& F)
{
u32 version = 0;
if(F.r_chunk(SOUND_CHUNK_VERSION,&version)){
if(version!=SOUND_SOURCE_VERSION){
ELog.Msg( mtError, "ESoundSource: Unsupported version.");
return false;
}
}else return false;
inherited::Load (F);
R_ASSERT(F.find_chunk(SOUND_CHUNK_TYPE));
m_Type = ESoundType(F.r_u32());
R_ASSERT(F.find_chunk(SOUND_CHUNK_SOURCE_NAME));
F.r_stringZ (m_WAVName);
if (F.find_chunk(SOUND_CHUNK_SOURCE_PARAMS3)){
m_Params.base_volume = 1.f;
F.r_fvector3 (m_Params.position);
m_Params.volume = F.r_float();
m_Params.freq = F.r_float();
m_Params.min_distance = F.r_float();
m_Params.max_distance = F.r_float();
m_Params.max_ai_distance= F.r_float();
}else if (F.find_chunk(SOUND_CHUNK_SOURCE_PARAMS2)){
m_Params.base_volume = 1.f;
F.r_fvector3 (m_Params.position);
m_Params.volume = F.r_float();
m_Params.freq = F.r_float();
m_Params.min_distance = F.r_float();
m_Params.max_distance = F.r_float();
m_Params.max_ai_distance= F.r_float();
}else{
if (!F.find_chunk(SOUND_CHUNK_SOURCE_PARAMS)){
ELog.DlgMsg( mtError, "ESoundSource: Can't load Sound Source '%s'. Unsupported version.",*m_WAVName);
return false;
}
m_Params.base_volume = 1.f;
F.r_fvector3 (m_Params.position);
m_Params.volume = F.r_float();
m_Params.freq = F.r_float();
m_Params.min_distance = F.r_float();
m_Params.max_distance = F.r_float();
m_Params.max_ai_distance= m_Params.max_distance;
}
if(F.find_chunk(SOUND_CHUNK_SOURCE_FLAGS))
F.r (&m_Flags,sizeof(m_Flags));
if(F.find_chunk(SOUND_CHUNK_GAME_PARAMS)){
F.r_fvector2 (m_RandomPause);
F.r_fvector2 (m_ActiveTime);
F.r_fvector2 (m_PlayTime);
}
ResetSource ();
switch (m_Type){
case stStaticSource:
if (m_Flags.is(flPlaying)) Play();
if (m_Flags.is(flSimulating)) Simulate();
break;
default: THROW;
}
return true;
}
int main(int argc,char *argv[])
{
int rank, p, N, G,X;
struct timeval t1, t2, t3, t4;
// Change this "N" from 2 up to 16
N = 16;
p = 2;
G = atoi(argv[1]);
// X = 3;
X = 1;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &p);
//Timing for total runtime
struct timeval totalRuntimeStart, totalRuntimeEnd;
int totalRuntime;
// Timing for average time per generation(excluding display)
struct timeval avgPerGenerationStart, avgPerGenerationEnd;
int averageTimePerGeneration;
int tempTime=0;
// Average time per the display function
struct timeval displayRuntimeStart, displayRuntimeEnd;
int averageDisplayTimePerGeneration;
int displayTempTime;
int displayMethodCounter = 0;
// Time for different communication steps.
struct timeval mpiCallRuntimeStart, mpiCallRuntimeEnd;
int MAX_SIZE = 30;
int MAX_TRIAL = 100;
int userInput;
int randomseed[p];
srand(time(NULL));
gettimeofday(&totalRuntimeStart, NULL);
int i;
if(rank == 0)
{
for (i = 0; i < p; i++)
randomseed[i] = rand();
}
int received_random;
int scatterTime;
gettimeofday(&t3, NULL);
MPI_Scatter(randomseed, 1, MPI_INT, &received_random, 1,MPI_INT,0, MPI_COMM_WORLD);
gettimeofday(&t4, NULL);
scatterTime = (t4.tv_sec-t3.tv_sec)*1000 + (t4.tv_usec-t3.tv_usec)/1000;
//printf("%d\t%d", rank, scatterTime);
int start_index, end_index;
start_index = rank * (N / p);
end_index = (rank + 1) * (N / p) - 1;
int cols_size = (end_index - start_index) +1;
int effective_cols_size = cols_size + 2;
int matrix[N][effective_cols_size];
struct timeval barrier1s,barrier1e;
int tBarrier = 0;
int tBarrierAvg = 0;
//initialize matrix part
int currentGatherTime = 0;
GenerateInitialGoL(rank, p, start_index, N, effective_cols_size,matrix,received_random);
for(i=0;i<G;i++)
{
gettimeofday(&avgPerGenerationStart, NULL);
gettimeofday(&barrier1s, NULL);
MPI_Barrier(MPI_COMM_WORLD);
gettimeofday(&barrier1e, NULL);
tBarrier += (barrier1e.tv_sec-barrier1s.tv_sec)*1000 + (barrier1e.tv_usec-barrier1s.tv_usec)/1000;
Simulate(i,rank,N,effective_cols_size,matrix,p);
if(i%X==0)
{
gettimeofday(&displayRuntimeStart, NULL);
currentGatherTime += DisplayGoL(N, effective_cols_size, matrix,rank);
gettimeofday(&displayRuntimeEnd, NULL);
displayTempTime += ((displayRuntimeEnd.tv_sec-displayRuntimeStart.tv_sec)*1000 + ((displayRuntimeEnd.tv_usec - displayRuntimeStart.tv_usec)/1000));
displayMethodCounter++;
}
gettimeofday(&avgPerGenerationEnd, NULL);
//printf("START: %d\n ", avgPerGenerationStart.tv_sec);
//printf("END: %d\n ", avgPerGenerationEnd.tv_sec);
tempTime+= ((avgPerGenerationEnd.tv_sec-avgPerGenerationStart.tv_sec)*1000 + ((avgPerGenerationEnd.tv_usec - avgPerGenerationStart.tv_usec)/1000));
}
tBarrierAvg = tBarrier / G;
averageTimePerGeneration = tempTime/G;
// Average the number of times the display method was called.
averageDisplayTimePerGeneration = displayTempTime / displayMethodCounter;
currentGatherTime = currentGatherTime / displayMethodCounter;
// Get the total runtime
gettimeofday(&totalRuntimeEnd, NULL);
totalRuntime = (totalRuntimeEnd.tv_sec - totalRuntimeStart.tv_sec)*1000 + (totalRuntimeEnd.tv_usec - totalRuntimeStart.tv_usec)/1000;
//printf("%d\t%d\n",rank, totalRuntime);
//printf("%d\t%d\n",rank, tBarrierAvg);
//printf("RANK: %d AVERAGE RUNTIME PER GENERATION: %d\n", rank, averageTimePerGeneration);
// printf("RANK: %d AVERAGE TIME PER DISPLAY METHOD: %d\n\n\n", rank, averageDisplayTimePerGeneration);
printf("%d\t%d\n", rank, currentGatherTime);
MPI_Finalize();
//This will output the array.
}
void CGameServer::Think(double flHostTime)
{
TPROF("CGameServer::Think");
m_iFrame++;
m_flFrameTime = flHostTime - m_flHostTime;
m_flFrameTime *= m_flTimeScale;
// If the framerate drops, don't let too much happen without the player seeing
if (GameNetwork()->IsConnected())
{
// But not as much in multiplayer games where we need to keep the game time synchronized
if (m_flFrameTime > 1.0f)
m_flFrameTime = 1.0f;
}
else
{
if (m_flFrameTime > 0.15f)
m_flFrameTime = 0.15f;
}
m_flGameTime += m_flFrameTime;
m_flHostTime = flHostTime;
if (GameNetwork()->IsConnected() && GameNetwork()->IsHost() && m_flHostTime > m_flNextClientInfoUpdate)
{
m_flNextClientInfoUpdate = m_flHostTime + 5.0f;
size_t iClientsConnected = GameNetwork()->GetClientsConnected();
for (size_t i = 0; i < iClientsConnected; i++)
{
size_t iClient = GameNetwork()->GetClientConnectionId(i);
if (iClient == ~0)
continue;
GameNetwork()->CallFunction(iClient, "ClientInfo", iClient, GetGameTime());
}
}
// Erase anything deleted last frame.
for (size_t i = 0; i < m_ahDeletedEntities.size(); i++)
delete m_ahDeletedEntities[i];
m_ahDeletedEntities.clear();
if (CWorkbench::IsActive())
Workbench()->Think();
CNetwork::Think();
size_t iMaxEntities = GameServer()->GetMaxEntities();
for (size_t i = 0; i < iMaxEntities; i++)
{
CBaseEntity* pEntity = CBaseEntity::GetEntity(i);
if (!pEntity)
continue;
pEntity->Think();
if (m_bHalting)
break;
}
Simulate();
Think();
if (GameNetwork()->IsHost())
CGameServerNetwork::UpdateNetworkVariables(NETWORK_TOCLIENTS);
if (GameNetwork()->IsHost())
{
for (size_t i = 0; i < iMaxEntities; i++)
{
CBaseEntity* pEntity = CBaseEntity::GetEntity(i);
if (!pEntity)
continue;
if (!pEntity->HasIssuedClientSpawn())
pEntity->IssueClientSpawn();
if (m_bHalting)
break;
}
}
CParticleSystemLibrary::Simulate();
TPortal_Think();
}
void NBodySimulator::Simulate(BodyList &bodies, const double time_simulated)
{
Simulate(bodies, time_simulated, nullptr);
}
