cthread_api.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2019-2022 Intel Corporation
 */
 
/*
 * Some portions of this software may have been derived from the
 * https://github.com/halayli/lthread which carrys the following license.
 *
 * Copyright (c) 2012, Hasan Alayli <halayli@gmail.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
 
#ifndef _CTHREAD_API_H
#define _CTHREAD_API_H
 
#include <sys/socket.h>
#include <fcntl.h>
#include <netinet/in.h>
 
#include <cne_cycles.h>
#include <cne_log.h>
#include <cne_branch_prediction.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct cthread;
struct cthread_cond;
struct cthread_sema;
struct cthread_mutex;
struct cthread_once;
struct cthread_barrier;
struct cthread_condattr;
struct cthread_sched;
 
struct cthread_semaattr {
    int32_t cnt;
};
 
struct cthread_mutexattr {
    uint32_t flags;
};
 
#define MUTEX_RECURSIVE_ATTR 0x00000001 
typedef void (*cthread_func_t)(void *);
 
/*
 * Define the size of stack for an cthread
 * Then this is the size that will be allocated on cthread creation
 * This is a fixed size and will not grow.
 */
#define CTHREAD_DEFAULT_STACK_SIZE (1024 * 16)
 
#define CTHREAD_MAX_KEYS 256
 
#define CTHREAD_DESTRUCTOR_ITERATIONS 4
 
#define CTHREAD_MAX_THREADS CNE_MAX_THREADS
 
#define CTHREAD_PREALLOC 64
 
CNDP_API int cthread_num_schedulers_set(int num);
 
CNDP_API int cthread_active_schedulers(void);
 
CNDP_API void cthread_scheduler_shutdown(int thread);
 
CNDP_API void cthread_scheduler_shutdown_all(void);
 
CNDP_API void cthread_run(void);
 
CNDP_API void cthread_sched_stack_size_set(size_t stack_size);
 
CNDP_API size_t cthread_sched_stack_size(void);
 
CNDP_API int cthread_sched_create(size_t stack_size);
 
CNDP_API struct cthread *cthread_create(const char *name, cthread_func_t func, void *arg);
 
CNDP_API int cthread_cancel(struct cthread *ct);
 
CNDP_API int cthread_join(struct cthread *ct, void **ptr);
 
CNDP_API void cthread_detach(void);
 
CNDP_API void cthread_exit(void *val);
 
CNDP_API void cthread_sleep(uint64_t nsecs);
 
CNDP_API void cthread_sleep_msec(uint64_t ms);
 
CNDP_API void cthread_sleep_clks(uint64_t clks);
 
CNDP_API void cthread_sleep_nsecs(uint64_t nsecs);
 
CNDP_API int cthread_timer_expired(struct cthread *ct);
 
CNDP_API void cthread_yield(void);
 
CNDP_API int cthread_set_affinity(int thread);
 
CNDP_API struct cthread *cthread_current(void);
 
CNDP_API void cthread_set_name(const char *f);
 
CNDP_API const char *cthread_get_name(struct cthread *ct);
 
CNDP_API void cthread_set_data(void *data);
 
CNDP_API void *cthread_get_data(void);
 
struct cthread_key;
typedef void (*tls_destructor_func)(void *);
 
CNDP_API int cthread_key_create(unsigned int *key, tls_destructor_func destructor);
 
CNDP_API int cthread_key_delete(unsigned int key);
 
CNDP_API void *cthread_getspecific(unsigned int key);
 
CNDP_API int cthread_setspecific(unsigned int key, const void *value);
 
/* start and end of per cthread section */
extern char __start_per_dt;
extern char __stop_per_dt;
 
#define CNE_DEFINE_PER_CTHREAD(type, name) \
    __typeof__(type) __attribute((section("per_dt"))) per_dt_##name
 
#define CNE_DECLARE_PER_CTHREAD(type, name) \
    extern __typeof__(type) __attribute((section("per_dt"))) per_dt_##name
