Minor nativeops changes for compiler (deeplearning4j#10177)

* Build changes
Update cpp standard to 17
Add more new flags for functrace for easier debugging

* legacy changes:
adds missing linker methods for nativeopexecutioner
updates some methods to avoid compiler warnigns about comparing elements of different sizes

Author: agibsonccc

libnd4j/include/legacy/NativeOpExecutioner.h

@@ -454,17 +454,8 @@ class SD_LIB_EXPORT NativeOpExecutioner {
                          const sd::LongType *dZShapeBuffer, void *extraArguments);
 
    static void execSort(sd::NDArray *x, bool descending);
-   static void execSortCooIndices(sd::LongType *indices, void *x, sd::LongType length,
-                                        const sd::LongType *xShapeInfo);
 
-   static void execRavelMultiIndex(sd::LongType *indices, sd::LongType *flatIndices, sd::LongType length,
-                                         sd::LongType *shapeInfo, int mode);
-
-   static void execUnravelIndex(sd::LongType *indices, sd::LongType *flatIndices, sd::LongType length,
-                                      sd::LongType *shapeInfo);
-   static sd::LongType encodeBitmap(sd::NDArray *x, sd::LongType N, long long int *dz,
-                                          float threshold);
-   static void execSort(sd::NDArray *x, sd::LongType *dimension,  sd::LongType dimensionLength,
+  static void execSort(sd::NDArray *x, sd::LongType *dimension,  sd::LongType dimensionLength,
                         bool descending) ;
 
 

libnd4j/include/legacy/NativeOps.h

@@ -88,16 +88,8 @@ SD_LIB_EXPORT void shuffle(sd::Pointer *extras,
                            OpaqueNDArray dimension,
                            OpaqueNDArray shuffleMap);
 
-SD_LIB_EXPORT void average(sd::Pointer *extras,
-                           OpaqueNDArrayArr x,
-                           OpaqueNDArray z,int n,
-                           sd::LongType length, bool propagate);
 
-SD_LIB_EXPORT void accumulate(sd::Pointer *extras,
-                              OpaqueNDArrayArr x,
-                              OpaqueNDArray z,
-                              int n,
-                              sd::LongType length);
+
 
 
 SD_LIB_EXPORT void pullRows(sd::Pointer *extraPointers,
@@ -255,8 +247,6 @@ SD_LIB_EXPORT int getDeviceMinor(int device) ;
 SD_LIB_EXPORT int getShapeInfoLength(OpaqueTadPack *pack) ;
 SD_LIB_EXPORT int memcpyConstantAsync(sd::LongType dst, sd::Pointer src, sd::LongType size, int flags, sd::Pointer reserved) ;
 SD_LIB_EXPORT sd::Pointer getConstantSpace() ;
-SD_LIB_EXPORT void average(sd::Pointer *extras, OpaqueNDArray *x, OpaqueNDArray z,int n, sd::LongType length, bool propagate) ;
-SD_LIB_EXPORT void accumulate(sd::Pointer *extras, OpaqueNDArray *x, OpaqueNDArray z, int n, sd::LongType length) ;
 SD_LIB_EXPORT bool isExperimentalEnabled() ;
 SD_LIB_EXPORT void setOmpMinThreads(int threads) ;
 SD_LIB_EXPORT int getDevice() ;
@@ -305,7 +295,6 @@ SD_LIB_EXPORT void sortTadByValue(sd::Pointer *extraPointers,
                                   OpaqueNDArray y,
                                   OpaqueNDArray dimension,
                                   bool descending);
-SD_LIB_EXPORT void sortCooIndices(sd::Pointer *extraPointers, OpaqueNDArray indices, OpaqueNDArray values);
 SD_LIB_EXPORT void munmapFile(sd::Pointer *extraPointers, sd::LongType *ptrMap, sd::LongType length) ;
 SD_LIB_EXPORT sd::LongType* mmapFile(sd::Pointer* extraPointers, const char* fileName, sd::LongType length);
 

libnd4j/include/legacy/impl/NativeOpsHelpers.cpp

@@ -261,7 +261,7 @@ static sd::Pointer _numpyHeaderForNd4j(sd::Pointer data, const sd::Pointer shape
   auto npHeader = cnpy::createNpyHeader<T>(npShape, rank, wordSize);
   char* ret = new char[npHeader.size() + 1];
   int count = 0;
-  for (int i = 0; i < npHeader.size(); i++) {
+  for (size_t i = 0; i < npHeader.size(); i++) {
     ret[count] = npHeader[i];
     count++;
   }
@@ -292,10 +292,6 @@ sd::Pointer loadNpyFromHeader(sd::Pointer 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;
@@ -539,8 +535,8 @@ void setGraphContextOutputArraysArr(OpaqueContext* ptr, int numArrays,OpaqueNDAr
       errorMessage += " was null!";
       THROW_EXCEPTION(errorMessage.c_str());
     }
-    for (int i = 0; i < numArrays; i++) {
-      ptr->setOutputArray(i, *arr[i], false);
+    for (int j = 0; j < numArrays; j++) {
+      ptr->setOutputArray(j, *arr[j], false);
     }
   }
 }
@@ -625,12 +621,12 @@ sd::LongType *mmapFile(sd::Pointer *extraPointers, const char *fileName, sd::Lon
       THROW_EXCEPTION("Failed to open file for MMAP");
     }
 
-    void *ptr = mmap(nullptr, length, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, fd, 0);
-    if (ptr == MAP_FAILED) {
+    void *ptr2 = mmap(nullptr, length, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, fd, 0);
+    if (ptr2 == MAP_FAILED) {
       sd_printf("Errno: %i\n", errno);
       THROW_EXCEPTION("Failed to mmap file");
     }
-    hZ[0] = (sd::LongType)ptr;
+    hZ[0] = (sd::LongType)ptr2;
     hZ[1] = fd;
 
 #endif
@@ -666,7 +662,7 @@ OpaqueShapeList *calculateOutputShapes2(sd::Pointer *extraPointers, sd::LongType
     fflush(stdout);
     sd::ShapeList inShapes;
 
-    for (int e = 0; e < context->width(); e++) {
+    for (size_t e = 0; e < context->width(); e++) {
       if (context->array(e) == nullptr) {
         std::string errorMessage = "Input array at index " + std::to_string(e) + " was null!";
         THROW_EXCEPTION(errorMessage.c_str());
@@ -738,7 +734,7 @@ void purgeOpTrace() { sd::ops::OpRegistrator::getInstance().purgeOpExecs();
 
 void printOpTrace() {
   auto execTrace = *sd::ops::OpRegistrator::getInstance().execTrace();
-  for(int i = 0; i < execTrace.size(); i++) {
+  for(size_t i = 0; i < execTrace.size(); i++) {
     auto curr = execTrace[i];
     if(curr->opName != nullptr) {
       sd_printf("Op name: %s\n", curr->opName->c_str());
@@ -749,7 +745,7 @@ void printOpTrace() {
       continue;
     } else {
       auto currInputShapeBuffers = *(curr->inputShapeBuffers);
-      for(int j = 0; j < currInputShapeBuffers.size(); j++) {
+      for(size_t j = 0; j < currInputShapeBuffers.size(); j++) {
         auto buff = currInputShapeBuffers[j];
         shape::printShapeInfo(buff);
         sd_printf("\n",0);
@@ -761,7 +757,7 @@ void printOpTrace() {
       continue;
     } else {
       auto currOutputShapeBuffers = *(curr->outputShapeBuffers);
-      for(int j = 0; j < curr->outputShapeBuffers->size(); j++) {
+      for(size_t j = 0; j < curr->outputShapeBuffers->size(); j++) {
         shape::printShapeInfo(currOutputShapeBuffers[j]);
         sd_printf("\n",0);
       }
@@ -887,7 +883,7 @@ std::vector<double> * tArgs(void *execTrace) {
 std::vector<int> * dArgs(void *execTrace) {
   ExecTrace *trace = (ExecTrace *) execTrace;
   std::vector<int> *dArgs = new std::vector<int>();
-  for (int e = 0; e < trace->dArgs.size(); e++) {
+  for (size_t e = 0; e < trace->dArgs.size(); e++) {
     dArgs->push_back(trace->dArgs[e]);
   }
   return dArgs;
@@ -965,7 +961,8 @@ static VariablesSet *executeStoredGraphT(sd::Pointer *extraPointers, sd::LongTyp
   if (hZ == sd::Status::OK) {
     // pull back results, and provide them
     auto outputs = graph->fetchOutputs();
-    for (int e = 0; e < outputs->size(); e++) {
+    int size = static_cast<int>(outputs->size());
+    for (int e = 0; e < size; e++) {
       // we're only getting variable ID/Index from original grap. values will be taken from cloned workspace
       std::pair<int, int> varId(outputs->at(e)->id(), outputs->at(e)->index());
 
@@ -1121,24 +1118,9 @@ sd::Status execCustomOpWithScope_(sd::Pointer *extraPointers, sd::graph::GraphSt
     varSpace->dropVariable(0, e);
   }
 
-  // after some bla-bla-bla we should have Graph and Node for current op
   return sd::Status::OK;
 }
 
-sd::Status execCustomOpWithScope(sd::Pointer *extraPointers, sd::Pointer state, sd::LongType  opHash, sd::LongType  *scopes, int numScopes,
-                                 sd::Pointer *inputBuffers, sd::Pointer *inputShapes, int numInputs, sd::Pointer *outputBuffers,
-                                 sd::Pointer *outputShapes, int numOutputs) {
-  try {
-    return execCustomOpWithScope(extraPointers, reinterpret_cast<GraphState *>(state), opHash, scopes,
-                                 numScopes, inputBuffers, inputShapes, numInputs, outputBuffers, outputShapes,
-                                 numOutputs);
-  } catch (std::exception &e) {
-    sd::LaunchContext::defaultContext()->errorReference()->setErrorCode(1);
-    sd::LaunchContext::defaultContext()->errorReference()->setErrorMessage(e.what());
-    return sd::Status::BAD_INPUT;
-  }
-}
-
 void deleteResultWrapper(sd::Pointer ptr) {
   auto p = reinterpret_cast<ResultWrapper *>(ptr);
   delete p;

libnd4j/include/legacy/impl/cnpy.cpp

@@ -172,7 +172,8 @@ sd::DataType cnpy::dataTypeFromHeader(char *data) {
 template <typename T>
 std::vector<char> &operator+=(std::vector<char> &lhs, const T rhs) {
   // write in little endian
-  for (char byte = 0; byte < sizeof(T); byte++) {
+  char size = sizeof(T);
+  for (char byte = 0; byte < size; byte++) {
     char val = *((char *)&rhs + byte);
     lhs.push_back(val);
   }
@@ -225,13 +226,6 @@ char *cnpy::loadFile(const char *path) {
     fseek(f, 0, SEEK_SET);
     buffer = (char *)malloc((length + 1) * sizeof(char));
 
-    // just getting rid of compiler warning
-    sd::LongType fps = 0;
-
-    if (buffer) {
-      fps += fread(buffer, sizeof(char), length, f);
-    }
-
     fclose(f);
   }
 
@@ -388,7 +382,7 @@ cnpy::NpyArray cnpy::loadNpyFromHeader(char *data) {
       std::string firstError;
       firstError += std::string("Pointer doesn't look like a NumPy header. Missing expected characters in middle.");
       std::string header;
-      for(int i = 0; i < hdr.size(); i++) {
+      for(size_t i = 0; i < hdr.size(); i++) {
         header+= hdr[i];
       }
 
@@ -406,19 +400,14 @@ cnpy::NpyArray cnpy::loadNpyFromHeader(char *data) {
   parseNpyHeaderStr(std::string(data), wordSize, shape, ndims, fortranOrder);
   // the "real" data starts after the \n
   char currChar = data[0];
-  int count = 0;
   while (currChar != '\n') {
     data++;
     currChar = data[0];
-    count++;
   }
 
   // move pass the \n
   data++;
-  count++;
 
-  unsigned long long size = 1;  // long long so no overflow when multiplying by word_size
-  for (unsigned int i = 0; i < ndims; i++) size *= shape[i];
   char *cursor = data;
   NpyArray arr;
   arr.wordSize = wordSize;
@@ -615,7 +604,7 @@ void cnpy::npy_save(std::string fname, const void *data, const unsigned int *sha
       assert(tmp_dims == ndims);
     }
 
-    for (int i = 1; i < ndims; i++) {
+    for (size_t i = 1; i < ndims; i++) {
       if (shape[i] != tmp_shape[i]) {
         std::cout << "libnpy error: npy_save attempting to append misshaped data to " << fname << "\n";
         assert(shape[i] == tmp_shape[i]);
@@ -637,7 +626,7 @@ void cnpy::npy_save(std::string fname, const void *data, const unsigned int *sha
   }
 
   unsigned long long nels = 1;
-  for (int i = 0; i < ndims; i++) nels *= shape[i];
+  for (unsigned int i = 0; i < ndims; i++) nels *= shape[i];
 
   fwrite(data, sizeof(T), nels, fp);
   fclose(fp);
@@ -663,7 +652,7 @@ std::vector<char> cnpy::createNpyHeader( const unsigned int *shape, const unsign
   dict += "', 'fortran_order': False, 'shape': (";
   if (ndims > 0) {
     dict += tostring(shape[0]);
-    for (int i = 1; i < ndims; i++) {
+    for (size_t i = 1; i < ndims; i++) {
       dict += ", ";
       dict += tostring(shape[i]);
     }