How to immediately receive incoming packets in a UDP server under ThreadX?

I'm developing a UDP server that runs under ThreadX. It must respond quickly to incoming requests, so my UDP server thread calls TCPIP_UDP_SignalHandlerRegister to allow it to immediately receive notification when a UDP packet arrives in the UDP server socket. But I'm confused about how to set up lower layers to support this. What else do I have to do to ensure the UDP server app will be notified immediately when a rx packet arrives?
 
The TCP/IP Stack Libraries Help manual (Manager Module section) says this:
 

In an RTOS environment it is preferred to have the stack manager run in its own thread. This thread will be blocked waiting for network interface events and when such an event occurs it will wake up and process the data. This is a more efficient way of using the CPU resources.

 
I assume this means TCPIP_STACK_Task should be called in a dedicated task as shown in the freertos UDP Server example:

void _TCPIP_STACK_Task(  void *pvParameters  )
{
    while(1)
    {
        TCPIP_STACK_Task(sysObj.tcpip);
        vTaskDelay(1 / portTICK_PERIOD_MS);
    }
}

But in this example TCPIP_STACK_Task is not blocked waiting for network interface events, it just seems to be called periodically.
 
How should I do this, and what else must I do to implement event-driven UDP receives?

Are you saying I should do something like this?

handlerfunc()
{
    TCPIP_STACK_Task(sysObj.tcpip);
}
 
 
 
AppInit()
{
    TCPIP_STACK_HandlerRegister(handlerfunc);
}

 
(EDIT) Or perhaps something like this?

handlerfunc()
{
    PutSemaphore();
}
 
HighPriorityThread()
{
    while (1) {
        GetSemaphore();
        TCPIP_STACK_Task(sysObj.tcpip);
    }
}
 
AppInit()
{
    TCPIP_STACK_HandlerRegister(handlerfunc);
}

rainad
2nd approach I was thinking of, with the high priority thread calling the TCPIP stack task.

 
I assume I must also do this for DRV_MIIM_Tasks and possibly other xxx_Tasks functions. Is that correct?
 
If my assumption is correct then I will have to create a dedicated thread and semaphore for each of these functions. Is there some other way to implement event-driven UDP that doesn't use so much memory and resources?