test-runqueue.c File Reference

#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include "uloop.h"
#include "runqueue.h"

Go to the source code of this file.

Data Structures
struct	sleeper

Functions
static void	q_empty (struct runqueue *q)
static const char *	sleeper_type (struct sleeper *s)
static void	q_sleep_run (struct runqueue *q, struct runqueue_task *t)
static void	q_sleep_cancel (struct runqueue *q, struct runqueue_task *t, int type)
static void	q_sleep_complete (struct runqueue *q, struct runqueue_task *p)
static void	my_runqueue_process_kill_cb (struct runqueue *q, struct runqueue_task *p)
static void	timer_cb (struct uloop_timeout *t)
static struct sleeper *	create_sleeper (int val, const struct runqueue_task_type *type, bool kill)
static void	add_sleeper (int val)
int	main (int argc, char **argv)

Variables
static struct runqueue	q

Function Documentation

add_sleeper()

static void add_sleeper ( int  val )

static

Definition at line 117 of file test-runqueue.c.

{
        static const struct runqueue_task_type sleeper_type = {
                .run = q_sleep_run,
                .cancel = q_sleep_cancel,
                .kill = runqueue_process_kill_cb,
        };
 
        static const struct runqueue_task_type killer_type = {
                .run = q_sleep_run,
                .cancel = q_sleep_cancel,
                .kill = my_runqueue_process_kill_cb,
        };
 
        struct sleeper *k = create_sleeper(val, &killer_type, true);
        uloop_timeout_set(&k->t, 10);
        uloop_timeout_add(&k->t);
        runqueue_task_add(&q, &k->proc.task, false);
 
        struct sleeper *s = create_sleeper(val, &sleeper_type, false);
        runqueue_task_add(&q, &s->proc.task, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_sleeper()

static struct sleeper* create_sleeper ( int  val, const struct runqueue_task_type *  type, bool  kill  )

static

Definition at line 104 of file test-runqueue.c.

{
        struct sleeper *s = calloc(1, sizeof(*s));
        s->kill = kill;
        s->t.cb = timer_cb;
        s->proc.task.type = type;
        s->proc.task.run_timeout = 500;
        s->proc.task.complete = q_sleep_complete;
        s->val = val;
 
        return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 140 of file test-runqueue.c.

{
        uloop_init();
 
        runqueue_init(&q);
        q.empty_cb = q_empty;
        q.max_running_tasks = 1;
 
        if (argc > 1)
                q.max_running_tasks = atoi(argv[1]);
 
        add_sleeper(1);
        add_sleeper(1);
        add_sleeper(1);
 
        uloop_run();
        uloop_done();
 
        return 0;
}

Here is the call graph for this function:

my_runqueue_process_kill_cb()

static void my_runqueue_process_kill_cb ( struct runqueue *  q, struct runqueue_task *  p  )

static

Definition at line 88 of file test-runqueue.c.

{
        struct sleeper *s = container_of(p, struct sleeper, proc.task);
 
        fprintf(stderr, "[%d/%d] killing process (%s)\n", q->running_tasks,
                        q->max_running_tasks, sleeper_type(s));
        runqueue_process_kill_cb(q, p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

q_empty()

static void q_empty ( struct runqueue *  q )

static

Definition at line 36 of file test-runqueue.c.

{
        fprintf(stderr, "All done!\n");
        uloop_end();
}

Here is the call graph for this function:

Here is the caller graph for this function:

q_sleep_cancel()

static void q_sleep_cancel ( struct runqueue *  q, struct runqueue_task *  t, int  type  )

static

Definition at line 70 of file test-runqueue.c.

{
        struct sleeper *s = container_of(t, struct sleeper, proc.task);
 
        fprintf(stderr, "[%d/%d] cancel 'sleep %d' (%s)\n", q->running_tasks,
                        q->max_running_tasks, s->val, sleeper_type(s));
        runqueue_process_cancel_cb(q, t, type);
}

Here is the call graph for this function:

Here is the caller graph for this function:

q_sleep_complete()

static void q_sleep_complete ( struct runqueue *  q, struct runqueue_task *  p  )

static

Definition at line 79 of file test-runqueue.c.

{
        struct sleeper *s = container_of(p, struct sleeper, proc.task);
 
        fprintf(stderr, "[%d/%d] finish 'sleep %d' (%s) \n", q->running_tasks,
                        q->max_running_tasks, s->val, sleeper_type(s));
        free(s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

q_sleep_run()

static void q_sleep_run ( struct runqueue *  q, struct runqueue_task *  t  )

static

Definition at line 47 of file test-runqueue.c.

{
        struct sleeper *s = container_of(t, struct sleeper, proc.task);
        char str[32];
        pid_t pid;
 
        fprintf(stderr, "[%d/%d] start 'sleep %d' (%s)\n", q->running_tasks,
                        q->max_running_tasks, s->val, sleeper_type(s));
 
        pid = fork();
        if (pid < 0)
                return;
 
        if (pid) {
                runqueue_process_add(q, &s->proc, pid);
                return;
        }
 
        sprintf(str, "%d", s->val);
        execlp("sleep", "sleep", str, NULL);
        exit(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sleeper_type()

static const char* sleeper_type ( struct sleeper *  s )

static

Definition at line 42 of file test-runqueue.c.

{
        return s->kill ? "killer" : "sleeper";
}

Here is the caller graph for this function:

timer_cb()

static void timer_cb ( struct uloop_timeout *  t )

static

Definition at line 97 of file test-runqueue.c.

{
        struct sleeper *s = container_of(t, struct sleeper, t);
        if (s->kill)
                runqueue_task_kill(&s->proc.task);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

q

struct runqueue q

static

Definition at line 1 of file test-runqueue.c.