clm4rm.h

Go to the documentation of this file.

#ifndef CLM4RM_H
#define CLM4RM_H

// Includes the normal OpenCL C header
#if defined(__APPLE__) || defined(__MACOSX)
# include <OpenCL/opencl.h>
#else
# include <CL/opencl.h>
#endif

//  host data structures from M4RI
//  row-major 64-bit unsigned integers
#if defined(__cplusplus) && !defined(_MSC_VER)
extern "C" {
#endif
#include <m4ri/mzd.h>
#if defined(__cplusplus) && !defined(_MSC_VER)
}
#endif

#define clm4rm_radix 32

#define IMAGE2D 0

#define BUFFERED 1

#define MAX_TILE_M 6

typedef uint32_t gpuword;
typedef size_t size2_t[2];

#define CEILDIV(x,y)    (((x)+(y)-1)/(y))

#define FLOOR(x,y)      ((y)*((x)/(y)))

#define CEILCOLS(i)     CEILDIV(i,clm4rm_radix)

#define POW2(i)         (((gpuword)1)<<(i))

struct clmatrix_t {
    rci_t nrows;        
    rci_t padded_rows;  
    rci_t ncols;        
    rci_t padded_cols;  
    rci_t width;        
    /*
     * Offset in words between rows.
     *
     * rowstride = ((width & 1) == 0) ? width : width + 1;
     * where width is the width of the underlying non-windowed matrix.
     * @deprecated not used anymore
     */
    //wi_t rowstride;

    gpuword* local_data;
    cl_mem data; 

    //  TODO indicators for Triangular matrices ?
};
typedef struct clmatrix_t clmatrix_t;
#define DATA_BYTES(m)       ( (m)->padded_rows * (m)->width * sizeof(gpuword) )

int padded_rows(int nrows, int padding);

gpuword*    copy_matrix_data(gpuword* dest, const mzd_t* src, int padded_rows);

void        copy_back_matrix_data(mzd_t* dest, const gpuword* src, int padded_rows);

extern cl_int clm4rm_error;

extern size_t max_group_size;
extern size_t max_items[3];

extern size_t shared_mem_bytes;
extern size_t shared_mem_words;
extern size_t heap_size, allocated_size;
extern size_t max_object_size;

cl_int clm4rm_setup(const char* cl_kernel_directory,
                    cl_context ctx, cl_device_id device);
void clm4rm_tear_down(cl_context ctx, cl_device_id device);

#define MAX_EVENTS 6

struct clm4rm_event_list {
    cl_uint count;  
    cl_event events[MAX_EVENTS];    
};
typedef struct clm4rm_event_list clm4rm_event_list;
void init_events(clm4rm_event_list* list);
void release_events(clm4rm_event_list* list);
void merge_events(clm4rm_event_list* a, clm4rm_event_list* b);

struct clm4rm_conditions {
    clm4rm_event_list event_lists [2];
    clm4rm_event_list *pre;
    clm4rm_event_list *post;
};
typedef struct clm4rm_conditions clm4rm_conditions;
void init_conditions(clm4rm_conditions* cond);
void release_conditions(clm4rm_conditions* cond);
void join_conditions(clm4rm_conditions* cond);
void merge_conditions(clm4rm_conditions* a, clm4rm_conditions* b);

cl_uint pre_count(clm4rm_conditions* cond);
cl_event* pre_events(clm4rm_conditions* cond);
cl_event* push_event(clm4rm_conditions* cond);
cl_event* pushed_event(clm4rm_conditions* cond);

clmatrix_t* clm4rm_create(rci_t rows, rci_t cols, int rowpadding,
                    int read_only, cl_context ctx);
clmatrix_t* clm4rm_copy(const mzd_t* host_matrix, int rowpadding,
                    int read_only, cl_context ctx);

//? clmatrix_t* clm4rm_copy(clmatrix_t* gpu_matrix);

void clm4rm_zero_fill(clmatrix_t* gpu_matrix,
                    cl_command_queue  queue, clm4rm_conditions* cond);

void clm4rm_write(clmatrix_t* gpu_matrix, const mzd_t* host_matrix,
                    cl_command_queue queue, clm4rm_conditions* cond);



mzd_t* clm4rm_read(mzd_t* host_matrix, clmatrix_t* gpu_matrix, 
                    cl_command_queue queue, clm4rm_conditions* cond);

void clm4rm_free(clmatrix_t* gpu_matrix);

void clm4rm_mul(clmatrix_t* C, clmatrix_t* A, clmatrix_t* B,
                        cl_command_queue queue, clm4rm_conditions* cond);
void clcubic_mul(clmatrix_t* C, clmatrix_t* A, clmatrix_t* B,
                        size2_t max_tile,
                        cl_command_queue queue, clm4rm_conditions* cond);

void clutri_mul(clmatrix_t* C, clmatrix_t* A, clmatrix_t* B,
                        size2_t max_tile,
                        cl_command_queue queue, clm4rm_conditions* cond);

/*
 * @brief C := C + A*B
 * @deprecated not used anymore
 */
/*cl_event clm4rm_addmul(clmatrix_t* C, clmatrix_t* A, clmatrix_t* B,
                       cl_command_queue queue);*/

void clm4rm_stack(clmatrix_t* C, clmatrix_t* A, clmatrix_t* B,
                      cl_command_queue queue, clm4rm_conditions* cond);

void clm4rm_concat(clmatrix_t* C, clmatrix_t* A, clmatrix_t* B,
                       cl_command_queue queue, clm4rm_conditions* cond);

void clm4rm_or(clmatrix_t* C, clmatrix_t* A, clmatrix_t* B,
                   cl_command_queue queue, clm4rm_conditions* cond);

void clm4rm_and(clmatrix_t* C, clmatrix_t* A, clmatrix_t* B,
                    cl_command_queue queue, clm4rm_conditions* cond);
//  TODO
//cl_event clutri_and(clmatrix_t* C, clmatrix_t* A, clmatrix_t* B,
//                   cl_command_queue queue, int wait_for_it);


//  @returns
cl_mem clm4rm_query_diagonal(clmatrix_t* M,
                            cl_context ctx, cl_command_queue queue,
                            clm4rm_conditions* cond);
int clm4rm_query_result(cl_mem result_buffer,
                        cl_command_queue queue,
                        clm4rm_conditions* cond);

/* @} */


#endif //CLM4RM_H