Merge pull request #167 from saxbophone/josh/107-track-time-spent

Josh/107 track time spent

Author: saxbophone

sxbp/initialise.c

@@ -27,7 +27,7 @@ sxbp_direction_t sxbp_change_direction(
 }
 
 sxbp_spiral_t sxbp_blank_spiral(void) {
-    return (sxbp_spiral_t){0, NULL, {{NULL, 0}, 0}, false, 0, 0, 0};
+    return (sxbp_spiral_t){0, NULL, {{NULL, 0}, 0}, false, 0, 0, 0, 0};
 }
 
 sxbp_status_t sxbp_init_spiral(sxbp_buffer_t buffer, sxbp_spiral_t* spiral) {

sxbp/saxbospiral.h

@@ -184,9 +184,6 @@ typedef struct sxbp_co_ord_cache_t {
  * spiral object may be produced from binary data, and a fully-complete spiral
  * may be produced from the partially complete one via the routines in the
  * library.
- * @note The solved_count and seconds_spent fields are currently unused by the
- * solver/generator code, but they are read to and written from files. They will
- * be used by the rest of the code in future versions.
  */
 typedef struct sxbp_spiral_t {
     /** @brief count of lines in the spiral */
@@ -205,16 +202,15 @@ typedef struct sxbp_spiral_t {
      * @private
      */
     uint32_t collider;
-    /**
-     * @brief the count of lines solved so far (index of next line to solve)
-     * @note Currently not used by solver/generator
-     */
+    /** @brief the count of lines solved so far (index of next line to solve) */
     uint32_t solved_count;
+    /** @brief count of seconds spent solving the spiral */
+    uint32_t seconds_spent;
     /**
-     * @brief count of seconds spent solving the spiral
-     * @note Currently not used by solver/generator
+     * @brief stores the number of seconds' accuracy of the `seconds_spent`
+     * field
      */
-    uint32_t seconds_spent;
+    uint32_t seconds_accuracy;
 } sxbp_spiral_t;
 
 /** @brief A simple buffer type for storing arrays of bytes. */

sxbp/serialise.c

@@ -151,6 +151,7 @@ sxbp_serialise_result_t sxbp_load_spiral(
     spiral->size = spiral_size;
     spiral->solved_count = load_uint32_t(&buffer, 14);
     spiral->seconds_spent = load_uint32_t(&buffer, 18);
+    spiral->seconds_accuracy = load_uint32_t(&buffer, 22);
     // allocate memory
     spiral->lines = calloc(sizeof(sxbp_line_t), spiral->size);
     // catch allocation error
@@ -211,6 +212,7 @@ sxbp_serialise_result_t sxbp_dump_spiral(
     dump_uint32_t(spiral.size, buffer, 10);
     dump_uint32_t(spiral.solved_count, buffer, 14);
     dump_uint32_t(spiral.seconds_spent, buffer, 18);
+    dump_uint32_t(spiral.seconds_accuracy, buffer, 22);
     // now write the data section
     for(size_t i = 0; i < spiral.size; i++) {
         /*

sxbp/solve.c

@@ -12,6 +12,7 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <time.h>
 
 #include "saxbospiral.h"
 #include "plot.h"
@@ -264,6 +265,15 @@ sxbp_status_t sxbp_plot_spiral(
 ) {
     // preconditional assertions
     assert(spiral->lines != NULL);
+    // get current time
+    time_t start_time = time(NULL);
+    // get original number of seconds spent
+    uint32_t seconds_spent_so_far = spiral->seconds_spent;
+    /*
+     * update accuracy of the seconds spent field
+     * (every run time makes it one second less accurate).
+     */
+    spiral->seconds_accuracy++;
     // set up result status
     sxbp_status_t result;
     // get index of highest line to plot
@@ -275,11 +285,21 @@ sxbp_status_t sxbp_plot_spiral(
         if(result != SXBP_OPERATION_OK) {
             return result;
         }
+        // update time spent solving
+        spiral->seconds_spent = (
+            // amount of time spent previously + time spent during this run time
+            seconds_spent_so_far + (uint32_t)difftime(time(NULL), start_time)
+        );
         // call callback if given
         if(progress_callback != NULL) {
             progress_callback(spiral, i, max_index, progress_callback_user_data);
         }
     }
+    // update time spent solving
+    spiral->seconds_spent = (
+        // amount of time spent previously + time spent during this run time
+        seconds_spent_so_far + (uint32_t)difftime(time(NULL), start_time)
+    );
     // all ok
     result = SXBP_OPERATION_OK;
     return result;

tests.c

@@ -393,7 +393,10 @@ static bool test_sxbp_load_spiral(void) {
     }
     // build expected output struct
     sxbp_spiral_t expected = {
-        .size = 16, .solved_count = 5, .seconds_spent = 3125,
+        .size = 16,
+        .solved_count = 5,
+        .seconds_spent = 3125,
+        .seconds_accuracy = 1,
     };
     expected.lines = calloc(sizeof(sxbp_line_t), 16);
     sxbp_direction_t directions[16] = {
@@ -419,6 +422,8 @@ static bool test_sxbp_load_spiral(void) {
         result = false;
     } else if(output.seconds_spent != expected.seconds_spent) {
         result = false;
+    } else if(output.seconds_accuracy != expected.seconds_accuracy) {
+        result = false;
     } else {
         // compare with expected struct
         for(uint8_t i = 0; i < 16; i++) {
@@ -593,6 +598,7 @@ static bool test_sxbp_dump_spiral(void) {
         .size = 16,
         .solved_count = 5,
         .seconds_spent = 3125,
+        .seconds_accuracy = 1,
     };
     input.lines = calloc(sizeof(sxbp_line_t), 16);
     sxbp_direction_t directions[16] = {
@@ -629,7 +635,7 @@ static bool test_sxbp_dump_spiral(void) {
         0, 0, 0, 16, // size
         0, 0, 0, 5, // solved count
         0, 0, 12, 53, // seconds spent
-        0, 0, 0, 0 // seconds accuracy - TODO: Change to something to test
+        0, 0, 0, 1 // seconds accuracy - TODO: Change to something to test
     );
     // construct expected data section
     uint8_t data[64] = {