Max 5 API Reference

jit.parallel.utils.c

// this class may be used to split image into n pieces and call functions of the form
//void jit_op_calculate_ndim(void *data, long dimcount, long *dim, long planecount, t_jit_matrix_info *in1_minfo, char *bip1, 
//  t_jit_matrix_info *in2_minfo, char *bip2, t_jit_matrix_info *out_minfo, char *bop/*, opttional t_jit_parallel_ndim_worker *w */);

#include "jit.common.h"
#include "ext_obex.h"
#include "ext_systhread.h"
#include "parallel.h"

typedef struct _long_splat
{
    void *a[32];
} t_long_splat;

typedef void (*t_long_splat_fn)(t_long_splat);

/**
 *  @defgroup parallelutilmod Parallel Utility Module
    @ingroup jitter
 */

void jit_parallel_ndim_single(t_jit_parallel_ndim *p);
void jit_parallel_ndim_multi(t_parallel_worker *w);

//this is not reentrant 
t_parallel_task *_jit_parallel_task=NULL;
static long _jit_parallel_init=0;
long _jit_parallel=0;
long _jit_parallelthreads=0;
long _jit_parallelthresh=10000; // minimum cell count to use parallel processing
long _jit_paralleldebug=0;

void jit_parallel_utils_init(void)
{
    if (!_jit_parallel_init) {
        parallel_init();
        _jit_parallel_init = 1;
        _jit_parallelthreads = parallel_processorcount();
        if (_jit_parallelthreads>1)
            _jit_parallel = 1;
        //jit_object_post((t_object *)x,"jitter parallel=%d, threadcount=%d",_jit_parallel,_jit_parallelthreads);
    }
}

/**
 * Tasks N-dimensional matrix calcuations to multiple threads if appropriate.
 * This function is ultimately what the other parallel 
 * utility functions call after having set up the 
 * t_jit_parallel_ndim struct. The operation is tasked
 * to multiple threads if all of the following conditions 
 * are met: 
 *  - multiple processors or cores are present 
 *  - parallel processing is enabled 
 *  - the size of the matrix data is larger then the parallel threshold
 *
 * @ingroup parallelutilmod
 *
 * @param   p       parallel ndim calc data
 *
 */
void jit_parallel_ndim_calc(t_jit_parallel_ndim *p)
{
    long i;
    unsigned long itemcount=1;
    
    for (i=0;i<p->dimcount;i++) {
        itemcount *= p->dim[i]; 
    }
    if ((!_jit_parallel)||((long)itemcount<_jit_parallelthresh))            
        jit_parallel_ndim_single(p);
    else {
        if (!_jit_parallel_task) {
            _jit_parallel_task = parallel_task_new(p,(method)jit_parallel_ndim_multi,_jit_parallelthreads);
        }
        parallel_task_data(_jit_parallel_task,p); 
        parallel_task_workerproc(_jit_parallel_task,(method)jit_parallel_ndim_multi); //will need later for different kinds 
        parallel_task_execute(_jit_parallel_task);
    }
}

void jit_parallel_ndim_single(t_jit_parallel_ndim *p)
{
    long i,j;
    t_long_splat splat;
    t_jit_parallel_ndim_worker pw;

    pw.paralleldata = p;
    pw.workercount = 1;
    pw.workerid = 0;
    pw.offset[0] = 0;
    pw.offset[1] = 0;
    
    splat.a[0] = (void *)p->data;   
    splat.a[1] = (void *)p->dimcount;   
    splat.a[2] = (void *)p->dim;    
    splat.a[3] = (void *)p->planecount; 
    for (i=0,j=4;i<p->iocount;i++) 
    {
        splat.a[j++] = (void *)p->io[i].minfo;  
        splat.a[j++] = (void *)p->io[i].bp; 
    }
    splat.a[j++] = (void *)&pw; 
    (*(t_long_splat_fn)p->fn)(splat);
    if (_jit_paralleldebug)
        post("parallel single");    
}

