1

#include <unistd.h>

     2

#include <errno.h>

     3

#include <string.h>

     4

#include <assert.h>

     5

#include <stdlib.h>

     6

     7

#include <pthread.h>

     8

#include <event2/event.h>

     9

    10

#include "common.h"

    11

#include "render_thread.h"

    12

#include "render_thread_struct.h"

    13

#include "render_local.h"

    14

    15

static void *_render_thread_func (void *arg) {

    16

    struct render_thread *ctx = arg;

    17

    18

    // measure how long it takes

    19

    double duration;

    20

    21

    struct render_local local_ctx;

    22

    23

    // initialize it...

    24

    if (!(ctx->err = render_local_init(&local_ctx, &ctx->render_info))) {

    25

        // setup the cancel exit handlers

    26

        pthread_cleanup_push( (void (*)(void *)) render_local_deinit, &local_ctx);

    27

    28

        // render it...

    29

        ctx->err = render_local_run(&local_ctx, &duration);

    30

    31

        if (!ctx->err) {

    32

#if INFO_ENABLED

    33

            u_int32_t img_w, img_h;

    34

    35

            render_get_size(&ctx->render_info, &img_w, &img_h);

    36

    37

            // report the duration

    38

            INFO("rendered [%ux%u] in %f seconds", img_w, img_h, duration);

    39

#endif

    40

        }

    41

    42

        // cleanup

    43

        pthread_cleanup_pop(1);

    44

    }

    45

    46

    // notify completion, writeall()

    47

    ssize_t ret;

    48

    char *buf = (void *) &ctx;

    49

    size_t len = sizeof(ctx);

    50

    51

    do {

    52

        ret = write(ctx->notify_fd, buf, len);

    53

    54

        if (ret > 0) {

    55

            buf += ret;

    56

            len -= ret;

    57

        }

    58

    } while ((ret == -1 && errno == EINTR) || len > 0);

    59

    60

    if (ret == -1)

    61

        PERROR("write");

    62

    63

    // done...

    64

    return NULL;

    65

    66

error:

    67

    // if notifying of completion failed...

    68

    return ctx;

    69

}

    70

    71

static void _render_thread_done (evutil_socket_t fd, short what, void *arg) {

    72

    struct render_thread *ctx = arg;

    73

    void *thread_return;

    74

    75

    // join the thread and check the return value

    76

    if (pthread_join(ctx->thread_id, &thread_return))

    77

        PWARNING("pthread_join");

    78

    else if (thread_return == PTHREAD_CANCELED)

    79

        PWARNING("PTHREAD_CANCELED");

    80

    else if (thread_return != NULL)

    81

        PWARNING("thread_return != NULL");

    82

    83

    // make a lazy effort to read the contents of the pipe

    84

    struct render_thread *ctx2;

    85

    char *buf = (void *) &ctx2;

    86

    size_t len = sizeof(ctx);

    87

    88

    ssize_t ret;

    89

    90

    if ((ret = read(fd, buf, len)) == -1)

    91

        PWARNING("read");

    92

    93

    else if (ret != len)

    94

        WARNING("short read");

    95

    96

    else if (ctx2 != ctx)

    97

        FATAL("wrong ctx: %p <> %p", ctx, ctx2);

    98

    99

    // close the pipe

   100

    if (close(fd))

   101

        PWARNING("close(pipe-read)");

   102

   103

    if (close(ctx->notify_fd))

   104

        PWARNING("close(pipe-write)");

   105

   106

    // mark it as done

   107

    ctx->is_active = 0;

   108

   109

    // call our callback

   110

    ctx->cb_func(ctx, ctx->err, ctx->cb_arg);

   111

}

   112

   113

int render_thread_init (struct render_thread *ctx, struct render *render_info, render_thread_done_cb cb_func, void *cb_arg) {

   114

    // we need to copy over the render info, as it will probably be invalidated before the thread finishes

   115

    memcpy(&ctx->render_info, render_info, sizeof(ctx->render_info));

   116

   117

    // the cb stuff

   118

    ctx->cb_func = cb_func;

   119

    ctx->cb_arg = cb_arg;

   120

   121

    // the notify pipe

   122

    int pipefds[2];

   123

   124

    if (pipe(pipefds))

   125

        PERROR("pipe");

   126

   127

    // the write end...

   128

    ctx->notify_fd = pipefds[1];

   129

   130

    // the read end...

   131

    event_set(&ctx->ev, pipefds[0], EV_READ, &_render_thread_done, ctx);

   132

   133

    if (event_add(&ctx->ev, NULL))

   134

        PERROR("event_add");

   135

   136

    // spawn the render thread

   137

    if (pthread_create(&ctx->thread_id, NULL, &_render_thread_func, ctx))

   138

        PERROR("pthread_create(manager_func)");

   139

   140

    // mark it as active

   141

    ctx->is_active = 1;

   142

   143

    return 0;

   144

   145

error:

   146

    render_thread_deinit(ctx);

   147

    return -1;

   148

}

   149

   150

void render_thread_cancel (struct render_thread *ctx) {

   151

    assert(ctx->is_active);

   152

   153

    // we don't care about joining the thread, detach

   154

    // XXX if already detached, it won't get canceled here

   155

    if (pthread_detach(ctx->thread_id))

   156

        PWARNING("pthread_detach");

   157

   158

    // cancel it

   159

    else if (pthread_cancel(ctx->thread_id))

   160

        PWARNING("pthread_cancel");

   161

   162

    // XXX: should we actually join it before continuing?

   163

   164

    // slam the pipe shut in front of its face

   165

    if (close(event_get_fd(&ctx->ev)))

   166

        PWARNING("close");

   167

   168

    if (close(ctx->notify_fd))

   169

        PWARNING("close");

   170

   171

    // pipe's closed, and don't call _render_thread_func

   172

    event_del(&ctx->ev);

   173

   174

    // we are now ready for deinit

   175

    ctx->is_active = 0;

   176

}

   177

   178

void render_thread_deinit (struct render_thread *ctx) {

   179

    assert(!ctx->is_active);

   180

   181

    // nothing to do

   182

}

   183

   184

struct render_thread *render_thread_alloc (struct render *render_info, render_thread_done_cb cb_func, void *cb_arg) {

   185

    struct render_thread *ctx = NULL;

   186

   187

    if (!(ctx = calloc(1, sizeof(*ctx))))

   188

        ERROR("calloc");

   189

   190

    // flag it for free()ing

   191

    ctx->owned_by_me = 1;

   192

   193

    // init with silent fall-through

   194

    if (render_thread_init(ctx, render_info, cb_func, cb_arg))

   195

        goto error;

   196

   197

    // success

   198

    return ctx;

   199

   200

error:

   201

    // XXX: do other modules do this?

   202

    free(ctx);

   203

   204

    return NULL;

   205

}

   206

   207

void render_thread_free (struct render_thread *ctx) {

   208

    render_thread_deinit(ctx);

   209

   210

    if (ctx->owned_by_me)

   211

        free(ctx);

   212

}

   213