diff --git a/CHANGELOG.md b/CHANGELOG.md
index feba3b05..c9909de4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,10 @@
+# v4.6.1-beta
+- [#1272](https://github.com/xmrig/xmrig/pull/1272) Optimized hashrate calculation.
+- [#1273](https://github.com/xmrig/xmrig/issues/1273) Fixed crash when use `GET /2/backends` API endpoint with disabled CUDA.
+
+# v4.6.0-beta
+- [#1263](https://github.com/xmrig/xmrig/pull/1263) Added new option `dataset_host` for NVIDIA GPUs with less than 4 GB memory (RandomX only).
+
 # v4.5.0-beta
 - Added NVIDIA CUDA support via external [CUDA plugun](https://github.com/xmrig/xmrig-cuda). XMRig now is unified 3 in 1 miner.
 
diff --git a/src/backend/common/Hashrate.cpp b/src/backend/common/Hashrate.cpp
index 1c9873e0..dedb7495 100644
--- a/src/backend/common/Hashrate.cpp
+++ b/src/backend/common/Hashrate.cpp
@@ -47,7 +47,6 @@ inline static const char *format(double h, char *buf, size_t size)
 
 
 xmrig::Hashrate::Hashrate(size_t threads) :
-    m_highest(0.0),
     m_threads(threads)
 {
     m_counts     = new uint64_t*[threads];
@@ -100,30 +99,30 @@ double xmrig::Hashrate::calc(size_t threadId, size_t ms) const
 
     uint64_t earliestHashCount = 0;
     uint64_t earliestStamp     = 0;
-    uint64_t lastestStamp      = 0;
-    uint64_t lastestHashCnt    = 0;
     bool haveFullSet           = false;
 
-    for (size_t i = 1; i < kBucketSize; i++) {
-        const size_t idx = (m_top[threadId] - i) & kBucketMask;
+    const uint64_t timeStampLimit = xmrig::Chrono::highResolutionMSecs() - ms;
+    uint64_t* timestamps = m_timestamps[threadId];
+    uint64_t* counts = m_counts[threadId];
 
-        if (m_timestamps[threadId][idx] == 0) {
+    const size_t idx_start = (m_top[threadId] - 1) & kBucketMask;
+    size_t idx = idx_start;
+
+    uint64_t lastestStamp = timestamps[idx];
+    uint64_t lastestHashCnt = counts[idx];
+
+    do {
+        if (timestamps[idx] < timeStampLimit) {
+            haveFullSet = (timestamps[idx] != 0);
+            if (idx != idx_start) {
+                idx = (idx + 1) & kBucketMask;
+                earliestStamp = timestamps[idx];
+                earliestHashCount = counts[idx];
+            }
             break;
         }
-
-        if (lastestStamp == 0) {
-            lastestStamp = m_timestamps[threadId][idx];
-            lastestHashCnt = m_counts[threadId][idx];
-        }
-
-        if (xmrig::Chrono::highResolutionMSecs() - m_timestamps[threadId][idx] > ms) {
-            haveFullSet = true;
-            break;
-        }
-
-        earliestStamp = m_timestamps[threadId][idx];
-        earliestHashCount = m_counts[threadId][idx];
-    }
+        idx = (idx - 1) & kBucketMask;
+    } while (idx != idx_start);
 
     if (!haveFullSet || earliestStamp == 0 || lastestStamp == 0) {
         return nan("");
@@ -150,15 +149,6 @@ void xmrig::Hashrate::add(size_t threadId, uint64_t count, uint64_t timestamp)
 }
 
 
-void xmrig::Hashrate::updateHighest()
-{
-   double highest = calc(ShortInterval);
-   if (std::isnormal(highest) && highest > m_highest) {
-       m_highest = highest;
-   }
-}
-
-
 const char *xmrig::Hashrate::format(double h, char *buf, size_t size)
 {
     return ::format(h, buf, size);
diff --git a/src/backend/common/Hashrate.h b/src/backend/common/Hashrate.h
index b9ca8430..ba60d2ad 100644
--- a/src/backend/common/Hashrate.h
+++ b/src/backend/common/Hashrate.h
@@ -53,9 +53,7 @@ public:
     double calc(size_t ms) const;
     double calc(size_t threadId, size_t ms) const;
     void add(size_t threadId, uint64_t count, uint64_t timestamp);
-    void updateHighest();
 
-    inline double highest() const { return m_highest; }
     inline size_t threads() const { return m_threads; }
 
     static const char *format(double h, char *buf, size_t size);
@@ -70,7 +68,6 @@ private:
     constexpr static size_t kBucketSize = 2 << 11;
     constexpr static size_t kBucketMask = kBucketSize - 1;
 
-    double m_highest;
     size_t m_threads;
     uint32_t* m_top;
     uint64_t** m_counts;
diff --git a/src/backend/common/Workers.cpp b/src/backend/common/Workers.cpp
index 319f2804..8e195b66 100644
--- a/src/backend/common/Workers.cpp
+++ b/src/backend/common/Workers.cpp
@@ -144,8 +144,6 @@ void xmrig::Workers<T>::tick(uint64_t)
 
         d_ptr->hashrate->add(handle->id(), handle->worker()->hashCount(), handle->worker()->timestamp());
     }
-
-    d_ptr->hashrate->updateHighest();
 }
 
 
diff --git a/src/backend/cuda/CudaBackend.cpp b/src/backend/cuda/CudaBackend.cpp
index feb1dd93..812ee270 100644
--- a/src/backend/cuda/CudaBackend.cpp
+++ b/src/backend/cuda/CudaBackend.cpp
@@ -474,19 +474,21 @@ rapidjson::Value xmrig::CudaBackend::toJSON(rapidjson::Document &doc) const
     out.AddMember("algo",       d_ptr->algo.toJSON(), allocator);
     out.AddMember("profile",    profileName().toJSON(), allocator);
 
-    Value versions(kObjectType);
-    versions.AddMember("cuda-runtime",   Value(CudaLib::version(d_ptr->runtimeVersion).c_str(), allocator), allocator);
-    versions.AddMember("cuda-driver",    Value(CudaLib::version(d_ptr->driverVersion).c_str(), allocator), allocator);
-    versions.AddMember("plugin",         String(CudaLib::pluginVersion()).toJSON(doc), allocator);
+    if (CudaLib::isReady()) {
+        Value versions(kObjectType);
+        versions.AddMember("cuda-runtime",   Value(CudaLib::version(d_ptr->runtimeVersion).c_str(), allocator), allocator);
+        versions.AddMember("cuda-driver",    Value(CudaLib::version(d_ptr->driverVersion).c_str(), allocator), allocator);
+        versions.AddMember("plugin",         String(CudaLib::pluginVersion()).toJSON(doc), allocator);
 
-#   ifdef XMRIG_FEATURE_NVML
-    if (NvmlLib::isReady()) {
-        versions.AddMember("nvml",       StringRef(NvmlLib::version()), allocator);
-        versions.AddMember("driver",     StringRef(NvmlLib::driverVersion()), allocator);
+#       ifdef XMRIG_FEATURE_NVML
+        if (NvmlLib::isReady()) {
+            versions.AddMember("nvml",       StringRef(NvmlLib::version()), allocator);
+            versions.AddMember("driver",     StringRef(NvmlLib::driverVersion()), allocator);
+        }
+#       endif
+
+        out.AddMember("versions", versions, allocator);
     }
-#   endif
-
-    out.AddMember("versions", versions, allocator);
 
     if (d_ptr->threads.empty() || !hashrate()) {
         return out;
diff --git a/src/backend/cuda/CudaThread.cpp b/src/backend/cuda/CudaThread.cpp
index 3100b662..d98989ab 100644
--- a/src/backend/cuda/CudaThread.cpp
+++ b/src/backend/cuda/CudaThread.cpp
@@ -40,6 +40,7 @@ static const char *kBlocks      = "blocks";
 static const char *kBSleep      = "bsleep";
 static const char *kIndex       = "index";
 static const char *kThreads     = "threads";
+static const char *kDatasetHost = "dataset_host";
 
 } // namespace xmrig
 
@@ -56,11 +57,19 @@ xmrig::CudaThread::CudaThread(const rapidjson::Value &value)
     m_bfactor   = std::min(Json::getUint(value, kBFactor, m_bfactor), 12u);
     m_bsleep    = Json::getUint(value, kBSleep, m_bsleep);
     m_affinity  = Json::getUint64(value, kAffinity, m_affinity);
+
+    if (Json::getValue(value, kDatasetHost).IsInt()) {
+        m_datasetHost = Json::getInt(value, kDatasetHost, m_datasetHost) != 0;
+    }
+    else {
+        m_datasetHost = Json::getBool(value, kDatasetHost);
+    }
 }
 
 
 xmrig::CudaThread::CudaThread(uint32_t index, nvid_ctx *ctx) :
     m_blocks(CudaLib::deviceInt(ctx, CudaLib::DeviceBlocks)),
+    m_datasetHost(CudaLib::deviceInt(ctx, CudaLib::DeviceDatasetHost)),
     m_threads(CudaLib::deviceInt(ctx, CudaLib::DeviceThreads)),
     m_index(index),
     m_bfactor(CudaLib::deviceUint(ctx, CudaLib::DeviceBFactor)),
@@ -72,12 +81,13 @@ xmrig::CudaThread::CudaThread(uint32_t index, nvid_ctx *ctx) :
 
 bool xmrig::CudaThread::isEqual(const CudaThread &other) const
 {
-    return m_blocks     == other.m_blocks &&
-           m_threads    == other.m_threads &&
-           m_affinity   == other.m_affinity &&
-           m_index      == other.m_index &&
-           m_bfactor    == other.m_bfactor &&
-           m_bsleep     == other.m_bsleep;
+    return m_blocks      == other.m_blocks &&
+           m_threads     == other.m_threads &&
+           m_affinity    == other.m_affinity &&
+           m_index       == other.m_index &&
+           m_bfactor     == other.m_bfactor &&
+           m_bsleep      == other.m_bsleep &&
+           m_datasetHost == other.m_datasetHost;
 }
 
 
@@ -95,5 +105,9 @@ rapidjson::Value xmrig::CudaThread::toJSON(rapidjson::Document &doc) const
     out.AddMember(StringRef(kBSleep),       bsleep(), allocator);
     out.AddMember(StringRef(kAffinity),     affinity(), allocator);
 
+    if (m_datasetHost >= 0) {
+        out.AddMember(StringRef(kDatasetHost), m_datasetHost > 0, allocator);
+    }
+
     return out;
 }
diff --git a/src/backend/cuda/CudaThread.h b/src/backend/cuda/CudaThread.h
index f6523d95..8943ac22 100644
--- a/src/backend/cuda/CudaThread.h
+++ b/src/backend/cuda/CudaThread.h
@@ -47,6 +47,7 @@ public:
     inline int32_t bfactor() const                           { return static_cast<int32_t>(m_bfactor); }
     inline int32_t blocks() const                            { return m_blocks; }
     inline int32_t bsleep() const                            { return static_cast<int32_t>(m_bsleep); }
+    inline int32_t datasetHost() const                       { return m_datasetHost; }
     inline int32_t threads() const                           { return m_threads; }
     inline int64_t affinity() const                          { return m_affinity; }
     inline uint32_t index() const                            { return m_index; }
@@ -58,10 +59,11 @@ public:
     rapidjson::Value toJSON(rapidjson::Document &doc) const;
 
 private:
-    int32_t m_blocks    = 0;
-    int32_t m_threads   = 0;
-    int64_t m_affinity  = -1;
-    uint32_t m_index    = 0;
+    int32_t m_blocks        = 0;
+    int32_t m_datasetHost   = -1;
+    int32_t m_threads       = 0;
+    int64_t m_affinity      = -1;
+    uint32_t m_index        = 0;
 
 #   ifdef _WIN32
     uint32_t m_bfactor      = 6;
diff --git a/src/backend/cuda/runners/CudaBaseRunner.cpp b/src/backend/cuda/runners/CudaBaseRunner.cpp
index 032d50c9..757f91de 100644
--- a/src/backend/cuda/runners/CudaBaseRunner.cpp
+++ b/src/backend/cuda/runners/CudaBaseRunner.cpp
@@ -47,7 +47,7 @@ xmrig::CudaBaseRunner::~CudaBaseRunner()
 bool xmrig::CudaBaseRunner::init()
 {
     m_ctx = CudaLib::alloc(m_data.thread.index(), m_data.thread.bfactor(), m_data.thread.bsleep());
-    if (CudaLib::deviceInfo(m_ctx, m_data.thread.blocks(), m_data.thread.threads(), m_data.algorithm) != 0) {
+    if (CudaLib::deviceInfo(m_ctx, m_data.thread.blocks(), m_data.thread.threads(), m_data.algorithm, m_data.thread.datasetHost()) != 0) {
         return false;
     }
 
diff --git a/src/backend/cuda/runners/CudaRxRunner.cpp b/src/backend/cuda/runners/CudaRxRunner.cpp
index 83bf21ff..20603e76 100644
--- a/src/backend/cuda/runners/CudaRxRunner.cpp
+++ b/src/backend/cuda/runners/CudaRxRunner.cpp
@@ -31,7 +31,8 @@
 #include "crypto/rx/RxDataset.h"
 
 
-xmrig::CudaRxRunner::CudaRxRunner(size_t index, const CudaLaunchData &data) : CudaBaseRunner(index, data)
+xmrig::CudaRxRunner::CudaRxRunner(size_t index, const CudaLaunchData &data) : CudaBaseRunner(index, data),
+  m_datasetHost(data.thread.datasetHost() > 0)
 {
     m_intensity                   = m_data.thread.threads() * m_data.thread.blocks();
     const size_t scratchpads_size = m_intensity * m_data.algorithm.l3();
@@ -59,7 +60,7 @@ bool xmrig::CudaRxRunner::set(const Job &job, uint8_t *blob)
     }
 
     auto dataset = Rx::dataset(job, 0);
-    m_ready = callWrapper(CudaLib::rxPrepare(m_ctx, dataset->raw(), dataset->size(false), m_intensity));
+    m_ready = callWrapper(CudaLib::rxPrepare(m_ctx, dataset->raw(), dataset->size(false), m_datasetHost, m_intensity));
 
     return m_ready;
 }
diff --git a/src/backend/cuda/runners/CudaRxRunner.h b/src/backend/cuda/runners/CudaRxRunner.h
index 06ed1b90..448400bc 100644
--- a/src/backend/cuda/runners/CudaRxRunner.h
+++ b/src/backend/cuda/runners/CudaRxRunner.h
@@ -44,8 +44,9 @@ protected:
     bool set(const Job &job, uint8_t *blob) override;
 
 private:
-    bool m_ready        = false;
-    size_t m_intensity  = 0;
+    bool m_ready             = false;
+    const bool m_datasetHost = false;
+    size_t m_intensity       = 0;
 };
 
 
diff --git a/src/backend/cuda/wrappers/CudaLib.cpp b/src/backend/cuda/wrappers/CudaLib.cpp
index 7264d67d..8d22fefb 100644
--- a/src/backend/cuda/wrappers/CudaLib.cpp
+++ b/src/backend/cuda/wrappers/CudaLib.cpp
@@ -67,7 +67,7 @@ static const char *kVersion                             = "version";
 using alloc_t                                           = nvid_ctx * (*)(uint32_t, int32_t, int32_t);
 using cnHash_t                                          = bool (*)(nvid_ctx *, uint32_t, uint64_t, uint64_t, uint32_t *, uint32_t *);
 using deviceCount_t                                     = uint32_t (*)();
-using deviceInfo_t                                      = int32_t (*)(nvid_ctx *, int32_t, int32_t, int32_t);
+using deviceInfo_t                                      = int32_t (*)(nvid_ctx *, int32_t, int32_t, int32_t, int32_t);
 using deviceInit_t                                      = bool (*)(nvid_ctx *);
 using deviceInt_t                                       = int32_t (*)(nvid_ctx *, CudaLib::DeviceProperty);
 using deviceName_t                                      = const char * (*)(nvid_ctx *);
@@ -78,7 +78,7 @@ using lastError_t                                       = const char * (*)(nvid_
 using pluginVersion_t                                   = const char * (*)();
 using release_t                                         = void (*)(nvid_ctx *);
 using rxHash_t                                          = bool (*)(nvid_ctx *, uint32_t, uint64_t, uint32_t *, uint32_t *);
-using rxPrepare_t                                       = bool (*)(nvid_ctx *, const void *, size_t, uint32_t);
+using rxPrepare_t                                       = bool (*)(nvid_ctx *, const void *, size_t, bool, uint32_t);
 using setJob_t                                          = bool (*)(nvid_ctx *, const void *, size_t, int32_t);
 using version_t                                         = uint32_t (*)(Version);
 
@@ -155,9 +155,9 @@ bool xmrig::CudaLib::rxHash(nvid_ctx *ctx, uint32_t startNonce, uint64_t target,
 }
 
 
-bool xmrig::CudaLib::rxPrepare(nvid_ctx *ctx, const void *dataset, size_t datasetSize, uint32_t batchSize) noexcept
+bool xmrig::CudaLib::rxPrepare(nvid_ctx *ctx, const void *dataset, size_t datasetSize, bool dataset_host, uint32_t batchSize) noexcept
 {
-    return pRxPrepare(ctx, dataset, datasetSize, batchSize);
+    return pRxPrepare(ctx, dataset, datasetSize, dataset_host, batchSize);
 }
 
 
@@ -185,9 +185,9 @@ const char *xmrig::CudaLib::pluginVersion() noexcept
 }
 
 
-int xmrig::CudaLib::deviceInfo(nvid_ctx *ctx, int32_t blocks, int32_t threads, const Algorithm &algorithm) noexcept
+int xmrig::CudaLib::deviceInfo(nvid_ctx *ctx, int32_t blocks, int32_t threads, const Algorithm &algorithm, int32_t dataset_host) noexcept
 {
-    return pDeviceInfo(ctx, blocks, threads, algorithm);
+    return pDeviceInfo(ctx, blocks, threads, algorithm, dataset_host);
 }
 
 
@@ -272,7 +272,7 @@ bool xmrig::CudaLib::load()
         return false;
     }
 
-    if (pVersion(ApiVersion) != 1u) {
+    if (pVersion(ApiVersion) != 2u) {
         return false;
     }
 
diff --git a/src/backend/cuda/wrappers/CudaLib.h b/src/backend/cuda/wrappers/CudaLib.h
index 7fb1c1eb..f18ed350 100644
--- a/src/backend/cuda/wrappers/CudaLib.h
+++ b/src/backend/cuda/wrappers/CudaLib.h
@@ -61,25 +61,27 @@ public:
         DeviceMemoryFree,
         DevicePciBusID,
         DevicePciDeviceID,
-        DevicePciDomainID
+        DevicePciDomainID,
+        DeviceDatasetHost,
     };
 
     static bool init(const char *fileName = nullptr);
     static const char *lastError() noexcept;
     static void close();
 
-    static inline bool isInitialized()   { return m_initialized; }
-    static inline const String &loader() { return m_loader; }
+    static inline bool isInitialized()    { return m_initialized; }
+    static inline bool isReady() noexcept { return m_ready; }
+    static inline const String &loader()  { return m_loader; }
 
     static bool cnHash(nvid_ctx *ctx, uint32_t startNonce, uint64_t height, uint64_t target, uint32_t *rescount, uint32_t *resnonce);
     static bool deviceInit(nvid_ctx *ctx) noexcept;
     static bool rxHash(nvid_ctx *ctx, uint32_t startNonce, uint64_t target, uint32_t *rescount, uint32_t *resnonce) noexcept;
-    static bool rxPrepare(nvid_ctx *ctx, const void *dataset, size_t datasetSize, uint32_t batchSize) noexcept;
+    static bool rxPrepare(nvid_ctx *ctx, const void *dataset, size_t datasetSize, bool dataset_host, uint32_t batchSize) noexcept;
     static bool setJob(nvid_ctx *ctx, const void *data, size_t size, const Algorithm &algorithm) noexcept;
     static const char *deviceName(nvid_ctx *ctx) noexcept;
     static const char *lastError(nvid_ctx *ctx) noexcept;
     static const char *pluginVersion() noexcept;
-    static int deviceInfo(nvid_ctx *ctx, int32_t blocks, int32_t threads, const Algorithm &algorithm) noexcept;
+    static int deviceInfo(nvid_ctx *ctx, int32_t blocks, int32_t threads, const Algorithm &algorithm, int32_t dataset_host = -1) noexcept;
     static int32_t deviceInt(nvid_ctx *ctx, DeviceProperty property) noexcept;
     static nvid_ctx *alloc(uint32_t id, int32_t bfactor, int32_t bsleep) noexcept;
     static std::string version(uint32_t version);
diff --git a/src/version.h b/src/version.h
index e02eec7b..ac6d4eec 100644
--- a/src/version.h
+++ b/src/version.h
@@ -28,15 +28,15 @@
 #define APP_ID        "xmrig"
 #define APP_NAME      "XMRig"
 #define APP_DESC      "XMRig miner"
-#define APP_VERSION   "4.5.0-beta-mo2"
+#define APP_VERSION   "4.6.1-beta-mo1"
 #define APP_DOMAIN    "xmrig.com"
 #define APP_SITE      "www.xmrig.com"
 #define APP_COPYRIGHT "Copyright (C) 2016-2019 xmrig.com"
 #define APP_KIND      "miner"
 
 #define APP_VER_MAJOR  4
-#define APP_VER_MINOR  5
-#define APP_VER_PATCH  0
+#define APP_VER_MINOR  6
+#define APP_VER_PATCH  1
 
 #ifdef _MSC_VER
 #   if (_MSC_VER >= 1920)