void jit_parallel_ndim_multi(t_parallel_worker *w)
{
    long i,j,offset,dim[32];
    t_long_splat splat;
    t_jit_parallel_ndim *p=(t_jit_parallel_ndim *)w->data;
    t_jit_matrix_info *minfo[JIT_PARALLEL_NDIM_MAX_IO];
    t_jit_parallel_ndim_worker pw;
    char *bp;
    
    for (i=0;i<32;i++)
        dim[i] = p->dim[i];

    // currently only slices along the 2d axis.
    // in the future we could support horizontal 
    // slicing for large 1d matrices
    if (w->id<(w->task->workercount-1)) {
        dim[1] = (dim[1]/w->task->workercount);
        offset = dim[1]*w->id;
    } else {
        // in case x->workercount is not a factor of dim[1]
        offset = (dim[1]/w->task->workercount)*(w->id);
        dim[1] = dim[1] - offset;
    }
    if (_jit_paralleldebug)
        post("wid %d, dim %d, offset %d",w->id, dim[1], offset);

    pw.paralleldata = p;
    pw.workercount = w->task->workercount;
    pw.workerid = w->id;
    pw.offset[0] = 0;
    pw.offset[1] = offset;
    pw.extent[0] = dim[0];
    pw.extent[1] = dim[1];
        
    splat.a[0] = (void *)p->data;   
    splat.a[1] = (void *)p->dimcount;   
    splat.a[2] = (void *)dim;   
    splat.a[3] = (void *)p->planecount; 
    for (i=0,j=4;i<p->iocount;i++) 
    {
        // need to make a copy of the matrix info struct since we are overwriting some values 
        minfo[i] = (t_jit_matrix_info *)jit_getbytes(sizeof(t_jit_matrix_info));
        (*minfo[i]) = (*p->io[i].minfo);
        if (!(p->io[i].flags&JIT_PARALLEL_NDIM_FLAGS_FULL_MATRIX)) {
            bp = p->io[i].bp + p->io[i].minfo->dimstride[1] * offset;
            minfo[i]->dim[1] = MIN(dim[1],minfo[i]->dim[1]);
        } else {
            bp = p->io[i].bp;
        }
        splat.a[j++] = (void *)minfo[i];    
        splat.a[j++] = (void *)bp;  
    }
    splat.a[j++] = (void *)&pw; 
    if (dim[1]>0)
        (*(t_long_splat_fn)p->fn)(splat);
    for (i=0;i<p->iocount;i++) 
    {
        jit_freebytes((char *)minfo[i],sizeof(t_jit_matrix_info));
    }
}

/**
 * Tasks one input/output N-dimensional matrix calcuations to multiple threads if appropriate.
 * This function fills out the t_jit_parallel_ndim struct
 * for a one input/output N-dimensional matrix calc 
 * method, and calls jit_parallel_ndim_calc. This function
 * does not distinguish between what is an input or output.
 *
 * @ingroup parallelutilmod
 *
 * @param   fn          N-dimensional matrix calc method
 * @param   data        user defined pointer (typically object)
 * @param   dimcount    master number of dimensions to iterate
 * @param   dim         master pointer to dimension sizes
 * @param   planecount  master number of planes
 * @param   minfo1      matrix info for first input/output
 * @param   bp1         matrix data pointer for first input/output
 * @param   flags1      parallel flags for first input/output
 *
 */
void jit_parallel_ndim_simplecalc1(method fn, void *data, long dimcount, long *dim, long planecount, t_jit_matrix_info *minfo1, char *bp1, long flags1)
{
    t_jit_parallel_ndim p;
    
    p.flags = 0;
    p.fn = fn;
    p.dimcount = dimcount;
    p.dim = dim;
    p.planecount = planecount;
    p.data = data;
    p.iocount = 1;

    p.io[0].flags = flags1;
    p.io[0].minfo = minfo1;
    p.io[0].bp = bp1;
    
    jit_parallel_ndim_calc(&p);
}

/**
 * Tasks two input/output N-dimensional matrix calcuations to multiple threads if appropriate.
 * This function fills out the t_jit_parallel_ndim struct
 * for a two input/output N-dimensional matrix calc 
 * method, and calls jit_parallel_ndim_calc. This function
 * does not distinguish between what is an input or output.
 *
 * @ingroup parallelutilmod
 *
 * @param   fn          N-dimensional matrix calc method
 * @param   data        user defined pointer (typically object)
 * @param   dimcount    master number of dimensions to iterate
 * @param   dim         master pointer to dimension sizes
 * @param   planecount  master number of planes
 * @param   minfo1      matrix info for first input/output
 * @param   bp1         matrix data pointer for first input/output
 * @param   flags1      parallel flags for first input/output
 * @param   minfo2      matrix info for second input/output
 * @param   bp2         matrix data pointer for second input/output
 * @param   flags2      parallel flags for second input/output
 *
 */
void jit_parallel_ndim_simplecalc2(method fn, void *data, long dimcount, long *dim, long planecount, t_jit_matrix_info *minfo1, char *bp1, 
    t_jit_matrix_info *minfo2, char *bp2, long flags1, long flags2)
{
    t_jit_parallel_ndim p;
    
    p.flags = 0;
    p.fn = fn;
    p.dimcount = dimcount;
    p.dim = dim;
    p.planecount = planecount;
    p.data = data;
    p.iocount = 2;

    p.io[0].flags = flags1;
    p.io[0].minfo = minfo1;
    p.io[0].bp = bp1;

    p.io[1].flags = flags2;
    p.io[1].minfo = minfo2;
    p.io[1].bp = bp2;
    
    jit_parallel_ndim_calc(&p);
}

