kerngen.h

/* ************************************************************************
 * Copyright 2013 Advanced Micro Devices, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ************************************************************************/


/*
 * Kernel generator related common definitions
 */

#ifndef KERNGEN_H_
#define KERNGEN_H_

#include <sys/types.h>
#include <errno.h>

#if defined (_MSC_VER)
#include <msvc.h>
#endif

#include <defbool.h>
#include <list.h>
#include <cltypes.h>
#include <mutex.h>
#include <granulation.h>
#include <trace_malloc.h>


#ifdef _MSC_VER
#define SPREFIX "I"
#else
#define SPREFIX "z"
#endif

#define SUBDIM_UNUSED (size_t)-1

enum {
    MAX_TABS = 16,
    MAX_STATEMENT_PRIORITY = 63,
    MAX_STATEMENT_LENGTH = 4096
};

enum {
    // maximum subproblem dimensions
    MAX_SUBDIMS = 3,
    // maximum code nesting
    MAX_NESTING = 10,
    KSTRING_MAXLEN = 256,
    // generated function name max len
    FUNC_NAME_MAXLEN = KSTRING_MAXLEN
};

typedef struct{
    SubproblemDim   subdims[MAX_SUBDIMS];
    PGranularity    pgran;
}DecompositionStruct;

struct KgenContext;
struct KgenGuard;
struct StatementBatch;


typedef enum CLMemFence {
    CLK_LOCAL_MEM_FENCE,
    CLK_GLOBAL_MEM_FENCE
} CLMemFence;

// TODO: deprecate
typedef enum UptrType {
    UPTR_GLOBAL,
    UPTR_LOCAL,
    UPTR_PRIVATE
} UptrType;

typedef struct Kstring {
    char buf[KSTRING_MAXLEN];
} Kstring;

typedef int
(*LoopUnrollGen)(struct KgenContext *ctx, void *priv);

typedef struct LoopCtl {
    const char *ocName;     
    union {
        const char *name;
        unsigned long val;
    } outBound;             
    bool obConst;           
    unsigned long inBound;  
} LoopCtl;

typedef struct LoopUnrollers {
    LoopUnrollGen preUnroll;
    LoopUnrollGen genSingleVec;
    LoopUnrollGen genSingle;
    LoopUnrollGen postUnroll;
    LoopUnrollGen getVecLen;
} LoopUnrollers;

static __inline void
emptyKstring(Kstring *kstr)
{
    kstr->buf[0] = '\0';
}

static __inline bool
isKstringEmpty(const Kstring *kstr)
{
    return (kstr->buf[0] == '\0');
}


struct KgenContext
*createKgenContext(char *srcBuf, size_t srcBufLen, bool fmt);

void
destroyKgenContext(struct KgenContext *ctx);

void
resetKgenContext(struct KgenContext *ctx);

int
kgenSyncFormatting(
    struct KgenContext *srcCtx,
    const struct KgenContext *dstCtx,
    int nrTabs);

int
kgenDeclareFunction(struct KgenContext *ctx, const char *decl);

int
kgenBeginFuncBody(struct KgenContext *ctx);

int
kgenEndFuncBody(struct KgenContext *ctx);

int
kgenGetLastFuncName(
    char *buf,
    size_t buflen,
    const struct KgenContext *ctx);

int
kgenBeginBranch(struct KgenContext *ctx, const char *stmt);

int
kgenEndBranch(struct KgenContext *ctx, const char *stmt);

int
kgenAddStmt(struct KgenContext *ctx, const char *stmt);

int
kgenPrintf(struct KgenContext *ctx, const char *fmt,...);

struct StatementBatch
*createStmtBatch(void);

int
kgenAddStmtToBatch(
    struct StatementBatch *batch,
    int priority,
    const char *stmt);

int
kgenBatchPrintf(
    struct StatementBatch *batch,
    int priority,
    const char *fmt,...);

int
flushStmtBatch(struct KgenContext *ctx, struct StatementBatch *batch);

void
destroyStmtBatch(struct StatementBatch *batch);

int
kgenAddBlankLine(struct KgenContext *ctx);

size_t
kgenSourceSize(struct KgenContext *ctx);


int
kgenAddBarrier(struct KgenContext *ctx, CLMemFence fence);

int
kgenAddMemFence(struct KgenContext *ctx, CLMemFence fence);

int
kgenDeclareLocalID(
    struct KgenContext *ctx,
    const char *lidName,
    const PGranularity *pgran);

int
kgenDeclareGroupID(
    struct KgenContext *ctx,
    const char *gidName,
    const PGranularity *pgran);

/*
 * TODO: deprecate when casting is eliminated
 *
 * declare unified pointers
 *
 * @withDouble: double based types pointers area needed
 *
 * On success returns 0, on buffer overflowing returns -EOVERFLOW
 */
int
kgenDeclareUptrs(struct KgenContext *ctx, bool withDouble);


int
kgenLoopUnroll(
    struct KgenContext *ctx,
    LoopCtl *loopCtl,
    DataType dtype,
    const LoopUnrollers *unrollers,
    void *priv);

struct KgenGuard
*createKgenGuard(
    struct KgenContext *ctx,
    int (*genCallback)(struct KgenContext *ctx, const void *pattern),
    size_t patSize);

void
reinitKgenGuard(
    struct KgenGuard *guard,
    struct KgenContext *ctx,
    int (*genCallback)(struct KgenContext *ctx, const void *pattern),
    size_t patSize);

int
findGenerateFunction(
    struct KgenGuard *guard,
    const void *pattern,
    char *name,
    size_t nameLen);

void
destroyKgenGuard(struct KgenGuard *guard);


void
kstrcpy(Kstring *kstr, const char *str);

void
ksprintf(Kstring *kstr, const char *fmt,...);

void
kstrcatf(Kstring *kstr, const char *fmt,...);

// unified pointer type name
const char
*uptrTypeName(UptrType type);

char
dtypeToPrefix(DataType type);

const char
*dtypeBuiltinType(DataType dtype);

const char
*dtypeUPtrField(DataType dtype);

const char
*strOne(DataType dtype);

void
getVectorTypeName(
    DataType dtype,
    unsigned int vecLen,
    const char **typeName,
    const char **typePtrName);

#endif /* KERNGEN_H_ */