hyung-hwan/hip
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed wrong chaining in hip_sleep()

Browse Source
This commit is contained in:
hyung-hwan 2025-06-10 22:27:12 +09:00
parent 92c4376498
commit 0865609ec7
3 changed files with 159 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
Makefile
View File

@ -1,2 +1,17 @@
all: SRCS = ctx.c
cc -Wall -g -o ctx ctx.c -lrt OBJS = $(SRCS:.c=.o)
CFLAGS := -Wall -g
LDFLAGS :=
LIBS := -lrt
all: $(OBJS)
$(CC) $(LDFLAGS) -o hip $(OBJS) $(LIBS)
clean:
rm -f $(OBJS) hip
.SUFFIXES: .c .o
.c.o:
$(CC) $(CFLAGS) -c $<

170
ctx.c
View File

@ -1,4 +1,5 @@
#include <ucontext.h> #include "hip.h"
#include <signal.h> #include <signal.h>
#include <time.h> #include <time.h>
#include <string.h> #include <string.h>
@ -21,70 +22,6 @@
#include <valgrind/valgrind.h> #include <valgrind/valgrind.h>
#endif #endif
typedef unsigned char hip_uint8_t;
typedef unsigned short hip_uint16_t;
typedef unsigned int hip_uint32_t;
typedef unsigned long long hip_uint64_t;
typedef signed char hip_int8_t;
typedef signed short hip_int16_t;
typedef signed int hip_int32_t;
typedef signed long long hip_int64_t;
typedef hip_uint64_t hip_nsecdur_t;
#if defined(__ILP32__) || defined(_WIN32)
# define MKCTX_NARGS 1
typedef hip_uint32_t hip_oow_t;
typedef hip_int32_t hip_ooi_t;
#else
# define MKCTX_NARGS 2
typedef hip_uint64_t hip_oow_t;
typedef hip_int64_t hip_ooi_t;
#endif
#define HIP_NULL ((void*)0)
#define HIP_INVALID_FD (-1)
typedef struct hip_t hip_t;
typedef struct hip_uctx_t hip_uctx_t;
typedef struct hip_uctx_link_t hip_uctx_link_t;
typedef void (*hip_ufun_t) (hip_uctx_t* uc, void* ctx);
enum hip_io_flag_t
{
HIP_IO_READ = (1 << 0),
HIP_IO_WRITE = (1 << 1)
};
typedef enum hip_io_flag_t hip_io_flag_t;
struct hip_uctx_link_t
{
hip_uctx_link_t* next;
hip_uctx_link_t* prev;
};
struct hip_uctx_t
{
hip_t* hip;
ucontext_t uc;
hip_ufun_t uf;
void* ctx;
hip_oow_t csi; /* number of context switches in */
hip_oow_t cso; /* number of context switches out */
hip_nsecdur_t wakeup_time;
int waiting_fd;
unsigned int stid;
hip_uctx_link_t uctx;
hip_uctx_link_t io_done;
};
#define HIP_OFFSETOF(type, field) ((hip_oow_t)&(((type*)0)->field))
#define HIP_CONTAINEROF(ptr, type, field) ((type*)((hip_uint8_t*)ptr - HIP_OFFSETOF(type, field)))
#define CHAIN(_link, _prev, _next) do { \ #define CHAIN(_link, _prev, _next) do { \
hip_uctx_link_t* _p = _prev; \ hip_uctx_link_t* _p = _prev; \
hip_uctx_link_t* _n = _next; \ hip_uctx_link_t* _n = _next; \
@ -108,11 +45,23 @@ struct hip_uctx_t
#define UCTX_FROM_LINK(_link) HIP_CONTAINEROF(_link, hip_uctx_t, uctx) #define UCTX_FROM_LINK(_link) HIP_CONTAINEROF(_link, hip_uctx_t, uctx)
enum hip_flag_t struct hip_uctx_t
{ {
HIP_FLAG_LAZY = (1 << 0) hip_t* hip;
ucontext_t uc;
int flags;
hip_ufun_t uf;
void* ctx;
hip_oow_t csi; /* number of context switches in */
hip_oow_t cso; /* number of context switches out */
hip_nsecdur_t wakeup_time;
int waiting_fd;
unsigned int stid;
hip_uctx_link_t uctx;
hip_uctx_link_t io_done;
}; };
typedef enum hip_flag_t hip_flag_t;
struct hip_t struct hip_t
{ {
@ -134,7 +83,6 @@ struct hip_t
hip_uctx_t* uctx_mux; hip_uctx_t* uctx_mux;
ucontext_t uc_main; ucontext_t uc_main;
}; };
/* ---------------------------------------------------- */ /* ---------------------------------------------------- */
#if (MKCTX_NARGS <= 1) #if (MKCTX_NARGS <= 1)
@ -171,13 +119,18 @@ printf ("invoke_uf XXXXXXXXXXXXXXXXXXXXX...%p\n", uctx);
/* switch to the scheduler */ /* switch to the scheduler */
UNCHAIN(&uctx->uctx); UNCHAIN(&uctx->uctx);
/* TODO: if auto-destroy is on, delete it */ if (uctx->flags & HIP_RTN_FLAG_AUTO_DESTROY)
//if (uctx->flags & HIP_UCTX_FLAG_AUTO_DESTROY) hip_freertn(hip, uctx); {
//else hip_uctx_close(uctx);
printf (">>>>>>>>>> *********************** CLOSED TERMINATED\n");
}
else
{
ADD_BACK(&uctx->uctx, &hip->terminated); ADD_BACK(&uctx->uctx, &hip->terminated);
printf ("ADDED TO TERMINATED\n"); printf (">>>>>>>>>> ************************ ADDED TO TERMINATED\n");
}
setcontext(&hip->uctx_sched->uc); setcontext(&hip->uctx_sched->uc); /* switch to the scheduler */
} }
//TODO: This part must not be interrupted? //TODO: This part must not be interrupted?
@ -186,7 +139,7 @@ printf ("ADDED TO TERMINATED\n");
// TODO: destroy the object? // TODO: destroy the object?
} }
hip_uctx_t* hip_uctx_open(hip_t* hip, hip_oow_t stack_size, hip_ufun_t uf, void* ctx) hip_uctx_t* hip_uctx_open(hip_t* hip, hip_oow_t stack_size, int flags, hip_ufun_t uf, void* ctx)
{ {
hip_uctx_t* uc; hip_uctx_t* uc;
void* sp; void* sp;
@ -197,6 +150,7 @@ hip_uctx_t* hip_uctx_open(hip_t* hip, hip_oow_t stack_size, hip_ufun_t uf, void*
memset(uc, 0, sizeof(*uc) + stack_size); memset(uc, 0, sizeof(*uc) + stack_size);
uc->hip = hip; uc->hip = hip;
uc->flags = flags;
uc->uf = uf; uc->uf = uf;
uc->ctx = ctx; uc->ctx = ctx;
uc->waiting_fd = HIP_INVALID_FD; uc->waiting_fd = HIP_INVALID_FD;
@ -277,7 +231,7 @@ static void schedule(hip_uctx_t* uctx, void *ctx)
if (IS_EMPTY(&hip->runnables)) if (IS_EMPTY(&hip->runnables))
{ {
/* TODO: check if there are sleeping ... */ /* TODO: check if there are sleeping ... */
printf ("<scheduler> NO TASK\n"); // printf ("<scheduler> NO TASK\n");
swapcontext(&hip->uctx_sched->uc, &hip->uctx_mux->uc); swapcontext(&hip->uctx_sched->uc, &hip->uctx_mux->uc);
if (IS_EMPTY(&hip->runnables)) break; /* no task? */ if (IS_EMPTY(&hip->runnables)) break; /* no task? */
} }
@ -305,12 +259,12 @@ static void multiplex(hip_uctx_t* uctx, void *ctx)
hip = uctx->hip; hip = uctx->hip;
while (1) while (1)
{ {
printf ("sleeping empty[%d] io_waiting empty[%d]\n", IS_EMPTY(&hip->sleeping), IS_EMPTY(&hip->io_waiting)); //printf ("sleeping empty[%d] io_waiting empty[%d]\n", IS_EMPTY(&hip->sleeping), IS_EMPTY(&hip->io_waiting));
if (IS_EMPTY(&hip->sleeping) && IS_EMPTY(&hip->io_waiting)) if (IS_EMPTY(&hip->sleeping) && IS_EMPTY(&hip->io_waiting))
{ {
// STILL NEED TO HANDLE IO FILE DESCRIPTORS... // STILL NEED TO HANDLE IO FILE DESCRIPTORS...
/* go back to the scheduler */ /* go back to the scheduler */
printf ("NO SLEEPING. BACK TO SCEDULER\n"); //printf ("NO SLEEPING. BACK TO SCEDULER\n");
swapcontext(&hip->uctx_mux->uc, &hip->uctx_sched->uc); swapcontext(&hip->uctx_mux->uc, &hip->uctx_sched->uc);
} }
else else
@ -340,7 +294,7 @@ printf ("NO SLEEPING. BACK TO SCEDULER\n");
epoll_ctl(hip->mux_id, EPOLL_CTL_DEL, u->waiting_fd, HIP_NULL); epoll_ctl(hip->mux_id, EPOLL_CTL_DEL, u->waiting_fd, HIP_NULL);
} }
printf ("WAITING %llu\n", (unsigned long long)wait); //printf ("WAITING %llu\n", (unsigned long long)wait);
/* TODO: support different io multiplexers...*/ /* TODO: support different io multiplexers...*/
#if defined(HAVE_EPOLL_PWAIT2) #if defined(HAVE_EPOLL_PWAIT2)
tmout.tv_sec = wait / 1000000000; tmout.tv_sec = wait / 1000000000;
@ -356,7 +310,7 @@ printf ("WAITING %llu\n", (unsigned long long)wait);
*/ */
n = epoll_pwait(hip->mux_id, ee, 100, (wait + 1000000 - 1) / 1000000, HIP_NULL); n = epoll_pwait(hip->mux_id, ee, 100, (wait + 1000000 - 1) / 1000000, HIP_NULL);
#endif #endif
printf ("Epoll returned [%d]\n", (int)n); //printf ("Epoll returned [%d]\n", (int)n);
if (n <= -1) if (n <= -1)
{ {
/* TODO: some error handling action is required */ /* TODO: some error handling action is required */
@ -385,7 +339,7 @@ printf ("Epoll returned [%d]\n", (int)n);
else else
{ {
printf ("PWAIT link MULTIPLEX DEL %p fd[%d] io_waiting empty[%d]\n", l, u->waiting_fd, IS_EMPTY(&hip->io_waiting)); //printf ("PWAIT link MULTIPLEX DEL %p fd[%d] io_waiting empty[%d]\n", l, u->waiting_fd, IS_EMPTY(&hip->io_waiting));
epoll_ctl(hip->mux_id, EPOLL_CTL_DEL, u->waiting_fd, HIP_NULL); epoll_ctl(hip->mux_id, EPOLL_CTL_DEL, u->waiting_fd, HIP_NULL);
u->waiting_fd = HIP_INVALID_FD; u->waiting_fd = HIP_INVALID_FD;
@ -409,7 +363,7 @@ printf ("PWAIT link MULTIPLEX DEL %p fd[%d] io_waiting empty[%d]\n", l, u->waiti
/* go back to the scheduler */ /* go back to the scheduler */
if (!IS_EMPTY(&hip->runnables)) if (!IS_EMPTY(&hip->runnables))
{ {
printf ("BACK TO SCHEDULER \n"); //printf ("BACK TO SCHEDULER \n");
swapcontext(&hip->uctx_mux->uc, &hip->uctx_sched->uc); swapcontext(&hip->uctx_mux->uc, &hip->uctx_sched->uc);
} }
} }
@ -516,11 +470,11 @@ void hip_close(hip_t* hip)
free(hip); free(hip);
} }
hip_uctx_t* hip_newrtn(hip_t* hip, hip_ufun_t uf, void* ctx) hip_uctx_t* hip_newrtn(hip_t* hip, int flags, hip_ufun_t uf, void* ctx)
{ {
hip_uctx_t* uctx; hip_uctx_t* uctx;
uctx = hip_uctx_open(hip, 8192, uf, ctx); /* TODO: stack size */ uctx = hip_uctx_open(hip, 8192, flags, uf, ctx); /* TODO: stack size */
if (!uctx) return HIP_NULL; if (!uctx) return HIP_NULL;
/* append to the list */ /* append to the list */
@ -531,13 +485,13 @@ hip_uctx_t* hip_newrtn(hip_t* hip, hip_ufun_t uf, void* ctx)
int hip_schedule(hip_t* hip, int preempt) int hip_schedule(hip_t* hip, int preempt)
{ {
hip->uctx_sched = hip_uctx_open(hip, 40960, schedule, hip); hip->uctx_sched = hip_uctx_open(hip, 40960, 0, schedule, hip);
if (!hip->uctx_sched) return -1; if (!hip->uctx_sched) return -1;
hip->uctx_mux = hip_uctx_open(hip, 40960, multiplex, hip); hip->uctx_mux = hip_uctx_open(hip, 40960, 0, multiplex, hip);
if (!hip->uctx_mux) if (!hip->uctx_mux)
{ {
hip_uctx_close (hip->uctx_sched); hip_uctx_close(hip->uctx_sched);
hip->uctx_sched = HIP_NULL; hip->uctx_sched = HIP_NULL;
return -1; return -1;
} }
@ -596,11 +550,7 @@ void hip_sleep(hip_t* hip, hip_nsecdur_t nsecs)
rr->wakeup_time = monotime() + nsecs; rr->wakeup_time = monotime() + nsecs;
/* TODO: switch to HEAP. for now simply linear search to keep this list sorted. */ /* TODO: switch to HEAP. for now simply linear search to keep this list sorted. */
if (IS_EMPTY(&hip->sleeping)) if (!IS_EMPTY(&hip->sleeping))
{
ADD_BACK(hip->running, &hip->sleeping);
}
else
{ {
hip_uctx_link_t* l; hip_uctx_link_t* l;
hip_uctx_t* r; hip_uctx_t* r;
@ -609,16 +559,17 @@ void hip_sleep(hip_t* hip, hip_nsecdur_t nsecs)
r = UCTX_FROM_LINK(l); r = UCTX_FROM_LINK(l);
if (rr->wakeup_time <= r->wakeup_time) if (rr->wakeup_time <= r->wakeup_time)
{ {
CHAIN(hip->running, l->prev, l->next); CHAIN(hip->running, l->prev, l);
goto do_sched; goto do_sched;
} }
} }
ADD_BACK(hip->running, &hip->sleeping);
} }
/* place the running rountine at the end of the sleeping routines list */
ADD_BACK(hip->running, &hip->sleeping);
do_sched: do_sched:
hip->running = HIP_NULL; hip->running = HIP_NULL;
swapcontext(&rr->uc, &hip->uctx_sched->uc); swapcontext(&rr->uc, &hip->uctx_sched->uc); /* switch to the scheduler */
} }
void hip_awaitio(hip_t* hip, int fd, int flags) void hip_awaitio(hip_t* hip, int fd, int flags)
@ -644,13 +595,13 @@ void hip_awaitio(hip_t* hip, int fd, int flags)
* - the waiting context could have changed. */ * - the waiting context could have changed. */
/* TODO: more optimization based on above */ /* TODO: more optimization based on above */
ev.data.ptr = hip->running; /* store running context link */ ev.data.ptr = hip->running; /* store running context link */
printf ("PWAIT link UPDATE %p fd[%d]\n", ev.data.ptr, fd); //printf ("PWAIT link UPDATE %p fd[%d]\n", ev.data.ptr, fd);
epoll_ctl(hip->mux_id, EPOLL_CTL_MOD, fd, &ev); epoll_ctl(hip->mux_id, EPOLL_CTL_MOD, fd, &ev);
} }
else else
{ {
/* delete and add */ /* delete and add */
printf ("PWAIT link DELETE fd[%d]\n", fd); //printf ("PWAIT link DELETE fd[%d]\n", fd);
epoll_ctl(hip->mux_id, EPOLL_CTL_DEL, fd, HIP_NULL); epoll_ctl(hip->mux_id, EPOLL_CTL_DEL, fd, HIP_NULL);
goto add; goto add;
} }
@ -662,7 +613,7 @@ printf ("PWAIT link DELETE fd[%d]\n", fd);
if (flags & HIP_IO_READ) ev.events |= EPOLLIN; if (flags & HIP_IO_READ) ev.events |= EPOLLIN;
if (flags & HIP_IO_WRITE) ev.events |= EPOLLOUT; if (flags & HIP_IO_WRITE) ev.events |= EPOLLOUT;
ev.data.ptr = hip->running; /* store running context link */ ev.data.ptr = hip->running; /* store running context link */
printf ("PWAIT link ADD %p fd[%d]\n", ev.data.ptr, fd); //printf ("PWAIT link ADD %p fd[%d]\n", ev.data.ptr, fd);
epoll_ctl(hip->mux_id, EPOLL_CTL_ADD, fd, &ev); epoll_ctl(hip->mux_id, EPOLL_CTL_ADD, fd, &ev);
/* TODO: error handling - probably panic? */ /* TODO: error handling - probably panic? */
} }
@ -780,12 +731,10 @@ static void uf1(hip_uctx_t* uc, void* ctx)
int i; int i;
for (i =0; i < 5; i++) for (i =0; i < 5; i++)
{ {
printf ("************************** uf1 \n"); printf (">> UF1 TOP [%d]\n", i);
//hip_yield(uc->hip); //hip_yield(uc->hip);
hip_sleep(uc->hip, 500000000); hip_sleep(uc->hip, 500000000);
printf ("************************* uf1 1111\n"); printf (">> UF1 SEC [%d]\n", i);
//hip_yield(uc->hip); //hip_yield(uc->hip);
hip_sleep(uc->hip, 1000000000); hip_sleep(uc->hip, 1000000000);
} }
@ -796,10 +745,10 @@ static void uf2(hip_uctx_t* uc, void* ctx)
int i; int i;
for (i =0; i < 10; i++) for (i =0; i < 10; i++)
{ {
printf ("************************** uf2 \n"); printf (">> UF2 TOP [%d]\n", i);
//hip_yield(uc->hip); //hip_yield(uc->hip);
hip_sleep(uc->hip, 1000000000); hip_sleep(uc->hip, 1000000000);
printf ("************************* uf2 2222 XXXXXXXXXXXXXXxxxxxxxxxxxxxxxxxxxxxx\n"); printf (">> UF2 SEC [%d]\n", i);
//hip_yield(uc->hip); //hip_yield(uc->hip);
hip_sleep(uc->hip, 500000000); hip_sleep(uc->hip, 500000000);
} }
@ -844,14 +793,15 @@ printf ("*********DISCONNECTED>>>>>>>>>>>>>>>\n");
for (i = 0; i < 15; i++) for (i = 0; i < 15; i++)
{ {
printf ("************************** uf3 TOP\n"); printf (">> UF3 TOP [%d]\n", i);
//hip_yield(uc->hip); //hip_yield(uc->hip);
hip_sleep(uc->hip, 1000000000); hip_sleep(uc->hip, 1000000000);
printf ("************************* uf3 3333 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"); printf (">> UF3 SEC [%d]\n", i);
//hip_yield(uc->hip); //hip_yield(uc->hip);
hip_sleep(uc->hip, 1000000000); hip_sleep(uc->hip, 1000000000);
if (i == 8) hip_newrtn(uc->hip, uf2, HIP_NULL); if (i == 8) hip_newrtn(uc->hip, HIP_RTN_FLAG_AUTO_DESTROY, uf2, HIP_NULL);
} }
printf (">> UF3 DONE DONE\n");
} }
int main() int main()
@ -860,9 +810,9 @@ int main()
hip = hip_open(HIP_FLAG_LAZY); hip = hip_open(HIP_FLAG_LAZY);
hip_newrtn(hip, uf1, HIP_NULL); hip_newrtn(hip, HIP_RTN_FLAG_AUTO_DESTROY, uf1, HIP_NULL);
hip_newrtn(hip, uf2, HIP_NULL); hip_newrtn(hip, HIP_RTN_FLAG_AUTO_DESTROY, uf2, HIP_NULL);
hip_newrtn(hip, uf3, HIP_NULL); hip_newrtn(hip, HIP_RTN_FLAG_AUTO_DESTROY, uf3, HIP_NULL);
/* jump to the scheduler */ /* jump to the scheduler */
hip_schedule(hip, 0); hip_schedule(hip, 0);

