Some tweaks to directory request download times.

- Use common prefixes DIRREQ_* and dirreq_*.
- Replace enums in structs with bitfields.

1 files changed, 59 insertions, 60 deletions

diff --git a/src/or/geoip.c b/src/or/geoip.c
index 819c9f0182..0ecc466088 100644
--- a/src/or/geoip.c
+++ b/src/or/geoip.c
@@ -580,107 +580,106 @@ _c_hist_compare(const void **_a, const void **_b)
  * response size, and completion time of a network status request. Used to
  * measure download times of requests to derive average client
  * bandwidths. */
-typedef struct dirreqdlmap_entry_t {
-  directory_request_state_t state; /**< State of this directory request. */
+typedef struct dirreq_map_entry_t {
   /** Unique identifier for this network status request; this is either the
    * conn->global_identifier of the dir conn (direct request) or a new
    * locally unique identifier of a circuit (tunneled request). This ID is
    * only unique among other direct or tunneled requests, respectively. */
-  uint64_t request_id;
-  /** Is this a direct or a tunneled request? */
-  directory_request_type_t type;
-  int completed:1; /**< Is this request complete? */
-  geoip_client_action_t action; /**< Is this a v2 or v3 request? */
+  uint64_t dirreq_id;
+  unsigned int state:3; /**< State of this directory request. */
+  unsigned int type:1; /**< Is this a direct or a tunneled request? */
+  unsigned int completed:1; /**< Is this request complete? */
+  unsigned int action:2; /**< Is this a v2 or v3 request? */
   /** When did we receive the request and started sending the response? */
   struct timeval request_time;
   size_t response_size; /**< What is the size of the response in bytes? */
   struct timeval completion_time; /**< When did the request succeed? */
-} dirreqdlmap_entry_t;
+} dirreq_map_entry_t;
 
 /** Map of all directory requests asking for v2 or v3 network statuses in
  * the current geoip-stats interval. Keys are strings starting with either
  * "dir" for direct requests or "tun" for tunneled requests, followed by
  * a unique uint64_t identifier represented as decimal string. Values are
- * of type *<b>dirreqdlmap_entry_t</b>. */
-static strmap_t *dirreqdlmap = NULL;
+ * of type *<b>dirreq_map_entry_t</b>. */
+static strmap_t *dirreq_map = NULL;
 
 /** Helper: Put <b>entry</b> into map of directory requests using
- * <b>tunneled</b> and <b>request_id</b> as key parts. If there is
+ * <b>tunneled</b> and <b>dirreq_id</b> as key parts. If there is
  * already an entry for that key, print out a BUG warning and return. */
 static void
-_dirreqdlmap_put(dirreqdlmap_entry_t *entry,
-                 directory_request_type_t type, uint64_t request_id)
+_dirreq_map_put(dirreq_map_entry_t *entry, dirreq_type_t type,
+               uint64_t dirreq_id)
 {
   char key[3+20+1]; /* dir|tun + 18446744073709551616 + \0 */
-  dirreqdlmap_entry_t *ent;
-  if (!dirreqdlmap)
-    dirreqdlmap = strmap_new();
+  dirreq_map_entry_t *ent;
+  if (!dirreq_map)
+    dirreq_map = strmap_new();
   tor_snprintf(key, sizeof(key), "%s"U64_FORMAT,
-               type == REQUEST_TUNNELED ? "tun" : "dir",
-               U64_PRINTF_ARG(request_id));
-  ent = strmap_get(dirreqdlmap, key);
+               type == DIRREQ_TUNNELED ? "tun" : "dir",
+               U64_PRINTF_ARG(dirreq_id));
+  ent = strmap_get(dirreq_map, key);
   if (ent) {
     log_warn(LD_BUG, "Error when putting directory request into local "
              "map. There is already an entry for the same identifier.");
     return;
   }
-  strmap_set(dirreqdlmap, key, entry);
+  strmap_set(dirreq_map, key, entry);
 }
 
 /** Helper: Look up and return an entry in the map of directory requests
- * using <b>tunneled</b> and <b>request_id</b> as key parts. If there
+ * using <b>tunneled</b> and <b>dirreq_id</b> as key parts. If there
  * is no such entry, return NULL. */
