Merge pull request #13 from oneapi-src/ethminer/code_update

jgtong · web-flow · commit aec41e576b23 · 2023-09-25T14:03:33.000-07:00
[ethminer] Code updates
diff --git a/ethminer/CLI11/include/CLI/App.hpp b/ethminer/CLI11/include/CLI/App.hpp
@@ -128,7 +128,7 @@ class App {
     Option *help_all_ptr_{nullptr};
 
     /// This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
-    std::shared_ptr<FormatterBase> formatter_{new Formatter()};
+    ///std::shared_ptr<FormatterBase> formatter_{new Formatter()};
 
     /// The error message printing function INHERITABLE
     std::function<std::string(const App *, const Error &e)> failure_message_ = FailureMessage::simple;
@@ -204,7 +204,7 @@ class App {
     Option *config_ptr_{nullptr};
 
     /// This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
-    std::shared_ptr<Config> config_formatter_{new ConfigINI()};
+    ///std::shared_ptr<Config> config_formatter_{new ConfigINI()};
 
     ///@}
 
@@ -233,8 +233,8 @@ class App {
             allow_windows_style_options_ = parent_->allow_windows_style_options_;
             group_ = parent_->group_;
             footer_ = parent_->footer_;
-            formatter_ = parent_->formatter_;
-            config_formatter_ = parent_->config_formatter_;
+            ///formatter_ = parent_->formatter_;
+            ///config_formatter_ = parent_->config_formatter_;
             require_subcommand_max_ = parent_->require_subcommand_max_;
         }
     }
@@ -319,22 +319,22 @@ class App {
     }
 
     /// Set the help formatter
-    App *formatter(std::shared_ptr<FormatterBase> fmt) {
-        formatter_ = fmt;
-        return this;
-    }
+    ///App *formatter(std::shared_ptr<FormatterBase> fmt) {
+    ///    formatter_ = fmt;
+    ///    return this;
+    ///}
 
     /// Set the help formatter
-    App *formatter_fn(std::function<std::string(const App *, std::string, AppFormatMode)> fmt) {
-        formatter_ = std::make_shared<FormatterLambda>(fmt);
-        return this;
-    }
+    ///App *formatter_fn(std::function<std::string(const App *, std::string, AppFormatMode)> fmt) {
+    ///    formatter_ = std::make_shared<FormatterLambda>(fmt);
+    ///    return this;
+    ///}
 
     /// Set the config formatter
-    App *config_formatter(std::shared_ptr<Config> fmt) {
-        config_formatter_ = fmt;
-        return this;
-    }
+    ///App *config_formatter(std::shared_ptr<Config> fmt) {
+    ///    config_formatter_ = fmt;
+    ///    return this;
+    ///}
 
     /// Check to see if this subcommand was parsed, true only if received on command line.
     bool parsed() const { return parsed_ > 0; }
@@ -1367,9 +1367,9 @@ class App {
 
     /// Produce a string that could be read in as a config of the current values of the App. Set default_also to
     /// include default arguments. Prefix will add a string to the beginning of each option.
-    std::string config_to_str(bool default_also = false, bool write_description = false) const {
-        return config_formatter_->to_config(this, default_also, write_description, "");
-    }
+    ///std::string config_to_str(bool default_also = false, bool write_description = false) const {
+    ///    return config_formatter_->to_config(this, default_also, write_description, "");
+    ///}
 
     /// Makes a help message, using the currently configured formatter
     /// Will only do one subcommand at a time
@@ -1383,19 +1383,19 @@ class App {
         auto selected_subcommands = get_subcommands();
         if(!selected_subcommands.empty())
             return selected_subcommands.at(0)->help(prev, mode);
-        else
-            return formatter_->make_help(this, prev, mode);
+///        else
+///            return formatter_->make_help(this, prev, mode);
     }
 
     ///@}
     /// @name Getters
     ///@{
 
     /// Access the formatter
-    std::shared_ptr<FormatterBase> get_formatter() const { return formatter_; }
+    ///std::shared_ptr<FormatterBase> get_formatter() const { return formatter_; }
 
     /// Access the config formatter
-    std::shared_ptr<Config> get_config_formatter() const { return config_formatter_; }
+    ///std::shared_ptr<Config> get_config_formatter() const { return config_formatter_; }
 
     /// Get the app or subcommand description
     std::string get_description() const { return description_; }
@@ -1624,24 +1624,24 @@ class App {
     // The parse function is now broken into several parts, and part of process
 
     /// Read and process an ini file (main app only)
-    void _process_ini() {
-        // Process an INI file
-        if(config_ptr_ != nullptr) {
-            if(*config_ptr_) {
-                config_ptr_->run_callback();
-                config_required_ = true;
-            }
-            if(!config_name_.empty()) {
-                try {
-                    std::vector<ConfigItem> values = config_formatter_->from_file(config_name_);
-                    _parse_config(values);
-                } catch(const FileError &) {
-                    if(config_required_)
-                        throw;
-                }
-            }
-        }
-    }
+    ///void _process_ini() {
+    ///    // Process an INI file
+    ///    if(config_ptr_ != nullptr) {
+    ///        if(*config_ptr_) {
+    ///            config_ptr_->run_callback();
+    ///            config_required_ = true;
+    ///        }
+    ///        if(!config_name_.empty()) {
+    ///            try {
+    ///                std::vector<ConfigItem> values = config_formatter_->from_file(config_name_);
+    ///                _parse_config(values);
+    ///            } catch(const FileError &) {
+    ///                if(config_required_)
+    ///                    throw;
+    ///            }
+    ///        }
+    ///    }
+    ///}
 
     /// Get envname options if not yet passed. Runs on *all* subcommands.
     void _process_env() {
@@ -1751,8 +1751,8 @@ class App {
 
     /// Process callbacks and such.
     void _process() {
-        _process_ini();
-        _process_env();
+        ///_process_ini();
+        ///_process_env();
         _process_callbacks();
         _process_help_flags();
         _process_requirements();
@@ -1835,7 +1835,7 @@ class App {
         if(op->empty()) {
             // Flag parsing
             if(op->get_type_size() == 0) {
-                op->set_results(config_formatter_->to_flag(item));
+                ///op->set_results(config_formatter_->to_flag(item));
             } else {
                 op->set_results(item.inputs);
                 op->run_callback();
diff --git a/ethminer/CMakeLists.txt b/ethminer/CMakeLists.txt
@@ -44,29 +44,57 @@ option(DEVBUILD   "Log developer metrics"              OFF)
 
 option(GPU_AOT                 "Build AOT for Intel GPU"             OFF)
 option(USE_NVIDIA_BACKEND      "Build for NVIDIA backend"            OFF)
-option(USE_AMDHIP_BACKEND      "Build for AMD HIP backend"           OFF)
+option(USE_AMD_BACKEND         "Build for AMD HIP backend"           OFF)
 option(USE_LOOP_UNROLLING      "Build with loop unrolling SYCL only" OFF)
 option(USE_SM                  "Build for CUDA architecture"     )
 
-set(USE_DEFAULT_FLAGS ON)
-set(INTEL_GPU_CXX_FLAGS  " -O2 -fsycl ")
-set(NVIDIA_GPU_CXX_FLAGS " -O3 -fsycl ")
-set(AMD_GPU_CXX_FLAGS    " -O3 -fsycl ")
-set(ROCM_CXX_FLAGS       " -O3" )
-set(NVCC_CXX_FLAGS       " -O3 ")
+### SYCL RELATED FLAGS START HERE
+set(DEF_INTEL_GENERAL_CXX_FLAGS  " -O2 -fsycl ")
+set(DEF_NVIDIA_GENERAL_CXX_FLAGS " -O3 -fsycl ")
+set(DEF_AMD_GENERAL_CXX_FLAGS    " -O3 -fsycl ")
 
-include_directories(${OPENSSL_INCLUDE_DIR} ${jsoncpp_DIR}/../../../include)
+set(DEF_INTEL_WL_CXX_FLAGS  " ")
+set(DEF_NVIDIA_WL_CXX_FLAGS " ")
+set(DEF_AMD_WL_CXX_FLAGS    " ")
 
-if("${CMAKE_CXX_FLAGS}" STREQUAL "")
-    message(STATUS "Using DEFAULT compilation flags for the application")
-    string(APPEND CMAKE_CXX_FLAGS "${INTEL_GPU_CXX_FLAGS}") # Default flags for NV backend
-else()
-    message(STATUS "OVERRIDING compilation flags")
-    set(USE_DEFAULT_FLAGS OFF)
+if(NOT "${CMAKE_CXX_FLAGS}" STREQUAL "" AND NOT "${OVERRIDE_GENERAL_CXX_FLAGS}" STREQUAL "")
+    message(FATAL_ERROR "Both  CMAKE_CXX_FLAGS and OVERRIDE_GENERAL_CXX_FLAGS cannot be passed in together")
+elseif("${CMAKE_CXX_FLAGS}" STREQUAL "" AND "${OVERRIDE_GENERAL_CXX_FLAGS}" STREQUAL "")
+    message(STATUS "Using DEFAULT compilation flags")
+    set(INTEL_GPU_CXX_FLAGS        "${DEF_INTEL_GENERAL_CXX_FLAGS}   ${DEF_INTEL_WL_CXX_FLAGS}")
+    set(NVIDIA_GPU_CXX_FLAGS       "${DEF_NVIDIA_GENERAL_CXX_FLAGS}  ${DEF_NVIDIA_WL_CXX_FLAGS}")
+    set(AMD_GPU_CXX_FLAGS          "${DEF_AMD_GENERAL_CXX_FLAGS}     ${DEF_AMD_WL_CXX_FLAGS}")
+elseif(NOT "${OVERRIDE_GENERAL_CXX_FLAGS}" STREQUAL "")
+    message(STATUS "OVERRIDING GENERAL compilation flags")
+    set(INTEL_GPU_CXX_FLAGS        "${OVERRIDE_GENERAL_CXX_FLAGS}    ${DEF_INTEL_WL_CXX_FLAGS}")
+    set(NVIDIA_GPU_CXX_FLAGS       "${OVERRIDE_GENERAL_CXX_FLAGS}    ${DEF_NVIDIA_WL_CXX_FLAGS}")
+    set(AMD_GPU_CXX_FLAGS          "${OVERRIDE_GENERAL_CXX_FLAGS}    ${DEF_AMD_WL_CXX_FLAGS}")
+elseif(NOT "${CMAKE_CXX_FLAGS}" STREQUAL "")
+    message(STATUS "OVERRIDING GENERAL and WORKLOAD SPECIFIC compilation flags")
+    set(INTEL_GPU_CXX_FLAGS        "${CMAKE_CXX_FLAGS}")
+    set(NVIDIA_GPU_CXX_FLAGS       "${CMAKE_CXX_FLAGS}")
+    set(AMD_GPU_CXX_FLAGS          "${CMAKE_CXX_FLAGS}")
 endif()
+### END OF SYCL RELATED FLAGS
+
+### NVCC RELATED FLAGS START HERE
+set(NVCC_WL_CXX_FLAGS       " ")
+set(NVCC_DEF_CXX_FLAGS      " -O3 ")
+set(NVCC_DEF_COMBINED_FLAGS "${NVCC_WL_CXX_FLAGS} ${NVCC_DEF_CXX_FLAGS} ")
+### END OF NVCC RELATED FLAGS
+
+
+### ROCM RELATED FLAGS START HERE 
+set(ROCM_WL_CXX_FLAGS        "  ")
+set(ROCM_DEF_CXX_FLAGS       " -O3 -D__HIP_PLATFORM_AMD__  " )
+set(ROCM_DEF_COMBINED_FLAGS  " ${ROCM_WL_CXX_FLAGS} ${ROCM_DEF_CXX_FLAGS} ")
+### END OF ROCM RELATED FLAGS
+
+include_directories(${OPENSSL_INCLUDE_DIR} ${jsoncpp_DIR}/../../../include)
 
 # JIT compilation 
-if(GPU_AOT) 
+if(GPU_AOT)
+    set(CMAKE_CXX_FLAGS "${INTEL_GPU_CXX_FLAGS}")
     if( (${GPU_AOT} STREQUAL "pvc") OR (${GPU_AOT} STREQUAL "PVC") )
         message(STATUS "Enabling Intel GPU AOT compilation for ${GPU_AOT}")
         string(APPEND CMAKE_CXX_FLAGS " -fsycl-targets=spir64_gen -Xs \"-device 0x0bd5 -revision_id 0x2f\" -Xs \"-options -ze-opt-large-register-file\" ") # Default flag for pvc 
@@ -76,40 +104,56 @@ if(GPU_AOT)
     endif()
 elseif(USE_NVIDIA_BACKEND)    
     message(STATUS "Enabling NVIDIA backend")
-    if(USE_DEFAULT_FLAGS)
-        set(CMAKE_CXX_FLAGS "${NVIDIA_GPU_CXX_FLAGS}") # Default flags for NV backend
-    endif()
+    set(CMAKE_CXX_FLAGS "${NVIDIA_GPU_CXX_FLAGS}")
     string(APPEND CMAKE_CXX_FLAGS " -fsycl-targets=nvptx64-nvidia-cuda ") # -O3 will be used, even though -O2 was set earlier 
     if(USE_SM)
         message(STATUS "Building for SM_${USE_SM} architecture")
         string(APPEND CMAKE_CXX_FLAGS " -Xsycl-target-backend --cuda-gpu-arch=sm_${USE_SM}")
     endif()
-elseif(USE_AMDHIP_BACKEND)
-    message(STATUS "Enabling AMD HIP backend for ${USE_AMDHIP_BACKEND} AMD architecture")
-    if(USE_DEFAULT_FLAGS)
-        set(CMAKE_CXX_FLAGS "${AMD_GPU_CXX_FLAGS}")
+elseif(USE_AMD_BACKEND)
+    if ("${USE_AMD_ARCH}" STREQUAL "")
+        message(FATAL_ERROR "Must specify AMD arch, e.g., -DUSE_AMD_ARCH=gfx90a")
     endif()
-    string(APPEND CMAKE_CXX_FLAGS " -fsycl-targets=amdgcn-amd-amdhsa -Xsycl-target-backend --offload-arch=${USE_AMDHIP_BACKEND}  ")
-    add_compile_options(-DUSE_AMDHIP_BACKEND)
+    message(STATUS "Enabling AMD backend for ${USE_AMD_ARCH} AMD architecture")
+    set(CMAKE_CXX_FLAGS "${AMD_GPU_CXX_FLAGS}")
+    string(APPEND CMAKE_CXX_FLAGS " -fsycl-targets=amdgcn-amd-amdhsa -Xsycl-target-backend --offload-arch=${USE_AMD_ARCH}  ")
+    add_compile_options(-DUSE_AMD_BACKEND)
 endif()
 
-if(USE_AMDHIP_BACKEND)
+if(USE_AMD_BACKEND)
     message(STATUS "Using 64 thread shuffle function code path")
 else()
     message(STATUS "Using 32 thread shuffle function code path")
 endif()
 
 if (ETHASHCUDA)
-    if (USE_DEFAULT_FLAGS)
-        message(STATUS "Using NVIDIA CUDA flags")
-        set(CMAKE_CXX_FLAGS "${NVCC_CXX_FLAGS}")
+    message(STATUS "Compiling for NVCC")
+    if(NOT "${CMAKE_CXX_FLAGS}" STREQUAL "" AND NOT "${OVERRIDE_GENERAL_CXX_FLAGS}" STREQUAL "")
+        message(FATAL_ERROR "Both  CMAKE_CXX_FLAGS and OVERRIDE_GENERAL_CXX_FLAGS cannot be passed in together")
+    elseif("${CMAKE_CXX_FLAGS}" STREQUAL "" AND "${OVERRIDE_GENERAL_CXX_FLAGS}" STREQUAL "")
+        message(STATUS "Using DEFAULT compilation flags")
+        set(CMAKE_CXX_FLAGS "${NVCC_DEF_COMBINED_FLAGS}")
+    elseif(NOT "${OVERRIDE_GENERAL_CXX_FLAGS}" STREQUAL "")
+        message(STATUS "OVERRIDING GENERAL compilation flags")
+        set(CMAKE_CXX_FLAGS "${OVERRIDE_GENERAL_CXX_FLAGS}")
+        string(APPEND CMAKE_CXX_FLAGS ${NVCC_WL_CXX_FLAGS})
+    elseif(NOT "${CMAKE_CXX_FLAGS}" STREQUAL "")
+        message(STATUS "OVERRIDING GENERAL and WORKLOAD SPECIFIC compilation flags")
     endif()
 endif()
 
 if (ETHASHHIP)
-    if (USE_DEFAULT_FLAGS)
-        message(STATUS "Using ROCM flags")
-        set(CMAKE_CXX_FLAGS "${ROCM_CXX_FLAGS}")
+    if(NOT "${CMAKE_CXX_FLAGS}" STREQUAL "" AND NOT "${OVERRIDE_GENERAL_CXX_FLAGS}" STREQUAL "")
+        message(FATAL_ERROR "Both  CMAKE_CXX_FLAGS and OVERRIDE_GENERAL_CXX_FLAGS cannot be passed in together")
+    elseif("${CMAKE_CXX_FLAGS}" STREQUAL "" AND "${OVERRIDE_GENERAL_CXX_FLAGS}" STREQUAL "")
+        message(STATUS "Using DEFAULT compilation flags")
+        set(CMAKE_CXX_FLAGS "${ROCM_DEF_COMBINED_FLAGS}")
+    elseif(NOT "${OVERRIDE_GENERAL_CXX_FLAGS}" STREQUAL "")
+        message(STATUS "OVERRIDING GENERAL compilation flags")
+        set(CMAKE_CXX_FLAGS "${OVERRIDE_GENERAL_CXX_FLAGS}")
+        string(APPEND CMAKE_CXX_FLAGS ${ROCM_WL_CXX_FLAGS})
+    elseif(NOT "${CMAKE_CXX_FLAGS}" STREQUAL "")
+        message(STATUS "OVERRIDING GENERAL and WORKLOAD SPECIFIC compilation flags")
     endif()
     
     if (USE_ROCM_PATH) 
@@ -187,9 +231,6 @@ include_directories(${Boost_INCLUDE_DIRS}/include ${OPENSSL_INCLUDE_DIR} ${jsonc
 
 if (ETHASHCUDA)
     add_subdirectory(libethash-cuda)
-    if (USE_DEFAULT_FLAGS)
-        set(CMAKE_CXX_FLAGS "${NVCC_CXX_FLAGS}")
-    endif()
 endif ()
 if (ETHASHHIP)
     add_subdirectory(libethash-hip)
diff --git a/ethminer/README.md b/ethminer/README.md
@@ -83,7 +83,7 @@ CC=/path/to/compiler/bin/clang cmake=/path/to/compiler/bin/clang++ .. -DUSE_NVID
 To compile the code for AMD, please use the following `cmake` command:
 
 ```
-CC=/path/to/compiler/bin/clang cmake=/path/to/compiler/bin/clang++ .. -DUSE_AMDHIP_BACKEND={gfx90a|gfx908} -DETHASHSYCL=ON  
+CC=/path/to/compiler/bin/clang cmake=/path/to/compiler/bin/clang++ .. -DUSE_AMD_BACKEND=ON -DUSE_AMD_ARCH={gfx90a|gfx908} -DETHASHSYCL=ON  
 
 ```
 
diff --git a/ethminer/libdevcore/vector_ref.h b/ethminer/libdevcore/vector_ref.h
@@ -26,6 +26,7 @@
 #include <string>
 #include <type_traits>
 #include <vector>
+#include <cstdint>
 
 namespace dev
 {
diff --git a/ethminer/libethash-sycl/SYCLMiner.cpp b/ethminer/libethash-sycl/SYCLMiner.cpp
@@ -51,6 +51,7 @@ along with ethminer.  If not, see <http://www.gnu.org/licenses/>.
 #include <execinfo.h>
 
 #include <iostream>
+#include <set>
 
 using namespace dev;
 using namespace eth;
@@ -139,7 +140,7 @@ SYCLMiner::SYCLMiner(unsigned _index, SYSettings _settings, DeviceDescriptor & /
         d_header               = sycl::malloc_device<hash32_t>   (1,  m_DefaultQueue);
         d_target               = sycl::malloc_device<uint64_t>   (1,  m_DefaultQueue);
         keccak_round_constants = sycl::malloc_device<sycl::uint2>(24, m_DefaultQueue); // There's 24 constants to store
-#ifdef USE_AMDHIP_BACKEND
+#ifdef USE_AMD_BACKEND
         pdShuffleOffsets = sycl::malloc_device<int>(64, m_DefaultQueue);
 #else
         pdShuffleOffsets = sycl::malloc_device<int>(32, m_DefaultQueue);
diff --git a/ethminer/libethash-sycl/ethash_sycl_miner_kernel.cpp b/ethminer/libethash-sycl/ethash_sycl_miner_kernel.cpp
@@ -116,7 +116,7 @@ void ethash_calculate_dag_item(uint32_t start, sycl::nd_item<1> item_ct1, uint32
             else if (item_ct1.get_sub_group().get_local_id() < 32)
                 shuffle_index = item_ct1.get_sub_group().shuffle(parent_index, t + 28);
 
-#ifdef USE_AMDHIP_BACKEND // Shuffle on AMD GPUs is done over 64 threads
+#ifdef USE_AMD_BACKEND // Shuffle on AMD GPUs is done over 64 threads
             else if (item_ct1.get_sub_group().get_local_id() < 36)
                 shuffle_index = item_ct1.get_sub_group().shuffle(parent_index, t + 32);
             else if (item_ct1.get_sub_group().get_local_id() < 40)
@@ -156,7 +156,7 @@ void ethash_calculate_dag_item(uint32_t start, sycl::nd_item<1> item_ct1, uint32
                     w1 = w + 24;
                 else if (iSubGroupThreadId < 32)
                     w1 = w + 28;
-#ifdef USE_AMDHIP_BACKEND
+#ifdef USE_AMD_BACKEND
                 else if (iSubGroupThreadId < 36)
                     w1 = w + 32;
                 else if (iSubGroupThreadId < 40)
diff --git a/ethminer/libethash-sycl/ethash_sycl_miner_kernel_globals.h b/ethminer/libethash-sycl/ethash_sycl_miner_kernel_globals.h
@@ -58,7 +58,7 @@ std::vector<int> const vShuffleOffsets({
     24,
     24,
     24,
-#ifdef USE_AMDHIP_BACKEND
+#ifdef USE_AMD_BACKEND
     32,
     32,
     32,

Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@`
`26`	`26`	`#include <string>`
`27`	`27`	`#include <type_traits>`
`28`	`28`	`#include <vector>`
	`29`	`+#include <cstdint>`
`29`	`30`
`30`	`31`	`namespace dev`
`31`	`32`	`{`