cavis/libnd4j/blas/NativeOps.h

/*******************************************************************************
 * Copyright (c) 2015-2018 Skymind, Inc.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://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.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by agibsonccc on 2/21/16.
//

#ifndef NATIVEOPERATIONS_NATIVEOPS_H
#define NATIVEOPERATIONS_NATIVEOPS_H

/*
#ifndef thread_local
# if __STDC_VERSION__ >= 201112 && !defined __STDC_NO_THREADS__
#  define thread_local _Thread_local
# elif defined _WIN32 && ( \
       defined _MSC_VER || \
       defined __ICL || \
       defined __DMC__ || \
       defined __BORLANDC__ )
#  define thread_local __declspec(thread)
// note that ICC (linux) and Clang are covered by __GNUC__ 
# elif defined __GNUC__ || \
       defined __SUNPRO_C || \
       defined __xlC__
#  define thread_local __thread
# else
#  error "Cannot define thread_local"
# endif
#endif
*/

#include <pointercast.h>
#include <types/float16.h>
#include <cnpy.h>

//DO NOT REMOVE: THIS IS AN EDITOR SEMANTICS THING FOR CLION
//IT DEFINES THE EXPORT MACRO FOR THE EDITOR AND THEN
//RE ADDS THE DEFINITION VIA dll.h
#ifdef  _WIN32
#define ND4J_EXPORT __declspec(dllexport)
#else
#define ND4J_EXPORT
#endif
#include <dll.h>
#include <helpers/BlasHelper.h>

/*
int tad_threshold = 1;
int element_threshold = 32;

bool debug = false;
bool verbose = false;
*/

#include <array/ShapeList.h>
#include <array/ConstantDescriptor.h>
#include <helpers/ConstantShapeHelper.h>
#include <array/ConstantDataBuffer.h>
#include <helpers/ConstantHelper.h>
#include <array/TadPack.h>
#include <graph/VariablesSet.h>
#include <graph/GraphState.h>
#include <graph/execution/LogicExecutor.h>
#include <graph/ResultWrapper.h>
#include <DebugInfo.h>

class ND4J_EXPORT NativeOps {

public:
    NativeOps();

    /**
     *
     * @param p
     * @param len
     */
    void tryPointer(Nd4jPointer extra, Nd4jPointer p, int len);

    /**
     *
     * @param num
     */
    void setElementThreshold(int num);

    /**
     *
     * @param num
     */
    void setTADThreshold(int num);

    /**
       *
       * @param opNum
       * @param x
       * @param xShapeInfo
       * @param extraParams
       */
    void execIndexReduceScalar(Nd4jPointer *extraPointers,
                                         int opNum,
                                         void *hX, Nd4jLong *hXShapeInfo,
                                         void *dX, Nd4jLong *dXShapeInfo,
                                         void *extraParams,
                                         void *hZ, Nd4jLong *hZShapeInfo,
                                         void *dZ, Nd4jLong *dZShapeInfo);

    /**
     *
     * @param opNum
     * @param x
     * @param xShapeInfo
     * @param extraParams
     * @param result
     * @param resultShapeInfoBuffer
     * @param dimension
     * @param dimensionLength
     */
    void   execIndexReduce(Nd4jPointer *extraPointers,
            int opNum,
            void *hX, Nd4jLong *hXShapeInfo,
            void *dX, Nd4jLong *dXShapeInfo,
            void *extraParams,
            void *hZ, Nd4jLong *hZShapeInfo,
            void *dZ, Nd4jLong *dZShapeInfo,
            void *hDimension, Nd4jLong *hDimensionShape,
            void *dDimension, Nd4jLong *dDimensionShape);

    /**
     *
     * @param opNum
     * @param x
     * @param xShapeInfo
     * @param y
     * @param yShapeInfo
     * @param result
     * @param resultShapeInfo
     * @param dimension
     * @param dimensionLength
     */
    void   execBroadcast(
            Nd4jPointer *extraPointers,
            int opNum,
            void *hX, Nd4jLong *hXShapeInfo,
            void *dX, Nd4jLong *dXShapeInfo,
            void *hY, Nd4jLong *hYShapeInfo,
            void *dY, Nd4jLong *dYShapeInfo,
            void *hZ, Nd4jLong *hZShapeInfo,
            void *dZ, Nd4jLong *dZShapeInfo,
            void *hDimension, Nd4jLong *hDimensionShape,
            void *dDimension, Nd4jLong *dDimensionShape);


    void   execBroadcastBool(
            Nd4jPointer *extraPointers,
            int opNum,
            void *hX, Nd4jLong *hXShapeInfo,
            void *dX, Nd4jLong *dXShapeInfo,
            void *hY, Nd4jLong *hYShapeInfo,
            void *dY, Nd4jLong *dYShapeInfo,
            void *hZ, Nd4jLong *hZShapeInfo,
            void *dZ, Nd4jLong *dZShapeInfo,
            void *hDimension, Nd4jLong *hDimensionShape,
            void *dDimension, Nd4jLong *dDimensionShape);

    /**
     *
     * @param opNum
     * @param dx
     * @param xShapeInfo
     * @param y
     * @param yShapeInfo
     * @param result
     * @param resultShapeInfo
     * @param extraParams
     * @param n
     */
    void execPairwiseTransform(
            Nd4jPointer *extraPointers,
            int opNum,
            void *hX, Nd4jLong *hXShapeInfo,
            void *dX, Nd4jLong *dXShapeInfo,
            void *hY, Nd4jLong *hYShapeInfo,
            void *dY, Nd4jLong *dYShapeInfo,
            void *hZ, Nd4jLong *hZShapeInfo,
            void *dZ, Nd4jLong *dZShapeInfo,
            void *extraParams);

    void execPairwiseTransformBool(
            Nd4jPointer *extraPointers,
            int opNum,
            void *hX, Nd4jLong *hXShapeInfo,
            void *dX, Nd4jLong *dXShapeInfo,
            void *hY, Nd4jLong *hYShapeInfo,
            void *dY, Nd4jLong *dYShapeInfo,
            void *hZ, Nd4jLong *hZShapeInfo,
            void *dZ, Nd4jLong *dZShapeInfo,
            void *extraParams);

    /**
     *
     * @param opNum
     * @param x
     * @param xShapeInfo
     * @param extraParams
     * @param result
     * @param resultShapeInfo
     */
    void  execReduceFloat(Nd4jPointer *extraPointers,
                            int opNum,
                            void *hX, Nd4jLong *hXShapeInfo,
                            void *dX, Nd4jLong *dXShapeInfo,
                            void *extraParams,
                            void *hZ, Nd4jLong *hZShapeInfo,
                            void *dZ, Nd4jLong *dZShapeInfo);

    void  execReduceSame(Nd4jPointer *extraPointers,
                          int opNum,
                          void *hX, Nd4jLong *hXShapeInfo,
                          void *dX, Nd4jLong *dXShapeInfo,
                          void *extraParams,
                          void *hZ, Nd4jLong *hZShapeInfo,
                          void *dZ, Nd4jLong *dZShapeInfo);