-static dirreqdlmap_entry_t *
-_dirreqdlmap_get(directory_request_type_t type, uint64_t request_id)
+static dirreq_map_entry_t *
+_dirreq_map_get(dirreq_type_t type, uint64_t dirreq_id)
 {
   char key[3+20+1]; /* dir|tun + 18446744073709551616 + \0 */
-  if (!dirreqdlmap)
-    dirreqdlmap = strmap_new();
+  if (!dirreq_map)
+    dirreq_map = strmap_new();
   tor_snprintf(key, sizeof(key), "%s"U64_FORMAT,
-               type == REQUEST_TUNNELED ? "tun" : "dir",
-               U64_PRINTF_ARG(request_id));
-  return strmap_get(dirreqdlmap, key);
+               type == DIRREQ_TUNNELED ? "tun" : "dir",
+               U64_PRINTF_ARG(dirreq_id));
+  return strmap_get(dirreq_map, key);
 }
 
 /** Note that an either direct or tunneled (see <b>type</b>) directory
- * request for a network status with unique ID <b>request_id</b> of size
+ * request for a network status with unique ID <b>dirreq_id</b> of size
  * <b>response_size</b> and action <b>action</b> (either v2 or v3) has
  * started. */
 void
-geoip_start_dirreq(uint64_t request_id, size_t response_size,
-                   geoip_client_action_t action,
-                   directory_request_type_t type)
+geoip_start_dirreq(uint64_t dirreq_id, size_t response_size,
+                   geoip_client_action_t action, dirreq_type_t type)
 {
-  dirreqdlmap_entry_t *ent = tor_malloc_zero(sizeof(dirreqdlmap_entry_t));
-  ent->request_id = request_id;
+  dirreq_map_entry_t *ent = tor_malloc_zero(sizeof(dirreq_map_entry_t));
+  ent->dirreq_id = dirreq_id;
   tor_gettimeofday(&ent->request_time);
   ent->response_size = response_size;
   ent->action = action;
   ent->type = type;
-  _dirreqdlmap_put(ent, type, request_id);
+  _dirreq_map_put(ent, type, dirreq_id);
 }
 
 /** Change the state of the either direct or tunneled (see <b>type</b>)
- * directory request with <b>request_id</b> to <b>new_state</b> and
+ * directory request with <b>dirreq_id</b> to <b>new_state</b> and
  * possibly mark it as completed. If no entry can be found for the given
  * key parts (e.g., if this is a directory request that we are not
  * measuring, or one that was started in the previous measurement period),
  * or if the state cannot be advanced to <b>new_state</b>, do nothing. */
 void
