Initial import.

stats.c

@@ -0,0 +1,137 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2016-2017 XMRig       <support@xmrig.com>
+ *
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <pthread.h>
+#include <sys/time.h>
+#include <stdlib.h>
+
+#include "stats.h"
+#include "options.h"
+#include "utils/applog.h"
+#include "persistent_memory.h"
+
+
+static unsigned long accepted_count = 0L;
+static unsigned long rejected_count = 0L;
+static double *thr_hashrates;
+static double *thr_times;
+static uint32_t target = 0;
+
+pthread_mutex_t stats_lock;
+
+
+static int timeval_subtract(struct timeval *result, struct timeval *x, struct timeval *y);
+
+
+/**
+ * @brief stats_init
+ */
+void stats_init() {
+    pthread_mutex_init(&stats_lock, NULL);
+
+    thr_hashrates = (double *) persistent_calloc(opt_n_threads, sizeof(double));
+    thr_times = (double *) persistent_calloc(opt_n_threads, sizeof(double));
+}
+
+
+
+/**
+ * @brief stats_set_target
+ * @param target
+ */
+void stats_set_target(uint32_t new_target)
+{
+    target = new_target;
+
+    applog(LOG_DEBUG, "Pool set diff to %g", ((double) 0xffffffff) / target);
+}
+
+
+/**
+ * @brief stats_share_result
+ * @param result
+ */
+void stats_share_result(bool success)
+{
+    double hashrate = 0.0;
+
+    pthread_mutex_lock(&stats_lock);
+
+    for (int i = 0; i < opt_n_threads; i++) {
+        if (thr_times[i] > 0) {
+            hashrate += thr_hashrates[i] / thr_times[i];
+        }
+    }
+
+    success ? accepted_count++ : rejected_count++;
+    pthread_mutex_unlock(&stats_lock);
+
+    applog(LOG_INFO, "accepted: %lu/%lu (%.2f%%), %.2f H/s at diff %g",
+            accepted_count, accepted_count + rejected_count,
+            100. * accepted_count / (accepted_count + rejected_count), hashrate,
+            (((double) 0xffffffff) / target));
+}
+
+
+void stats_add_hashes(int thr_id, struct timeval *tv_start, unsigned long hashes_done)
+{
+    struct timeval tv_end, diff;
+
+    /* record scanhash elapsed time */
+    gettimeofday(&tv_end, NULL);
+    timeval_subtract(&diff, &tv_end, tv_start);
+
+    if (diff.tv_usec || diff.tv_sec) {
+        pthread_mutex_lock(&stats_lock);
+        thr_hashrates[thr_id] = hashes_done;
+        thr_times[thr_id] = (diff.tv_sec + 1e-6 * diff.tv_usec);
+        pthread_mutex_unlock(&stats_lock);
+    }
+}
+
+
+/* Subtract the `struct timeval' values X and Y,
+   storing the result in RESULT.
+   Return 1 if the difference is negative, otherwise 0.  */
+static int timeval_subtract(struct timeval *result, struct timeval *x, struct timeval *y)
+{
+    /* Perform the carry for the later subtraction by updating Y. */
+    if (x->tv_usec < y->tv_usec) {
+        int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
+        y->tv_usec -= 1000000 * nsec;
+        y->tv_sec += nsec;
+    }
+    if (x->tv_usec - y->tv_usec > 1000000) {
+        int nsec = (x->tv_usec - y->tv_usec) / 1000000;
+        y->tv_usec += 1000000 * nsec;
+        y->tv_sec -= nsec;
+    }
+
+    /* Compute the time remaining to wait.
+     * `tv_usec' is certainly positive. */
+    result->tv_sec = x->tv_sec - y->tv_sec;
+    result->tv_usec = x->tv_usec - y->tv_usec;
+
+    /* Return 1 if result is negative. */
+    return x->tv_sec < y->tv_sec;
+}