    void  execReduceBool(Nd4jPointer *extraPointers,
                          int opNum,
                          void *hX, Nd4jLong *hXShapeInfo,
                          void *dX, Nd4jLong *dXShapeInfo,
                          void *extraParams,
                          void *hZ, Nd4jLong *hZShapeInfo,
                          void *dZ, Nd4jLong *dZShapeInfo);


    void  execReduceLong(Nd4jPointer *extraPointers,
                          int opNum,
                          void *hX, Nd4jLong *hXShapeInfo,
                          void *dX, Nd4jLong *dXShapeInfo,
                          void *extraParams,
                          void *hZ, Nd4jLong *hZShapeInfo,
                          void *dZ, Nd4jLong *dZShapeInfo);

    /**
     *
     * @param opNum
     * @param x
     * @param xShapeInfo
     * @param extraParams
     * @param result
     * @param resultShapeInfo
     */
    void   execReduceFloat(Nd4jPointer *extraPointers,
                            int opNum,
                            void *hX, Nd4jLong *hXShapeInfo,
                            void *dX, Nd4jLong *dXShapeInfo,
                            void *extraParams,
                            void *hZ, Nd4jLong *hZShapeInfo,
                            void *dZ, Nd4jLong *dZShapeInfo,
                           void *hDimension, Nd4jLong *hDimensionShape,
                           void *dDimension, Nd4jLong *dDimensionShape);


    void   execReduceSame(Nd4jPointer *extraPointers,
                      int opNum,
                      void *hX, Nd4jLong *hXShapeInfo,
                      void *dX, Nd4jLong *dXShapeInfo,
                      void *extraParams,
                      void *hZ, Nd4jLong *hZShapeInfo,
                      void *dZ, Nd4jLong *dZShapeInfo,
                          void *hDimension, Nd4jLong *hDimensionShape,
                          void *dDimension, Nd4jLong *dDimensionShape);


    void   execReduceBool(Nd4jPointer *extraPointers,
                      int opNum,
                      void *hX, Nd4jLong *hXShapeInfo,
                      void *dX, Nd4jLong *dXShapeInfo,
                      void *extraParams,
                      void *hZ, Nd4jLong *hZShapeInfo,
                      void *dZ, Nd4jLong *dZShapeInfo,
                          void *hDimension, Nd4jLong *hDimensionShape,
                          void *dDimension, Nd4jLong *dDimensionShape);


    void   execReduceLong(Nd4jPointer *extraPointers,
                      int opNum,
                      void *hX, Nd4jLong *hXShapeInfo,
                      void *dX, Nd4jLong *dXShapeInfo,
                      void *extraParams,
                      void *hZ, Nd4jLong *hZShapeInfo,
                      void *dZ, Nd4jLong *dZShapeInfo,
                          void *hDimension, Nd4jLong *hDimensionShape,
                          void *dDimension, Nd4jLong *dDimensionShape);

    /**
     *
     * @param opNum
     * @param x
     * @param xShapeInfo
     * @param extraParamsVals
     * @param y
     * @param yShapeInfo
     * @param result
     * @param resultShapeInfo
     */
    void  execReduce3(Nd4jPointer *extraPointers,
                            int opNum,
                            void *hX, Nd4jLong *hXShapeInfo,
                            void *dX, Nd4jLong *dXShapeInfo,
                            void *extraParamsVals,
                            void *hY, Nd4jLong *hYShapeInfo,
                            void *dY, Nd4jLong *dYShapeInfo,
                            void *hZ, Nd4jLong *hZShapeInfo,
                            void *dZ, Nd4jLong *dZShapeInfo);

    /**
     *
     * @param opNum
     * @param x
     * @param xShapeInfo
     * @param extraParamsVals
     * @param y
     * @param yShapeInfo
     */
    void execReduce3Scalar(Nd4jPointer *extraPointers,
                            int opNum,
                            void *hX, Nd4jLong *hXShapeInfo,
                            void *dX, Nd4jLong *dXShapeInfo,
                            void *extraParamsVals,
                            void *hY, Nd4jLong *hYShapeInfo,
                            void *dY, Nd4jLong *dYShapeInfo,
                            void *hZ, Nd4jLong *hZShapeInfo,
                            void *dZ, Nd4jLong *dZShapeInfo);
    /**
     *
     * @param opNum
     * @param x
     * @param xShapeInfo
     * @param extraParamsVals
     * @param y
     * @param yShapeInfo
     * @param result
     * @param resultShapeInfoBuffer
     * @param dimension
     * @param dimensionLength
     */
    void execReduce3(Nd4jPointer *extraPointers,
                            int opNum,
                            void *hX, Nd4jLong *hXShapeInfo,
                            void *dX, Nd4jLong *dXShapeInfo,
                            void *extraParamsVals,
                            void *hY, Nd4jLong *hYShapeInfo,
                            void *dY, Nd4jLong *dYShapeInfo,
                            void *hZ, Nd4jLong *hZShapeInfo,
                            void *dZ, Nd4jLong *dZShapeInfo,
                            void *hDimension, Nd4jLong *hDimensionShape,
                            void *dDimension, Nd4jLong *dDimensionShape,
                            Nd4jLong *tadOnlyShapeInfo, Nd4jLong *tadOffsets,
                            Nd4jLong *yTadOnlyShapeInfo, Nd4jLong *yTadOffsets);


    void execReduce3All(Nd4jPointer *extraPointers,
                            int opNum,
                            void *hX, Nd4jLong *hXShapeInfo,
                            void *dX, Nd4jLong *dXShapeInfo,
                            void *extraParamsVals,
                            void *hY, Nd4jLong *hYShapeInfo,
                            void *dY, Nd4jLong *dYShapeInfo,
                            void *hZ, Nd4jLong *hZShapeInfo,
                            void *dZ, Nd4jLong *dZShapeInfo,
                            void *hDimension, Nd4jLong *hDimensionShape,
                            void *dDimension, Nd4jLong *dDimensionShape,
                            Nd4jLong *xTadShapeInfo, Nd4jLong *xOffsets,
                            Nd4jLong *yTadShapeInfo, Nd4jLong *yOffsets);

    /**
     *
     * @param opNum
     * @param x
     * @param xShapeInfo
     * @param result
     * @param resultShapeInfo
     * @param scalar
     * @param extraParams
     * @param n
     */
    void execScalar(Nd4jPointer *extraPointers,
                          int opNum,
                          void *hX, Nd4jLong *hXShapeInfo,
                          void *dX, Nd4jLong *dXShapeInfo,
                          void *hZ, Nd4jLong *hZShapeInfo,
                          void *dZ, Nd4jLong *dZShapeInfo,
                          void *hScalar, Nd4jLong *hSscalarShapeInfo,
                          void *dScalar, Nd4jLong *dSscalarShapeInfo,
                          void *extraParams);

