void Run(INT MPI_RNG_SEED){
///////////
// SETUP //
///////////
//SET SEED //
MY_MPI_RNG_SEED=MPI_RNG_SEED;
//INITIALIZE RANDOM NUMBER GENERATOR //
RandomNumberGenerator::Init(MY_MPI_RNG_SEED);
//INITIALIZE DYNAMICS //
Dynamics::Reset();
//////////////////////
// CREATE INFO FILE //
//////////////////////
CreateInfoFile();
////////////////////////////
// SET INITIAL CONDITIONS //
////////////////////////////
#if IC_FLAG==QP_FLAG
InitialConditions::SetQuasiParticles();
#endif
#if IC_FLAG==LOAD_FLAG
IO::LoadConfiguration(GLinks::U,EFields::E);
#endif
#if IC_FLAG==THERMAL_FLAG
InitialConditions::SetZero();
// THERMALIZE
ThermalDynamics::Thermalize(30,50.0);
#endif
////////////////////
// TIME EVOLUTION //
////////////////////
Evolve(20.0);
}
void Run(INT MPI_RNG_SEED){
///////////
// SETUP //
///////////
//SET SEED //
MY_MPI_RNG_SEED=1443154311;//MPI_RNG_SEED;//1443037688;//1442551674;//1443037688;//
//INITIALIZE RANDOM NUMBER GENERATOR //
RandomNumberGenerator::Init(MY_MPI_RNG_SEED);
//INITIALIZE DYNAMICS //
Dynamics::Reset();
////////////////////////////
// SET INITIAL CONDITIONS //
////////////////////////////
#if IC_FLAG==QP_FLAG
InitialConditions::SetQuasiParticles();
//RestartInitialConditions::SetQuasiParticles();
//IO::LoadConfiguration(GLinks::U,EFields::E);
//IO::LoadLinks(GLinks::U);
#endif
#if IC_FLAG==THERMAL_FLAG
InitialConditions::SetZero();
// THERMALIZE
ThermalDynamics::Thermalize(20,50.0);
#endif
////////////////////
// TIME EVOLUTION //
////////////////////
std::cerr << "### STARTING TIME EVOLUTION ###" << std::endl;
Evolve(1000.0);
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
World world;
for (int i = 0; i < 500; i++)
{
int x = qrand() % ((2500 + 1) - 0) + 0;
int y = qrand() % ((2500 + 1) - 0) + 0;
if(!world.ContainsCellAt(x, y))
world.AddCell(x,y);
}
QtQuick2ApplicationViewer viewer;
viewer.rootContext()->setContextProperty("world", &world);
viewer.setMainQmlFile(QStringLiteral("qml/UI/main.qml"));
viewer.showExpanded();
auto rootobject = viewer.rootObject();
QObject::connect(rootobject, SIGNAL(evolve()), &world, SLOT(Evolve()));
return app.exec();
}
void CGameClient::OnNewSnapshot()
{
m_NewTick = true;
// clear out the invalid pointers
mem_zero(&g_GameClient.m_Snap, sizeof(g_GameClient.m_Snap));
m_Snap.m_LocalClientID = -1;
// secure snapshot
{
int Num = Client()->SnapNumItems(IClient::SNAP_CURRENT);
for(int Index = 0; Index < Num; Index++)
{
IClient::CSnapItem Item;
void *pData = Client()->SnapGetItem(IClient::SNAP_CURRENT, Index, &Item);
if(m_NetObjHandler.ValidateObj(Item.m_Type, pData, Item.m_DataSize) != 0)
{
if(g_Config.m_Debug)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "invalidated index=%d type=%d (%s) size=%d id=%d", Index, Item.m_Type, m_NetObjHandler.GetObjName(Item.m_Type), Item.m_DataSize, Item.m_ID);
Console()->Print(IConsole::OUTPUT_LEVEL_DEBUG, "game", aBuf);
}
Client()->SnapInvalidateItem(IClient::SNAP_CURRENT, Index);
}
}
}
ProcessEvents();
if(g_Config.m_DbgStress)
{
if((Client()->GameTick()%100) == 0)
{
char aMessage[64];
int MsgLen = rand()%(sizeof(aMessage)-1);
for(int i = 0; i < MsgLen; i++)
aMessage[i] = 'a'+(rand()%('z'-'a'));
aMessage[MsgLen] = 0;
CNetMsg_Cl_Say Msg;
Msg.m_Team = rand()&1;
Msg.m_pMessage = aMessage;
Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
}
}
// go trough all the items in the snapshot and gather the info we want
{
m_Snap.m_aTeamSize[TEAM_RED] = m_Snap.m_aTeamSize[TEAM_BLUE] = 0;
int Num = Client()->SnapNumItems(IClient::SNAP_CURRENT);
for(int i = 0; i < Num; i++)
{
IClient::CSnapItem Item;
const void *pData = Client()->SnapGetItem(IClient::SNAP_CURRENT, i, &Item);
if(Item.m_Type == NETOBJTYPE_CLIENTINFO)
{
const CNetObj_ClientInfo *pInfo = (const CNetObj_ClientInfo *)pData;
int ClientID = Item.m_ID;
IntsToStr(&pInfo->m_Name0, 4, m_aClients[ClientID].m_aName);
IntsToStr(&pInfo->m_Clan0, 3, m_aClients[ClientID].m_aClan);
m_aClients[ClientID].m_Country = pInfo->m_Country;
IntsToStr(&pInfo->m_Skin0, 6, m_aClients[ClientID].m_aSkinName);
m_aClients[ClientID].m_UseCustomColor = pInfo->m_UseCustomColor;
m_aClients[ClientID].m_ColorBody = pInfo->m_ColorBody;
m_aClients[ClientID].m_ColorFeet = pInfo->m_ColorFeet;
// prepare the info
if(m_aClients[ClientID].m_aSkinName[0] == 'x' || m_aClients[ClientID].m_aSkinName[1] == '_')
str_copy(m_aClients[ClientID].m_aSkinName, "default", 64);
m_aClients[ClientID].m_SkinInfo.m_ColorBody = m_pSkins->GetColorV4(m_aClients[ClientID].m_ColorBody);
m_aClients[ClientID].m_SkinInfo.m_ColorFeet = m_pSkins->GetColorV4(m_aClients[ClientID].m_ColorFeet);
m_aClients[ClientID].m_SkinInfo.m_Size = 64;
// find new skin
m_aClients[ClientID].m_SkinID = g_GameClient.m_pSkins->Find(m_aClients[ClientID].m_aSkinName);
if(m_aClients[ClientID].m_SkinID < 0)
{
m_aClients[ClientID].m_SkinID = g_GameClient.m_pSkins->Find("default");
if(m_aClients[ClientID].m_SkinID < 0)
m_aClients[ClientID].m_SkinID = 0;
}
if(m_aClients[ClientID].m_UseCustomColor)
m_aClients[ClientID].m_SkinInfo.m_Texture = g_GameClient.m_pSkins->Get(m_aClients[ClientID].m_SkinID)->m_ColorTexture;
else
{
m_aClients[ClientID].m_SkinInfo.m_Texture = g_GameClient.m_pSkins->Get(m_aClients[ClientID].m_SkinID)->m_OrgTexture;
m_aClients[ClientID].m_SkinInfo.m_ColorBody = vec4(1,1,1,1);
m_aClients[ClientID].m_SkinInfo.m_ColorFeet = vec4(1,1,1,1);
}
m_aClients[ClientID].UpdateRenderInfo();
}
else if(Item.m_Type == NETOBJTYPE_PLAYERINFO)
{
const CNetObj_PlayerInfo *pInfo = (const CNetObj_PlayerInfo *)pData;
m_aClients[pInfo->m_ClientID].m_Team = pInfo->m_Team;
m_aClients[pInfo->m_ClientID].m_Active = true;
m_Snap.m_paPlayerInfos[pInfo->m_ClientID] = pInfo;
m_Snap.m_NumPlayers++;
if(pInfo->m_Local)
{
m_Snap.m_LocalClientID = Item.m_ID;
m_Snap.m_pLocalInfo = pInfo;
if(pInfo->m_Team == TEAM_SPECTATORS)
{
m_Snap.m_SpecInfo.m_Active = true;
m_Snap.m_SpecInfo.m_SpectatorID = SPEC_FREEVIEW;
}
}
// calculate team-balance
if(pInfo->m_Team != TEAM_SPECTATORS)
m_Snap.m_aTeamSize[pInfo->m_Team]++;
}
else if(Item.m_Type == NETOBJTYPE_CHARACTER)
{
const void *pOld = Client()->SnapFindItem(IClient::SNAP_PREV, NETOBJTYPE_CHARACTER, Item.m_ID);
m_Snap.m_aCharacters[Item.m_ID].m_Cur = *((const CNetObj_Character *)pData);
if(pOld)
{
m_Snap.m_aCharacters[Item.m_ID].m_Active = true;
m_Snap.m_aCharacters[Item.m_ID].m_Prev = *((const CNetObj_Character *)pOld);
if(m_Snap.m_aCharacters[Item.m_ID].m_Prev.m_Tick)
Evolve(&m_Snap.m_aCharacters[Item.m_ID].m_Prev, Client()->PrevGameTick());
if(m_Snap.m_aCharacters[Item.m_ID].m_Cur.m_Tick)
Evolve(&m_Snap.m_aCharacters[Item.m_ID].m_Cur, Client()->GameTick());
}
}
else if(Item.m_Type == NETOBJTYPE_SPECTATORINFO)
{
m_Snap.m_pSpectatorInfo = (const CNetObj_SpectatorInfo *)pData;
m_Snap.m_pPrevSpectatorInfo = (const CNetObj_SpectatorInfo *)Client()->SnapFindItem(IClient::SNAP_PREV, NETOBJTYPE_SPECTATORINFO, Item.m_ID);
m_Snap.m_SpecInfo.m_SpectatorID = m_Snap.m_pSpectatorInfo->m_SpectatorID;
}
else if(Item.m_Type == NETOBJTYPE_GAMEINFO)
{
static bool s_GameOver = 0;
m_Snap.m_pGameInfoObj = (const CNetObj_GameInfo *)pData;
if(!s_GameOver && m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_GAMEOVER)
OnGameOver();
else if(s_GameOver && !(m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_GAMEOVER))
OnStartGame();
s_GameOver = m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_GAMEOVER;
}
else if(Item.m_Type == NETOBJTYPE_GAMEDATA)
{
m_Snap.m_pGameDataObj = (const CNetObj_GameData *)pData;
m_Snap.m_GameDataSnapID = Item.m_ID;
if(m_Snap.m_pGameDataObj->m_FlagCarrierRed == FLAG_TAKEN)
{
if(m_FlagDropTick[TEAM_RED] == 0)
m_FlagDropTick[TEAM_RED] = Client()->GameTick();
}
else if(m_FlagDropTick[TEAM_RED] != 0)
m_FlagDropTick[TEAM_RED] = 0;
if(m_Snap.m_pGameDataObj->m_FlagCarrierBlue == FLAG_TAKEN)
{
if(m_FlagDropTick[TEAM_BLUE] == 0)
m_FlagDropTick[TEAM_BLUE] = Client()->GameTick();
}
else if(m_FlagDropTick[TEAM_BLUE] != 0)
m_FlagDropTick[TEAM_BLUE] = 0;
}
else if(Item.m_Type == NETOBJTYPE_FLAG)
m_Snap.m_paFlags[Item.m_ID%2] = (const CNetObj_Flag *)pData;
}
}
// setup local pointers
if(m_Snap.m_LocalClientID >= 0)
{
CSnapState::CCharacterInfo *c = &m_Snap.m_aCharacters[m_Snap.m_LocalClientID];
if(c->m_Active)
{
m_Snap.m_pLocalCharacter = &c->m_Cur;
m_Snap.m_pLocalPrevCharacter = &c->m_Prev;
m_LocalCharacterPos = vec2(m_Snap.m_pLocalCharacter->m_X, m_Snap.m_pLocalCharacter->m_Y);
}
else if(Client()->SnapFindItem(IClient::SNAP_PREV, NETOBJTYPE_CHARACTER, m_Snap.m_LocalClientID))
{
// player died
m_pControls->OnPlayerDeath();
}
}
else
{
m_Snap.m_SpecInfo.m_Active = true;
if(Client()->State() == IClient::STATE_DEMOPLAYBACK && DemoPlayer()->GetDemoType() == IDemoPlayer::DEMOTYPE_SERVER &&
m_DemoSpecID != SPEC_FREEVIEW && m_Snap.m_aCharacters[m_DemoSpecID].m_Active)
m_Snap.m_SpecInfo.m_SpectatorID = m_DemoSpecID;
else
m_Snap.m_SpecInfo.m_SpectatorID = SPEC_FREEVIEW;
}
// clear out unneeded client data
for(int i = 0; i < MAX_CLIENTS; ++i)
{
if(!m_Snap.m_paPlayerInfos[i] && m_aClients[i].m_Active)
m_aClients[i].Reset();
}
// update friend state
for(int i = 0; i < MAX_CLIENTS; ++i)
{
if(i == m_Snap.m_LocalClientID || !m_Snap.m_paPlayerInfos[i] || !Friends()->IsFriend(m_aClients[i].m_aName, m_aClients[i].m_aClan, true))
m_aClients[i].m_Friend = false;
else
m_aClients[i].m_Friend = true;
}
// sort player infos by score
mem_copy(m_Snap.m_paInfoByScore, m_Snap.m_paPlayerInfos, sizeof(m_Snap.m_paInfoByScore));
for(int k = 0; k < MAX_CLIENTS-1; k++) // ffs, bubblesort
{
for(int i = 0; i < MAX_CLIENTS-k-1; i++)
{
if(m_Snap.m_paInfoByScore[i+1] && (!m_Snap.m_paInfoByScore[i] || m_Snap.m_paInfoByScore[i]->m_Score < m_Snap.m_paInfoByScore[i+1]->m_Score))
{
const CNetObj_PlayerInfo *pTmp = m_Snap.m_paInfoByScore[i];
m_Snap.m_paInfoByScore[i] = m_Snap.m_paInfoByScore[i+1];
m_Snap.m_paInfoByScore[i+1] = pTmp;
}
}
}
// sort player infos by team
int Teams[3] = { TEAM_RED, TEAM_BLUE, TEAM_SPECTATORS };
int Index = 0;
for(int Team = 0; Team < 3; ++Team)
{
for(int i = 0; i < MAX_CLIENTS && Index < MAX_CLIENTS; ++i)
{
if(m_Snap.m_paPlayerInfos[i] && m_Snap.m_paPlayerInfos[i]->m_Team == Teams[Team])
m_Snap.m_paInfoByTeam[Index++] = m_Snap.m_paPlayerInfos[i];
}
}
CTuningParams StandardTuning;
CServerInfo CurrentServerInfo;
Client()->GetServerInfo(&CurrentServerInfo);
if(CurrentServerInfo.m_aGameType[0] != '0')
{
if(str_comp(CurrentServerInfo.m_aGameType, "DM") != 0 && str_comp(CurrentServerInfo.m_aGameType, "TDM") != 0 && str_comp(CurrentServerInfo.m_aGameType, "CTF") != 0)
m_ServerMode = SERVERMODE_MOD;
else if(mem_comp(&StandardTuning, &m_Tuning, sizeof(CTuningParams)) == 0)
m_ServerMode = SERVERMODE_PURE;
else
m_ServerMode = SERVERMODE_PUREMOD;
}
// add tuning to demo
if(DemoRecorder()->IsRecording() && mem_comp(&StandardTuning, &m_Tuning, sizeof(CTuningParams)) != 0)
{
CMsgPacker Msg(NETMSGTYPE_SV_TUNEPARAMS);
int *pParams = (int *)&m_Tuning;
for(unsigned i = 0; i < sizeof(m_Tuning)/sizeof(int); i++)
Msg.AddInt(pParams[i]);
Client()->SendMsg(&Msg, MSGFLAG_RECORD|MSGFLAG_NOSEND);
}
if(!m_DDRaceMsgSent && m_Snap.m_pLocalInfo)
{
CNetMsg_Cl_IsDDRace Msg;
Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
m_DDRaceMsgSent = true;
}
if(m_ShowOthers == -1 || (m_ShowOthers != -1 && m_ShowOthers != g_Config.m_ClShowOthers))
{
// no need to send, default settings
//if(!(m_ShowOthers == -1 && g_Config.m_ClShowOthers))
{
CNetMsg_Cl_ShowOthers Msg;
Msg.m_Show = g_Config.m_ClShowOthers;
Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
}
// update state
m_ShowOthers = g_Config.m_ClShowOthers;
}
}
void CGameClient::OnNewSnapshot()
{
m_NewTick = true;
// clear out the invalid pointers
mem_zero(&g_GameClient.m_Snap, sizeof(g_GameClient.m_Snap));
m_Snap.m_LocalCid = -1;
// secure snapshot
{
int Num = Client()->SnapNumItems(IClient::SNAP_CURRENT);
for(int Index = 0; Index < Num; Index++)
{
IClient::CSnapItem Item;
void *pData = Client()->SnapGetItem(IClient::SNAP_CURRENT, Index, &Item);
if(m_NetObjHandler.ValidateObj(Item.m_Type, pData, Item.m_DataSize) != 0)
{
if(g_Config.m_Debug)
dbg_msg("game", "invalidated index=%d type=%d (%s) size=%d id=%d", Index, Item.m_Type, m_NetObjHandler.GetObjName(Item.m_Type), Item.m_DataSize, Item.m_Id);
Client()->SnapInvalidateItem(IClient::SNAP_CURRENT, Index);
}
}
}
ProcessEvents();
if(g_Config.m_DbgStress)
{
if((Client()->GameTick()%100) == 0)
{
char aMessage[64];
int MsgLen = rand()%(sizeof(aMessage)-1);
for(int i = 0; i < MsgLen; i++)
aMessage[i] = 'a'+(rand()%('z'-'a'));
aMessage[MsgLen] = 0;
CNetMsg_Cl_Say Msg;
Msg.m_Team = rand()&1;
Msg.m_pMessage = aMessage;
Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
}
}
// go trough all the items in the snapshot and gather the info we want
{
m_Snap.m_aTeamSize[0] = m_Snap.m_aTeamSize[1] = 0;
int Num = Client()->SnapNumItems(IClient::SNAP_CURRENT);
for(int i = 0; i < Num; i++)
{
IClient::CSnapItem Item;
const void *pData = Client()->SnapGetItem(IClient::SNAP_CURRENT, i, &Item);
if(Item.m_Type == NETOBJTYPE_CLIENTINFO)
{
const CNetObj_ClientInfo *pInfo = (const CNetObj_ClientInfo *)pData;
int Cid = Item.m_Id;
IntsToStr(&pInfo->m_Name0, 6, m_aClients[Cid].m_aName);
IntsToStr(&pInfo->m_Skin0, 6, m_aClients[Cid].m_aSkinName);
m_aClients[Cid].m_UseCustomColor = pInfo->m_UseCustomColor;
m_aClients[Cid].m_ColorBody = pInfo->m_ColorBody;
m_aClients[Cid].m_ColorFeet = pInfo->m_ColorFeet;
// prepare the info
if(m_aClients[Cid].m_aSkinName[0] == 'x' || m_aClients[Cid].m_aSkinName[1] == '_')
str_copy(m_aClients[Cid].m_aSkinName, "default", 64);
m_aClients[Cid].m_SkinInfo.m_ColorBody = m_pSkins->GetColor(m_aClients[Cid].m_ColorBody);
m_aClients[Cid].m_SkinInfo.m_ColorFeet = m_pSkins->GetColor(m_aClients[Cid].m_ColorFeet);
m_aClients[Cid].m_SkinInfo.m_Size = 64;
// find new skin
m_aClients[Cid].m_SkinId = g_GameClient.m_pSkins->Find(m_aClients[Cid].m_aSkinName);
if(m_aClients[Cid].m_SkinId < 0)
{
m_aClients[Cid].m_SkinId = g_GameClient.m_pSkins->Find("default");
if(m_aClients[Cid].m_SkinId < 0)
m_aClients[Cid].m_SkinId = 0;
}
if(m_aClients[Cid].m_UseCustomColor)
m_aClients[Cid].m_SkinInfo.m_Texture = g_GameClient.m_pSkins->Get(m_aClients[Cid].m_SkinId)->m_ColorTexture;
else
{
m_aClients[Cid].m_SkinInfo.m_Texture = g_GameClient.m_pSkins->Get(m_aClients[Cid].m_SkinId)->m_OrgTexture;
m_aClients[Cid].m_SkinInfo.m_ColorBody = vec4(1,1,1,1);
m_aClients[Cid].m_SkinInfo.m_ColorFeet = vec4(1,1,1,1);
}
m_aClients[Cid].UpdateRenderInfo();
g_GameClient.m_Snap.m_NumPlayers++;
}
else if(Item.m_Type == NETOBJTYPE_PLAYERINFO)
{
const CNetObj_PlayerInfo *pInfo = (const CNetObj_PlayerInfo *)pData;
m_aClients[pInfo->m_ClientId].m_Team = pInfo->m_Team;
m_Snap.m_paPlayerInfos[pInfo->m_ClientId] = pInfo;
if(pInfo->m_Local)
{
m_Snap.m_LocalCid = Item.m_Id;
m_Snap.m_pLocalInfo = pInfo;
if (pInfo->m_Team == -1)
m_Snap.m_Spectate = true;
}
// calculate team-balance
if(pInfo->m_Team != -1)
m_Snap.m_aTeamSize[pInfo->m_Team]++;
}
else if(Item.m_Type == NETOBJTYPE_CHARACTER)
{
const void *pOld = Client()->SnapFindItem(IClient::SNAP_PREV, NETOBJTYPE_CHARACTER, Item.m_Id);
if(pOld)
{
m_Snap.m_aCharacters[Item.m_Id].m_Active = true;
m_Snap.m_aCharacters[Item.m_Id].m_Prev = *((const CNetObj_Character *)pOld);
m_Snap.m_aCharacters[Item.m_Id].m_Cur = *((const CNetObj_Character *)pData);
if(m_Snap.m_aCharacters[Item.m_Id].m_Prev.m_Tick)
Evolve(&m_Snap.m_aCharacters[Item.m_Id].m_Prev, Client()->PrevGameTick());
if(m_Snap.m_aCharacters[Item.m_Id].m_Cur.m_Tick)
Evolve(&m_Snap.m_aCharacters[Item.m_Id].m_Cur, Client()->GameTick());
}
}
else if(Item.m_Type == NETOBJTYPE_GAME)
m_Snap.m_pGameobj = (CNetObj_Game *)pData;
else if(Item.m_Type == NETOBJTYPE_FLAG)
m_Snap.m_paFlags[Item.m_Id%2] = (const CNetObj_Flag *)pData;
}
}
// setup local pointers
if(m_Snap.m_LocalCid >= 0)
{
CSnapState::CCharacterInfo *c = &m_Snap.m_aCharacters[m_Snap.m_LocalCid];
if(c->m_Active)
{
m_Snap.m_pLocalCharacter = &c->m_Cur;
m_Snap.m_pLocalPrevCharacter = &c->m_Prev;
m_LocalCharacterPos = vec2(m_Snap.m_pLocalCharacter->m_X, m_Snap.m_pLocalCharacter->m_Y);
}
}
else
m_Snap.m_Spectate = true;
CTuningParams StandardTuning;
CServerInfo CurrentServerInfo;
Client()->GetServerInfo(&CurrentServerInfo);
if(CurrentServerInfo.m_aGameType[0] != '0')
{
if(str_comp(CurrentServerInfo.m_aGameType, "DM") != 0 && str_comp(CurrentServerInfo.m_aGameType, "TDM") != 0 && str_comp(CurrentServerInfo.m_aGameType, "CTF") != 0)
m_ServerMode = SERVERMODE_MOD;
else if(mem_comp(&StandardTuning, &m_Tuning, sizeof(CTuningParams)) == 0)
m_ServerMode = SERVERMODE_PURE;
else
m_ServerMode = SERVERMODE_PUREMOD;
}
// update render info
for(int i = 0; i < MAX_CLIENTS; i++)
m_aClients[i].UpdateRenderInfo();
}
int main (int argc, char *argv[])
{
MPI_Request reqSR[4], reqRR[4], reqSF[4], reqRF[4];
MPI_Status statRR[4], statRF[4], statSR[4], statSF[4];
MPI_Comm cartcomm;
int n_proc, nbrs[4], dims[2], periods[2]={1,1}, reorder=1;
int landNS, landWE, err,i;
float sumFox, sumRabb, nbrab, nbfox, model[2][3];
double time;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &n_proc);
if(rank==0){
time= MPI_Wtime();
printf("N_proc:%d",n_proc);
}
/****************************************************
********** CASO DE 1 PROCESSO ******************
***************************************************/
if (n_proc==1) {
echoSingle();
}else{
/****************************************************
**********+++ MULTI PROCESSOS ******************
***************************************************/
int lado = sqrt(n_proc);
dims[0] = lado;
dims[1] = lado;
if((lado * lado) != n_proc){
if(rank==0)
printf("ERRO: Numero incorreto de processos\n");
MPI_Finalize();
exit(0);
}
MPI_Cart_create(MPI_COMM_WORLD, 2, dims, periods, reorder, &cartcomm);
MPI_Comm_rank(cartcomm, &rank);
MPI_Cart_coords(cartcomm, rank, 2, coords);
MPI_Cart_shift(cartcomm, 0, 1, &nbrs[UP], &nbrs[DOWN]);
MPI_Cart_shift(cartcomm, 1, 1, &nbrs[LEFT], &nbrs[RIGHT]);
//Actualizar offsets de cada processo
landNS = offsetNS = NS_Size / lado;
landWE = offsetWE = WE_Size / lado;
if(coords[0] == (lado-1)){
offsetNS += NS_Size % lado;
}
if(coords[1] == (lado-1)){
offsetWE += WE_Size % lado;
}
//Buffers para envio e receção de dados
float buf_sendFoxN[offsetWE],buf_sendFoxS[offsetWE],buf_sendFoxW[offsetNS],buf_sendFoxE[offsetNS];
float buf_recvFoxN[offsetWE],buf_recvFoxS[offsetWE],buf_recvFoxW[offsetNS],buf_recvFoxE[offsetNS];
float buf_sendRabbitN[offsetWE],buf_sendRabbitS[offsetWE],buf_sendRabbitW[offsetNS],buf_sendRabbitE[offsetNS];
float buf_recvRabbitN[offsetWE],buf_recvRabbitS[offsetWE],buf_recvRabbitW[offsetNS],buf_recvRabbitE[offsetNS];
float Rabbit[offsetNS+2][offsetWE+2];
float Fox[offsetNS+2][offsetWE+2];
/* The next two arrays are used in function Evolve() to compute
* the next generation of rabbits and foxes.
*/
float TRabbit[offsetNS+2][offsetWE+2];
float TFox[offsetNS+2][offsetWE+2];
//Inicialização das comunicações
//********* Raposas **************
//Enviar
//Cima e baixo
MPI_Send_init(&buf_sendFoxN[0], offsetWE, MPI_FLOAT, nbrs[UP], 0, cartcomm, &reqSF[UP]);
MPI_Send_init(&buf_sendFoxS[0], offsetWE, MPI_FLOAT, nbrs[DOWN], 0, cartcomm, &reqSF[DOWN]);
//Esquerda e direita
MPI_Send_init(&buf_sendFoxW[0], offsetNS, MPI_FLOAT, nbrs[LEFT], 0, cartcomm, &reqSF[LEFT]);
MPI_Send_init(&buf_sendFoxE[0], offsetNS, MPI_FLOAT, nbrs[RIGHT], 0, cartcomm, &reqSF[RIGHT]);
//Receber
//Cima e Baixo
MPI_Recv_init(&buf_recvFoxS[0], offsetWE, MPI_FLOAT, nbrs[DOWN], 0, cartcomm, &reqRF[DOWN]);
MPI_Recv_init(&buf_recvFoxN[0], offsetWE, MPI_FLOAT, nbrs[UP], 0, cartcomm, &reqRF[UP]);
//Esquerda e direita
MPI_Recv_init(&buf_recvFoxE[0], offsetNS, MPI_FLOAT, nbrs[RIGHT], 0, cartcomm, &reqRF[RIGHT]);
MPI_Recv_init(&buf_recvFoxW[0], offsetNS, MPI_FLOAT, nbrs[LEFT], 0, cartcomm, &reqRF[LEFT]);
//********* Coelhos ***************
//Enviar
//Cima e baixo
MPI_Send_init(&buf_sendRabbitN[0], offsetWE, MPI_FLOAT, nbrs[UP], 0, cartcomm, &reqSR[UP]);
MPI_Send_init(&buf_sendRabbitS[0], offsetWE, MPI_FLOAT, nbrs[DOWN], 0, cartcomm, &reqSR[DOWN]);
//Esquerda e direita
MPI_Send_init(&buf_sendRabbitW[0], offsetNS, MPI_FLOAT, nbrs[LEFT], 0, cartcomm, &reqSR[LEFT]);
MPI_Send_init(&buf_sendRabbitE[0], offsetNS, MPI_FLOAT, nbrs[RIGHT], 0, cartcomm, &reqSR[RIGHT]);
//Receber
//Cima e Baixo
MPI_Recv_init(&buf_recvRabbitS[0], offsetWE, MPI_FLOAT, nbrs[DOWN], 0, cartcomm, &reqRR[DOWN]);
MPI_Recv_init(&buf_recvRabbitN[0], offsetWE, MPI_FLOAT, nbrs[UP], 0, cartcomm, &reqRR[UP]);
//Esquerda e direita
MPI_Recv_init(&buf_recvRabbitE[0], offsetNS, MPI_FLOAT, nbrs[RIGHT], 0, cartcomm, &reqRR[RIGHT]);
MPI_Recv_init(&buf_recvRabbitW[0], offsetNS, MPI_FLOAT, nbrs[LEFT], 0, cartcomm, &reqRR [LEFT]);
/* Initialise the problem. */
err = SetLand(Rabbit,Fox,model,landNS, landWE);
// Iterate.
for( k=1; k<=NITER; k++) {
/******************************************************
**** Começa comunicação de actualização ********
******************************************************/
//************** Envios ***************/
//Raposas
//Cima e baixo
for(i=1; i <= offsetWE; i++)
buf_sendFoxN[i-1] = Fox[1][i];
MPI_Start(&reqSF[UP]);
for(i=1; i <= offsetWE; i++)
buf_sendFoxS[i-1] = Fox[offsetNS][i];
MPI_Start(&reqSF[DOWN]);
//Esquerda e direita
for(i=1; i <= offsetNS; i++)
buf_sendFoxW[i-1] = Fox[i][1];
MPI_Start(&reqSF[LEFT]);
for(i=1; i <= offsetNS; i++)
buf_sendFoxE[i-1] = Fox[i][offsetWE];
MPI_Start(&reqSF[RIGHT]);
//Coelhos
//Cima e baixo
for(i=1; i <= offsetWE; i++)
buf_sendRabbitN[i-1] = Rabbit[1][i];
MPI_Start(&reqSR[UP]);
for(i=1; i <= offsetWE; i++)
buf_sendRabbitS[i-1] = Rabbit[offsetNS][i];
MPI_Start(&reqSR[DOWN]);
//Esquerda e direita
for(i=1; i <= offsetNS; i++)
buf_sendRabbitW[i-1] = Rabbit[i][1];
MPI_Start(&reqSR[LEFT]);
for(i=1; i <= offsetNS; i++)
buf_sendRabbitE[i-1] = Rabbit[i][offsetWE];
MPI_Start(&reqSR[RIGHT]);
//************** Recepção ***************/
//Raposas
//Cima e baixo
MPI_Start(&reqRF[DOWN]);
MPI_Start(&reqRF[UP]);
//Esquerda e direita
MPI_Start(&reqRF[RIGHT]);
MPI_Start(&reqRF[LEFT]);
//Coelhos
//Cima e baixo
MPI_Start(&reqRR[DOWN]);
MPI_Start(&reqRR[UP]);
//Esquerda e direita
MPI_Start(&reqRR[RIGHT]);
MPI_Start(&reqRR[LEFT]);
//Esperar pelos Receives e aplicar alterações nos quadros
//Raposas
MPI_Waitall(4, reqRR , statRR);
for(i=1; i <= offsetWE; i++)
Fox[offsetNS+1][i] = buf_recvFoxS[i-1];
for(i=1; i <= offsetWE; i++)
Fox[0][i] = buf_recvFoxN[i-1];
for(i=1; i <= offsetNS; i++)
Fox[i][offsetWE+1] = buf_recvFoxE[i-1];
for(i=1; i <= offsetNS; i++)
Fox[i][0] = buf_recvFoxW[i-1];
//Coelhos
MPI_Waitall(4, reqRF, statRF);
for(i=1; i <= offsetWE; i++)
Rabbit[offsetNS+1][i] = buf_recvRabbitS[i-1];
for(i=1; i <= offsetWE; i++)
Rabbit[0][i] = buf_recvRabbitN[i-1];
for(i=1; i <= offsetNS; i++)
Rabbit[i][offsetWE+1] = buf_recvRabbitE[i-1];
for(i=1; i <= offsetNS; i++)
Rabbit[i][0] = buf_recvRabbitW[i-1];
/******************************************************
**** Termina comunicação de actualização ********
******************************************************/
err = Evolve(Rabbit,Fox,TRabbit,TFox,model);
if( !(k%PERIOD) ) {
err = GetPopulation(Rabbit,&nbrab);
err = GetPopulation(Fox,&nbfox);
MPI_Reduce(&nbrab, &sumRabb, 1, MPI_FLOAT, MPI_SUM, 0, cartcomm);
MPI_Reduce(&nbfox, &sumFox, 1, MPI_FLOAT, MPI_SUM, 0, cartcomm);
//if(rank==0)
// printf("Year %d: %.0f rabbits and %.0f foxes\n", k, sumRabb, sumFox);
}
//Esperar que os Sends estejam concluidos para ter a certeza que que já podemos mexer nos buffers
//(Não creio de que 100% obrigatório)
MPI_Waitall(4, reqSR , statSR);
MPI_Waitall(4, reqSF , statSF);
}
if(rank==0)
printf("Year %d: %.0f rabbits and %.0f foxes\n", k, sumRabb, sumFox);
}
if(rank==0)
printf("Time: %f\n",MPI_Wtime()-time);
MPI_Finalize();
return 0;
}
int main ()
{
printf("x = 0, y = 0, rule = B3/S23\n");
#pragma omp parallel
{
New();
LifeState* blck = NewState("2o$o$b3o$3bo!");
LifeState* gldL = NewState("3o$2bo$bo!");
LifeState* gldR = NewState("bo$o$3o!");
LifeIterator *iterL = NewIterator(gldL, -10, 5, 10, 1);
LifeIterator *iterR1 = NewIterator(gldR, 0, -15, 10, 10, 4);
LifeIterator *iterR2 = NewIterator(gldR, 0, -15, 10, 10, 4);
int initPop = GetPop(blck);
do{
#pragma omp single nowait
{
if(Validate(iterR1, iterR2) != FAIL)
{
New();
PutState(blck);
PutState(iterL);
PutState(iterR1);
PutState(iterR2);
int collide = NO;
for(int i = 0; i < 4; i++)
{
if(GetPop() != 5 * 3 + initPop)
{
collide = YES;
break;
}
Run(1);
}
if(collide != YES)
{
for(int i = 0; i < 300; i++)
{
Run(1);
uint64_t gld = LocateAtX(GlobalState, _glidersTarget[0], 2);
int found = NO;
if(strlen(GlobalState->emittedGliders->value) != 0)
break;
int gen = GlobalState->gen;
if(gld != 0 && GetPop() == 5)
{
found = YES;
for(int j = 0; j < 4; j++)
{
if(GlobalState->gen%4 == 0)
break;
Run(1);
}
Capture(0);
Move(Captures[0], (GlobalState->gen) / 4 + 4, (GlobalState->gen) / 4 + 4);
Evolve(Captures[0], 2);
New();
PutState(blck);
PutState(iterL);
PutState(iterR1);
PutState(iterR2);
PutState(Captures[0]);
Run(gen);
uint64_t gld = LocateAtX(GlobalState, _glidersTarget[0], 2);
if(gld != 0 && GetPop() == 10)
{
New();
PutState(blck);
PutState(iterL);
PutState(iterR1);
PutState(iterR2);
PutState(Captures[0]);
#pragma omp critical
{
printf(GetRLE(GlobalState));
printf("100$");
}
}
}
if(found == YES)
break;
}
}
}
}
}while(Next(iterL, iterR1, iterR2, NO));
}
printf("!");
printf("\n\nFINISH");
getchar();
}