Added basic server functionality from ex 2 lesson 11
This commit is contained in:
elvis
240
lib/threadpool/threadpool.c
Normal file
240
lib/threadpool/threadpool.c
Normal file
@ -0,0 +1,240 @@
|
||||
/**
|
||||
* @file threadpool.c
|
||||
* @brief File di implementazione dell'interfaccia Threadpool
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include <util.h>
|
||||
#include <threadpool.h>
|
||||
|
||||
/**
|
||||
* @function void *threadpool_thread(void *threadpool)
|
||||
* @brief funzione eseguita dal thread worker che appartiene al pool
|
||||
*/
|
||||
static void *workerpool_thread(void *threadpool) {
|
||||
threadpool_t *pool = (threadpool_t *)threadpool; // cast
|
||||
taskfun_t task; // generic task
|
||||
pthread_t self = pthread_self();
|
||||
int myid = -1;
|
||||
|
||||
// non efficiente, si puo' fare meglio.....
|
||||
do {
|
||||
for (int i=0;i<pool->numthreads;++i)
|
||||
if (pthread_equal(pool->threads[i], self)) {
|
||||
myid = i;
|
||||
break;
|
||||
}
|
||||
} while (myid < 0);
|
||||
|
||||
LOCK_RETURN(&(pool->lock), NULL);
|
||||
for (;;) {
|
||||
|
||||
// in attesa di un messaggio, controllo spurious wakeups.
|
||||
while((pool->count == 0) && (!pool->exiting)) {
|
||||
pthread_cond_wait(&(pool->cond), &(pool->lock));
|
||||
}
|
||||
|
||||
if (pool->exiting > 1) break; // exit forzato, esco immediatamente
|
||||
// devo uscire ma ci sono messaggi pendenti
|
||||
if (pool->exiting == 1 && !pool->count) break;
|
||||
|
||||
// nuovo task
|
||||
task.fun = pool->pending_queue[pool->head].fun;
|
||||
task.arg = pool->pending_queue[pool->head].arg;
|
||||
|
||||
pool->head++; pool->count--;
|
||||
pool->head = (pool->head == abs(pool->queue_size)) ? 0 : pool->head;
|
||||
|
||||
pool->taskonthefly++;
|
||||
UNLOCK_RETURN(&(pool->lock), NULL);
|
||||
|
||||
// eseguo la funzione
|
||||
(*(task.fun))(task.arg);
|
||||
|
||||
LOCK_RETURN(&(pool->lock), NULL);
|
||||
pool->taskonthefly--;
|
||||
}
|
||||
UNLOCK_RETURN(&(pool->lock), NULL);
|
||||
|
||||
fprintf(stderr, "thread %d exiting\n", myid);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
static int freePoolResources(threadpool_t *pool) {
|
||||
if(pool->threads) {
|
||||
free(pool->threads);
|
||||
free(pool->pending_queue);
|
||||
|
||||
pthread_mutex_destroy(&(pool->lock));
|
||||
pthread_cond_destroy(&(pool->cond));
|
||||
}
|
||||
free(pool);
|
||||
return 0;
|
||||
}
|
||||
|
||||
threadpool_t *createThreadPool(int numthreads, int pending_size) {
|
||||
if(numthreads <= 0 || pending_size < 0) {
|
||||
errno = EINVAL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
threadpool_t *pool = (threadpool_t *)malloc(sizeof(threadpool_t));
|
||||
if (pool == NULL) return NULL;
|
||||
|
||||
// condizioni iniziali
|
||||
pool->numthreads = 0;
|
||||
pool->taskonthefly = 0;
|
||||
pool->queue_size = (pending_size == 0 ? -1 : pending_size);
|
||||
pool->head = pool->tail = pool->count = 0;
|
||||
pool->exiting = 0;
|
||||
|
||||
/* Allocate thread and task queue */
|
||||
pool->threads = (pthread_t *)malloc(sizeof(pthread_t) * numthreads);
|
||||
if (pool->threads == NULL) {
|
||||
free(pool);
|
||||
return NULL;
|
||||
}
|
||||
pool->pending_queue = (taskfun_t *)malloc(sizeof(taskfun_t) * abs(pool->queue_size));
|
||||
if (pool->pending_queue == NULL) {
|
||||
free(pool->threads);
|
||||
free(pool);
|
||||
return NULL;
|
||||
}
|
||||
if ((pthread_mutex_init(&(pool->lock), NULL) != 0) ||
|
||||
(pthread_cond_init(&(pool->cond), NULL) != 0)) {
|
||||
free(pool->threads);
|
||||
free(pool->pending_queue);
|
||||
free(pool);
|
||||
return NULL;
|
||||
}
|
||||
for(int i = 0; i < numthreads; i++) {
|
||||
if(pthread_create(&(pool->threads[i]), NULL,
|
||||
workerpool_thread, (void*)pool) != 0) {
|
||||
/* errore fatale, libero tutto forzando l'uscita dei threads */
|
||||
destroyThreadPool(pool, 1);
|
||||
errno = EFAULT;
|
||||
return NULL;
|
||||
}
|
||||
pool->numthreads++;
|
||||
}
|
||||
return pool;
|
||||
}
|
||||
|
||||
|
||||
int destroyThreadPool(threadpool_t *pool, int force) {
|
||||
if(pool == NULL || force < 0) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
LOCK_RETURN(&(pool->lock), -1);
|
||||
|
||||
pool->exiting = 1 + force;
|
||||
|
||||
if (pthread_cond_broadcast(&(pool->cond)) != 0) {
|
||||
UNLOCK_RETURN(&(pool->lock),-1);
|
||||
errno = EFAULT;
|
||||
return -1;
|
||||
}
|
||||
UNLOCK_RETURN(&(pool->lock), -1);
|
||||
|
||||
for(int i = 0; i < pool->numthreads; i++) {
|
||||
if (pthread_join(pool->threads[i], NULL) != 0) {
|
||||
errno = EFAULT;
|
||||
UNLOCK_RETURN(&(pool->lock),-1);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
freePoolResources(pool);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int addToThreadPool(threadpool_t *pool, void (*f)(void *), void *arg) {
|
||||
if(pool == NULL || f == NULL) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
LOCK_RETURN(&(pool->lock), -1);
|
||||
int queue_size = abs(pool->queue_size);
|
||||
int nopending = (pool->queue_size == -1); // non dobbiamo gestire messaggi pendenti
|
||||
|
||||
// coda piena o in fase di uscita
|
||||
if (pool->count >= queue_size || pool->exiting) {
|
||||
UNLOCK_RETURN(&(pool->lock),-1);
|
||||
return 1; // esco con valore "coda piena"
|
||||
}
|
||||
|
||||
if (pool->taskonthefly >= pool->numthreads) {
|
||||
if (nopending) {
|
||||
// tutti i thread sono occupati e non si gestiscono task pendenti
|
||||
assert(pool->count == 0);
|
||||
|
||||
UNLOCK_RETURN(&(pool->lock),-1);
|
||||
return 1; // esco con valore "coda piena"
|
||||
}
|
||||
}
|
||||
|
||||
pool->pending_queue[pool->tail].fun = f;
|
||||
pool->pending_queue[pool->tail].arg = arg;
|
||||
pool->count++;
|
||||
pool->tail++;
|
||||
if (pool->tail >= queue_size) pool->tail = 0;
|
||||
|
||||
int r;
|
||||
if((r=pthread_cond_signal(&(pool->cond))) != 0) {
|
||||
UNLOCK_RETURN(&(pool->lock),-1);
|
||||
errno = r;
|
||||
return -1;
|
||||
}
|
||||
|
||||
UNLOCK_RETURN(&(pool->lock),-1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @function void *thread_proxy(void *argl)
|
||||
* @brief funzione eseguita dal thread worker che non appartiene al pool
|
||||
*/
|
||||
static void *proxy_thread(void *arg) {
|
||||
taskfun_t *task = (taskfun_t*)arg;
|
||||
// eseguo la funzione
|
||||
(*(task->fun))(task->arg);
|
||||
|
||||
free(task);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// fa lo spawn di un thread in modalità detached
|
||||
int spawnThread(void (*f)(void*), void* arg) {
|
||||
if (f == NULL) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
taskfun_t *task = malloc(sizeof(taskfun_t)); // la memoria verra' liberata dal proxy
|
||||
if (!task) return -1;
|
||||
task->fun = f;
|
||||
task->arg = arg;
|
||||
|
||||
pthread_t thread;
|
||||
pthread_attr_t attr;
|
||||
if (pthread_attr_init(&attr) != 0) return -1;
|
||||
if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0) return -1;
|
||||
if (pthread_create(&thread, &attr,
|
||||
proxy_thread, (void*)task) != 0) {
|
||||
free(task);
|
||||
errno = EFAULT;
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
81
lib/threadpool/threadpool.h
Normal file
81
lib/threadpool/threadpool.h
Normal file
@ -0,0 +1,81 @@
|
||||
#ifndef THREADPOOL_H_
|
||||
#define THREADPOOL_H_
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
/**
|
||||
* @file threadpool.h
|
||||
* @brief Interfaccia per il ThreadPool
|
||||
*/
|
||||
|
||||
/**
|
||||
* @struct threafun_t
|
||||
* @brief generico task che un thread del threadpool deve eseguire
|
||||
*
|
||||
* @var fun Puntatore alla funzione da eseguire
|
||||
* @var arg Argomento della funzione
|
||||
*/
|
||||
typedef struct taskfun_t {
|
||||
void (*fun)(void *);
|
||||
void *arg;
|
||||
} taskfun_t;
|
||||
|
||||
/**
|
||||
* @struct threadpool
|
||||
* @brief Rappresentazione dell'oggetto threadpool
|
||||
*/
|
||||
typedef struct threadpool_t {
|
||||
pthread_mutex_t lock; // mutua esclusione nell'accesso all'oggetto
|
||||
pthread_cond_t cond; // usata per notificare un worker thread
|
||||
pthread_t * threads; // array di worker id
|
||||
int numthreads; // numero di thread (size dell'array threads)
|
||||
taskfun_t *pending_queue; // coda interna per task pendenti
|
||||
int queue_size; // massima size della coda, puo' essere anche -1 ad indicare che non si vogliono gestire task pendenti
|
||||
int taskonthefly; // numero di task attualmente in esecuzione
|
||||
int head, tail; // riferimenti della coda
|
||||
int count; // numero di task nella coda dei task pendenti
|
||||
int exiting; // se > 0 e' iniziato il protocollo di uscita, se 1 il thread aspetta che non ci siano piu' lavori in coda
|
||||
} threadpool_t;
|
||||
|
||||
/**
|
||||
* @function createThreadPool
|
||||
* @brief Crea un oggetto thread pool.
|
||||
* @param numthreads è il numero di thread del pool
|
||||
* @param pending_size è la size delle richieste che possono essere pendenti. Questo parametro è 0 se si vuole utilizzare un modello per il pool con 1 thread 1 richiesta, cioe' non ci sono richieste pendenti.
|
||||
*
|
||||
* @return un nuovo thread pool oppure NULL ed errno settato opportunamente
|
||||
*/
|
||||
threadpool_t *createThreadPool(int numthreads, int pending_size);
|
||||
|
||||
/**
|
||||
* @function destroyThreadPool
|
||||
* @brief stoppa tutti i thread e distrugge l'oggetto pool
|
||||
* @param pool oggetto da liberare
|
||||
* @param force se 1 forza l'uscita immediatamente di tutti i thread e libera subito le risorse, se 0 aspetta che i thread finiscano tutti e soli i lavori pendenti (non accetta altri lavori).
|
||||
*
|
||||
* @return 0 in caso di successo <0 in caso di fallimento ed errno viene settato opportunamente
|
||||
*/
|
||||
int destroyThreadPool(threadpool_t *pool, int force);
|
||||
|
||||
/**
|
||||
* @function addTaskToThreadPool
|
||||
* @brief aggiunge un task al pool, se ci sono thread liberi il task viene assegnato ad uno di questi, se non ci sono thread liberi e pending_size > 0 allora si cerca di inserire il task come task pendente. Se non c'e' posto nella coda interna allora la chiamata fallisce.
|
||||
* @param pool oggetto thread pool
|
||||
* @param fun funzione da eseguire per eseguire il task
|
||||
* @param arg argomento della funzione
|
||||
* @return 0 se successo, 1 se non ci sono thread disponibili e/o la coda è piena, -1 in caso di fallimento, errno viene settato opportunamente.
|
||||
*/
|
||||
int addToThreadPool(threadpool_t *pool, void (*fun)(void *),void *arg);
|
||||
|
||||
|
||||
/**
|
||||
* @function spawnThread
|
||||
* @brief lancia un thread che esegue la funzione fun passata come parametro, il thread viene lanciato in modalità detached e non fa parte del pool.
|
||||
* @param fun funzione da eseguire per eseguire il task
|
||||
* @param arg argomento della funzione
|
||||
* @return 0 se successo, -1 in caso di fallimento, errno viene settato opportunamente.
|
||||
*/
|
||||
int spawnThread(void (*f)(void*), void* arg);
|
||||
|
||||
#endif /* THREADPOOL_H_ */
|
||||
|
||||
68
lib/utils/conn.h
Normal file
68
lib/utils/conn.h
Normal file
@ -0,0 +1,68 @@
|
||||
#ifndef CONN_H
|
||||
#define CONN_H
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/uio.h>
|
||||
#include <sys/un.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#if !defined(BUFSIZE)
|
||||
#define BUFSIZE 256
|
||||
#endif
|
||||
#if !defined(SOCKNAME)
|
||||
#define SOCKNAME "./cs_sock"
|
||||
#endif
|
||||
#if !defined(MAXBACKLOG)
|
||||
#define MAXBACKLOG 32
|
||||
#endif
|
||||
|
||||
/** Evita letture parziali
|
||||
*
|
||||
* \retval -1 errore (errno settato)
|
||||
* \retval 0 se durante la lettura da fd leggo EOF
|
||||
* \retval size se termina con successo
|
||||
*/
|
||||
static inline int readn(long fd, void *buf, size_t size) {
|
||||
size_t left = size;
|
||||
int r;
|
||||
char *bufptr = (char*)buf;
|
||||
while(left>0) {
|
||||
if ((r=read((int)fd ,bufptr,left)) == -1) {
|
||||
if (errno == EINTR) continue;
|
||||
return -1;
|
||||
}
|
||||
if (r == 0) return 0; // EOF
|
||||
left -= r;
|
||||
bufptr += r;
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
/** Evita scritture parziali
|
||||
*
|
||||
* \retval -1 errore (errno settato)
|
||||
* \retval 0 se durante la scrittura la write ritorna 0
|
||||
* \retval 1 se la scrittura termina con successo
|
||||
*/
|
||||
static inline int writen(long fd, void *buf, size_t size) {
|
||||
size_t left = size;
|
||||
int r;
|
||||
char *bufptr = (char*)buf;
|
||||
while(left>0) {
|
||||
if ((r=write((int)fd ,bufptr,left)) == -1) {
|
||||
if (errno == EINTR) continue;
|
||||
return -1;
|
||||
}
|
||||
if (r == 0) return 0;
|
||||
left -= r;
|
||||
bufptr += r;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
#endif /* CONN_H */
|
||||
12
lib/utils/message.h
Normal file
12
lib/utils/message.h
Normal file
@ -0,0 +1,12 @@
|
||||
#ifndef _MESSAGE_H
|
||||
#define _MESSAGE_H
|
||||
|
||||
/**
|
||||
* tipo del messaggio
|
||||
*/
|
||||
typedef struct msg {
|
||||
int len;
|
||||
char *str;
|
||||
} msg_t;
|
||||
|
||||
#endif
|
||||
151
lib/utils/util.h
Normal file
151
lib/utils/util.h
Normal file
@ -0,0 +1,151 @@
|
||||
#ifndef _UTIL_H
|
||||
#define _UTIL_H
|
||||
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <pthread.h>
|
||||
#include <errno.h>
|
||||
|
||||
#if !defined(BUFSIZE)
|
||||
#define BUFSIZE 256
|
||||
#endif
|
||||
|
||||
#if !defined(EXTRA_LEN_PRINT_ERROR)
|
||||
#define EXTRA_LEN_PRINT_ERROR 512
|
||||
#endif
|
||||
|
||||
#define SYSCALL_EXIT(name, r, sc, str, ...) \
|
||||
if ((r=sc) == -1) { \
|
||||
perror(#name); \
|
||||
int errno_copy = errno; \
|
||||
print_error(str, __VA_ARGS__); \
|
||||
exit(errno_copy); \
|
||||
}
|
||||
|
||||
#define SYSCALL_PRINT(name, r, sc, str, ...) \
|
||||
if ((r=sc) == -1) { \
|
||||
perror(#name); \
|
||||
int errno_copy = errno; \
|
||||
print_error(str, __VA_ARGS__); \
|
||||
errno = errno_copy; \
|
||||
}
|
||||
|
||||
#define SYSCALL_RETURN(name, r, sc, str, ...) \
|
||||
if ((r=sc) == -1) { \
|
||||
perror(#name); \
|
||||
int errno_copy = errno; \
|
||||
print_error(str, __VA_ARGS__); \
|
||||
errno = errno_copy; \
|
||||
return r; \
|
||||
}
|
||||
|
||||
#define CHECK_EQ_EXIT(name, X, val, str, ...) \
|
||||
if ((X)==val) { \
|
||||
perror(#name); \
|
||||
int errno_copy = errno; \
|
||||
print_error(str, __VA_ARGS__); \
|
||||
exit(errno_copy); \
|
||||
}
|
||||
|
||||
#define CHECK_NEQ_EXIT(name, X, val, str, ...) \
|
||||
if ((X)!=val) { \
|
||||
perror(#name); \
|
||||
int errno_copy = errno; \
|
||||
print_error(str, __VA_ARGS__); \
|
||||
exit(errno_copy); \
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Procedura di utilita' per la stampa degli errori
|
||||
*
|
||||
*/
|
||||
static inline void print_error(const char * str, ...) {
|
||||
const char err[]="ERROR: ";
|
||||
va_list argp;
|
||||
char * p=(char *)malloc(strlen(str)+strlen(err)+EXTRA_LEN_PRINT_ERROR);
|
||||
if (!p) {
|
||||
perror("malloc");
|
||||
fprintf(stderr,"FATAL ERROR nella funzione 'print_error'\n");
|
||||
return;
|
||||
}
|
||||
strcpy(p,err);
|
||||
strcpy(p+strlen(err), str);
|
||||
va_start(argp, str);
|
||||
vfprintf(stderr, p, argp);
|
||||
va_end(argp);
|
||||
free(p);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief Controlla se la stringa passata come primo argomento e' un numero.
|
||||
* \return 0 ok 1 non e' un numbero 2 overflow/underflow
|
||||
*/
|
||||
static inline int isNumber(const char* s, long* n) {
|
||||
if (s==NULL) return 1;
|
||||
if (strlen(s)==0) return 1;
|
||||
char* e = NULL;
|
||||
errno=0;
|
||||
long val = strtol(s, &e, 10);
|
||||
if (errno == ERANGE) return 2; // overflow/underflow
|
||||
if (e != NULL && *e == (char)0) {
|
||||
*n = val;
|
||||
return 0; // successo
|
||||
}
|
||||
return 1; // non e' un numero
|
||||
}
|
||||
|
||||
#define LOCK(l) if (pthread_mutex_lock(l)!=0) { \
|
||||
fprintf(stderr, "ERRORE FATALE lock\n"); \
|
||||
pthread_exit((void*)EXIT_FAILURE); \
|
||||
}
|
||||
#define LOCK_RETURN(l, r) if (pthread_mutex_lock(l)!=0) { \
|
||||
fprintf(stderr, "ERRORE FATALE lock\n"); \
|
||||
return r; \
|
||||
}
|
||||
|
||||
#define UNLOCK(l) if (pthread_mutex_unlock(l)!=0) { \
|
||||
fprintf(stderr, "ERRORE FATALE unlock\n"); \
|
||||
pthread_exit((void*)EXIT_FAILURE); \
|
||||
}
|
||||
#define UNLOCK_RETURN(l,r) if (pthread_mutex_unlock(l)!=0) { \
|
||||
fprintf(stderr, "ERRORE FATALE unlock\n"); \
|
||||
return r; \
|
||||
}
|
||||
#define WAIT(c,l) if (pthread_cond_wait(c,l)!=0) { \
|
||||
fprintf(stderr, "ERRORE FATALE wait\n"); \
|
||||
pthread_exit((void*)EXIT_FAILURE); \
|
||||
}
|
||||
/* ATTENZIONE: t e' un tempo assoluto! */
|
||||
#define TWAIT(c,l,t) { \
|
||||
int r=0; \
|
||||
if ((r=pthread_cond_timedwait(c,l,t))!=0 && r!=ETIMEDOUT) { \
|
||||
fprintf(stderr, "ERRORE FATALE timed wait\n"); \
|
||||
pthread_exit((void*)EXIT_FAILURE); \
|
||||
} \
|
||||
}
|
||||
#define SIGNAL(c) if (pthread_cond_signal(c)!=0) { \
|
||||
fprintf(stderr, "ERRORE FATALE signal\n"); \
|
||||
pthread_exit((void*)EXIT_FAILURE); \
|
||||
}
|
||||
#define BCAST(c) if (pthread_cond_broadcast(c)!=0) { \
|
||||
fprintf(stderr, "ERRORE FATALE broadcast\n"); \
|
||||
pthread_exit((void*)EXIT_FAILURE); \
|
||||
}
|
||||
static inline int TRYLOCK(pthread_mutex_t* l) {
|
||||
int r=0;
|
||||
if ((r=pthread_mutex_trylock(l))!=0 && r!=EBUSY) {
|
||||
fprintf(stderr, "ERRORE FATALE unlock\n");
|
||||
pthread_exit((void*)EXIT_FAILURE);
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
#endif /* _UTIL_H */
|
||||
Reference in New Issue
Block a user