    void execScalarBool(Nd4jPointer *extraPointers,
                    int opNum,
                    void *hX, Nd4jLong *hXShapeInfo,
                    void *dX, Nd4jLong *dXShapeInfo,
                    void *hZ, Nd4jLong *hZShapeInfo,
                    void *dZ, Nd4jLong *dZShapeInfo,
                    void *hScalar, Nd4jLong *hSscalarShapeInfo,
                    void *dScalar, Nd4jLong *dSscalarShapeInfo,
                    void *extraParams);

    /**
     *
     * @param opNum
     * @param x
     * @param xShapeInfo
     * @param extraParams
     */
    void execSummaryStatsScalar(Nd4jPointer *extraPointers,
                                          int opNum,
                                          void *hX, Nd4jLong *hXShapeInfo,
                                          void *dX, Nd4jLong *dXShapeInfo,
                                          void *extraParams,
                                          void *hZ, Nd4jLong *hZShapeInfo,
                                          void *dZ, Nd4jLong *dZShapeInfo,
                                          bool biasCorrected);
    /**
     *
     * @param opNum
     * @param x
     * @param xShapeInfo
     * @param extraParams
     * @param result
     * @param resultShapeInfo
     */
    void execSummaryStats(Nd4jPointer *extraPointers,
                                  int opNum,
                                  void *hX, Nd4jLong *hXShapeInfo,
                                  void *dX, Nd4jLong *dXShapeInfo,
                                  void *extraParams,
                                  void *hZ, Nd4jLong *hZShapeInfo,
                                  void *dZ, Nd4jLong *dZShapeInfo,
                                  bool biasCorrected);
    /**
     *
     * @param opNum
     * @param x
     * @param xShapeInfo
     * @param extraParams
     * @param result
     * @param resultShapeInfoBuffer
     * @param dimension
     * @param dimensionLength
     */
    void execSummaryStats(Nd4jPointer *extraPointers,
                                  int opNum,
                                  void *hX, Nd4jLong *hXShapeInfo,
                                  void *dX, Nd4jLong *dXShapeInfo,
                                  void *extraParams,
                                  void *hZ, Nd4jLong *hZShapeInfo,
                                  void *dZ, Nd4jLong *dZShapeInfo,
                                  void *hDimension, Nd4jLong *hDimensionShape,
                                  void *dDimension, Nd4jLong *dDimensionShape,
                                  bool biasCorrected,
                                  Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets);

    /**
     *
     * @param opNum
     * @param dx
     * @param xShapeInfo
     * @param result
     * @param resultShapeInfo
     * @param extraParams
     * @param n
     */
    void execTransformFloat(Nd4jPointer *extraPointers,
                              int opNum,
                              void *hX, Nd4jLong *hXShapeInfo,
                              void *dX, Nd4jLong *dXShapeInfo,
                              void *hZ, Nd4jLong *hZShapeInfo,
                              void *dZ, Nd4jLong *dZShapeInfo,
                              void *extraParams);

    void execTransformSame(Nd4jPointer *extraPointers,
                      int opNum,
                      void *hX, Nd4jLong *hXShapeInfo,
                      void *dX, Nd4jLong *dXShapeInfo,
                      void *hZ, Nd4jLong *hZShapeInfo,
                      void *dZ, Nd4jLong *dZShapeInfo,
                      void *extraParams);

    void execTransformBool(Nd4jPointer *extraPointers,
                      int opNum,
                      void *hX, Nd4jLong *hXShapeInfo,
                      void *dX, Nd4jLong *dXShapeInfo,
                      void *hZ, Nd4jLong *hZShapeInfo,
                      void *dZ, Nd4jLong *dZShapeInfo,
                      void *extraParams);

    void execTransformAny(Nd4jPointer *extraPointers,
                           int opNum,
                           void *hX, Nd4jLong *hXShapeInfo,
                           void *dX, Nd4jLong *dXShapeInfo,
                           void *hZ, Nd4jLong *hZShapeInfo,
                           void *dZ, Nd4jLong *dZShapeInfo,
                           void *extraParams);

    void execTransformStrict(Nd4jPointer *extraPointers,
                          int opNum,
                          void *hX, Nd4jLong *hXShapeInfo,
                          void *dX, Nd4jLong *dXShapeInfo,
                          void *hZ, Nd4jLong *hZShapeInfo,
                          void *dZ, Nd4jLong *dZShapeInfo,
                          void *extraParams);

    /**
     *
     * @param extraPointers
     * @param opNum
     * @param x
     * @param xShapeInfo
     * @param z
     * @param zShapeInfo
     * @param scalars
     * @param extraParams
     * @param dimension
     * @param dimensionLength
     */
    void execScalar(Nd4jPointer *extraPointers,
                          int opNum,
                          void *hX, Nd4jLong *hXShapeInfo,
                          void *dX, Nd4jLong *dXShapeInfo,
                          void *hZ, Nd4jLong *hZShapeInfo,
                          void *dZ, Nd4jLong *dZShapeInfo,
                          void *hScalars, Nd4jLong *hScalarShapeInfo,
                          void *dScalars, Nd4jLong *dScalarShapeInfo,
                          void *extraParams,
                          void *hDimension, Nd4jLong *hDimensionShape,
                          void *dDimension, Nd4jLong *dDimensionShape,
                          Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets,
                          Nd4jLong *tadShapeInfoZ, Nd4jLong *tadOffsetsZ);

    void execScalarBool(Nd4jPointer *extraPointers,
                    int opNum,
                    void *hX, Nd4jLong *hXShapeInfo,
                    void *dX, Nd4jLong *dXShapeInfo,
                    void *hZ, Nd4jLong *hZShapeInfo,
                    void *dZ, Nd4jLong *dZShapeInfo,
                    void *hScalars, Nd4jLong *hScalarShapeInfo,
                    void *dScalars, Nd4jLong *dScalarShapeInfo,
                    void *extraParams,
                    void *hDimension, Nd4jLong *hDimensionShape,
                    void *dDimension, Nd4jLong *dDimensionShape,
                    Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets,
                    Nd4jLong *tadShapeInfoZ, Nd4jLong *tadOffsetsZ);


/**
* Append an input array
* to the end of a flat array
* in a particular order
* @param offset the offset of the array to start at
* @param order the order
* @param result the result array
* @param resultShapeInfo the shape info for te array
* @param input the input for the array
* @param inputShapeInfo the shape information for that array
*/
    void flatten(
            Nd4jPointer *extraPointers,
            int offset,
            char order,
            void *result, Nd4jLong *resultShapeInfo,
            void *dresult, Nd4jLong *dresultShapeInfo,
            void *input, Nd4jLong *inputShapeInfo,
            void *dinput, Nd4jLong *dinputShapeInfo);

    void concat(
            Nd4jPointer *extraPointers,
            int dimension,
            int numArrays,
            Nd4jPointer *data, Nd4jPointer *inputShapeInfo,
            Nd4jPointer *ddata, Nd4jPointer *dinputShapeInfo,
            void *result, Nd4jLong *resultShapeInfo,
            void *dresult, Nd4jLong *dresultShapeInfo,
            Nd4jPointer *tadPointers, Nd4jPointer *offsetPointers);


