I've made a post already about thread pools, but as it involved resource manager, and there were some inconsistencies 
about C++ usage, I decided to make a new one.

I am developing a controller that is based in a pool of threads, that keep listening to Qnet (thus messages from 
different parts of my system) and then taking actions accordingly. 
Again, this is not a resource manager, it creates the dispatch and channel through name_attach().

The lifecycle of a single thread works as expected (context_alloc -> block_fun -> handler_fun -> block_fun -> ...), but 
even with the thread_pool being set and initialised as below, new threads are not being created as it should (having a 
number of threads in blocked state between lo water and hi water).

int Comm::InitComm()
{
    //  Set up the the server path and attach to channel
    name_attach_t *name_att;
    if((name_att = name_attach(NULL, CmsData::Instance()->cms_self_.hostname.c_str(), NAME_FLAG_ATTACH_GLOBAL)) == NULL)

    {
        //  Throw error
        return -1;
    }
    g_comm_chid = name_att->chid;

    //  Set up the thread parameters for the threads that will populate the pool
    pthread_attr_t t_attr;
    pthread_attr_init (&t_attr);

    //  Set up the thread pool parameters
    thread_pool_attr_t tp_attr;
    thread_pool_t    *tpp;
    memset(&tp_attr, 0, sizeof (tp_attr));
    tp_attr.handle = name_att->dpp;
    tp_attr.block_func = WaitForMessage;
    tp_attr.unblock_func = UnblockFunc;
    tp_attr.context_alloc = ContextAlloc;
    tp_attr.handler_func = ParseMessage;
    tp_attr.context_free = ContextFree;
    tp_attr.lo_water = 3;
    tp_attr.hi_water = 6;
    tp_attr.increment = 2;
    tp_attr.maximum = 10;
    tp_attr.attr = &t_attr;

    //  Create a thread pool that returns
    tpp = thread_pool_create (&tp_attr, 0);
    if (tpp == NULL)
    {
        //  Could not create thread pool
        name_detach(name_att, 0);
        return -1;
    }

    if (thread_pool_start(tpp) == -1)
    {
        //  Could not start thread pool
        name_detach(name_att, 0);
        return -1;
    }

    //  If it gets here, thread pool is up and running
    return 1;
}

THREAD_POOL_PARAM_T * Comm::ContextAlloc(THREAD_POOL_HANDLE_T *handle)
{
    resmgr_context_t *ctp = resmgr_context_alloc(handle);
    CommServerStruct *comm_server = new CommServerStruct;
    SETIOV(ctp->iov, comm_server, sizeof(*comm_server));
    return ctp;
}

//  Function to block waiting for a message from client
THREAD_POOL_PARAM_T * Comm::WaitForMessage(THREAD_POOL_PARAM_T *ctp)
{
    //  Cast pointer
    CommServerStruct *comm_server = (CommServerStruct *)ctp->iov->iov_base;
    //  Blocks waiting for message
    comm_server->comm_rcvid = MsgReceive(g_comm_chid, comm_server->msg, 8, NULL);
    //ctp->rcvid = MsgReceive(g_comm_chid, comm_server.msg, 8, NULL);
    char rmsg[8];
    //  Reply to sender to unblock it immediately
    MsgReply(comm_server->comm_rcvid, EOK, rmsg, 8);

    SETIOV(ctp->iov, comm_server, sizeof(*comm_server));
    return ctp;
}

//  Message parsing function when unblocks with received message
int Comm::ParseMessage(THREAD_POOL_PARAM_T *ctp)
{
    //  Cast pointer
    CommServerStruct *comm_server = (CommServerStruct *)ctp->iov->iov_base;
	//	If the message is coming from the UI
	if (comm_server->msg[0] == SCREEN)
	{
...
...
}


Is anyone working with thread pools outside the context of a resource manager?
Can anyone give me some directions on why the threads are not being created and destroyed as expected?