/**
 * Tasks three input/output N-dimensional matrix calcuations to multiple threads if appropriate.
 * This function fills out the t_jit_parallel_ndim struct
 * for a three input/output N-dimensional matrix calc 
 * method, and calls jit_parallel_ndim_calc. This function
 * does not distinguish between what is an input or output.
 *
 * @ingroup parallelutilmod
 *
 * @param   fn          N-dimensional matrix calc method
 * @param   data        user defined pointer (typically object)
 * @param   dimcount    master number of dimensions to iterate
 * @param   dim         master pointer to dimension sizes
 * @param   planecount  master number of planes
 * @param   minfo1      matrix info for first input/output
 * @param   bp1         matrix data pointer for first input/output
 * @param   flags1      parallel flags for first input/output
 * @param   minfo2      matrix info for second input/output
 * @param   bp2         matrix data pointer for second input/output
 * @param   flags2      parallel flags for second input/output
 * @param   minfo3      matrix info for third input/output
 * @param   bp3         matrix data pointer for third input/output
 * @param   flags3      parallel flags for third input/output
 *
 */
void jit_parallel_ndim_simplecalc3(method fn, void *data, long dimcount, long *dim, long planecount, t_jit_matrix_info *minfo1, char *bp1, 
    t_jit_matrix_info *minfo2, char *bp2, t_jit_matrix_info *minfo3, char *bp3, long flags1, long flags2, long flags3)
{
    t_jit_parallel_ndim p;
    
    p.flags = 0;
    p.fn = fn;
    p.dimcount = dimcount;
    p.dim = dim;
    p.planecount = planecount;
    p.data = data;
    p.iocount = 3;

    p.io[0].flags = flags1;
    p.io[0].minfo = minfo1;
    p.io[0].bp = bp1;

    p.io[1].flags = flags2;
    p.io[1].minfo = minfo2;
    p.io[1].bp = bp2;

    p.io[2].flags = flags3;
    p.io[2].minfo = minfo3;
    p.io[2].bp = bp3;
    
    jit_parallel_ndim_calc(&p);
}

/**
 * Tasks four input/output N-dimensional matrix calcuations to multiple threads if appropriate.
 * This function fills out the t_jit_parallel_ndim struct
 * for a three input/output N-dimensional matrix calc 
 * method, and calls jit_parallel_ndim_calc. This function
 * does not distinguish between what is an input or output.
 *
 * @ingroup parallelutilmod
 *
 * @param   fn          N-dimensional matrix calc method
 * @param   data        user defined pointer (typically object)
 * @param   dimcount    master number of dimensions to iterate
 * @param   dim         master pointer to dimension sizes
 * @param   planecount  master number of planes
 * @param   minfo1      matrix info for first input/output
 * @param   bp1         matrix data pointer for first input/output
 * @param   flags1      parallel flags for first input/output
 * @param   minfo2      matrix info for second input/output
 * @param   bp2         matrix data pointer for second input/output
 * @param   flags2      parallel flags for second input/output
 * @param   minfo3      matrix info for third input/output
 * @param   bp3         matrix data pointer for third input/output
 * @param   flags3      parallel flags for third input/output
 * @param   minfo4      matrix info for fourth input/output
 * @param   bp4         matrix data pointer for fourth input/output
 * @param   flags4      parallel flags for fourth input/output
 *
 */
void jit_parallel_ndim_simplecalc4(method fn, void *data, long dimcount, long *dim, long planecount, t_jit_matrix_info *minfo1, char *bp1, 
    t_jit_matrix_info *minfo2, char *bp2, t_jit_matrix_info *minfo3, char *bp3, t_jit_matrix_info *minfo4, char *bp4, 
    long flags1, long flags2, long flags3, long flags4)
{
    t_jit_parallel_ndim p;
    
    p.flags = 0;
    p.fn = fn;
    p.dimcount = dimcount;
    p.dim = dim;
    p.planecount = planecount;
    p.data = data;
    p.iocount = 4;

    p.io[0].flags = flags1;
    p.io[0].minfo = minfo1;
    p.io[0].bp = bp1;

    p.io[1].flags = flags2;
    p.io[1].minfo = minfo2;
    p.io[1].bp = bp2;

    p.io[2].flags = flags3;
    p.io[2].minfo = minfo3;
    p.io[2].bp = bp3;

    p.io[3].flags = flags4;
    p.io[3].minfo = minfo4;
    p.io[3].bp = bp4;
    
    jit_parallel_ndim_calc(&p);
}

Copyright © 2008, Cycling '74