    void specialConcat (
            Nd4jPointer *extraPointers,
            int dimension,
            int numArrays,
            Nd4jPointer *data,
            Nd4jPointer *inputShapeInfo,
            void *result,
            Nd4jLong *resultShapeInfo,
            Nd4jPointer *tadPointers,
            Nd4jPointer *offsetPointers);

    /**
     * This method implementation exists only for cuda.
     * The other backends should have dummy method for JNI compatibility reasons.
     */
    void initializeDevicesAndFunctions();

    void initializeFunctions(Nd4jPointer *functions);

    /**
     * This method acquires memory chunk of requested size on host side
     *
     * @param pointer pointer that'll be used for allocation
     * @param memorySize memory size, in bytes
     * @param flags optional parameter
     */
    Nd4jPointer mallocHost(Nd4jLong memorySize, int flags);

    /**
     * This method acquires memory chunk of requested size on specified device
     *
     * @param pointer pointer that'll be used for allocation
     * @param memorySize memory size, in bytes
     * @param ptrToDeviceId pointer to deviceId. For cuda that's just and int, for OpenCL that's pointer to device_id, etc
     * @param flags optional parameter
     */
    Nd4jPointer mallocDevice(Nd4jLong memorySize, int deviceId, int flags);

    /**
     * This method releases previously allocated host memory space
     *
     * @param pointer pointer that'll be freed
     */
    int freeHost(Nd4jPointer pointer);

    /**
     * This method releases previously allocated memory space on device
     *
     * @param pointer pointer that'll be freed
     * @param ptrToDeviceId pointer to deviceId.
     */
    int freeDevice(Nd4jPointer pointer, int deviceId);

    /**
     *
     * @return
     */
    int ompGetMaxThreads();

    /**
     *
     * @return
     */
    int ompGetNumThreads();

    /**
     *
     * @param threads
     */
    void setOmpNumThreads(int threads);

    /**
     *
     * @param threads
     */
    void setOmpMinThreads(int threads);




    /**
     *
     * @return
     */
    Nd4jPointer createContext();

    /**
     *
     * @return
     */
    Nd4jPointer createStream();

    /**
     *
     * @return
     */
    Nd4jPointer createEvent();

    /**
     *
     * @param event
     * @param stream
     * @return
     */
    int registerEvent(Nd4jPointer event, Nd4jPointer stream);

    /**
     *
     * @param event
     * @return
     */
    int destroyEvent(Nd4jPointer event);

    /**
     *
     * @param ptrToDeviceId
     * @return
     */
    int setDevice(int deviceId);

    /**
     *
     * @return
     */
    int getDevice();

    /**
     *
     * @param stream
     * @return
     */
    int streamSynchronize(Nd4jPointer stream);

    /**
     *
     * @param event
     * @return
     */
    int eventSynchronize(Nd4jPointer event);

    /**
     *
     * @param ptrToDeviceId
     * @return
     */
    Nd4jLong getDeviceFreeMemory(int deviceId);

    /**
     * Returns amount of free memory for current device
     * @return
     */
    Nd4jLong getDeviceFreeMemory();

    /**
     *
     * @param ptrToDeviceId
     * @return
     */
    Nd4jLong getDeviceTotalMemory(int deviceId);

    /**
     *
     * @param ptrToDeviceId
     * @return
     */
    int getDeviceMajor(int deviceId);

    /**
     * This method returns amount of cached memory
     * @param deviceId
     * @return
     */
    Nd4jLong getCachedMemory(int deviceId);

    /**
     *
     * @param ptrToDeviceId
     * @return
     */
    int getDeviceMinor(int deviceId);

    /**
     *
     * @param ptrToDeviceId
     * @return
     */
    const char * getDeviceName(int deviceId);

    /**
     *
     * @param dst
     * @param src
     * @param size
     * @param flags
     * @param reserved
     * @return
     */
    int memcpy(Nd4jPointer dst,
               Nd4jPointer src,
               Nd4jLong size,
               int flags,
               Nd4jPointer reserved);

    /**
     *
     * @param dst
     * @param src
     * @param size
     * @param flags
     * @param reserved
     * @return
     */
    int memcpyAsync(Nd4jPointer dst,
                    Nd4jPointer src,
                    Nd4jLong size,
                    int flags,
                    Nd4jPointer reserved);

    /**
     *
     * @param dst
     * @param value
     * @param size
     * @param flags
     * @param reserved
     * @return
     */
    int memset(Nd4jPointer dst,
               int value,
               Nd4jLong size,
               int flags,
               Nd4jPointer reserved);

    /**
     *
     * @param dst
     * @param value
     * @param size
     * @param flags
     * @param reserved
     * @return
     */
    int memsetAsync(Nd4jPointer dst,
                    int value,
                    Nd4jLong size,
                    int flags,
                    Nd4jPointer reserved);

    /**
     *
     * @param dst
     * @param src
     * @param size
     * @param flags
     * @param reserved
     * @return
     */
    int memcpyConstantAsync(Nd4jLong dst,
                            Nd4jPointer src,
                            Nd4jLong size,
                            int flags,
                            Nd4jPointer reserved);

    /**
     *
     * @return
     */
    Nd4jPointer getConstantSpace();

    /**
     *
     * @return
     */
    int getAvailableDevices();

    /**
     *
     * @param reallyEnable
     */
    void enableDebugMode(bool reallyEnable);

    /**
     *
     * @param reallyEnable
     */
    void enableVerboseMode(bool reallyEnable);

    /**
     *
     * @param gridSize
     */
    void setGridLimit(int gridSize);

    /**
     *
     * @param xShapeInfo
     * @param dimension
     * @param dimensionLength
     * @param targetBuffer
     * @param offsetsBuffer
     */
    nd4j::TadPack* tadOnlyShapeInfo(Nd4jLong *xShapeInfo,
                          int *dimension,
                          int dimensionLength);

    /*
     * PullRow special op
     */

    /**
     *
     * @param extraPointers
     * @param x
     * @param xShapeInfo
     * @param z
     * @param zShapeInfo
     * @param n
     * @param indexes
     * @param tadShapeInfo
     * @param tadOffsets
     * @param zTadShapeInfo
     * @param zTadOffsets
     */
    void pullRows(Nd4jPointer *extraPointers,
                        void *x, Nd4jLong *xShapeInfo,
                        void *dx, Nd4jLong *dxShapeInfo,
                        void *z, Nd4jLong *zShapeInfo,
                        void *dz, Nd4jLong *dzShapeInfo,
                        Nd4jLong n,
                        Nd4jLong *indexes,
                        Nd4jLong *tadShapeInfo,
                        Nd4jLong *tadOffsets,
                        Nd4jLong *zTadShapeInfo,
                        Nd4jLong *zTadOffsets);

    /**
     *
     * @param extras
     * @param dx
     * @param dz
     * @param n
     * @param length
     * @param propagate
     */
    void average(Nd4jPointer *extras,
                       Nd4jPointer *x, Nd4jLong *xShapeInfo,
                       Nd4jPointer *dx, Nd4jLong *dxShapeInfo,
                       void *z, Nd4jLong *zShapeInfo,
                       void *dz, Nd4jLong *dzShapeInfo,
                       int n,
                       Nd4jLong length,
                       bool propagate);