#define CNE_PER_CTHREAD(name)                               \
    ((typeof(per_dt_##name) *)((char *)cthread_get_data() + \
                               ((char *)&per_dt_##name - &__start_per_dt)))
 
CNDP_API int cthread_mutex_init(const char *name, struct cthread_mutex **mutex,
                                const struct cthread_mutexattr *attr);
 
CNDP_API int cthread_mutex_destroy(struct cthread_mutex *mutex);
 
CNDP_API int cthread_mutex_lock(struct cthread_mutex *mutex);
 
CNDP_API int cthread_mutex_trylock(struct cthread_mutex *mutex);
 
CNDP_API int cthread_mutex_unlock(struct cthread_mutex *mutex);
 
CNDP_API int cthread_mutex_state(struct cthread_mutex *m);
 
CNDP_API int cthread_barrier_init(const char *name, struct cthread_barrier **barr, unsigned count);
 
CNDP_API int cthread_barrier_destroy(struct cthread_barrier *b);
 
CNDP_API int cthread_barrier_wait(struct cthread_barrier *b);
 
CNDP_API int cthread_cond_init(const char *name, struct cthread_cond **c,
                               const struct cthread_condattr *attr);
 
CNDP_API int cthread_cond_destroy(struct cthread_cond *cond);
 
CNDP_API int cthread_cond_reset(struct cthread_cond *cond);
 
CNDP_API int cthread_cond_wait(struct cthread_cond *c, struct cthread_mutex *m);
 
CNDP_API int cthread_cond_timedwait(struct cthread_cond *c, struct cthread_mutex *m,
                                    const struct timespec *abstime);
 
CNDP_API int cthread_cond_signal(struct cthread_cond *c);
 
CNDP_API int cthread_cond_broadcast(struct cthread_cond *c);
 
CNDP_API int cthread_cond_broadcast_no_sched(struct cthread_cond *c);
 
CNDP_API int cthread_sema_init(const char *name, struct cthread_sema **s,
                               const struct cthread_semaattr *attr);
 
CNDP_API int cthread_sema_destroy(struct cthread_sema *sema);
 
CNDP_API int cthread_sema_reset(struct cthread_sema *sema);
 
CNDP_API int cthread_sema_wait(struct cthread_sema *s, struct cthread_mutex *m);
 
CNDP_API int cthread_sema_timedwait(struct cthread_sema *s, struct cthread_mutex *m,
                                    const struct timespec *abstime);
 
CNDP_API int cthread_sema_signal(struct cthread_sema *s);
 
CNDP_API int cthread_sema_flush(struct cthread_sema *s);
 
CNDP_API int cthread_sema_flush_no_sched(struct cthread_sema *s);
 
CNDP_API int is_cthread_running(void);
 
typedef int (*cthread_cb_t)(struct cthread *c, void *arg, int idx);
 
CNDP_API struct cthread *cthread_find(struct cthread_sched *s, int threadid);
 
CNDP_API int cthread_foreach(struct cthread_sched *s, cthread_cb_t func, void *arg);
 
CNDP_API struct cthread_sched *cthread_get_sched(struct cthread *c);
 
typedef int (*sched_cb_t)(struct cthread_sched *s, void *arg, int idx);
 
CNDP_API int cthread_sched_id(struct cthread_sched *s);
 
CNDP_API struct cthread_sched *cthread_sched_find(int schedid);
 
CNDP_API int cthread_sched_foreach(sched_cb_t func, void *arg);
 
CNDP_API void *cthread_thread_private(struct cthread *c);
 
CNDP_API int cthread_set_thread_private(struct cthread *c, void *arg);
 
CNDP_API int cthread_once_init(struct cthread_once **once);
 
CNDP_API int cthread_once_destroy(struct cthread_once *once);
 
CNDP_API int cthread_once_reset(struct cthread_once *once);
 
CNDP_API int cthread_once(struct cthread_once *once, int (*func)(void *), void *arg);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _CTHREAD_API_H */