// 状态
typedef enum _co_status{
        CO_NEW,
        CO_READY,
        CO_WAIT,
        CO_SLEEP,
        CO_EXIT
}co_status_t;

// 协程体
struct coroutine {
    int coid;
    struct context ctx;
    void *(*entry)(void *);
    void *arg;
    void *stack; // 独立栈or共享栈
    size_t size;
    co_status_t status;

    // 以下是互斥关系，一个协程不可能同时有两个状态
    queue_node(coroutine) readyq;
    rbtree_node(coroutine) sleept;
    rbtree_node(coroutine) waitt;
    queue_node(coroutine) exitq;
};

fun1(){}
func(){fun1();} // 这样直接调用func，就只是一个从main函数再压栈func再压栈fun1的过程
pthread_create(fun1); // 通过协程或者线程去调用fun1，fun1有独立的栈空间

// 协程调度器
struct scheduler {
    struct coroutine *cur_co;
    // 在协程实现中，以下内容是共用节点的，如何理解？
    queue_head(coroutine) readyh; 
    rbtree_root(coroutine) sleepr;
    rbtree_root(coroutine) waitr;
    queue_head(coroutine) exith;
};

// 调度策略，其中一种，很可能处理顺序根据情况调换位置
schedule(struct sheduler *sched){
    coroutine *co = NULL;
    // 先将睡眠队列超时的节点执行完，不然可能导致一直执行不到
    while((co = get_expired_node(sched->sleepr)) != NULL){ 
        #if 0
        // resume(co); 可以直接resume当前co，也可以先改成就绪
        #else
        push_ready_queue(co); // co->status = CO_READY;
        #endif
    }
    #if 0
        
    #else
        // 如果wait也采用push到ready的方式进行编程，那么这里需要先对wait状态进行处理，最后再处理ready队列
        while((co = get_wait_node(sched->waitr)) != NULL)
        {
            push_ready_queue(co); // co->status = CO_READY;
        }
    #endif
    while((co = get_next_node(sched->readyh)) != NULL)
    {
        resume(co);
    }
    while((co = get_next_node(sched->exitq)) != NULL)
    {
        destroy(co);
    }
}

##include <mysql/mysql.h>
int main()
{
    MYSQL *mysql = mysql_init(NULL);
    if(!mysql){
        printf("mysql_init failed\n");
        return 0;
    }
    // mysql -u root -p -h127.0.0.1 -P3306
    if(!mysql_real_connect(mysql, "127.0.0.1", "root", "123456", "KING_DB", 3306, NULL, CLIENT_FOUND_ROWS)){
        printf("mysql_real_connect failed\n");
        return 0;
    }
    printf("mysql_real_connect success\n");
}

##define _GUN_SOURCE
##include <dlfcn.h>
##include <sys/types.h>
##include <sys/socket.h>
##include <mysql/mysql.h>

typedef int (*connect_t)(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
connect_t connect_f = NULL;

typedef ssize_t (*recv_t)(int sockfd, void *buf, size_t len, int flags);
recv_t recv_f = NULL;

typedef ssize_t (*send_t)(int sockfd, const void* buf, size_t len, int flags);
send_t send_f = NULL;

// 编写我们自己的connect recv send
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen){
    printf("connect\n");
    return connect_f(sockfd, addr, addrlen); // 在main函数里会给connect_f这个函数赋予动态链接库里的connect入口地址
}
ssize_t recv(int sockfd, void *buf, size_t len, int flags){
    printf("recv\n");
    return recv_f(sockfd, buf, len, flags);
}
ssize_t send(int sockfd, const void* buf, size_t len, int flags){
    printf("send\n");
    return send_f(sockfd, buf, len, flags);
}

void init_hook(void)
{
    /* dlsym, dlvsym - obtain address of a symbol in a shared object or executable */
    if(connect_f == NULL)
        connect_f = dlsym(RTLD_NEXT, "connect");
    if(recv_f == NULL)
        recv_f = dlsym(RTLD_NEXT, "recv");
    if(send_f == NULL)
        send_f = dlsym(RTLD_NEXT, "send");
}

int main()
{
    init_hook();

    MYSQL *mysql = mysql_init(NULL);
    if(!mysql){
        printf("mysql_init failed\n");
        return 0;
    }
    // mysql -u root -p -h127.0.0.1 -P3306
    if(!mysql_real_connect(mysql, "127.0.0.1", "root", "123456", "KING_DB", 3306, NULL, CLIENT_FOUND_ROWS)){
        printf("mysql_real_connect failed\n");
        return 0;
    }
    printf("mysql_real_connect success\n");
}

##define _GNU_SOURCE
##include <sched.h>

##include <stdio.h>
##include <pthread.h>

##define THREAD_COUNT 4

void *thread_func(void *arg){
    int threadid = *(int*)arg;

    printf("threadid %d is running on cpu %d\n", threadid, sched_getcpu());

    while(1) ; // current cpu kernel -> 100%
}

int main(){
    pthread_t threads[THREAD_COUNT];
    int threadid[THREAD_COUNT];

    cpu_set_t cpus;
    CPU_ZERO(&cpus);
    int i = 0;
    for(int i = 0 ; i < THREAD_COUNT ; i++){
        CPU_SET(i, &cpus);
    }
    for(int i = 0 ; i < THREAD_COUNT ; i++){
        threadid[i] = i;
        pthread_create(&threads[i], NULL, thread_func, &threadid[i]);
        // *** 这个会先于函数的入口函数执行（问就是线程的调度策略决定的，上面的create会将函数加入到就绪队列，所以不是立即执行的），所以可以完成线程和固定cpu核心的绑定
        pthread_sefaffinity_np(threads[i], sizeof(cpu_set_t)); 
    }
    for(int i = 0 ; i < THREAD_COUNT ; i++){
        pthread_join(threads[i], NULL);
    }
}

##include <unistd.h>
##include <sys/sysinfo.h>
##include <sys/syscall.h>

int process_bind(void)
{
    int num = sysconf(_SC_NPROCESSORS_CONF);
    pid_t self_id = syscall(__NR_gettid);

    cpu_set_t mask;
    CPU_ZERO(&mask);
    CPU_SET(self_id % num, &mask);
    sched_setaffinity(0, sizeof(mask), &mask);

    printf("processid %d is running on cpu %d\n", self_id, sched_getcpu());

    while(1){}
}
int main()
{
    fork(); // 一个进程变两个
    fork(); // 两个进程变四个
    process_bind();
    return 0;
}