    void accumulate(Nd4jPointer *extras,
                       Nd4jPointer *x, Nd4jLong *xShapeInfo,
                       Nd4jPointer *dx, Nd4jLong *dxShapeInfo,
                       void *z, Nd4jLong *zShapeInfo,
                       void *dz, Nd4jLong *dzShapeInfo,
                       int n,
                       Nd4jLong length);


    /**
     * P2P enabler
     */
    /**
     *
     * @param enable
     */
    void enableP2P(bool enable);

    /**
     *
     */
    void checkP2P();

    /**
     *
     * @return
     */
    bool isP2PAvailable();

    /**
     * Shuffle methods
     */

    /**
     *
     * @param extras
     * @param dx
     * @param xShapeInfo
     * @param dz
     * @param zShapeInfo
     * @param N
     * @param shuffleMap
     * @param tadShapeInfo
     * @param tadOffsets
     */
    void shuffle(Nd4jPointer *extras,
                       Nd4jPointer *x, Nd4jPointer *xShapeInfo,
                       Nd4jPointer *dx, Nd4jPointer *dxShapeInfo,
                       Nd4jPointer *z, Nd4jPointer *zShapeInfo,
                       Nd4jPointer *dz, Nd4jPointer *dzShapeInfo,
                       int N,
                       int *shuffleMap,
                       Nd4jPointer *tadShapeInfo,
                       Nd4jPointer *tadOffsets);


    /**
     * Type Conversions
     */

    /**
     *
     * @param extras
     * @param srcType
     * @param x
     * @param N
     * @param dstType
     * @param z
     */
    void convertTypes(Nd4jPointer *extras, int srcType, Nd4jPointer x, Nd4jLong N, int dstType, Nd4jPointer z);


    /**
     *
     * @return
     */
    bool isExperimentalEnabled();

    /**
     * Aggregate
     */

    /**
     *
     * @param extraPointers
     * @param opNum
     * @param arguments
     * @param numArguments
     * @param shapeArguments
     * @param numShapeArguments
     * @param indexArguments
     * @param numIndexArguments
     * @param intArrays
     * @param numIntArrays
     * @param realArguments
     * @param numRealArguments
     */
    void execAggregate(Nd4jPointer *extraPointers,
                             int opNum,
                             void **arguments,
                             int numArguments,
                             Nd4jLong **shapeArguments,
                             int numShapeArguments,
                             int *indexArguments,
                             int numIndexArguments,
                             int **intArrays,
                             int numIntArrays,
                             void *realArguments,
                             int numRealArguments,
                             nd4j::DataType dtype);


    template <typename T>
    void _batchExecutor(Nd4jPointer *extraPointers,
                                   int numAggregates,
                                   int opNum,
                                   int maxArgs,
                                   int maxShapes,
                                   int maxIntArrays,
                                   int maxIntArraySize,
                                   int maxIdx,
                                   int maxReals,
                                   void *ptrToArguments,
                                   nd4j::DataType dtype);

    void execAggregateBatch(Nd4jPointer *extraPointers,
                                  int numAggregates,
                                  int opNum,
                                  int maxArgs,
                                  int maxShapes,
                                  int maxIntArrays,
                                  int maxIntArraySize,
                                  int maxIdx,
                                  int maxReals,
                                  void *ptrToArguments,
                                  nd4j::DataType dtype);

    /**
     * Random operations
     */

    /**
     *
     * @param extraPointers
     * @param opNum
     * @param state
     * @param z
     * @param zShapeBuffer
     * @param extraArguments
     */
    void execRandom(Nd4jPointer *extraPointers,
                          int opNum,
                          Nd4jPointer state,
                          void *hZ, Nd4jLong *hZShapeBuffer,
                          void *dZ, Nd4jLong *dZShapeBuffer,
                          void *extraArguments);

    /**
     *
     * @param extraPointers
     * @param opNum
     * @param state
     * @param x
     * @param xShapeBuffer
     * @param y
     * @param yShapeBuffer
     * @param z
     * @param zShapeBuffer
     * @param extraArguments
     */
    void execRandom(Nd4jPointer *extraPointers,
                          int opNum,
                          Nd4jPointer state,
                          void *hX, Nd4jLong *hXShapeBuffer,
                          void *dX, Nd4jLong *dXShapeBuffer,
                          void *hY, Nd4jLong *hYShapeBuffer,
                          void *dY, Nd4jLong *dYShapeBuffer,
                          void *hZ, Nd4jLong *hZShapeBuffer,
                          void *dZ, Nd4jLong *dZShapeBuffer,
                          void *extraArguments);

    /**
     *
     * @param extraPointers
     * @param opNum
     * @param state
     * @param x
     * @param xShapeBuffer
     * @param z
     * @param zShapeBuffer
     * @param extraArguments
     */
    void execRandom(Nd4jPointer *extraPointers,
                          int opNum,
                          Nd4jPointer state,
                          void *hX, Nd4jLong *hXShapeBuffer,
                          void *dX, Nd4jLong *dXShapeBuffer,
                          void *hZ, Nd4jLong *hZShapeBuffer,
                          void *dZ, Nd4jLong *dZShapeBuffer,
                          void *extraArguments);


    /**
     *
     * @param extraPointers
     * @param seed
     * @param bufferSize
     * @param ptrToBuffer
     * @return
     */
    Nd4jPointer initRandom(Nd4jPointer *extraPointers,
                           long seed,
                           long bufferSize,
                           Nd4jPointer ptrToBuffer);

    /**
     *
     * @param extraPointers
     * @param seed
     * @param ptrRandom
     */
    void refreshBuffer(Nd4jPointer *extraPointers,
                       long seed,
                       Nd4jPointer ptrRandom);

    /**
     *
     * @param extraPointers
     * @param seed
     * @param ptrRandom
     */
    void reSeedBuffer(Nd4jPointer *extraPointers,
                      long seed,
                      Nd4jPointer ptrRandom);

    /**
     *
     * @param ptrRandom
     */
    void destroyRandom(Nd4jPointer ptrRandom);

    /**
     * Grid operations
     */




    /**
     *
     * @param extras
     * @param opTypeA
     * @param opNumA
     * @param opTypeB
     * @param opNumB
     * @param N
     * @param dx
     * @param xShapeInfo
     * @param dy
     * @param yShapeInfo
     * @param dz
     * @param zShapeInfo
     * @param extraA
     * @param extraB
     * @param scalarA
     * @param scalarB
     */
     /*
    void execMetaPredicateShape(Nd4jPointer *extras,
                                      const int opTypeA,
                                      const int opNumA,
                                      const int opTypeB,
                                      const int opNumB,
                                      Nd4jLong N,
                                      void *hX, Nd4jLong *hXShapeBuffer,
                                      void *dX, Nd4jLong *dXShapeBuffer,
                                      void *hY, Nd4jLong *hYShapeBuffer,
                                      void *dY, Nd4jLong *dYShapeBuffer,
                                      void *hZ, Nd4jLong *hZShapeBuffer,
                                      void *dZ, Nd4jLong *dZShapeBuffer,
                                      void *extraA,
                                      void *extraB,
                                      double scalarA,
                                      double scalarB);

*/
/**
 *
 * @param data
 * @param shapeBuffer
 * @param wordSize
 * @param headerSize
 * @return
 */

