Managing tasks

Thu, 02 Apr 2009 20:09:05 GMT

I'm fiddling with some C code, experimenting with different approaches to various subtasks, some of which depend on previous tasks. Results are valid only for the duration of the current frame. Performance matters, so I tend to comment pieces I'm not currently working on unless they're needed. For the time being, the data is often only displayed as debugging output, but sometimes the debug display is turned off, making the computation wasteful. Up to this point I'd been juggling the dependencies manually, calling each computation in order from a central point, but finally I've gotten restless to automate things. Here's some cute C preprocessor fun I bashed out a few minutes ago:


struct task {
    char *name;
    int last_time;
    int locked;
    void (*taskfn) (void);
};

#define deftask(name) \
  void task_do_##name (void); \
  struct task name = {#name, -1, 0, task_do_##name}; \
  noinline void task_do_##name (void)

static inline void require_task (struct task *task, int time)
{
    assert(task != NULL);
    if (task->last_time < time) {
        if (task->locked) {
            fprintf(stderr, "Fatal: Circular dependency on task \"%s\".\n", task->name);
            exit(1);
        }
        task->locked = 1;
        task->taskfn();
        task->last_time = time;
        task->locked = 0;
    }
}

I interface this with my code and the global frame_number as follows:

#define using(name) require_task(&name, frame_number)

Next I define various tasks. Some depend on others:

deftask(track_motion)
{
    .. some code here ..
}

deftask(feature_matrix)
{
  .. more code here ..
}

deftask(grid_alignment)
{
    using(track_motion);
    .. yet more code..
}

Code elsewhere also relies on the 'using' macro to ensure computations are up to date. The components communicate through global state. If they didn't, and the style were more functional, I supposed I'd be blogging about how I'd implemented memoization instead. Eventually, I might rig this up to farm the computation out to other threads (though this doesn't seem like such a huge win unless I go back to eagerly computing things in advance of needing them). I'd need a parallel 'using' operator.

The New C Standard

Sat, 26 Apr 2008 06:38:37 GMT

I've just happened upon the PDF of "The New C Standard: An Economic and Cultural Commentary", an unpublished book by Derek Jones, available here. Although it has now been available for several years, I have unfortunately overlooked it until this evening. At 1616 pages, the breadth is staggering, and the introductory material on software development, engineering, and the author's experience nearly constitutes a book of its own. The book takes the exhaustive approach of examining each sentence of the C99 standard in sequence, providing expert commentary, comparison between language versions, and statistics gleaned from well known large C programs.

This approach is of dissecting the standard is of particular interest to me, being someone who despite having programmed in C for more than ten years has had (I'm ashamed to say) little or no exposure to the actual language standard, and a mental model of the language grown by accretion from hearsay, intuition, code I've read, and the intersection of things which work in the implementations of the language I have experience with. This approach has worked reasonably well for C, but is probably quite a dangerous way to proceed in a more intricate language such as C++ (although I fear a great many programmers learn it in just that fashion). This situation has become particularly unsatisfactory when considered in contrast with Common Lisp, a language which I've worked with equally extensively over the last five or six years, and where a direct HTML conversion of the ANSI standard (the Common Lisp Hyperspec) serves comfortably as both an everyday reference and the ultimate arbiter of language semantics.

In any case, the book looks interesting, and I look forward to any insights and corrections/extensions to my inferred model of the language which it can provide.

Informal Methods

Managing tasks

The New C Standard