memory problems when creating/shutting down of socket

vines — Fri, 07 Jun 2013 14:30:30 GMT

Hi,

Here is the scenario:

1. When I try to connect/disconnect the socket on my device a million times by sending notification to the board, everything is working fine.

2. However, for the use case mentioned below I am having a memory problem:

1. Connect to the board

2.Kill the application software by task manager and not sending a close notification to the board.

3. Re-launch the application and try to reconnect

4. The connection is fine and I can communicate perfectly. However I saw the size of my ram to increase with this.

5. When I repeat steps 2-4, it will come to a point that my memory is not enough and my task is giving an out of memory blocks problem. With each passing cycle it adds 9k+ to the memory(which is the memory of socket stack below)

When I call RTCS_create it alloc a memory for the TCPIP:

500	0x10001 TCP Control Block;RTCS/TCP

4392 0x10001 TCP Tx Window;RTCS/TCP

4392 0x10001 TCP Rx Window;RTCS/TCP

148	0x10001 TCP Send Clock;RTCS/TCP

However, isn't the purpose of shutdown(handle,FLAG_CLOSE_TX) to free this memory? Correct me if I am wrong.

Here is a snippet of my code:

func()

{

//some code here

     _RTCS_socket_part_init = 4;
     _RTCS_socket_part_grow = 2;
     _RTCS_socket_part_max = 20;

    gLocalAddr.sin_family = AF_INET;
    gLocalAddr.sin_port = getTCP_port();//TCP_PORT;
    gLocalAddr.sin_addr.s_addr = INADDR_ANY;

    gSock = socket(PF_INET, SOCK_STREAM, 0); // pag TCP, SOCK_STREAM ang gagamitin
    if (gSock == RTCS_SOCKET_ERROR)
        os_task_block();

    error = bind(gSock, &gLocalAddr, sizeof(sockaddr_in));
    if (error != RTCS_OK)
        os_task_block();

    if (listen(gSock, 0) != RTCS_OK)
        os_task_block();
    gPeerLen = sizeof(gPeerAddr);

    while (TRUE)
    {
        activeSock = RTCS_selectall(0);
        if (activeSock == gSock)
        {
            gChildHandle = accept(gSock, &gPeerAddr, &gPeerLen);
            if (gChildHandle != RTCS_SOCKET_ERROR)
            {
                if (error == RTCS_OK)
                {
                    if (gChildHandle != RTCS_SOCKET_ERROR)
                    {
                        os_time_delay(1000);
                        gTcpLinkUp = true;
                        while (gTcpLinkUp)
                        {
                            os_mutexlockwhileloopcheck(&Nic_mutex,5);
                            activeSock = RTCS_selectall(0);
                            if (activeSock != gChildHandle & activeSock != 0) //this will detect if connection request done other than gChildHandle
                                gTcpLinkUp=false;
                            if (ipcfg_get_link_active(BSP_DEFAULT_ENET_DEVICE) == FALSE)
                                gTcpLinkUp = false;

                            os_time_delay(100);
                            os_mutex_unlock(&Nic_mutex);
                        }
                        shutdown(gChildHandle, FLAG_CLOSE_TX);
                    }
                }
                else
                {
                    shutdown(gChildHandle, FLAG_CLOSE_TX);
                }
            }
        }
        os_time_delay(100);
    }

}

As an additional question:

There is an option to reduce the size of the socket stack by calling setsockopt. However I don't think it is working for me. The reason is because whenever the scenario discussed above happen, it recreates the whole memory below.

500      0x10001 TCP Control Block;RTCS/TCP
4392   0x10001 TCP Tx Window;RTCS/TCP
4392   0x10001 TCP Rx Window;RTCS/TCP
148     0x10001 TCP Send Clock;RTCS/TCP

I was expecting 512bytes only for both TCP Rx and Tx.Thus it should be around 1k+ only.

Here is the snippet

#define MAX_MESSAGE 512

opt_value=MAX_MESSAGE;
error = setsockopt(gChildHandle , SOL_TCP, OPT_RBSIZE, &opt_value,2);
error = setsockopt(gChildHandle , SOL_TCP, OPT_TBSIZE, &opt_value,2);

//status of error after this is RTCS_OK

I read somewhere to do it before RTCS_create. However, is it really possible because setsockopt function needs a handle. Before RTCS_Create it is still not created.

Thank You.

Re: memory problems when creating/shutting down of socket

Martin_ — Wed, 12 Jun 2013 14:22:22 GMT

Hi vines,

If you're using shutdown(socket, FLAG_CLOSE_TX) I think it means the TCP connection will be kept for DEFAULT_TIMEWAIT_TIMEOUT until tcp socket moves to CLOSED state. By default this is about 2 minutes (see rtcs.h for this definition) if I remember correctly.

Try to put 2 minutes delay between step 3 and 4.

Re: memory problems when creating/shutting down of socket

Monica — Thu, 20 Jun 2013 23:46:53 GMT

Hello Vines,

Was that workaround helpful? Keep us posted :smileywink:

Best regards,

Monica

Re: memory problems when creating/shutting down of socket

vines — Fri, 21 Jun 2013 05:41:02 GMT

Hi Martin, Monica,

The suggestion was helpful to an extent. I revise the program by passing FLAG_ABORT_CONNECTION on the shhutdown function. I read on the datasheet that it destroys the socket immediately without waiting for existing transmission or reception to finish. Thus am I right to assume that this should free up the memory? However what is happening now is when I try to connect again it does not free the previous one even if I shut it down. Thus it creates 2 stack for the RTCS.

The improvement however is even I try to connect/shutdown couple of times it only caters for another set of stack (so 2 sets only regardless of how many times I connect and shutdown). As compared to previously where in my stack are running out depends on how fast I connect/shutdown the socket (if within 2 minutes).

Any suggestion on how to eliminate the mirror copy of RTCS stack? By the way I am using MQX 3.8. I hope I won't have to upgrade my version if it is not a known issue in 3.8.

Thanks.

MQX Software Solutionsのトピックmemory problems when creating/shutting down of socket

memory problems when creating/shutting down of socket

Re: memory problems when creating/shutting down of socket

Re: memory problems when creating/shutting down of socket

Re: memory problems when creating/shutting down of socket