-geoip_change_dirreq_state(uint64_t request_id,
-                          directory_request_type_t type,
-                          directory_request_state_t new_state)
+geoip_change_dirreq_state(uint64_t dirreq_id, dirreq_type_t type,
+                          dirreq_state_t new_state)
 {
-  dirreqdlmap_entry_t *ent = _dirreqdlmap_get(type, request_id);
+  dirreq_map_entry_t *ent = _dirreq_map_get(type, dirreq_id);
   if (!ent)
     return;
-  if (new_state == REQUEST_IS_FOR_NETWORK_STATUS)
+  if (new_state == DIRREQ_IS_FOR_NETWORK_STATUS)
     return;
   if (new_state - 1 != ent->state)
     return;
   ent->state = new_state;
-  if ((type == REQUEST_DIRECT && new_state == FLUSHING_DIR_CONN_FINISHED) ||
-      (type == REQUEST_TUNNELED && new_state == OR_CONN_BUFFER_FLUSHED)) {
+  if ((type == DIRREQ_DIRECT &&
+         new_state == DIRREQ_FLUSHING_DIR_CONN_FINISHED) ||
+      (type == DIRREQ_TUNNELED &&
+         new_state == DIRREQ_OR_CONN_BUFFER_FLUSHED)) {
     tor_gettimeofday(&ent->completion_time);
     ent->completed = 1;
   }
@@ -693,22 +692,22 @@ geoip_change_dirreq_state(uint64_t request_id,
  * times by deciles and quartiles. Return NULL if we have not observed
  * requests for long enough. */
 static char *
-geoip_get_dirreqdl_history(geoip_client_action_t action,
-                           directory_request_type_t type)
+geoip_get_dirreq_history(geoip_client_action_t action,
+                           dirreq_type_t type)
 {
   char *result = NULL;
-  smartlist_t *dirreqdl_times = NULL;
+  smartlist_t *dirreq_times = NULL;
   uint32_t complete = 0, timeouts = 0, running = 0;
   int i = 0, bufsize = 1024, written;
   struct timeval now;
   tor_gettimeofday(&now);
-  if (!dirreqdlmap)
+  if (!dirreq_map)
     return NULL;
   if (action != GEOIP_CLIENT_NETWORKSTATUS &&
       action != GEOIP_CLIENT_NETWORKSTATUS_V2)
     return NULL;
-  dirreqdl_times = smartlist_create();
-  STRMAP_FOREACH_MODIFY(dirreqdlmap, key, dirreqdlmap_entry_t *, ent) {
+  dirreq_times = smartlist_create();
+  STRMAP_FOREACH_MODIFY(dirreq_map, key, dirreq_map_entry_t *, ent) {
     if (ent->action == action && type == ent->type) {
       if (ent->completed) {
         uint32_t *bytes_per_second = tor_malloc_zero(sizeof(uint32_t));
@@ -718,7 +717,7 @@ geoip_get_dirreqdl_history(geoip_client_action_t action,
           time_diff = 1; /* Avoid DIV/0; "instant" answers are impossible
                           * anyway by law of nature or something.. */
         *bytes_per_second = 1000000 * ent->response_size / time_diff;
-        smartlist_add(dirreqdl_times, bytes_per_second);
+        smartlist_add(dirreq_times, bytes_per_second);
         complete++;
       } else {
         if (tv_udiff(&ent->request_time, &now) / 1000000 > DIRREQ_TIMEOUT)
@@ -745,7 +744,7 @@ geoip_get_dirreqdl_history(geoip_client_action_t action,
 #define MIN_DIR_REQ_RESPONSES 16
   if (complete >= MIN_DIR_REQ_RESPONSES) {
     uint32_t *dltimes = tor_malloc(sizeof(uint32_t) * complete);
-    SMARTLIST_FOREACH(dirreqdl_times, uint32_t *, dlt, {
+    SMARTLIST_FOREACH(dirreq_times, uint32_t *, dlt, {
       dltimes[i++] = *dlt;
       tor_free(dlt);
     });
@@ -770,7 +769,7 @@ geoip_get_dirreqdl_history(geoip_client_action_t action,
   }
   if (written < 0)
     result = NULL;
-  smartlist_free(dirreqdl_times);
+  smartlist_free(dirreq_times);
   return result;
 }
 #endif
@@ -990,19 +989,19 @@ dump_geoip_stats(void)
       goto done;
   }
 
-  data_v2 = geoip_get_dirreqdl_history(GEOIP_CLIENT_NETWORKSTATUS_V2,
-                                       REQUEST_DIRECT);
-  data_v3 = geoip_get_dirreqdl_history(GEOIP_CLIENT_NETWORKSTATUS,
-                                       REQUEST_DIRECT);
+  data_v2 = geoip_get_dirreq_history(GEOIP_CLIENT_NETWORKSTATUS_V2,
+                                       DIRREQ_DIRECT);
+  data_v3 = geoip_get_dirreq_history(GEOIP_CLIENT_NETWORKSTATUS,
+                                       DIRREQ_DIRECT);
   if (fprintf(out, "ns-direct-dl %s\nns-v2-direct-dl %s\n",
               data_v3 ? data_v3 : "", data_v2 ? data_v2 : "") < 0)
     goto done;
   tor_free(data_v2);
   tor_free(data_v3);
-  data_v2 = geoip_get_dirreqdl_history(GEOIP_CLIENT_NETWORKSTATUS_V2,
-                                       REQUEST_TUNNELED);
-  data_v3 = geoip_get_dirreqdl_history(GEOIP_CLIENT_NETWORKSTATUS,
-                                       REQUEST_TUNNELED);
+  data_v2 = geoip_get_dirreq_history(GEOIP_CLIENT_NETWORKSTATUS_V2,
+                                       DIRREQ_TUNNELED);
+  data_v3 = geoip_get_dirreq_history(GEOIP_CLIENT_NETWORKSTATUS,
+                                       DIRREQ_TUNNELED);
   if (fprintf(out, "ns-tunneled-dl %s\nns-v2-tunneled-dl %s\n",
               data_v3 ? data_v3 : "", data_v2 ? data_v2 : "") < 0)
     goto done;