    template <typename T>
    static Nd4jPointer _numpyHeaderForNd4j(Nd4jPointer data,Nd4jPointer shapeBuffer,Nd4jLong wordSize,Nd4jLong *headerSize) {
        Nd4jLong *shapeBufferCast = reinterpret_cast<Nd4jLong *>(shapeBuffer);
        int  rank = shape::rank(shapeBufferCast);
        Nd4jLong *shape = shape::shapeOf(shapeBufferCast);
        unsigned int *npShape = new unsigned int[rank];
        for(int i = 0; i < rank; i++) {
            npShape[i] = shape[i];
        }

        Nd4jLong length = shape::prodLong(shape,rank);
        auto npHeader = cnpy::createNpyHeader<T>(data,npShape,rank,wordSize);
        char *ret = new char[npHeader.size() + 1];
        int count = 0;
        for(int i = 0; i < npHeader.size(); i++) {
                ret[count] = npHeader[i];
                count++;
        }

        ret[count] = '\0';
        count++;

        *headerSize = count;
        return reinterpret_cast<Nd4jPointer>(ret);
    }

    Nd4jPointer numpyHeaderForNd4j(Nd4jPointer data,Nd4jPointer shapeBuffer,Nd4jLong wordSize,Nd4jLong *headerSize) {
        auto shapeBufferCast = reinterpret_cast<Nd4jLong *>(shapeBuffer);
        auto type = nd4j::ArrayOptions::dataType(shapeBufferCast);
        BUILD_SINGLE_SELECTOR(type, return _numpyHeaderForNd4j, (data, shapeBuffer, wordSize, headerSize), LIBND4J_TYPES);
    }

/**
   * Load numpy from a header
    * based on the cnpy parse from header method.
   * @param data the header data to parse
   * @return a pointer to a numpy cnpy:NpyArray struct
   */
    Nd4jPointer loadNpyFromHeader(Nd4jPointer data) {
        char *header = reinterpret_cast<char *>(data);

        cnpy::NpyArray arr = cnpy::loadNpyFromHeader(header);
        cnpy::NpyArray *ret = new cnpy::NpyArray();
        int totalLengthOfShape = 1;
        for(int i = 0; i < arr.shape.size(); i++) {
            totalLengthOfShape *= arr.shape[i];
        }

        ret->data = arr.data;
        ret->wordSize = arr.wordSize;
        ret->shape = arr.shape;
        return reinterpret_cast<Nd4jPointer>(ret);
    }


/**
   * Create a numpy array from an nd4j
   * array
   * @param data a pointer to the data
   * @param shapeBuffer  the shapebuffer for the nd4j array
   * @param wordSize  the word size (4 for float, 8 for doubles)
   * @return a pointer to a numpy array
   */

    template <typename T>
    static Nd4jPointer _numpyFromNd4j(Nd4jPointer data,Nd4jPointer shapeBuffer,Nd4jLong wordSize) {
        Nd4jLong *shapeBufferCast = reinterpret_cast<Nd4jLong *>(shapeBuffer);
        int  rank = shape::rank(shapeBufferCast);
        Nd4jLong *shape = shape::shapeOf(shapeBufferCast);
        unsigned int *npShape = new unsigned int[rank];
        for(int i = 0; i < rank; i++) {
            npShape[i] = shape[i];
        }

        Nd4jLong length = shape::prodLong(shape,rank);
        auto npHeader = cnpy::createNpyHeader<T>(data,npShape,rank,wordSize);
        char *dataChar = reinterpret_cast<char *>(data);
        char *npHeaderData = npHeader.data();
        char *ret = new char[(wordSize * length) +  npHeader.size()];
        char *cursorStart = ret;
        std::memcpy(reinterpret_cast<void *>(ret), reinterpret_cast<void *>(npHeaderData), npHeader.size() * sizeof(Nd4jLong));
        //move to next
        cursorStart += npHeader.size();
        std::memcpy(reinterpret_cast<void *>(ret), reinterpret_cast<void *>(dataChar), length * wordSize * sizeof(Nd4jLong));
        Nd4jPointer  rettPointer = reinterpret_cast<Nd4jPointer>(ret);
        return rettPointer;
    }


    Nd4jPointer numpyFromNd4j(Nd4jPointer data,Nd4jPointer shapeBuffer,Nd4jLong wordSize) {
        auto shapeBufferCast = reinterpret_cast<Nd4jLong *>(shapeBuffer);
        auto type = nd4j::ArrayOptions::dataType(shapeBufferCast);
        BUILD_SINGLE_SELECTOR(type, return _numpyFromNd4j, (data, shapeBuffer, wordSize), LIBND4J_TYPES);
    }


/**
 *
 * @param npyArray
 * @return
 */
    Nd4jPointer shapeBufferForNumpy(Nd4jPointer npyArray);


/**
* Get the shape buffer from a
* numpy array.
* **Warning** this allocates memory
* @param npyArray
* @return
*/
    Nd4jPointer shapeBufferForNumpyHeader(Nd4jPointer npyArray) {
        cnpy::NpyArray arr = cnpy::loadNpyFromHeader(reinterpret_cast<char *>(npyArray));
        auto shape = new unsigned int[arr.shape.size()];
        for(unsigned int i = 0; i < arr.shape.size(); i++) {
            shape[i] = arr.shape[i];
        }

        auto shapeBuffer = shape::shapeBufferOfNpy(arr.shape.size(), shape, arr.fortranOrder);
        delete[] shape;
        return reinterpret_cast<Nd4jPointer>(shapeBuffer);
    }



/**
 *
 * @param npyArray
 * @return
 */
    Nd4jPointer dataPointForNumpyHeader(Nd4jPointer npyArray) {
        cnpy::NpyArray arr = cnpy::loadNpyFromHeader(reinterpret_cast<char *>(npyArray));
        unsigned  char *dataToPrint = reinterpret_cast<unsigned  char *>(arr.data);
        return dataToPrint;
    }

/**
 *
 * @param npyArray
 * @return
 */
    Nd4jPointer dataPointForNumpyStruct(Nd4jPointer npyArrayStruct) {
        cnpy::NpyArray *arrPointer = reinterpret_cast<cnpy::NpyArray *>(npyArrayStruct);
        unsigned  char *dataToPrint = reinterpret_cast<unsigned  char *>(arrPointer->data);
        return reinterpret_cast<Nd4jPointer>(dataToPrint);
    }

/**
 *
 * @param npyArray
 * @param fromFile
 * @return
 */
    Nd4jPointer dataPointForNumpy(Nd4jPointer npyArray) {
        char *npyArrayBuffer = reinterpret_cast<  char *>(npyArray);
        cnpy::NpyArray arr = cnpy::loadNpyFromPointer(npyArrayBuffer);
        return dataPointForNumpyStruct(reinterpret_cast<Nd4jPointer>(&arr));
    }

/**
 * Load a numpy array from a file
 * and return it as an Nd4jPointer
 * @param path
 * @return
 */
    Nd4jPointer numpyFromFile(std::string path) {
        char *numpyBuffer = cnpy::loadFile(path.data());
        return reinterpret_cast<Nd4jPointer >(numpyBuffer);
    }


