[Code] Add lib logger and expose this feature into python api

Author: EgorOrachyov

README.md

@@ -268,7 +268,7 @@ This project is licensed under MIT License. License text can be found in the
 ## Acknowledgments
 
 This is a research project of the Programming Languages and Tools Laboratory
-at JetBrains Research company. Laboratory website [link](https://research.jetbrains.org/groups/plt_lab/).
+at JetBrains-Research. Laboratory website [link](https://research.jetbrains.org/groups/plt_lab/).
 
 ## Also
 

cubool/CMakeLists.txt

@@ -21,7 +21,9 @@ set(CUBOOL_SOURCES
     sources/core/library.cpp
     sources/core/library.hpp
     sources/core/matrix.cpp
-    sources/core/matrix.hpp)
+    sources/core/matrix.hpp
+    sources/io/logger.cpp
+    sources/io/logger.hpp)
 
 set(CUBOOL_C_API_SOURCES
     include/cubool/cubool.h
@@ -30,6 +32,7 @@ set(CUBOOL_C_API_SOURCES
     sources/cuBool_LicenseInfo_Get.cpp
     sources/cuBool_Initialize.cpp
     sources/cuBool_Finalize.cpp
+    sources/cuBool_SetupLogger.cpp
     sources/cuBool_Matrix_New.cpp
     sources/cuBool_Matrix_Build.cpp
     sources/cuBool_Matrix_ExtractPairs.cpp

cubool/include/cubool/cubool.h

@@ -83,7 +83,13 @@ typedef enum cuBool_Hint {
     /** Accumulate result of the operation in the result matrix */
     CUBOOL_HINT_ACCUMULATE = 0x8,
     /** Finalize library state, even if not all resources were explicitly released */
-    CUBOOL_HINT_RELAXED_FINALIZE = 0x16
+    CUBOOL_HINT_RELAXED_FINALIZE = 0x16,
+    /** Logging hint: log error message */
+    CUBOOL_HINT_LOG_ERROR = 0x32,
+    /** Logging hint: log warning message */
+    CUBOOL_HINT_LOG_WARNING = 0x64,
+    /** Logging hint: log all messages */
+    CUBOOL_HINT_LOG_ALL = 0x128,
 } cuBool_Hint;
 
 /** Hit mask */
@@ -141,6 +147,26 @@ CUBOOL_EXPORT CUBOOL_API cuBool_Status cuBool_Version_Get(
     int* sub
 );
 
+/**
+ * Allows to setup logging file for all operations, invoked after this function call.
+ * Empty hints field is interpreted as `CUBOOL_HINT_LOG_ALL` by default.
+ *
+ * @note It is safe to call this function before the library is initialized.
+ *
+ * @note Pass `CUBOOL_HINT_LOG_ERROR` to include error messages into log
+ * @note Pass `CUBOOL_HINT_LOG_WARNING` to include warning messages into log
+ * @note Pass `CUBOOL_HINT_LOG_ALL` to include all messages into log
+ *
+ * @param logFileName File name in the encoding of the target platform.
+ * @param hints Logging hints to filter messages.
+ *
+ * @return Error code on this operation
+ */
+CUBOOL_EXPORT CUBOOL_API cuBool_Status cuBool_SetupLogging(
+    const char* logFileName,
+    cuBool_Hints hints
+);
+
 /**
  * Initialize library instance object, which provides context to all library operations and primitives.
  * This function must be called before any other library function is called,
@@ -171,13 +197,13 @@ CUBOOL_EXPORT CUBOOL_API cuBool_Status cuBool_Finalize(
 /**
  * Query device capabilities/properties if cuda compatible device is present.
  *
- * @note This function must be called only for cuda backend.
+ * @note This function returns no actual info if cuda backend is not presented.
  * @param deviceCaps Pointer to device caps structure to store result
  *
  * @return Error if cuda device not present or if failed to query capabilities
  */
 CUBOOL_EXPORT CUBOOL_API cuBool_Status cuBool_DeviceCaps_Get(
-        CuBool_DeviceCaps* deviceCaps
+    CuBool_DeviceCaps* deviceCaps
 );
 
 /**

cubool/sources/core/library.cpp

@@ -27,7 +27,12 @@
 #include <core/matrix.hpp>
 #include <backend/backend_base.hpp>
 #include <backend/matrix_base.hpp>
+#include <io/logger.hpp>
+
+#include <fstream>
 #include <iostream>
+#include <memory>
+#include <iomanip>
 
 #ifdef CUBOOL_WITH_CUDA
 #include <cuda/cuda_backend.hpp>
@@ -41,6 +46,7 @@ namespace cubool {
 
     std::unordered_set<class MatrixBase*> Library::mAllocated;
     BackendBase* Library::mBackend = nullptr;
+    std::shared_ptr<class Logger>  Library::mLogger = std::make_shared<DummyLogger>();
     bool Library::mRelaxedRelease = false;
 
     void Library::initialize(hints initHints) {
@@ -58,6 +64,8 @@ namespace cubool {
             if (!mBackend->isInitialized()) {
                 delete mBackend;
                 mBackend = nullptr;
+
+                mLogger->logWarning("Failed to initialize Cuda backend");
             }
 #endif
         }
@@ -71,6 +79,8 @@ namespace cubool {
             if (!mBackend->isInitialized()) {
                 delete mBackend;
                 mBackend = nullptr;
+
+                mLogger->logWarning("Failed to initialize Cpu fallback backend");
             }
         }
 #endif
@@ -101,6 +111,62 @@ namespace cubool {
         CHECK_RAISE_CRITICAL_ERROR(mBackend != nullptr || mRelaxedRelease, InvalidState, "Library is not initialized");
     }
 
+    void Library::setupLogging(const char *logFileName, cuBool_Hints hints) {
+        CHECK_RAISE_ERROR(logFileName != nullptr, InvalidArgument, "Null file name is not allowed");
+
+        auto lofFile = std::make_shared<std::ofstream>();
+
+        lofFile->open(logFileName, std::ios::out);
+
+        if (!lofFile->is_open()) {
+            RAISE_ERROR(InvalidArgument, "Failed to create logging file");
+        }
+
+        // Create logger and setup filters && post-actions
+        auto textLogger = std::make_shared<TextLogger>();
+
+        textLogger->addFilter([=](Logger::Level level, const std::string& message) -> bool {
+            bool all = hints == 0x0 || (hints & CUBOOL_HINT_LOG_ALL);
+            bool error = hints & CUBOOL_HINT_LOG_ERROR;
+            bool warning = hints & CUBOOL_HINT_LOG_WARNING;
+
+            return all ||
+                    (error && level == Logger::Level::Error) ||
+                    (warning && level == Logger::Level::Warning);
+        });
+
+        textLogger->addOnLoggerAction([=](size_t id, Logger::Level level, const std::string& message) {
+            auto& file = *lofFile;
+
+            const auto idSize = 10;
+            const auto levelSize = 20;
+
+            file << "[" << std::setw(idSize) << id << std::setw(-1) << "]";
+            file << "[" << std::setw(levelSize);
+            switch (level) {
+                case Logger::Level::Info:
+                    file << "Level::Info";
+                    break;
+                case Logger::Level::Warning:
+                    file << "Level::Warning";
+                    break;
+                case Logger::Level::Error:
+                    file << "Level::Error";
+                    break;
+                default:
+                    file << "Level::Always";
+            }
+            file << std::setw(-1) << "] ";
+            file << message << std::endl <<  std::endl;
+        });
+
+        // Assign new text logger
+        mLogger = textLogger;
+
+        // Initial message
+        mLogger->logInfo("*** cuBool::Logger file ***");
+    }
+
     MatrixBase *Library::createMatrix(size_t nrows, size_t ncols) {
         CHECK_RAISE_ERROR(nrows > 0, InvalidArgument, "Cannot create matrix with zero dimension");
         CHECK_RAISE_ERROR(ncols > 0, InvalidArgument, "Cannot create matrix with zero dimension");
@@ -118,7 +184,11 @@ namespace cubool {
     }
 
     void Library::handleError(const std::exception& error) {
-        std::cerr << "cuBool:Error: " << error.what() << std::endl;
+        mLogger->log(Logger::Level::Error, error.what());
+    }
+
+    class Logger * Library::getLogger() {
+        return mLogger.get();
     }
 
 }

cubool/sources/core/library.hpp

@@ -37,13 +37,16 @@ namespace cubool {
         static void initialize(hints initHints);
         static void finalize();
         static void validate();
+        static void setupLogging(const char* logFileName, cuBool_Hints hints);
         static class MatrixBase *createMatrix(size_t nrows, size_t ncols);
         static void releaseMatrix(class MatrixBase *matrixBase);
         static void handleError(const std::exception& error);
+        static class Logger* getLogger();
 
     private:
         static std::unordered_set<class MatrixBase*> mAllocated;
         static class BackendBase* mBackend;
+        static std::shared_ptr<class Logger> mLogger;
         static bool mRelaxedRelease;
     };
 

cubool/sources/cuBool_SetupLogger.cpp

@@ -0,0 +1,34 @@
+/**********************************************************************************/
+/* MIT License                                                                    */
+/*                                                                                */
+/* Copyright (c) 2020, 2021 JetBrains-Research                                    */
+/*                                                                                */
+/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
+/* of this software and associated documentation files (the "Software"), to deal  */
+/* in the Software without restriction, including without limitation the rights   */
+/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
+/* copies of the Software, and to permit persons to whom the Software is          */
+/* furnished to do so, subject to the following conditions:                       */
+/*                                                                                */
+/* The above copyright notice and this permission notice shall be included in all */
+/* copies or substantial portions of the Software.                                */
+/*                                                                                */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
+/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
+/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
+/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
+/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
+/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
+/* SOFTWARE.                                                                      */
+/**********************************************************************************/
+
+#include <cuBool_Common.hpp>
+
+cuBool_Status cuBool_SetupLogging(
+        const char* logFileName,
+        cuBool_Hints hints
+) {
+    CUBOOL_BEGIN_BODY
+        cubool::Library::setupLogging(logFileName, hints);
+    CUBOOL_END_BODY
+}

cubool/sources/io/logger.cpp

@@ -0,0 +1,93 @@
+/**********************************************************************************/
+/* MIT License                                                                    */
+/*                                                                                */
+/* Copyright (c) 2020, 2021 JetBrains-Research                                    */
+/*                                                                                */
+/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
+/* of this software and associated documentation files (the "Software"), to deal  */
+/* in the Software without restriction, including without limitation the rights   */
+/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
+/* copies of the Software, and to permit persons to whom the Software is          */
+/* furnished to do so, subject to the following conditions:                       */
+/*                                                                                */
+/* The above copyright notice and this permission notice shall be included in all */
+/* copies or substantial portions of the Software.                                */
+/*                                                                                */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
+/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
+/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
+/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
+/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
+/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
+/* SOFTWARE.                                                                      */
+/**********************************************************************************/
+
+#include <io/logger.hpp>
+
+namespace cubool {
+
+    void Logger::logInfo(const std::string &message) {
+        this->log(Level::Info, message);
+    }
+
+    void Logger::logWarning(const std::string &message) {
+        this->log(Level::Warning, message);
+    }
+
+    void Logger::logError(const std::string &message) {
+        this->log(Level::Error, message);
+    }
+
+    void TextLogger::log(Logger::Level level, const std::string &message) {
+        bool pass = true;
+
+        // If pass all filters
+        for (const auto& filter: mFilters) {
+            pass = pass && filter(level, message);
+        }
+
+        if (pass || level == Level::Always) {
+            auto id = mNextMessageId++;
+
+            Entry entry;
+            entry.message = message;
+            entry.level = level;
+            entry.id = id;
+
+            mEntries.emplace_back(std::move(entry));
+
+            // Notify listeners
+            for (const auto& action: mOnLogged) {
+                action(id, level, message);
+            }
+        }
+    }
+
+    size_t TextLogger::getMessagesCount() const {
+        return mEntries.size();
+    }
+
+    void TextLogger::addFilter(Filter filter) {
+        mFilters.emplace_back(std::move(filter));
+    }
+
+    void TextLogger::removeAllFilters() {
+        mFilters.clear();
+    }
+
+    void TextLogger::addOnLoggerAction(OnLogged onLogged) {
+        mOnLogged.emplace_back(std::move(onLogged));
+    }
+
+    void TextLogger::removeAllOnLoggedActions() {
+        mOnLogged.clear();
+    }
+
+    void DummyLogger::log(Logger::Level level, const std::string &message) {
+        // no op.
+    }
+
+    size_t DummyLogger::getMessagesCount() const {
+        return 0;
+    }
+}