Fixes for backend Golang select-multi-channel implementation.

battle_srv/main.go

@@ -25,9 +25,16 @@ import (
 	"go.uber.org/zap"
 
 	"net"
+	// _ "net/http/pprof"
 )
 
 func main() {
+	/*
+		        // Only used for profiling
+			go func() {
+				http.ListenAndServe("0.0.0.0:6060", nil)
+			}()
+	*/
 	MustParseConfig()
 	MustParseConstants()
 	storage.Init()

battle_srv/models/room.go

@@ -483,7 +483,7 @@ func (pR *Room) StartBattle() {
 			*/
 			totalElapsedNanos := utils.UnixtimeNano() - battleStartedAt
 			nextRenderFrameId := int32((totalElapsedNanos + pR.dilutedRollbackEstimatedDtNanos - 1) / pR.dilutedRollbackEstimatedDtNanos) // fast ceiling
-			toSleepNanos := int64(0)
+			toSleepNanos := int64(pR.dilutedRollbackEstimatedDtNanos >> 1)                                                                // Sleep half-frame time by default
 			if nextRenderFrameId > pR.RenderFrameId {
 				if 0 == pR.RenderFrameId {
 					// It's important to send kickoff frame iff  "0 == pR.RenderFrameId && nextRenderFrameId > pR.RenderFrameId", otherwise it might send duplicate kickoff frames
@@ -515,7 +515,7 @@ func (pR *Room) StartBattle() {
 				pR.LastRenderFrameIdTriggeredAt = utils.UnixtimeNano()
 
 				elapsedInCalculation := (utils.UnixtimeNano() - stCalculation)
-				toSleepNanos = pR.dilutedRollbackEstimatedDtNanos - elapsedInCalculation // don't sleep if "nextRenderFrame == pR.RenderFrameId"
+				toSleepNanos = pR.dilutedRollbackEstimatedDtNanos - elapsedInCalculation
 				if elapsedInCalculation > pR.RollbackEstimatedDtNanos {
 					Logger.Warn(fmt.Sprintf("SLOW FRAME! Elapsed time statistics: roomId=%v, room.RenderFrameId=%v, elapsedInCalculation=%v ns, dynamicsDuration=%v ns, RollbackEstimatedDtNanos=%v, dilutedRollbackEstimatedDtNanos=%v", pR.Id, pR.RenderFrameId, elapsedInCalculation, dynamicsDuration, pR.RollbackEstimatedDtNanos, pR.dilutedRollbackEstimatedDtNanos))
 				}
@@ -544,13 +544,13 @@ func (pR *Room) StartBattle() {
 			}
 
 			select {
+			// [WARNING] DON'T put a "default" block here! Otherwise "for { select {... default: } }" pattern would NEVER block on empty channel and thus consume a lot of CPU time unnecessarily!
 			case inputsBufferSnapshot := <-playerDownsyncChan:
 				pR.downsyncToSinglePlayer(playerId, player, inputsBufferSnapshot.RefRenderFrameId, inputsBufferSnapshot.UnconfirmedMask, inputsBufferSnapshot.ToSendInputFrameDownsyncs, inputsBufferSnapshot.ShouldForceResync)
 				//Logger.Info(fmt.Sprintf("Sent inputsBufferSnapshot(refRenderFrameId:%d, unconfirmedMask:%v) to for (roomId: %d, playerId:%d)#2", inputsBufferSnapshot.RefRenderFrameId, inputsBufferSnapshot.UnconfirmedMask, pR.Id, playerId))
 			case inputsBufferSnapshot2 := <-playerSecondaryDownsyncChan:
 				pR.downsyncPeerInputFrameUpsyncToSinglePlayer(playerId, player, inputsBufferSnapshot2.ToSendInputFrameDownsyncs, inputsBufferSnapshot2.PeerJoinIndex)
 				//Logger.Info(fmt.Sprintf("Sent secondary inputsBufferSnapshot to for (roomId: %d, playerId:%d)#2", pR.Id, playerId))
-			default:
 			}
 		}
 	}

frontend/build-templates/jsb-link/frameworks/runtime-src/Classes/udp_session.cpp

@@ -160,7 +160,6 @@ void startRecvLoop(void* arg) {
 
     int uvCloseRet = uv_loop_close(l);
     CCLOG("UDP recv loop is closed in UvRecvThread, uvCloseRet=%d", uvCloseRet);
-    uv_mutex_destroy(&recvRingBuffLock);
 }
 
 void startSendLoop(void* arg) {
@@ -174,7 +173,6 @@ void startSendLoop(void* arg) {
 
     int uvCloseRet = uv_loop_close(l);
     CCLOG("UDP send loop is closed in UvSendThread, uvCloseRet=%d", uvCloseRet);
-    uv_mutex_destroy(&sendRingBuffLock);
 }
 
 int initSendLoop(struct sockaddr const* pUdpAddr) {
@@ -189,9 +187,6 @@ int initSendLoop(struct sockaddr const* pUdpAddr) {
     uv_mutex_init(&sendRingBuffLock);
     sendRingBuff = new SendRingBuff(maxBuffedMsgs);
 
-    uv_mutex_init(&recvRingBuffLock);
-    recvRingBuff = new RecvRingBuff(maxBuffedMsgs);
-
     uv_async_init(sendLoop, &uvSendLoopStopSig, _onUvStopSig);
     uv_async_init(sendLoop, &uvSendLoopTriggerSig, _onUvSthNewToSend);
 
@@ -208,6 +203,9 @@ bool initRecvLoop(struct sockaddr const* pUdpAddr) {
         CCLOGERROR("Failed to bind recv; recvSockInitRes=%d, recvbindRes=%d, reason=%s", recvSockInitRes, recvbindRes, uv_strerror(recvbindRes));
         exit(-1);
     }
+    uv_mutex_init(&recvRingBuffLock);
+    recvRingBuff = new RecvRingBuff(maxBuffedMsgs);
+
     uv_udp_recv_start(udpRecvSocket, _allocBuffer, _onRead);
     uv_async_init(recvLoop, &uvRecvLoopStopSig, _onUvStopSig);
 
@@ -249,6 +247,12 @@ bool DelayNoMore::UdpSession::openUdpSession(int port) {
 bool DelayNoMore::UdpSession::closeUdpSession() {
     CCLOG("About to close udp session and dealloc all resources...");
     
+    /*
+    [WARNING] It's possible that "closeUdpSession" is called when "openUdpSession" was NEVER CALLED, thus we have to avoid program crash in this case.  
+
+    In general one shouldn't just check the state of "sendTid" by whether or not "NULL == sendLoop", but in this particular game, both "openUdpSession" and "closeUdpSession" are only called from "GameThread", no thread-safety concern here, i.e. if "openUdpSession" was ever called earlier, then "sendLoop" wouldn't be NULL when "closeUdpSession" is later called.
+    */
+    if (NULL != sendLoop) {
         uv_async_send(&uvSendLoopStopSig);
         CCLOG("Signaling UvSendThread to end in GameThread...");
         uv_thread_join(&sendTid);
@@ -256,6 +260,14 @@ bool DelayNoMore::UdpSession::closeUdpSession() {
         free(sendLoop);
         delete sendRingBuff;
         
+        udpSendSocket = NULL;
+        sendLoop = NULL;
+        sendRingBuff = NULL;
+
+        uv_mutex_destroy(&sendRingBuffLock);
+    }
+
+    if (NULL != recvLoop) {
         uv_async_send(&uvRecvLoopStopSig); // The few if not only guaranteed thread safe utility of libuv :) See http://docs.libuv.org/en/v1.x/async.html#c.uv_async_send
         CCLOG("Signaling UvRecvThread to end in GameThread...");
         uv_thread_join(&recvTid);
@@ -263,6 +275,13 @@ bool DelayNoMore::UdpSession::closeUdpSession() {
         free(recvLoop);
         delete recvRingBuff;
 
+        udpRecvSocket = NULL;
+        recvLoop = NULL;
+        recvRingBuff = NULL;
+
+        uv_mutex_destroy(&recvRingBuffLock);
+    }
+
     CCLOG("Closed udp session and dealloc all resources in GameThread...");
 
     return true;
@@ -356,8 +375,10 @@ bool DelayNoMore::UdpSession::pollUdpRecvRingBuff() {
     while (true) {
         RecvWork f;
         bool res = recvRingBuff->pop(&f); 
-        if (!res) return false;
-
+        if (!res) {
+            // Deliberately returning "true" here to prevent "jswrapper" from printing "Failed to invoke Xxx..." too frequently
+            return true;
+        }
         // [WARNING] Declaring "AutoHandleScope" is critical here, otherwise "onUdpMessageCb.toObject()" wouldn't be recognized as a function of the ScriptEngine!
         se::AutoHandleScope hs;
         // [WARNING] Use of the "ScriptEngine" is only allowed in "GameThread a.k.a. CocosThread"!