82
hip.h Normal file
View File

@ -0,0 +1,82 @@
#ifndef _HIP_H_
#define _HIP_H_
#include <ucontext.h>
typedef unsigned char hip_uint8_t;
typedef unsigned short hip_uint16_t;
typedef unsigned int hip_uint32_t;
typedef unsigned long long hip_uint64_t;
typedef signed char hip_int8_t;
typedef signed short hip_int16_t;
typedef signed int hip_int32_t;
typedef signed long long hip_int64_t;
typedef hip_uint64_t hip_nsecdur_t;
#if defined(__ILP32__) || defined(_WIN32)
# define MKCTX_NARGS 1
typedef hip_uint32_t hip_oow_t;
typedef hip_int32_t hip_ooi_t;
#else
# define MKCTX_NARGS 2
typedef hip_uint64_t hip_oow_t;
typedef hip_int64_t hip_ooi_t;
#endif
#define HIP_NULL ((void*)0)
#define HIP_INVALID_FD (-1)
typedef struct hip_t hip_t;
typedef struct hip_uctx_t hip_uctx_t;
typedef struct hip_uctx_link_t hip_uctx_link_t;
typedef void (*hip_ufun_t) (hip_uctx_t* uc, void* ctx);
enum hip_io_flag_t
{
HIP_IO_READ = (1 << 0),
HIP_IO_WRITE = (1 << 1)
};
typedef enum hip_io_flag_t hip_io_flag_t;
struct hip_uctx_link_t
{
hip_uctx_link_t* next;
hip_uctx_link_t* prev;
};
#define HIP_OFFSETOF(type, field) ((hip_oow_t)&(((type*)0)->field))
#define HIP_CONTAINEROF(ptr, type, field) ((type*)((hip_uint8_t*)ptr - HIP_OFFSETOF(type, field)))
enum hip_flag_t
{
HIP_FLAG_LAZY = (1 << 0)
};
typedef enum hip_flag_t hip_flag_t;
enum hip_rtn_flag_t
{
HIP_RTN_FLAG_AUTO_DESTROY = (1 << 0)
};
typedef enum hip_rtn_flag_t hip_rtn_flag_t;
#if defined(__cplusplus)
extern "C" {
#endif
hip_t* hip_open(int flags);
void hip_close(hip_t* hip);
hip_uctx_t* hip_newrtn(hip_t* hip, int flags, hip_ufun_t uf, void* ctx);
hip_uctx_t* hip_uctx_open(hip_t* hip, hip_oow_t stack_size, int flags, hip_ufun_t uf, void* ctx);
void hip_uctx_close(hip_uctx_t* uctx);
#if defined(__cplusplus)
}
#endif
#endif