• Create Account

### #Actualslicer4ever

Posted 31 October 2013 - 02:20 PM

I have suspicions that the following concept is not very cache friendly, but i'm no expert on the subject, and like some pointers.

essentially, i have 2 threads, one for networking, and one for the game simulation.  i want to process the packets in the game simulation thread, rather than in the network thread so that the simulation can be maintained as deterministic.

here's the concept i came up with for switching in/out packets between the two threads:



violatile int LockState = UNLOCKED;

RetrievePendingPackets(InPackets);
if(LockState==LOCK_REQUESTED){
linklist<Packet*> *Temp = TempList;
TempList = InPackets;
InPackets = Temp;
LockState = LOCKED;
}
if(LockState==UNLOCK_REQUESTED){
for(link<Packet*> *Lnk = TempList->GetFirst(); Lnk!=null; Lnk = Lnk->Next){
SendPacket(Lnk->value);
}
TempList->Clear();
LockState = UNLOCKED;
}
return;
}

if(LockState==LOCKED){
for(link<Packet*> *Lnk = TempList->GetFirst(); Lnk!=null; Lnk = Lnk->Next){
ProcessPacket(Lnk->value);
}
TempList->Clear();
linklist<Packet*> *Temp = TempList;
TempList = OutPackets;
OutPackets = Temp;
LockState=UNLOCK_REQUESTED;
}
if(LockState==UNLOCKED) LockState = LOCK_REQUESTED;
UpdateGames();  //Will push packets into the outpackets list.
}



my thoughts are that if the pointers are being swapped in one thread on a different core, then it needs to update the pointer for the value of the pointer for the cache on the thread for the other core.

so, thoughts on it are much appreciated.

### #3slicer4ever

Posted 31 October 2013 - 02:19 PM

I have suspicions that the following concept is not very cache friendly, but i'm no expert on the subject, and like some pointers.

essentially, i have 2 threads, one for networking, and one for the game simulation.  i want to process the packets in the game simulation thread, rather than in the network thread so that the simulation can be maintained as deterministic.

here's the concept i came up with for switching in/out packets between the two threads:



violatile int LockState = UNLOCKED;

RetrievePendingPackets(InPackets);
if(LockState==LOCK_REQUESTED){
linklist<Packet*> *Temp = TempList;
TempList = InPackets;
InPackets = Temp;
LockState = LOCKED;
}
if(LockState==UNLOCK_REQUESTED){
for(link<Packet*> *Lnk = TempList->GetFirst(); Lnk!=null; Lnk = Lnk->Next){
SendPacket(Lnk->value);
}
TempList->Clear();
LockState = UNLOCKED;
}
return;
}

if(LockState==LOCKED){
for(link<Packet*> *Lnk = TempList->GetFirst(); Lnk!=null; Lnk = Lnk->Next){
ProcessPacket(Lnk->value);
}
TempList->Clear();
linklist<Packet*> *Temp = TempList;
TempList = OutPackets;
OutPackets = Temp;
LockState=UNLOCK_REQUESTED;
}
if(LockState==UNLOCKED) LockState = LOCK_REQUESTED;
UpdateGames();  //Will push packets into the outpackets list.
}



my thoughts are that if the pointers are being swapped in one thread on a different core, then it needs to update the pointer for the value of the pointer for the cache on the thread for the other core.

so, thoughts on it are much appreciated.

### #2slicer4ever

Posted 31 October 2013 - 09:58 AM

I have suspicions that the following concept is not very cache friendly, but i'm no expert on the subject, and like some pointers.

essentially, i have 2 threads, one for networking, and one for the game simulation.  i want to process the packets in the game simulation thread, rather than in the network thread so that the simulation can be maintained as deterministic.

here's the concept i came up with for switching in/out packets between the two threads:



int LockState = UNLOCKED;

RetrievePendingPackets(InPackets);
if(LockState==LOCK_REQUESTED){
linklist<Packet*> *Temp = TempList;
TempList = InPackets;
InPackets = Temp;
LockState = LOCKED;
}
if(LockState==UNLOCK_REQUESTED){
for(link<Packet*> *Lnk = TempList->GetFirst(); Lnk!=null; Lnk = Lnk->Next){
SendPacket(Lnk->value);
}
TempList->Clear();
LockState = UNLOCKED;
}
return;
}

if(LockState==LOCKED){
for(link<Packet*> *Lnk = TempList->GetFirst(); Lnk!=null; Lnk = Lnk->Next){
ProcessPacket(Lnk->value);
}
TempList->Clear();
linklist<Packet*> *Temp = TempList;
TempList = OutPackets;
OutPackets = Temp;
LockState=UNLOCK_REQUESTED;
}
if(LockState==UNLOCKED) LockState = LOCK_REQUESTED;
UpdateGames();  //Will push packets into the outpackets list.
}



my thoughts are that if the pointers are being swapped in one thread on a different core, then it needs to update the pointer for the value of the pointer for the cache on the thread for the other core.

so, thoughts on it are much appreciated.

### #1slicer4ever

Posted 31 October 2013 - 09:57 AM

I have suspicions that the following concept is not very cache friendly, but i'm no expert on the subject, and like some pointers.

essentially, i have 2 threads, one for networking, and one for the game simulation.  i want to process the packets in the game simulation thread, rather than in the network thread so that the simulation can be maintained as deterministic.

here's the concept i came up with for switching in/out packets between the two threads:



int LockState = UNLOCKED;

RetrievePendingPackets(InPackets);
if(LockState==LOCK_REQUESTED){
linklist<Packet*> *Temp = TempList;
TempList = InPackets;
InPackets = Temp;
LockState = LOCKED;
}
if(LockState==UNLOCK_REQUESTED){
for(link<Packet*> *Lnk = TempList->GetFirst(); Lnk!=null; Lnk = Lnk->Next){
SendPacket(Lnk->value);
}
TempList->Clear();
LockState = UNLOCKED;
}
return;
}

if(LockState==LOCKED){
for(link<Packet*> *Lnk = TempList->GetFirst(); Lnk!=null; Lnk = Lnk->Next){
ProcessPacket(Lnk->value);
}
TempList->Clear();
linklist<Packet*> *Temp = TempList;
TempList = OutPackets;
OutPackets = Temp;
LockState=UNLOCK_REQUESTED;
}
if(LockState==UNLOCKED) LockState = LOCK_REQUESTED;
UpdateGames();  //Will push packets into the outpackets list.
}



my thoughts are that if the pointers are being swapped in one thread on a different core, then it needs to update the pointer for the value of the pointer for the cache on the thread for the other core.

so, thoughts on it are much appreciated.

PARTNERS