C++17 filesystem and chrono alternative implementations

Author: boberfly

lib/common/grid_util/DebugConsoleDriver.cc

@@ -5,8 +5,8 @@
 //
 #include "DebugConsoleDriver.h"
 
+#include <chrono>
 #include <iostream>
-#include <unistd.h>
 
 namespace scene_rdl2 {
 namespace grid_util {
@@ -89,7 +89,7 @@ DebugConsoleDriver::threadMain(DebugConsoleDriver *driver)
         if (recvByte == 0 || recvByte == -1) {
             // empty or EOF
             driver->mThreadState = ThreadState::IDLE;
-            usleep(10000); // 10000us = 10ms : wake up every 10ms and check TlSvr
+            std::this_thread::sleep_for(std::chrono::microseconds(10000)); // 10000us = 10ms : wake up every 10ms and check TlSvr
 
         } else if (recvByte < -1) { // error
             std::cerr << "telnet server failed\n";

lib/common/grid_util/LatencyLog.h

@@ -16,11 +16,10 @@
 #include <scene_rdl2/scene/rdl2/ValueContainerDeq.h>
 #include <scene_rdl2/scene/rdl2/ValueContainerEnq.h>
 
+#include <chrono>
 #include <string>
 #include <vector>
 
-#include <sys/time.h>
-
 //
 // We should always use variable length coding.
 // This directive is designed for performance comparison purpose.
@@ -196,9 +195,10 @@ class LatencyItem
 finline uint64_t
 LatencyItem::getCurrentMicroSec()
 {
-    struct timeval tv;
-    gettimeofday(&tv, 0x0);
-    uint64_t microSec = static_cast<uint64_t>(tv.tv_sec) * 1000 * 1000 + static_cast<uint64_t>(tv.tv_usec);
+    const auto tnow = std::chrono::high_resolution_clock::now().time_since_epoch();
+    const auto cTime = std::chrono::duration_cast<std::chrono::microseconds>(tnow);
+    uint64_t microSec = static_cast<uint64_t>(static_cast<int64_t>(cTime.count()));
+
     if (LatencyClockOffset::getInstance().isPositive()) {
         microSec += LatencyClockOffset::getInstance().getAbsOffsetMicroSec();
     } else {

lib/common/rec_time/RecTime.h

@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 #pragma once
 
+#include <chrono>
 #include <sstream>
 
-#include <sys/time.h>
 #include <stdint.h>
 #include <time.h> // clock_gettime()
 
@@ -38,9 +38,9 @@ class RecTime
 
     static uint64_t getCurrentMicroSec() // MTsafe
     {
-        struct timeval tv;
-        gettimeofday(&tv, 0x0);
-        return static_cast<uint64_t>(tv.tv_sec) * 1000000 + static_cast<uint64_t>(tv.tv_usec);
+        const auto tnow = std::chrono::high_resolution_clock::now().time_since_epoch();
+        const auto cTime = std::chrono::duration_cast<std::chrono::microseconds>(tnow);
+        return cTime.count();
     }
 
 protected:
@@ -159,7 +159,7 @@ class RecTimeRDTSC
         //
         const uint64_t c0 = __rdtsc();
         const uint64_t ns0 = RecTimeVDSO::getCurrentNanoSec(); // ns
-        usleep(100000); // 100ms
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
         const uint64_t c1 = __rdtsc();
         const uint64_t ns1 = RecTimeVDSO::getCurrentNanoSec(); // ns
         const double deltaNs = static_cast<double>(ns1 - ns0);

lib/render/util/Files.cc

@@ -34,6 +34,8 @@
 #endif
 #include <unistd.h>
 
+#include <filesystem>
+
 namespace scene_rdl2 {
 namespace util {
 
@@ -49,12 +51,9 @@ struct FreeDeleter
 std::pair<std::string, std::string>
 splitPath(const std::string& filePath)
 {
-    const char* path = filePath.c_str();
-    std::unique_ptr<char, FreeDeleter> dirStr(strdup(path));
-    std::unique_ptr<char, FreeDeleter> baseStr(strdup(path));
-
-    std::string directory(dirname(dirStr.get()));
-    std::string filename(basename(baseStr.get()));
+    std::filesystem::path p(filePath);
+    std::string directory(p.parent_path().string());
+    std::string filename(p.filename().string());
 
     return std::make_pair(std::move(directory), std::move(filename));
 }

lib/render/util/ThreadPoolExecutor.cc

@@ -9,7 +9,7 @@
 #include <pthread.h> // pthread_setaffinity_np
 #include <sstream>
 #include <thread>
-#include <unistd.h> // usleep
+#include <chrono>
 
 //#define DEBUG_MSG_THREAD
 //#define DEBUG_MSG_THREAD_CPUAFFINITY
@@ -325,10 +325,7 @@ ThreadPoolExecutor::testBootShutdown()
                 // This simulates MoonRay's MCRT thread boot logic
                 ++bootedThreadTotal;
                 while (bootedThreadTotal < threadTotal) {
-                    struct timespec tm;
-                    tm.tv_sec = 0;
-                    tm.tv_nsec = 1000; // 0.001ms
-                    nanosleep(&tm, NULL); // yield CPU resources
+                    std::this_thread::sleep_for(std::chrono::nanoseconds(1000)); // yield CPU resources
                 }
 
                 sum += static_cast<int>(threadId);

lib/scene/rdl2/Dso.cc

@@ -23,6 +23,7 @@
 #include <dlfcn.h>
 #include <libgen.h>
 #include <unistd.h>
+#include <filesystem>
 
 namespace scene_rdl2 {
 namespace rdl2 {
@@ -56,12 +57,9 @@ classNameFromFileName(const std::string& baseName,
 std::string
 Dso::classNameFromFileName(const std::string& filePath)
 {
-    char* dirStr = strdup(filePath.c_str());
-    std::string directory(dirname(dirStr));
-    free(dirStr);
-    char* baseStr = strdup(filePath.c_str());
-    std::string baseName(basename(baseStr));
-    free(baseStr);
+    std::filesystem::path p(filePath);
+    std::string directory(p.parent_path().string());
+    std::string baseName(p.stem().string());
 
     // Bail early if we can't determine the class name.
 
@@ -228,15 +226,10 @@ Dso::getDestroy()
 bool
 Dso::isValidDso(const std::string& filePath, bool proxyModeEnabled)
 {
-    // Break the path into directory and basename components. Painfully, both
-    // dirname() and basename() may do just about anything with your pointers,
-    // so its safest to make a copy first.
-    char* dirStr = strdup(filePath.c_str());
-    std::string directory(dirname(dirStr));
-    free(dirStr);
-    char* baseStr = strdup(filePath.c_str());
-    std::string baseName(basename(baseStr));
-    free(baseStr);
+    // Break the path into directory and basename components.
+    std::filesystem::path p = filePath;
+    std::string directory(p.parent_path().string());
+    std::string baseName(p.filename().string());
 
     // Bail early if we can't determine the class name.
     const char* extension = (proxyModeEnabled) ? ".so.proxy" : ".so";

lib/scene/rdl2/DsoFinder.cc

@@ -9,74 +9,89 @@
 
 #include <cstdlib>
 #include <vector>
-#include <dirent.h>
-#include <libgen.h>
+
+#include <filesystem>
 
 namespace scene_rdl2 {
 namespace rdl2 {
 
-using util::Args;
+#ifdef _WIN32
+static const std::string sRaasRender("moonray.exe");
+static const std::string sOsPathSep(";");
+#else
+static const std::string sRaasRender("moonray");
+static const std::string sOsPathSep(":");
+#endif
 
-int isMatching(const dirent* entry) {
-    std::string name = "raas_render";
-    if (name == std::string(entry->d_name)) {
-        return 1;
-    }
-    
-    return 0;
-}
+using util::Args;
 
 std::string
 DsoFinder::guessDsoPath()
 {
     std::string dsoPath = "";
-    dirent** nameList;
-    
+
     // First, search PATH for raas_render executable
     const std::string pathEnv = util::getenv<std::string>("PATH");
     if (pathEnv.empty()) {
         return "";
     }
-    
-    size_t found = pathEnv.find(':');
-    int numFound;
-    std::string path;
+    bool pathFound = false;
+    size_t found = pathEnv.find(sOsPathSep);
+    std::filesystem::path path;
     if (found == std::string::npos) { // single path
-        path = pathEnv;
-        numFound = scandir(path.c_str(), &nameList, isMatching, alphasort);
+        path = std::filesystem::path(pathEnv).make_preferred();
+
+        if (std::filesystem::exists(path)) {
+            for (auto const& dirEntry : std::filesystem::directory_iterator(path)) {
+                if (dirEntry.path().filename().string() == sRaasRender) {
+                    pathFound = true;
+                    break;
+                }
+            }
+        }
     } else {
         int counter = 0;
         while (found != std::string::npos) {
-            path = pathEnv.substr(counter, found - counter);
-            numFound = scandir(path.c_str(), &nameList, isMatching, alphasort);
-            if (numFound > 0) {
+            path = std::filesystem::path(pathEnv.substr(counter, found - counter)).make_preferred();
+            if (std::filesystem::exists(path)) {
+                for ( const auto & dirEntry : std::filesystem::directory_iterator(path)) {
+                    std::string file = dirEntry.path().stem().string();
+                    if (file == sRaasRender) {
+                        pathFound = true;
+                        break;
+                    }
+                }
+            }
+            if (pathFound) {
                 break;
             }
             counter = found + 1;
-            found = pathEnv.find(':', found + 1);
+            found = pathEnv.find(sOsPathSep, found + 1);
         }
-        
-        if (numFound <= 0) { // Haven't found raas_render yet
-            // Process last path
-            path = pathEnv.substr(counter);
-            numFound = scandir(path.c_str(), &nameList, isMatching, alphasort);
+    }
+
+    if (pathFound) {
+        std::filesystem::path raasRdl2dso = std::filesystem::path(std::filesystem::absolute(path.parent_path()) / "rdl2dso").make_preferred();
+        if (std::filesystem::exists(raasRdl2dso)) {
+            dsoPath = raasRdl2dso.string();
         }
     }
-    
-    if (numFound > 0) {
-        // We found raas_render, now construct path to rdl2dso
-        // This assumes that the immediate parent directory is /bin
-        char* buf = realpath(path.c_str(), NULL); // Resolve any relative links
-        dsoPath = std::string(dirname(buf)) + "/" + "rdl2dso";
-        free(buf);
+#ifndef __APPLE__
+    else {
+#ifdef _WIN32
+        char exePathCStr[MAX_PATH];
+        ::GetModuleFileNameA(nullptr, exePathCStr, MAX_PATH);
+        std::filesystem::path exePath(exePathCStr);
+#else
+        std::filesystem::path exePath("/proc/self/exe");
+        exePath = std::filesystem::canonical(exePath);
+#endif
+        std::filesystem::path raasRdl2dso = std::filesystem::path(std::filesystem::absolute(exePath.parent_path().parent_path()) / "rdl2dso").make_preferred();
+        if (std::filesystem::exists(raasRdl2dso)) {
+            dsoPath = raasRdl2dso.string();
+        }
     }
-    
-    // clean up
-    /*while (numFound--) {
-        free(nameList[numFound]);
-    }*/
-    free(nameList);
-
+#endif
     return dsoPath;
 }
 
@@ -85,14 +100,14 @@ std::string DsoFinder::find() {
     std::string dsoPathString = "."; // Search '.' path first
     if (const char* const dsoPathEnvVar = util::getenv<const char*>("RDL2_DSO_PATH")) {
         // append dso path as sourced from RDL2_DSO_PATH
-        dsoPathString += ":" + std::string(dsoPathEnvVar);
+        dsoPathString += sOsPathSep + std::string(dsoPathEnvVar);
     }
 
     // finally, guess dso path based on location of raas_render
     std::string guessedDsoPath = guessDsoPath();
     if (!guessedDsoPath.empty()) {
         // append dso path as sourced from location of raas_render executable
-        dsoPathString += ":" + guessedDsoPath;   
+        dsoPathString += sOsPathSep + guessedDsoPath;   
     }
 
     return dsoPathString;
@@ -125,7 +140,7 @@ std::string DsoFinder::parseDsoPath(int argc, char* argv[]) {
 
     if (!dsoPath.empty()) {
         // prepend dso path as sourced from command line
-        return dsoPath + ":" + findPath; 
+        return dsoPath + sOsPathSep + findPath; 
     }
 
     return findPath; 

lib/scene/rdl2/SceneContext.cc

@@ -49,6 +49,8 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <filesystem>
+
 namespace scene_rdl2 {
 
 using logging::Logger;
@@ -725,23 +727,18 @@ SceneContext::loadAllSceneClasses()
         // Grab the next path entry.
         std::size_t colonPos = remaining.find_first_of(':');
         std::string directory = remaining.substr(0, colonPos);
-
-        // Grab the contents of each directory.
-        DIR* directoryPtr = opendir(directory.c_str());
-        if (directoryPtr != nullptr) {
-            struct dirent* entryPtr;
-            while ((entryPtr = readdir(directoryPtr))) {
-                std::string fileName(entryPtr->d_name);
-
+        std::filesystem::path p(directory);
+        if (std::filesystem::exists(p)) {
+            for (auto const& dirEntry : std::filesystem::directory_iterator(p)) {
                 // If the file is a valid DSO, then create a SceneClass from it.
-                if (Dso::isValidDso(directory + '/' + fileName, mProxyModeEnabled)) {
+                if (Dso::isValidDso(dirEntry.path().string(), mProxyModeEnabled)) {
                     // Class name is the file name without ".so" (or
                     // ".so.proxy" in proxy mode).
                     std::string className;
                     if (mProxyModeEnabled) {
-                        className = fileName.substr(0, fileName.size() - 9);
+                        className = dirEntry.path().stem().stem().string();
                     } else {
-                        className = fileName.substr(0, fileName.size() - 3);
+                        className = dirEntry.path().stem().string();
                     }
 
                     try {
@@ -754,7 +751,6 @@ SceneContext::loadAllSceneClasses()
                 }
             }
         }
-        closedir(directoryPtr);
 
         // Move to the next path entry.
         if (colonPos != std::string::npos) {

tests/lib/render/util/TestThreadPoolExecutor.cc

@@ -6,7 +6,7 @@
 #include <scene_rdl2/common/rec_time/RecTime.h>
 
 #include <thread>
-#include <unistd.h>
+#include <chrono>
 
 // This directive should not commented out for the release version.
 // This is only used for local debugging purposes.
@@ -101,7 +101,7 @@ TestThreadPoolExecutor::watcherThreadMain(const float maxTestDurationSec)
                       << " duration:" << maxTestDurationSec << " sec\n";
             exit(1);
         }
-        usleep(10000);
+        std::this_thread::sleep_for(std::chrono::microseconds(10000));
     }
 
     std::cerr << ">> Watcher thread shutdown <<\n";