Function vm_engine_iter_task

numexpr3/interpreter.cpp:245–302

Serial/parallel task iterator version of the VM engine

// Serial/parallel task iterator version of the VM engine
int vm_engine_iter_task(NpyIter *iter, 
                    const NumExprObject *params, int tid,
                    int *pc_error, char **errorMessage)
{
    NpyIter_IterNextFunc *iterNext;
    npy_intp task_size, *sizePtr;
    char **iterDataPtr;
    npy_intp *iterStrides;

    iterNext = NpyIter_GetIterNext(iter, errorMessage);
    if (iterNext == NULL) {
        return -1;
    }
    
    sizePtr = NpyIter_GetInnerLoopSizePtr(iter);
    iterDataPtr = NpyIter_GetDataPtrArray(iter);
    iterStrides = NpyIter_GetInnerStrideArray(iter);

    // DEBUG
    // printf( "DEBUG vm_enginer_iter_task\n" );
    // for( int I = 0; I < params->program_len; I++ ) {                                         
    //     printf( "program[%d]:: r:%d a1:%d a1:%d a2:%d a3:%d \n", I,
    //         (int)params->program[I].op, (int)params->program[I].ret, (int)params->program[I].arg1, 
    //         (int)params->program[I].arg2, (int)params->program[I].arg3 );
    // }
    // for( int I = 0; I < params->n_reg; I++ ) {
    //     printf( "regs[%d]:: kind:%d, mem:%p, \n", I, params->registers[I].kind, params->registers[I].mem  );
    // }
    // printf( "params: %p, n_reg: %d, iter: %p\n", params, params->n_reg, iter );
    // for( int I = 0; I < params->n_reg; I++ ) {
    //     int ac = 0;
    //     if( params->registers[I].kind & (KIND_ARRAY | KIND_RETURN) ) {
    //         printf( "iterDataPtr[%d]:: %p, iterStrides[%d]:: %ld, sizePtr:: %ld \n", 
    //             I, iterDataPtr[ac], I, (void *)iterStrides[ac], *sizePtr );
    //         ac++;
    //     }
    // }
    // printf("END DEBUG\n");

    // First do all the blocks with a compile-time fixed size. This makes a 
    // big difference (30-50% on some tests).
    // TODO: this can be replaced in the generator with a fixed size in 
    // _bytes_ instead of _elements_

    task_size = *sizePtr;
    // Success, with auto-vectorization it doesn't need to be a fixed size, 
    // compared to unrolling loops. Looks like we can cut-down the number of 
    // includes which will shrink the machine code.
    while( task_size > 0 ) {
#define REDUCTION_INNER_LOOP            
#include "interp_body_GENERATED.cpp"
#undef REDUCTION_INNER_LOOP
        iterNext(iter);
        task_size = *sizePtr;   
    }

    return 0;
}