step.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.
 * ************************************************************************/


#ifndef KTEST_PATTERN_H__
#define KTEST_PATTERN_H__

#ifdef __APPLE__
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
#include <list>
#include <map>
#include <string>

#include <clblas-internal.h>
#include <blas_funcs.h>
#include <granulation.h>
#include <kernel_extra.h>
#include <solution_seq.h>
#include <mempat.h>
#include <list.h>
#include "var.h"

namespace clMath {

// This structure reflects CLBlasKargs structure, declared in clblas-internal.h
typedef struct StepKargs {
    // kernType
    // dtype
    // order
    // side
    // uplo
    // transA
    // transB
    // diag
    Variable *M;
    Variable *N;
    Variable *K;
    Variable *alpha;
    Variable *A;
    Variable *lda;
    Variable *B;
    Variable *ldb;
    Variable *beta;
    Variable *C;
    Variable *ldc;
    // addrBits
    Variable *offsetM;
    Variable *offsetN;
    Variable *offsetK;
    Variable *scimage0;
    Variable *scimage1;
    Variable *offA;
    Variable *offBX;
    Variable *offCY;
} Kargs;

typedef std::list<Variable*> VarList;
typedef std::list<ArrayVariableInterface*> ArrayVarList;
typedef std::map<unsigned int, const Variable*> KArgMap;

class Step {
private:
    CLBLASKernExtra kextra_;
    cl_platform_id platform_;

    VarList vars_;
    ArrayVarList arrays_;
    VarList buffers_;
    KArgMap kargMap_;

    std::string dumpMemoryPattern();
    std::string dumpSubdim(const SubproblemDim *subdim);
    std::string dumpPgran();
    std::string dumpKextra();

    cl_device_id device()                       { return step_.device.id; };
    void setKernelArg(unsigned int index, const Variable *var);

protected:
    SolutionStep step_;
    MemoryPattern* pattern_;
    std::string naiveCall_;
    std::string compareCall_;
    std::string postRandomCall_;
    std::string kernelName_;


    Variable* addVar(const std::string& name, const std::string& type,
        const std::string& defaultValue = "");
    Variable* addVar(const std::string& name, const std::string& type,
        size_t value);
    Variable* addVar(const std::string& name, const std::string& type,
        int value);
    Variable* addConst(const std::string& name, const std::string& type,
        const std::string& defaultValue);
    Variable* addConst(const std::string& name, const std::string& type,
        size_t value);
    Variable* addConst(const std::string& name, const std::string& type,
        int value);
    MatrixVariable* addMatrix(const std::string& name, const std::string& type,
        Variable *rows, Variable *columns, Variable *ld, Variable *off = NULL);
    VectorVariable* addVector(const std::string& name, const std::string& type,
        Variable *N, Variable *inc, Variable *off = NULL);
    Variable* addBuffer(BufferID bufID, const std::string& name,
        const std::string& type, cl_mem_flags flags,
        ArrayVariableInterface* hostPtr);

    void assignKargs(const Kargs& kargs);

    static std::string deviceVendor(cl_device_id device);

public:
    Step(BlasFunctionID funcID, cl_device_id device);
    Step(ListNode *node);
    virtual ~Step();

    const VarList& vars() const                 { return vars_; };
    const ArrayVarList& arrays() const          { return arrays_; };
    const VarList& buffers() const              { return buffers_; };

    virtual void fixLD() = 0;
    virtual void declareVars(Step *masterStep) = 0;
    Variable* getBuffer(BufferID bufID);

    void completeDecompositionSingle();
    void makeSolutionSequence(ListHead *seq, cl_platform_id platform);
    void freeSolutionSequence(ListHead *seq);
    std::string generate();
    std::string globalWorkSize();

    BlasFunctionID blasFunctionID() const       { return step_.funcID; };
    const CLBlasKargs& kargs() const            { return step_.args; };
    const PGranularity& pgran() const           { return step_.pgran; };
    const std::string& naiveCall() const        { return naiveCall_; };
    const std::string& compareCall() const      { return compareCall_; };
    const std::string& postRandomCall() const   { return postRandomCall_; };
    const std::string& kernelName() const       { return kernelName_; };
    const char* getBlasFunctionName();

    const std::map<unsigned int, const Variable*>& kargMap() const { return kargMap_; }
    void setKargs(const CLBlasKargs& kargs);
    void setDecomposition(const SubproblemDim *subdims);
    void setKernelName(std::string name);
    std::string matrixSize(MatrixVariable *var);
    std::string vectorSize(VectorVariable *vector);

    static std::string multiplierToString(DataType dtype, ArgMultiplier arg);
    static std::string dtypeToString(DataType dtype);
    static BlasFunctionID getStepNodeFuncID(ListNode *node);
};

}   // namespace clMath

#endif  // KTEST_PATTERN_H__