cwrapper.h

Go to the documentation of this file.

/*******************************************************************************
 *     Copyright © 2015, 2016 Saman Barghi
 *
 *     This program is free software: you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation, either version 3 of the License, or
 *     (at your option) any later version.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *******************************************************************************/

#ifndef UTHREADS_CWRAPPER_H_
#define UTHREADS_CWRAPPER_H_

#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <inttypes.h>

#ifdef __cplusplus
extern "C"{
#endif
#include <stdbool.h>

/**************Cluster*************/
struct      WCluster;
typedef     struct WCluster WCluster;
WCluster*   cluster_create();
void        cluster_destroy(WCluster* cluster);
WCluster*   cluster_get_default();//return default Cluster
WCluster*   cluster_get_current();
uint64_t    cluster_get_id(WCluster* cluster);
size_t      cluster_get_number_of_kThreads(WCluster* cluster);
/**********************************/

/*************kThread**************/
struct      WkThread;
typedef     struct WkThread WkThread;
WkThread*   kThread_create(WCluster* cluster);
void        kThread_destroy(WkThread* kt);
uint64_t    kThread_get_total_number_of_kThreads();
WkThread*   kThread_get_current();
//if linux
pthread_t   kThread_get_current_pthread_id(); //return pthread_t for current running thread
pthread_t   kThread_get_pthread_id(WkThread* kt); //return pthread_t for the provided kThread
//endif linux
/**********************************/

/*************uThread**************/
struct      WuThread;
typedef     struct WuThread WuThread;
WuThread*   uThread_create(bool joinable);
void        uThread_start(WuThread* ut, WCluster* cluster, void *func, void *arg1 , void* arg2, void* arg3);
void        uThread_migrate(WCluster* cluster);
void        uThread_terminate(WuThread* ut);
void        uThread_yield();
bool        uThread_join(WuThread* ut);
void        uThread_detach(WuThread* ut);
uint64_t    uThread_get_id(WuThread* ut);
WuThread*   uThread_get_current();
uint64_t uThread_get_total_number_of_uThreads();
/**********************************/

/*************Connection************/
struct       WConnection;
typedef      struct WConnection WConnection;
WConnection* connection_create();
WConnection* connection_create_with_fd(int fd);
WConnection* connection_create_socket(int domain, int type, int protocol);
void         connection_destroy(WConnection* c);


int          connection_accept(WConnection* acceptor, WConnection *conn, struct sockaddr *addr, socklen_t *addrlen);
WConnection* connection_accept_connenction(WConnection* acceptor, struct sockaddr *addr, socklen_t *addrlen);


int          connection_socket(WConnection* conn, int domain, int type, int protocol);

int          connection_listen(WConnection* conn, int backlog);
int          connection_bind(WConnection* conn, const struct sockaddr *addr,socklen_t addrlen);
int          connection_connect(WConnection* conn, const struct sockaddr *addr,socklen_t addrlen);
int          connection_close(WConnection* conn);

ssize_t     connection_recv(WConnection* conn, void *buf, size_t len, int flags);
ssize_t     connection_recvfrom(WConnection* conn, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
ssize_t     connection_recvmsg(WConnection* conn, int sockfd, struct msghdr *msg, int flags);
int         connection_recvmmsg(WConnection* conn, int sockfd, struct mmsghdr *msgvec, unsigned int vlen, unsigned int flags, struct timespec *timeout);

ssize_t     connection_send(WConnection* conn, const void *buf, size_t len, int flags);
ssize_t     connection_sendto(WConnection* conn, int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
ssize_t     connection_sendmsg(WConnection* conn, const struct msghdr *msg, int flags);
int         connection_sendmmsg(WConnection* conn, int sockfd, struct mmsghdr *msgvec, unsigned int vlen, unsigned int flags);

ssize_t     connection_read(WConnection* conn, void *buf, size_t count);
ssize_t     connection_write(WConnection* conn, const void *buf, size_t count);


void        connection_block_on_read(WConnection* conn);

void        connection_block_on_write(WConnection* conn);

int         connection_get_fd(WConnection* conn);
/**********************************/


/******************** Mutex *********************/
struct      WMutex;
typedef     struct WMutex WMutex;
WMutex*     mutex_create();
void        mutex_destroy(WMutex* mutex);
bool        mutex_acquire(WMutex* mutex);
void        mutex_release(WMutex* mutex);
/**********************************/

/******************** OwnlerLock ****************/
struct      WOwnerLock;
typedef     struct WOwnerLock WOwnerLock;
WOwnerLock* ownerlock_create();
void        ownerlock_destroy(WOwnerLock* olock);
uint64_t        ownerlock_acquire(WOwnerLock* olock);
void        ownerlock_release(WOwnerLock* olock);
/**********************************/

/******************** ConditionVariable *********/
struct      WConditionVariable;
typedef     struct WConditionVariable WConditionVariable;
WConditionVariable* condition_variable_create();
void                condition_variable_destroy(WConditionVariable* cv);
void                condition_variable_wait(WConditionVariable* cv, WMutex* mutex);
void                condition_variable_signal(WConditionVariable* cv, WMutex* mutex);
void                condition_variable_signall_all(WConditionVariable* cv, WMutex* mutex);
bool                condition_variable_empty(WConditionVariable* cv);
/**********************************/

/******************** Semaphore ****************/
struct      WSemaphore;
typedef     struct WSemaphore WSemaphore;
WSemaphore* semaphore_create();
void        semaphore_destroy(WSemaphore* sem);
bool        semaphore_p(WSemaphore* sem);
void        semaphore_v(WSemaphore* sem);
/**********************************/

/******************** uThreadPool **************/
struct WuThreadPool;
typedef struct WuThreadPool WuThreadPool;
WuThreadPool* uthreadpool_create();
void uthreadpool_destory(WuThreadPool* utp);
void uthreadpool_execute(WuThreadPool* utp, WCluster* cluster, void *(*start_routine) (void *), void *arg);
/**********************************/
#ifdef __cplusplus
}
#endif

#endif /* UTHREADS_CWRAPPER_H_ */