Measure Job Submit Latency

.clangd

@@ -0,0 +1,3 @@
+CompileFlags:
+    Remove: [-f*, -m*]
+    Add: -Wno-unknown-warning-option

.gitignore

@@ -34,3 +34,5 @@ managed_components/*
 .DS_Store
 Thumbs.db
 debug.log
+.cache
+.vscode/settings.json

components/asic/asic.c

@@ -32,17 +32,17 @@ uint8_t ASIC_init(GlobalState * GLOBAL_STATE)
     return ESP_OK;
 }
 
-task_result * ASIC_process_work(GlobalState * GLOBAL_STATE)
+bool ASIC_process_work(GlobalState * GLOBAL_STATE, task_result * result)
 {
     switch (GLOBAL_STATE->DEVICE_CONFIG.family.asic.id) {
         case BM1397:
-            return BM1397_process_work(GLOBAL_STATE);
+            return BM1397_process_work(GLOBAL_STATE, result);
         case BM1366:
-            return BM1366_process_work(GLOBAL_STATE);
+            return BM1366_process_work(GLOBAL_STATE, result);
         case BM1368:
-            return BM1368_process_work(GLOBAL_STATE);
+            return BM1368_process_work(GLOBAL_STATE, result);
         case BM1370:
-            return BM1370_process_work(GLOBAL_STATE);
+            return BM1370_process_work(GLOBAL_STATE, result);
     }
     return NULL;
 }

components/asic/bm1366.c

@@ -73,8 +73,6 @@ typedef struct __attribute__((__packed__))
 
 static const char * TAG = "bm1366";
 
-static task_result result;
-
 static int address_interval;
 
 /// @brief
@@ -311,26 +309,24 @@ void BM1366_send_work(void * pvParameters, bm_job * next_bm_job)
     _send_BM1366((TYPE_JOB | GROUP_SINGLE | CMD_WRITE), (uint8_t *)&job, sizeof(BM1366_job), BM1366_DEBUG_WORK);
 }
 
-task_result * BM1366_process_work(void * pvParameters)
+bool BM1366_process_work(void * pvParameters, task_result * result)
 {
     bm1366_asic_result_t asic_result = {0};
 
-    memset(&result, 0, sizeof(task_result));
-
-    if (receive_work((uint8_t *)&asic_result, sizeof(asic_result)) == ESP_FAIL) {
-        return NULL;
+    if (receive_work((uint8_t *)&asic_result, sizeof(asic_result), &result->receive_time_us) == ESP_FAIL) {
+        return false;
     }
 
     if (!asic_result.is_job_response) {
-        result.register_type = REGISTER_MAP[asic_result.cmd.register_address];
-        if (result.register_type == REGISTER_INVALID) {
+        result->register_type = REGISTER_MAP[asic_result.cmd.register_address];
+        if (result->register_type == REGISTER_INVALID) {
             ESP_LOGW(TAG, "Unknown register read: %02x", asic_result.cmd.register_address);
-            return NULL;
+            return false;
         }
-        result.asic_nr = asic_result.cmd.asic_address / address_interval;
-        result.value = ntohl(asic_result.cmd.value);
+        result->asic_nr = asic_result.cmd.asic_address / address_interval;
+        result->value = ntohl(asic_result.cmd.value);
 
-        return &result;
+        return true;
     }
 
     uint8_t job_id = asic_result.job.id & 0xf8;
@@ -345,17 +341,17 @@ task_result * BM1366_process_work(void * pvParameters)
 
     if (GLOBAL_STATE->valid_jobs[job_id] == 0) {
         ESP_LOGW(TAG, "Invalid job nonce found, 0x%02X", job_id);
-        return NULL;
+        return false;
     }
 
     uint32_t rolled_version = GLOBAL_STATE->ASIC_TASK_MODULE.active_jobs[job_id]->version | version_bits;
 
-    result.job_id = job_id;
-    result.nonce = asic_result.job.nonce;
-    result.rolled_version = rolled_version;
-    result.asic_nr = asic_nr;
+    result->job_id = job_id;
+    result->nonce = asic_result.job.nonce;
+    result->rolled_version = rolled_version;
+    result->asic_nr = asic_nr;
 
-    return &result;
+    return true;
 }
 
 void BM1366_read_registers(void)

components/asic/bm1368.c

@@ -74,8 +74,6 @@ typedef struct __attribute__((__packed__))
 
 static const char * TAG = "bm1368";
 
-static task_result result;
-
 static int address_interval;
 
 static void _send_BM1368(uint8_t header, uint8_t * data, uint8_t data_len, bool debug)
@@ -254,26 +252,24 @@ void BM1368_send_work(void * pvParameters, bm_job * next_bm_job)
     _send_BM1368((TYPE_JOB | GROUP_SINGLE | CMD_WRITE), (uint8_t *)&job, sizeof(BM1368_job), BM1368_DEBUG_WORK);
 }
 
-task_result * BM1368_process_work(void * pvParameters)
+bool BM1368_process_work(void * pvParameters, task_result * result)
 {
     bm1368_asic_result_t asic_result = {0};
 
-    memset(&result, 0, sizeof(task_result));
-
-    if (receive_work((uint8_t *)&asic_result, sizeof(asic_result)) == ESP_FAIL) {
-        return NULL;
+    if (receive_work((uint8_t *)&asic_result, sizeof(asic_result), &result->receive_time_us) == ESP_FAIL) {
+        return false;
     }
 
     if (!asic_result.is_job_response) {
-        result.register_type = REGISTER_MAP[asic_result.cmd.register_address];
-        if (result.register_type == REGISTER_INVALID) {
+        result->register_type = REGISTER_MAP[asic_result.cmd.register_address];
+        if (result->register_type == REGISTER_INVALID) {
             ESP_LOGW(TAG, "Unknown register read: %02x", asic_result.cmd.register_address);
-            return NULL;
+            return false;
         }
-        result.asic_nr = asic_result.cmd.asic_address / address_interval;
-        result.value = ntohl(asic_result.cmd.value);
+        result->asic_nr = asic_result.cmd.asic_address / address_interval;
+        result->value = ntohl(asic_result.cmd.value);
 
-        return &result;
+        return true;
     }
 
     uint8_t job_id = (asic_result.job.id & 0xf0) >> 1;
@@ -288,17 +284,17 @@ task_result * BM1368_process_work(void * pvParameters)
 
     if (GLOBAL_STATE->valid_jobs[job_id] == 0) {
         ESP_LOGW(TAG, "Invalid job nonce found, 0x%02X", job_id);
-        return NULL;
+        return false;
     }
 
     uint32_t rolled_version = GLOBAL_STATE->ASIC_TASK_MODULE.active_jobs[job_id]->version | version_bits;
 
-    result.job_id = job_id;
-    result.nonce = asic_result.job.nonce;
-    result.rolled_version = rolled_version;
-    result.asic_nr = asic_nr;
+    result->job_id = job_id;
+    result->nonce = asic_result.job.nonce;
+    result->rolled_version = rolled_version;
+    result->asic_nr = asic_nr;
 
-    return &result;
+    return true;
 }
 
 void BM1368_read_registers(void)

components/asic/bm1370.c

@@ -75,8 +75,6 @@ typedef struct __attribute__((__packed__))
 
 static const char * TAG = "bm1370";
 
-static task_result result;
-
 static int address_interval;
 
 /// @brief
@@ -331,26 +329,24 @@ void BM1370_send_work(void * pvParameters, bm_job * next_bm_job)
     _send_BM1370((TYPE_JOB | GROUP_SINGLE | CMD_WRITE), (uint8_t *)&job, sizeof(BM1370_job), BM1370_DEBUG_WORK);
 }
 
-task_result * BM1370_process_work(void * pvParameters)
+bool BM1370_process_work(void * pvParameters, task_result * result)
 {
     bm1370_asic_result_t asic_result = {0};
 
-    memset(&result, 0, sizeof(task_result));
-
-    if (receive_work((uint8_t *)&asic_result, sizeof(asic_result)) == ESP_FAIL) {
-        return NULL;
+    if (receive_work((uint8_t *)&asic_result, sizeof(asic_result), &result->receive_time_us) == ESP_FAIL) {
+        return false;
     }
-    
+
     if (!asic_result.is_job_response) {
-        result.register_type = REGISTER_MAP[asic_result.cmd.register_address];
-        if (result.register_type == REGISTER_INVALID) {
+        result->register_type = REGISTER_MAP[asic_result.cmd.register_address];
+        if (result->register_type == REGISTER_INVALID) {
             ESP_LOGW(TAG, "Unknown register read: %02x", asic_result.cmd.register_address);
-            return NULL;
+            return false;
         }
-        result.asic_nr = asic_result.cmd.asic_address / address_interval;
-        result.value = ntohl(asic_result.cmd.value);
+        result->asic_nr = asic_result.cmd.asic_address / address_interval;
+        result->value = ntohl(asic_result.cmd.value);
 
-        return &result;
+        return true;
     }
 
     uint8_t job_id = (asic_result.job.id & 0xf0) >> 1;
@@ -365,17 +361,17 @@ task_result * BM1370_process_work(void * pvParameters)
 
     if (GLOBAL_STATE->valid_jobs[job_id] == 0) {
         ESP_LOGW(TAG, "Invalid job nonce found, 0x%02X", job_id);
-        return NULL;
+        return false;
     }
 
     uint32_t rolled_version = GLOBAL_STATE->ASIC_TASK_MODULE.active_jobs[job_id]->version | version_bits;
 
-    result.job_id = job_id;
-    result.nonce = asic_result.job.nonce;
-    result.rolled_version = rolled_version;
-    result.asic_nr = asic_nr;
+    result->job_id = job_id;
+    result->nonce = asic_result.job.nonce;
+    result->rolled_version = rolled_version;
+    result->asic_nr = asic_nr;
 
-    return &result;
+    return true;
 }
 
 void BM1370_read_registers(void)

components/asic/bm1397.c

@@ -77,7 +77,6 @@ typedef struct __attribute__((__packed__))
 static const char * TAG = "bm1397";
 
 static uint32_t prev_nonce = 0;
-static task_result result;
 
 static int address_interval;
 
@@ -294,26 +293,25 @@ void BM1397_send_work(void *pvParameters, bm_job *next_bm_job)
     _send_BM1397((TYPE_JOB | GROUP_SINGLE | CMD_WRITE), (uint8_t *)&job, sizeof(job_packet), BM1397_DEBUG_WORK);
 }
 
-task_result *BM1397_process_work(void *pvParameters)
+bool BM1397_process_work(void *pvParameters, task_result * result)
 {
-    bm1397_asic_result_t asic_result = {0};
+    bm1397_asic_result_t asic_result;
 
-    memset(&result, 0, sizeof(task_result));
-
-    if (receive_work((uint8_t *)&asic_result, sizeof(asic_result)) == ESP_FAIL) {
-        return NULL;
+    if (receive_work((uint8_t *)&asic_result, sizeof(asic_result), &result->receive_time_us) == ESP_FAIL) {
+        return false;
     }
 
     if (!asic_result.is_job_response) {
-        result.register_type = REGISTER_MAP[asic_result.cmd.register_address];
-        if (result.register_type == REGISTER_INVALID) {
+        result->register_type = REGISTER_MAP[asic_result.cmd.register_address];
+        if (result->register_type == REGISTER_INVALID) {
             ESP_LOGW(TAG, "Unknown register read: %02x", asic_result.cmd.register_address);
-            return NULL;
+            return false;
         }
-        result.asic_nr = asic_result.cmd.asic_address / address_interval;
-        result.value = ntohl(asic_result.cmd.value);
 
-        return &result;
+        result->asic_nr = asic_result.cmd.asic_address / address_interval;
+        result->value = ntohl(asic_result.cmd.value);
+
+        return true;
     }
 
     uint8_t nonce_found = 0;
@@ -326,7 +324,7 @@ task_result *BM1397_process_work(void *pvParameters)
     if (GLOBAL_STATE->valid_jobs[rx_job_id] == 0)
     {
         ESP_LOGW(TAG, "Invalid job nonce found, id=%d", rx_job_id);
-        return NULL;
+        return false;
     }
 
     uint32_t rolled_version = GLOBAL_STATE->ASIC_TASK_MODULE.active_jobs[rx_job_id]->version;
@@ -346,12 +344,12 @@ task_result *BM1397_process_work(void *pvParameters)
     else if (asic_result.job.nonce == first_nonce)
     {
         // stop if we've already seen this nonce
-        return NULL;
+        return false;
     }
 
     if (asic_result.job.nonce == prev_nonce)
     {
-        return NULL;
+        return false;
     }
     else
     {
@@ -361,17 +359,17 @@ task_result *BM1397_process_work(void *pvParameters)
     uint32_t nonce_h = ntohl(asic_result.job.nonce);
     uint8_t asic_nr = (uint8_t)((nonce_h >> 17) & 0xff) / address_interval;
 
-    result.job_id = rx_job_id;
-    result.nonce = asic_result.job.nonce;
-    result.rolled_version = rolled_version;
-    result.asic_nr = asic_nr;
+    result->job_id = rx_job_id;
+    result->nonce = asic_result.job.nonce;
+    result->rolled_version = rolled_version;
+    result->asic_nr = asic_nr;
 
     uint8_t core_id = (uint8_t)((nonce_h >> 25) & 0x7f);
     uint8_t small_core_id = asic_result.job.id & 0x0f;
 
     ESP_LOGI(TAG, "Job ID: %02X, Asic nr: %d, Core: %d/%d, Ver: %08" PRIX32, rx_job_id, asic_nr, core_id, small_core_id, rolled_version);    
 
-    return &result;
+    return true;
 }
 
 void BM1397_read_registers(void)

components/asic/common.c

@@ -4,6 +4,7 @@
 #include "common.h"
 #include "serial.h"
 #include "esp_log.h"
+#include "esp_timer.h"
 #include "crc.h"
 
 #define PREAMBLE 0xAA55
@@ -88,10 +89,12 @@ int count_asic_chips(uint16_t asic_count, uint16_t chip_id, int chip_id_response
     return chip_counter;
 }
 
-esp_err_t receive_work(uint8_t * buffer, int buffer_size)
+esp_err_t receive_work(uint8_t * buffer, int buffer_size, int64_t *result_receive_time_us)
 {
     int received = SERIAL_rx(buffer, buffer_size, 10000);
 
+    *result_receive_time_us = esp_timer_get_time();
+
     if (received < 0) {
         ESP_LOGE(TAG, "UART error in serial RX");
         return ESP_FAIL;

components/asic/include/asic.h

@@ -6,7 +6,7 @@
 #include "common.h"
 
 uint8_t ASIC_init(GlobalState * GLOBAL_STATE);
-task_result * ASIC_process_work(GlobalState * GLOBAL_STATE);
+bool ASIC_process_work(GlobalState * GLOBAL_STATE, task_result * result);
 int ASIC_set_max_baud(GlobalState * GLOBAL_STATE);
 void ASIC_send_work(GlobalState * GLOBAL_STATE, void * next_job);
 void ASIC_set_version_mask(GlobalState * GLOBAL_STATE, uint32_t mask);

components/asic/include/bm1366.h

@@ -27,7 +27,7 @@ void BM1366_set_version_mask(uint32_t version_mask);
 int BM1366_set_max_baud(void);
 int BM1366_set_default_baud(void);
 void BM1366_send_hash_frequency(float frequency);
-task_result * BM1366_process_work(void * GLOBAL_STATE);
+bool BM1366_process_work(void * GLOBAL_STATE, task_result * result);
 void BM1366_read_registers(void);
 
 #endif /* BM1366_H_ */

components/asic/include/bm1368.h

@@ -27,7 +27,7 @@ void BM1368_set_version_mask(uint32_t version_mask);
 int BM1368_set_max_baud(void);
 int BM1368_set_default_baud(void);
 void BM1368_send_hash_frequency(float frequency);
-task_result * BM1368_process_work(void * GLOBAL_STATE);
+bool BM1368_process_work(void * GLOBAL_STATE, task_result * result);
 void BM1368_read_registers(void);
 
 #endif /* BM1368_H_ */

components/asic/include/bm1370.h

@@ -27,7 +27,7 @@ void BM1370_set_version_mask(uint32_t version_mask);
 int BM1370_set_max_baud(void);
 int BM1370_set_default_baud(void);
 void BM1370_send_hash_frequency(float frequency);
-task_result * BM1370_process_work(void * GLOBAL_STATE);
+bool BM1370_process_work(void * GLOBAL_STATE, task_result * result);
 void BM1370_read_registers(void);
 
 #endif /* BM1370_H_ */