[#399][Sys] Remove sysctl usage

.github/workflows/build.yml

@@ -87,39 +87,39 @@ jobs:
     - uses: actions/checkout@v2
 
     - name: Compiler info
-      run: make -j 16 info
       if: ${{ !matrix.useCMake }}
+      run: make -j 16 info
 
     - name: CMake build
+      if: ${{ matrix.useCMake }}
       run: |
         cmake -E make_directory ${{runner.workspace}}/occa/build
         cd ${{runner.workspace}}/occa/build
         cmake -DENABLE_TESTS=On -DENABLE_EXAMPLES=On ${{runner.workspace}}/occa
         make -j 16
-      if: ${{ matrix.useCMake }}
 
     - name: Compile library
-      run: make -j 16
       if: ${{ !matrix.useCMake }}
+      run: make -j 16
 
     - name: Compile tests
-      run: make -j 16 tests
       if: ${{ !matrix.useCMake }}
+      run: make -j 16 tests
 
     - name: Run unit tests
-      run: ./tests/run_tests
       if: ${{ !matrix.useCMake }}
+      run: ./tests/run_tests
 
     - name: Run examples
-      run: ./tests/run_examples
       if: ${{ !matrix.useCMake }}
+      run: ./tests/run_examples
 
     - name: Run CTests
+      if: ${{ matrix.useCMake }}
       run: |
         cd ${{runner.workspace}}/occa/build
-        make test
-      if: ${{ matrix.useCMake }}
+        CTEST_OUTPUT_ON_FAILURE=1 make test
 
     - name: Upload code coverage
-      run: bash <(curl --no-buffer -s https://codecov.io/bash) -x "${GCOV}"
       if: ${{ matrix.OCCA_COVERAGE }}
+      run: bash <(curl --no-buffer -s https://codecov.io/bash) -x "${GCOV}"

include/occa/io.hpp

@@ -2,6 +2,7 @@
 #define OCCA_IO_HEADER
 
 #include <occa/io/cache.hpp>
+#include <occa/io/enums.hpp>
 #include <occa/io/fileOpener.hpp>
 #include <occa/io/lock.hpp>
 #include <occa/io/utils.hpp>

include/occa/io/enums.hpp

@@ -0,0 +1,14 @@
+#ifndef OCCA_IO_ENUMS_HEADER
+#define OCCA_IO_ENUMS_HEADER
+
+namespace occa {
+  namespace enums {
+    enum FileType {
+      FILE_TYPE_TEXT,
+      FILE_TYPE_BINARY,
+      FILE_TYPE_PSEUDO
+    };
+  }
+}
+
+#endif

include/occa/io/utils.hpp

@@ -4,6 +4,7 @@
 #include <iostream>
 
 #include <occa/types.hpp>
+#include <occa/io/enums.hpp>
 
 namespace occa {
   // Kernel Caching
@@ -69,10 +70,10 @@ namespace occa {
 
     char* c_read(const std::string &filename,
                  size_t *chars = NULL,
-                 const bool readingBinary = false);
+                 const enums::FileType fileType = enums::FILE_TYPE_TEXT);
 
     std::string read(const std::string &filename,
-                     const bool readingBinary = false);
+                     const enums::FileType fileType = enums::FILE_TYPE_TEXT);
 
     void write(const std::string &filename,
                const std::string &content);

include/occa/lang/primitive.hpp

@@ -10,8 +10,8 @@
 
 #include <occa/defines.hpp>
 #include <occa/io/output.hpp>
+#include <occa/tools/logging.hpp>
 #include <occa/tools/string.hpp>
-#include <occa/tools/sys.hpp>
 
 namespace occa {
   //---[ Primitive Type ]---------------

include/occa/tools.hpp

@@ -6,6 +6,7 @@
 #include <occa/tools/exception.hpp>
 #include <occa/tools/gc.hpp>
 #include <occa/tools/hash.hpp>
+#include <occa/tools/enums.hpp>
 #include <occa/tools/json.hpp>
 #include <occa/tools/lex.hpp>
 #include <occa/tools/misc.hpp>

include/occa/tools/enums.hpp

@@ -0,0 +1,21 @@
+#ifndef OCCA_TOOLS_ENUMS_HEADER
+#define OCCA_TOOLS_ENUMS_HEADER
+
+namespace occa {
+  namespace sys {
+    namespace language {
+      static const int notFound = 0;
+      static const int CPP      = 1;
+      static const int C        = 2;
+    }
+
+    enum class CacheLevel {
+      L1D,
+      L1I,
+      L2,
+      L3
+    };
+  }
+}
+
+#endif

include/occa/tools/logging.hpp

@@ -0,0 +1,43 @@
+#ifndef OCCA_TOOLS_LOGGING_HEADER
+#define OCCA_TOOLS_LOGGING_HEADER
+
+#include <iostream>
+
+namespace occa {
+  namespace io {
+    class output;
+  }
+
+  void _message(const std::string &header,
+                const bool exitInFailure,
+                const std::string &filename,
+                const std::string &function,
+                const int line,
+                const std::string &message);
+
+  void warn(const std::string &filename,
+            const std::string &function,
+            const int line,
+            const std::string &message);
+
+  void error(const std::string &filename,
+             const std::string &function,
+             const int line,
+             const std::string &message);
+
+  void printWarning(io::output &out,
+                    const std::string &message,
+                    const std::string &code = "");
+
+  void printWarning(const std::string &message,
+                    const std::string &code = "");
+
+  void printError(io::output &out,
+                  const std::string &message,
+                  const std::string &code = "");
+
+  void printError(const std::string &message,
+                  const std::string &code = "");
+}
+
+#endif

include/occa/tools/misc.hpp

@@ -1,12 +1,36 @@
 #ifndef OCCA_TOOLS_MISC_HEADER
 #define OCCA_TOOLS_MISC_HEADER
 
+#include <initializer_list>
+
 #include <occa/defines.hpp>
 #include <occa/types.hpp>
 
 namespace occa {
   udim_t ptrDiff(void *start, void *end);
 
+  template <class TM>
+  TM min(std::initializer_list<TM> values) {
+    TM minValue = *values.begin();
+    for (const TM &value : values) {
+      if (value < minValue) {
+        minValue = value;
+      }
+    }
+    return minValue;
+  }
+
+  template <class TM>
+  TM max(std::initializer_list<TM> values) {
+    TM maxValue = *values.begin();
+    for (const TM &value : values) {
+      if (maxValue < value) {
+        maxValue = value;
+      }
+    }
+    return maxValue;
+  }
+
   template <class TM>
   void ignoreResult(const TM &t) {
     (void) t;

include/occa/tools/string.hpp

@@ -12,6 +12,7 @@
 #include <occa/types.hpp>
 
 namespace occa {
+  //---[ Helper Methods ]---------------
   std::string strip(const std::string &str);
 
   std::string stripLeft(const std::string &str);
@@ -35,6 +36,9 @@ namespace occa {
                   const char delimeter,
                   const char escapeChar = 0);
 
+  std::string join(const strVector &vec,
+                   const std::string &delimiter);
+
   inline char uppercase(const char c) {
     if (('a' <= c) && (c <= 'z')) {
       return ((c + 'A') - 'a');
@@ -63,6 +67,30 @@ namespace occa {
     return lowercase(s.c_str(), s.size());
   }
 
+  inline bool startsWith(const std::string &s,
+                         const std::string &match) {
+    const int matchChars = (int) match.size();
+    return ((matchChars <= (int) s.size()) &&
+            (!strncmp(s.c_str(), match.c_str(), matchChars)));
+  }
+
+  inline bool endsWith(const std::string &s,
+                       const std::string &match) {
+    const int sChars = (int) s.size();
+    const int matchChars = (int) match.size();
+    return ((matchChars <= sChars) &&
+            (!strncmp(s.c_str() + (sChars - matchChars),
+                      match.c_str(),
+                      matchChars)));
+  }
+
+  inline bool contains(const std::string &s,
+                       const std::string &match) {
+    return s.find(match) != std::string::npos;
+  }
+  //====================================
+
+  //---[ Stringify ]--------------------
   template <class TM>
   std::string toString(const TM &t) {
     std::stringstream ss;
@@ -134,33 +162,19 @@ namespace occa {
     }
     return ret;
   }
+  //====================================
 
-  inline bool startsWith(const std::string &s,
-                         const std::string &match) {
-    const int matchChars = (int) match.size();
-    return ((matchChars <= (int) s.size()) &&
-            (!strncmp(s.c_str(), match.c_str(), matchChars)));
-  }
+  //---[ Formatters ]-------------------
+  udim_t parseInt(const std::string &str);
+  udim_t parseInt(const char *c);
 
-  inline bool endsWith(const std::string &s,
-                       const std::string &match) {
-    const int sChars = (int) s.size();
-    const int matchChars = (int) match.size();
-    return ((matchChars <= sChars) &&
-            (!strncmp(s.c_str() + (sChars - matchChars),
-                      match.c_str(),
-                      matchChars)));
-  }
-
-  udim_t atoi(const char *c);
-  udim_t atoiBase2(const char *c);
-  udim_t atoi(const std::string &str);
+  udim_t parseBinary(const char *c);
 
-  double atof(const char *c);
-  double atof(const std::string &str);
+  double parseFloat(const std::string &str);
+  double parseFloat(const char *c);
 
-  double atod(const char *c);
-  double atod(const std::string &str);
+  double parseDouble(const std::string &str);
+  double parseDouble(const char *c);
 
   inline char toHexChar(const char c) {
     if (c < 16) {
@@ -247,10 +261,12 @@ namespace occa {
   }
 
   std::string stringifyBytes(udim_t bytes);
-
   void stringifyBytesFraction(std::stringstream &ss,
                               uint64_t fraction);
 
+  std::string stringifyFrequency(udim_t frequency);
+  //====================================
+
   //---[ Color Strings ]----------------
   namespace color {
     enum color_t {