    ////// NPZ //////

    void* mapFromNpzFile(std::string path){
        cnpy::npz_t* mapPtr = new cnpy::npz_t();
        cnpy::npz_t map = cnpy::npzLoad(path);
        mapPtr->insert(map.begin(), map.end());
        return reinterpret_cast<void*>(mapPtr);
    }


    int getNumNpyArraysInMap(void *map){
        cnpy::npz_t* arrays = reinterpret_cast<cnpy::npz_t*>(map);
        int n = arrays->size();
        return n;
    }

    const char* getNpyArrayNameFromMap(void *map, int index){
        cnpy::npz_t* arrays = reinterpret_cast<cnpy::npz_t*>(map);
        cnpy::npz_t::iterator it = arrays->begin();
        cnpy::npz_t::iterator end = arrays->end();
        int cnt = 0;
        for(; it != end; ++it, ++cnt){
            if (cnt == index){
                // FIXME: @fariz, this is a leak!
                return const_cast<const char *>(strdup(it->first.c_str()));
            }
        }
        throw std::runtime_error("No array at index.");
    }

    void* getNpyArrayFromMap(void *map, int index){
        cnpy::npz_t* arrays = reinterpret_cast<cnpy::npz_t*>(map);
        cnpy::npz_t::iterator it = arrays->begin();
        cnpy::npz_t::iterator end = arrays->end();
        cnpy::NpyArray *arr = new cnpy::NpyArray();
        int cnt = 0;
        for(; it != end; ++it, ++cnt){
            if (cnt == index){
                *arr = it->second;
                return arr;
            }
        }
        throw std::runtime_error("No array at index.");
    }

    int dataTypeFromNpyHeader(void *header);

    void* getNpyArrayData(void *npArray){
        cnpy::NpyArray* npyArray2 = reinterpret_cast<cnpy::NpyArray*>(npArray);
        return reinterpret_cast<void*>(npyArray2->data);
    }

    int getNpyArrayRank(void *npArray){
        cnpy::NpyArray* arr = reinterpret_cast<cnpy::NpyArray*>(npArray);
        int rank = arr->shape.size();
        return rank;
    }

    Nd4jLong* getNpyArrayShape(void *npArray){
        cnpy::NpyArray* arr = reinterpret_cast<cnpy::NpyArray*>(npArray);
        int ndim = arr->shape.size();
        Nd4jLong* shape = new Nd4jLong[ndim];
        for (int i=0; i<ndim; i++){
            shape[i] = arr->shape.at(i);
        }
        return shape;
    }

    char getNpyArrayOrder(void *npArray){
        cnpy::NpyArray* arr = reinterpret_cast<cnpy::NpyArray*>(npArray);
        return (arr->fortranOrder)?'f':'c';
    }

    int getNpyArrayElemSize(void *npArray){
        cnpy::NpyArray* arr = reinterpret_cast<cnpy::NpyArray*>(npArray);
        return arr->wordSize;
    }

    void deleteNPArrayStruct(void *npArray){
        cnpy::NpyArray* arr = reinterpret_cast<cnpy::NpyArray*>(npArray);
        delete arr;
    }

    void deleteNPArrayMap(void *map){
        cnpy::npz_t* arrays = reinterpret_cast<cnpy::npz_t*>(map);
        delete arrays;
    }
    //////

/**
  * Get the element size for a numpy array
  * @param npyArray  the numpy array's address
  * to get the length for
  * @return
  */
    int elementSizeForNpyArray(Nd4jPointer npyArray) {
        cnpy::NpyArray arr = cnpy::loadNpyFromPointer(reinterpret_cast<char *>(npyArray));
        cnpy::NpyArray *arrPointer = &arr;
        int size = arrPointer->wordSize;
        // arrPointer->destruct();
        return size;
    }


/**
* Get the element size for a numpy array
* @param npyArray  the numpy array's address
* to get the length for
* @return
*/
    int elementSizeForNpyArrayHeader(Nd4jPointer npyArray) {
        cnpy::NpyArray arr = cnpy::loadNpyFromHeader(reinterpret_cast<char *>(npyArray));
        cnpy::NpyArray *arrPointer = &arr;
        int size = arrPointer->wordSize;
        return size;
    }


    void releaseNumpy(Nd4jPointer npyArray) {
        free(reinterpret_cast<void *>(npyArray));
    }


    /**
     * Return the length of a shape buffer
     * based on the pointer
     * @param buffer  the buffer pointer to check
     * @return
     */
    int lengthForShapeBufferPointer(Nd4jPointer buffer);


      /**
   * The pointer to get the address for
   *
   * @param address the address to get the pointer
   * @return the pointer for the given address
   */

    Nd4jPointer pointerForAddress(Nd4jLong address);

    /**
     * This method takes single N-dimensional tensor, and copies its TADs to target arrays
     *
     * @param x
     * @param xShapeInfo
     * @param targets
     * @param zShapeInfo
     * @return
     */
    void tear(Nd4jPointer *extraPointers,
            void *x, Nd4jLong *xShapeInfo,
            void *dx, Nd4jLong *dxShapeInfo,
            Nd4jPointer *targets, Nd4jLong *zShapeInfo,
            Nd4jLong *tadShapeInfo,
            Nd4jLong *tadOffsets);

    Nd4jLong encodeBitmap(Nd4jPointer *extraPointers, void *dx, Nd4jLong *xShapeInfo, Nd4jLong N, int *dz, float threshold);
    void decodeBitmap(Nd4jPointer *extraPointers, void *dx, Nd4jLong N, void *dz, Nd4jLong *zShapeInfo);


    void encodeThresholdP1(Nd4jPointer *extraPointers, void *dx, Nd4jLong *xShapeInfo, Nd4jLong N, int *dz, float threshold);
    void encodeThresholdP2Int(Nd4jPointer *extraPointers, int *dx, Nd4jLong N, int *dz);
    void encodeThresholdP3(Nd4jPointer *extraPointers, void *dx, Nd4jLong *xShapeInfo, int *offsets, Nd4jLong N, int *dz);


    void decodeThreshold(Nd4jPointer *extraPointers, void *dx, Nd4jLong N, void *dz, Nd4jLong *zShapeInfo);


    void sort(Nd4jPointer *extraPointers,
            void *x, Nd4jLong *xShapeInfo,
            void *dx, Nd4jLong *dxShapeInfo,
            bool descending);

