typedef struct MYDATA
{
   int test_int[20][20][3];
   var test_var[20][20][3];
} MYDATA;

function fill_data(MYDATA *data)
{
   int i = 0;
   int j = 0;
   int k = 0;
   
   for (i = 0; i < 20; i++)
   {
      for (j = 0; j < 20; j++)
      {
        for (k = 0; k < 3; k++)
        {
           data->test_int[i][j][k] = i * j * k;
           data->test_var[i][j][k] = (var)((i * j * k) + 1);
        }
      }  
   }
}
...

#include <string.h>
#include <WINSOCK2.H>
#include <stdio.h>
#pragma comment(lib,"ws2_32.lib")
#include "conf/BufferConf.h"

#include "memPoolList.h"

#include "core/Queue.h"
/*
*
*	
*/
void startRun(ServerObject* t);





DWORD WINAPI listenThreadFun(LPVOID lpParam){
	

	ServerObject* se=Server_getinstance();
	queue* q=se->mProtocolQueue;
	void*pool=memPoolList_get();
	int re;
	while(true){
		re = QueueIsEmpty(q);
		if(re!=1 && se->mQueueLock==0){
			
			se->mQueueLock = 1;
			int i;
			QueueDelete(q,&i);
			SocketProtocol* sp = (SocketProtocol*)i;
			
			ParseData_get(sp);
			
			mempool_free(pool,sp->buffer);
			mempool_free(pool,sp);
			
			printfMemFree(pool);
			
			tool_printf(LOG_DEBUG,"bytes)ParseData_get finish...");
			
			Sleep(1);
			se->mQueueLock = 0;
		}
		Sleep(1);
	}
	return 0;
}
ServerObject* Server_getinstance(){
	if(ser==NULL){
		
		void* pool = memPoolList_get();
		
		ser=(ServerObject*)mempool_malloc(pool,sizeof(ServerObject));
		
		queue* q=QueueInit(10);

		ser->mProtocolQueue = q;
		
		ser->port = 6002;
		
		GameWorld_Instance();
		
		
		HANDLE hThread = CreateThread(NULL,0,listenThreadFun,NULL,0,NULL);
		CloseHandle(hThread);
		ser->mQueueLock = 0;
		
		
		startRun(ser);
	}
	return ser;
}

void startRun(ServerObject* t){
	u_short _port = t->port;
	queue* que = t->mProtocolQueue;
	void*  pool=memPoolList_get();

	if(!t->hWnd){
		
	}

	WORD wVersionRequested;
	WSADATA wsaData;
	int _err;
	wVersionRequested = MAKEWORD(1,1);
	_err = WSAStartup( wVersionRequested, &wsaData );
	if(LOBYTE(wsaData.wVersion)!=1||HIBYTE(wsaData.wVersion)!=1||_err!=0||_port==0){
		WSACleanup();
		return;
	}
	SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);
	SOCKADDR_IN addrSrv;
	addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
	addrSrv.sin_family=AF_INET;
	addrSrv.sin_port=htons(_port);
	bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
	listen(sockSrv,5);
	SOCKADDR_IN addrClient;
	int len=sizeof(SOCKADDR);

	char rbuf[SOCKET_MAXBUFFER_SIZE];
	int bufferSize = SOCKET_MAXBUFFER_SIZE; 
	memset(rbuf,0,bufferSize);
	printfMemFree(pool);
	while(true){		
		SOCKET _socket=accept(sockSrv,(SOCKADDR*)&addrClient,&len);
		
		
		ParseData_socket((int)_socket);
		
		
		recv(_socket,rbuf,bufferSize,0);
		
		int len;
		ParseData_len(rbuf,&len);
		SocketProtocol* sp=(SocketProtocol*)mempool_malloc(pool,sizeof(SocketProtocol));
		tool_getclientIp(sp->ip,int(_socket),addrClient);
		sp->buffer	=(char*)mempool_malloc(pool,len);
		memcpy(sp->buffer,rbuf,len);
		
		
				
		
		QueueEnter(que,(int)sp);
		

		closesocket(_socket);
	}
}