thread.h

Go to the documentation of this file.

#ifndef _CP_THREAD_H
#define _CP_THREAD_H

#include "common.h"

__BEGIN_DECLS

#include "config.h"
/* synchronization api abstraction (a bunch of pthread-like macros basically)
 * is in collection.h
 */
#include "collection.h"
#include "linked_list.h"
#include "hashlist.h"
#include "vector.h"

typedef void *(*cp_thread_action) (void *);


typedef int (*cp_thread_stop_fn)(void *);

typedef CPROPS_DLL struct _cp_pooled_thread
{
    long id;                        
    struct _cp_thread_pool *owner;  
    cp_thread *worker;              
    cp_thread_action action;        
    void *action_prm;               
    cp_thread_stop_fn stop_fn;      
    void *stop_prm;                 

    cp_mutex *suspend_lock;         
    cp_cond *suspend_cond;          

    int done;                       
    int wait;                       
} cp_pooled_thread;

CPROPS_DLL
long cp_pooled_thread_get_id(cp_pooled_thread *thread);

CPROPS_DLL
cp_pooled_thread *cp_pooled_thread_create(struct _cp_thread_pool *owner);

CPROPS_DLL
void cp_pooled_thread_destroy(cp_pooled_thread *t);

CPROPS_DLL
int cp_pooled_thread_stop(cp_pooled_thread *t);

CPROPS_DLL
long cp_pooled_thread_get_id(cp_pooled_thread *t);

CPROPS_DLL
int cp_pooled_thread_run_task(cp_pooled_thread *pt, 
                              cp_thread_action action, 
                              void *prm);

CPROPS_DLL
int cp_pooled_thread_run_stoppable_task(cp_pooled_thread *pt, 
                                        cp_thread_action action,
                                        void *action_prm,
                                        cp_thread_stop_fn stop_fn,
                                        void *stop_prm);

CPROPS_DLL
void *cp_pooled_thread_run(void *prm);
    

typedef CPROPS_DLL struct _cp_thread_pool
{
    int size;               

    int min_size;           
    int max_size;           

    int running;

    cp_mutex *pool_lock;    
    cp_cond *pool_cond;     

    cp_list *free_pool;     
    cp_hashlist *in_use;    
} cp_thread_pool;

CPROPS_DLL
cp_thread_pool *cp_thread_pool_create(int min_size, int max_size);

CPROPS_DLL
void cp_thread_pool_destroy(cp_thread_pool *pool);

CPROPS_DLL
int cp_thread_pool_wait(cp_thread_pool *pool);

CPROPS_DLL
int cp_thread_pool_stop(cp_thread_pool *pool);

CPROPS_DLL 
cp_thread *cp_thread_pool_get(cp_thread_pool *pool, 
                              cp_thread_action action, 
                              void *prm);

CPROPS_DLL 
cp_thread *cp_thread_pool_get_stoppable(cp_thread_pool *pool, 
                                        cp_thread_action action, 
                                        void *action_prm, 
                                        cp_thread_stop_fn stop_fn,
                                        void *stop_prm);

CPROPS_DLL 
cp_thread *cp_thread_pool_get_nb(cp_thread_pool *pool, 
                                 cp_thread_action action, 
                                 void *prm);
CPROPS_DLL 
cp_thread *cp_thread_pool_get_stoppable_nb(cp_thread_pool *pool, 
                                  cp_thread_action action, 
                                  void *action_prm,
                                  cp_thread_stop_fn stop_fn,
                                  void *stop_prm);

CPROPS_DLL 
int cp_thread_pool_count_available(cp_thread_pool *pool);

/* **************************************************************************
 *                                                                          *
 *                      thread management framework                         *
 *                                                                          *
 ************************************************************************** */


typedef CPROPS_DLL struct cp_pooled_thread_scheduler
{
    cp_thread_pool *pool; 
    cp_vector *client_list; 
    int bypass; 
} cp_pooled_thread_scheduler;

CPROPS_DLL struct _cp_pooled_thread_client_interface;

typedef int (*cp_pooled_thread_report_load) //~~ change prm to void *client
    (struct _cp_pooled_thread_client_interface *s);
typedef void (*cp_pooled_thread_shrink) //~~ change prm to void *client
    (struct _cp_pooled_thread_client_interface *);

typedef CPROPS_DLL struct _cp_pooled_thread_client_interface
{
    int max;    
    int min;    

    int count;  

    void *client;   
    cp_pooled_thread_scheduler *owner;  
    cp_pooled_thread_report_load report_load; 
    cp_pooled_thread_shrink shrink; 
    cp_thread_action action; 
    void *action_prm; 
    cp_thread_stop_fn stop_fn; 
    void *stop_prm; 
} cp_pooled_thread_client_interface;

CPROPS_DLL
cp_pooled_thread_client_interface *
    cp_pooled_thread_client_interface_create
        (cp_pooled_thread_scheduler *owner, 
         void *client, 
         int min_threads, 
         int max_threads,
         cp_pooled_thread_report_load report_load,
         cp_pooled_thread_shrink shrink,
         cp_thread_action action,
         void *action_prm,
         cp_thread_stop_fn stop_fn,
         void *stop_prm);

CPROPS_DLL
void cp_pooled_thread_client_interface_destroy
    (cp_pooled_thread_client_interface *client);

CPROPS_DLL
void cp_pooled_thread_client_negociate(cp_pooled_thread_client_interface *c);

CPROPS_DLL
cp_pooled_thread_scheduler *cp_pooled_thread_scheduler_create(cp_thread_pool *pool);

CPROPS_DLL
void cp_pooled_thread_scheduler_destroy(cp_pooled_thread_scheduler *scheduler);

CPROPS_DLL
void cp_pooled_thread_scheduler_register_client
        (cp_pooled_thread_scheduler *scheduler, 
         cp_pooled_thread_client_interface *client);

CPROPS_DLL 
void cp_pooled_thread_client_get(cp_pooled_thread_client_interface *c);

CPROPS_DLL 
void cp_pooled_thread_client_get_stoppable(cp_pooled_thread_client_interface *c);

CPROPS_DLL 
void cp_pooled_thread_client_get_nb(cp_pooled_thread_client_interface *c);

CPROPS_DLL 
void cp_pooled_thread_client_get_stoppable_nb(cp_pooled_thread_client_interface *c);

__END_DECLS

#endif /* _CP_THREAD */

---