    void sortByKey(Nd4jPointer *extraPointers,
                   void *x, Nd4jLong *xShapeInfo,
                   void *dx, Nd4jLong *dxShapeInfo,
                   void *y, Nd4jLong *yShapeInfo,
                   void *dy, Nd4jLong *dyShapeInfo,
                   bool descending);

    void sortByValue(Nd4jPointer *extraPointers,
                     void *x, Nd4jLong *xShapeInfo,
                     void *dx, Nd4jLong *dxShapeInfo,
                     void *y, Nd4jLong *yShapeInfo,
                     void *dy, Nd4jLong *dyShapeInfo,
                     bool descending);

    void sortTad(Nd4jPointer *extraPointers,
            void *x, Nd4jLong *xShapeInfo,
            void *dx, Nd4jLong *dxShapeInfo,
            int *dimension,
            int dimensionLength,
            Nd4jLong *tadShapeInfo,
            Nd4jLong *tadOffsets,
            bool descending);

    void sortTadByKey(Nd4jPointer *extraPointers,
                 void *x, Nd4jLong *xShapeInfo,
                 void *dx, Nd4jLong *dxShapeInfo,
                 void *y, Nd4jLong *yShapeInfo,
                 void *dy, Nd4jLong *dyShapeInfo,
                 int *dimension,
                 int dimensionLength,
                 bool descending);

    void sortTadByValue(Nd4jPointer *extraPointers,
                 void *x, Nd4jLong *xShapeInfo,
                 void *dx, Nd4jLong *dxShapeInfo,
                 void *y, Nd4jLong *yShapeInfo,
                 void *dy, Nd4jLong *dyShapeInfo,
                 int *dimension,
                 int dimensionLength,
                 bool descending);


    // special sort impl for sorting out COO indices and values
    void sortCooIndices(Nd4jPointer *extraPointers, Nd4jLong *indices, void *values, Nd4jLong length, int rank);


    Nd4jLong* mmapFile(Nd4jPointer *extraPointers, const char *fileName, Nd4jLong length);

    void munmapFile(Nd4jPointer *extraPointers, Nd4jLong* ptrMap, Nd4jLong length);


    // flatbuffers execution
    nd4j::graph::ResultWrapper* executeFlatGraph(Nd4jPointer *extraPointers, Nd4jPointer flatBufferPointer);


    const char* getAllCustomOps();

    const char* getAllOperations();

    // customOp executioner
    int execCustomOp(Nd4jPointer* extraPointers, Nd4jLong hash, Nd4jPointer* inputBuffers, Nd4jPointer* inputShapes, int numInputs, Nd4jPointer* outputBuffers, Nd4jPointer* outputShapes, int numOutputs, double* tArgs, int numTArgs, Nd4jLong *iArgs, int numIArgs, bool* bArgs, int numBArgs, bool isInplace);
    int execCustomOp(Nd4jPointer* extraPointers, Nd4jLong hash, Nd4jPointer opContext);

    nd4j::ShapeList* calculateOutputShapes(Nd4jPointer* extraPointers, Nd4jLong hash, Nd4jPointer* inputShapes, int numInputShapes, double* tArgs, int numTArgs, Nd4jLong *iArgs, int numIArgs);
    nd4j::ShapeList* calculateOutputShapes(Nd4jPointer* extraPointers, Nd4jLong hash, Nd4jPointer* inputBuffers, Nd4jPointer* inputShapes, int numInputShapes, double* tArgs, int numTArgs, Nd4jLong *iArgs, int numIArgs, bool *bArgs, int numBArgs);

    void deleteShapeList(Nd4jPointer shapeList);

    int registerGraph(Nd4jPointer *extraPointers, Nd4jLong graphId, Nd4jPointer flatBufferPointer);

    nd4j::graph::VariablesSet *executeStoredGraph(Nd4jPointer *extraPointers, Nd4jLong graphId, Nd4jPointer *inputBuffers, Nd4jPointer *inputShapes, int* inputIndices, int numInputs);

    int unregisterGraph(Nd4jPointer *extraPointers, Nd4jLong graphId);

    void deleteCharArray(Nd4jPointer pointer);
    void deleteIntArray(Nd4jPointer pointer);
    void deleteLongArray(Nd4jPointer pointer);
    void deletePointerArray(Nd4jPointer pointer);

    void deleteVariablesSet(Nd4jPointer pointer);

    // GraphState creation
    Nd4jPointer getGraphState(Nd4jLong id);

    void deleteGraphState(Nd4jPointer state);

    void deleteResultWrapper(Nd4jPointer ptr);

    int estimateThreshold(Nd4jPointer *extraPointers, Nd4jPointer x, Nd4jLong *xShapeInfo, int N, float threshold);

    // this method executes op that requires scope to be present: if/while/cond/whatever
    Nd4jStatus execCustomOpWithScope(Nd4jPointer *extraPointers, Nd4jPointer state, Nd4jLong opHash, Nd4jLong *scopes, int numScopes, Nd4jPointer *inputBuffers, Nd4jPointer *inputShapes, int numInputs, Nd4jPointer *outputBuffers, Nd4jPointer *outputShapes, int numOutputs);

    //void fillUtf8String(Nd4jPointer *extraPointers, const char **string, int numStrings, Nd4jPointer buffer);
    Nd4jPointer createUtf8String(Nd4jPointer *extraPointers, const char *string, int length);
    void deleteUtf8String(Nd4jPointer *extraPointers, Nd4jPointer ptr);

    void scatterUpdate(Nd4jPointer *extraPointers, int opCode, int numOfSubArrs,
                      void* hX, Nd4jLong* hXShapeInfo, Nd4jLong* hXOffsets,
                      void* dX, Nd4jLong* dXShapeInfo, Nd4jLong* dXOffsets,
                      void* hY, Nd4jLong* hYShapeInfo, Nd4jLong* hYOffsets,
                      void* dY, Nd4jLong* dYShapeInfo, Nd4jLong* dYOffsets,
                      int* hIindexes, int* dIindexes);

    void inspectArray(Nd4jPointer *extraPointers, Nd4jPointer buffer, Nd4jLong *shapeInfo, Nd4jPointer specialBuffer, Nd4jLong *specialShapeInfo, Nd4jPointer debugInfo);


    nd4j::ConstantDataBuffer* shapeBuffer(int rank, Nd4jLong *shape, Nd4jLong *strides, nd4j::DataType dtype, char order, Nd4jLong ews, bool empty);

    nd4j::ConstantDataBuffer* constantBuffer(nd4j::DataType dtype, Nd4jLong *data, int length);
    nd4j::ConstantDataBuffer* constantBuffer(nd4j::DataType dtype, double *data, int length);
    nd4j::ConstantDataBuffer* constantBuffer(nd4j::DataType dtype, nd4j::ConstantDescriptor *descriptor);

    void deleteShapeBuffer(Nd4jPointer ptr);
    void deleteTadPack(Nd4jPointer ptr);

    const char* runLightBenchmarkSuit(bool printOut);
    const char* runFullBenchmarkSuit(bool printOut);
};






#endif //NATIVEOPERATIONS_NATIVEOPS_H