Skip to content
Snippets Groups Projects
Commit 5b55e0e1 authored by Nick Mathewson's avatar Nick Mathewson :game_die:
Browse files

Merge remote-tracking branch 'public/no_itime_queue' 

The conflicts here were tricky, and required me to eliminate the
command-queue as well.  That wasn't so hard.

Conflicts:
	src/or/or.h
	src/or/relay.c
parents a73b0da6 3133cde3
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
changes/bug10870 0 → 100644
+ 6
− 0
View file @ 5b55e0e1
o Code simplification and refactoring:
- Remove data structures which were introduced to implement the
CellStatistics option: they are now redundant with the addition
of timestamp to the regular packed_cell_t data structure, which
we did in 0.2.4.18-rc in order to resolve #9093. Fixes bug
10870.
\ No newline at end of file
src/or/or.h
+ 0
− 36
View file @ 5b55e0e1
......@@ -1121,48 +1121,12 @@ typedef struct packed_cell_t {
* bits truncated) when this cell was inserted. */
} packed_cell_t;
/* XXXX This next structure may be obsoleted by inserted_time in
* packed_cell_t */
/** Number of cells added to a circuit queue including their insertion
* time on 10 millisecond detail; used for buffer statistics. */
typedef struct insertion_time_elem_t {
struct insertion_time_elem_t *next; /**< Next element in queue. */
uint32_t insertion_time; /**< When were cells inserted (in 10 ms steps
* starting at 0:00 of the current day)? */
unsigned counter; /**< How many cells were inserted? */
} insertion_time_elem_t;
/** Queue of insertion times. */
typedef struct insertion_time_queue_t {
struct insertion_time_elem_t *first; /**< First element in queue. */
struct insertion_time_elem_t *last; /**< Last element in queue. */
} insertion_time_queue_t;
/** Number of cells with the same command consecutively added to a circuit
* queue; used for cell statistics only if CELL_STATS events are enabled. */
typedef struct insertion_command_elem_t {
struct insertion_command_elem_t *next; /**< Next element in queue. */
/** Which command did these consecutively added cells have? */
uint8_t command;
unsigned counter; /**< How many cells were inserted? */
} insertion_command_elem_t;
/** Queue of insertion commands. */
typedef struct insertion_command_queue_t {
struct insertion_command_elem_t *first; /**< First element in queue. */
struct insertion_command_elem_t *last; /**< Last element in queue. */
} insertion_command_queue_t;
/** A queue of cells on a circuit, waiting to be added to the
* or_connection_t's outbuf. */
typedef struct cell_queue_t {
/** Linked list of packed_cell_t*/
TOR_SIMPLEQ_HEAD(cell_simpleq, packed_cell_t) head;
int n; /**< The number of cells in the queue. */
insertion_time_queue_t *insertion_times; /**< Insertion times of cells. */
/** Commands of inserted cells. */
insertion_command_queue_t *insertion_commands;
} cell_queue_t;
/** Beginning of a RELAY cell payload. */
......
src/or/relay.c
+ 37
− 168
View file @ 5b55e0e1
......@@ -2047,14 +2047,6 @@ static size_t total_cells_allocated = 0;
/** A memory pool to allocate packed_cell_t objects. */
static mp_pool_t *cell_pool = NULL;
/** Memory pool to allocate insertion_time_elem_t objects used for cell
* statistics. */
static mp_pool_t *it_pool = NULL;
/** Memory pool to allocate insertion_command_elem_t objects used for cell
* statistics if CELL_STATS events are enabled. */
static mp_pool_t *ic_pool = NULL;
/** Allocate structures to hold cells. */
void
init_cell_pool(void)
......@@ -2073,14 +2065,6 @@ free_cell_pool(void)
mp_pool_destroy(cell_pool);
cell_pool = NULL;
}
if (it_pool) {
mp_pool_destroy(it_pool);
it_pool = NULL;
}
if (ic_pool) {
mp_pool_destroy(ic_pool);
ic_pool = NULL;
}
}
/** Free excess storage in cell pool. */
......@@ -2153,57 +2137,6 @@ cell_queue_append(cell_queue_t *queue, packed_cell_t *cell)
++queue->n;
}
/** Append command of type <b>command</b> in direction to <b>queue</b> for
* CELL_STATS event. */
static void
cell_command_queue_append(cell_queue_t *queue, uint8_t command)
{
insertion_command_queue_t *ic_queue = queue->insertion_commands;
if (!ic_pool)
ic_pool = mp_pool_new(sizeof(insertion_command_elem_t), 1024);
if (!ic_queue) {
ic_queue = tor_malloc_zero(sizeof(insertion_command_queue_t));
queue->insertion_commands = ic_queue;
}
if (ic_queue->last && ic_queue->last->command == command) {
ic_queue->last->counter++;
} else {
insertion_command_elem_t *elem = mp_pool_get(ic_pool);
elem->next = NULL;
elem->command = command;
elem->counter = 1;
if (ic_queue->last) {
ic_queue->last->next = elem;
ic_queue->last = elem;
} else {
ic_queue->first = ic_queue->last = elem;
}
}
}
/** Retrieve oldest command from <b>queue</b> and write it to
* <b>command</b> for CELL_STATS event. Return 0 for success, -1
* otherwise. */
static int
cell_command_queue_pop(uint8_t *command, cell_queue_t *queue)
{
int res = -1;
insertion_command_queue_t *ic_queue = queue->insertion_commands;
if (ic_queue && ic_queue->first) {
insertion_command_elem_t *ic_elem = ic_queue->first;
ic_elem->counter--;
if (ic_elem->counter < 1) {
ic_queue->first = ic_elem->next;
if (ic_elem == ic_queue->last)
ic_queue->last = NULL;
mp_pool_release(ic_elem);
}
*command = ic_elem->command;
res = 0;
}
return res;
}
/** Append a newly allocated copy of <b>cell</b> to the end of the
* <b>exitward</b> (or app-ward) <b>queue</b> of <b>circ</b>. If
* <b>use_stats</b> is true, record statistics about the cell.
......@@ -2215,52 +2148,12 @@ cell_queue_append_packed_copy(circuit_t *circ, cell_queue_t *queue,
{
struct timeval now;
packed_cell_t *copy = packed_cell_copy(cell, wide_circ_ids);
(void)circ;
(void)exitward;
(void)use_stats;
tor_gettimeofday_cached(&now);
copy->inserted_time = (uint32_t)tv_to_msec(&now);
/* Remember the time when this cell was put in the queue. */
/*XXXX This may be obsoleted by inserted_time */
if ((get_options()->CellStatistics ||
get_options()->TestingEnableCellStatsEvent) && use_stats) {
uint32_t added;
insertion_time_queue_t *it_queue = queue->insertion_times;
if (!it_pool)
it_pool = mp_pool_new(sizeof(insertion_time_elem_t), 1024);
#define SECONDS_IN_A_DAY 86400L
added = (uint32_t)(((now.tv_sec % SECONDS_IN_A_DAY) * 100L)
+ ((uint32_t)now.tv_usec / (uint32_t)10000L));
if (!it_queue) {
it_queue = tor_malloc_zero(sizeof(insertion_time_queue_t));
queue->insertion_times = it_queue;
}
if (it_queue->last && it_queue->last->insertion_time == added) {
it_queue->last->counter++;
} else {
insertion_time_elem_t *elem = mp_pool_get(it_pool);
elem->next = NULL;
elem->insertion_time = added;
elem->counter = 1;
if (it_queue->last) {
it_queue->last->next = elem;
it_queue->last = elem;
} else {
it_queue->first = it_queue->last = elem;
}
}
}
/* Remember that we added a cell to the queue, and remember the cell
* command. */
if (get_options()->TestingEnableCellStatsEvent && circ) {
testing_cell_stats_entry_t *ent =
tor_malloc_zero(sizeof(testing_cell_stats_entry_t));
ent->command = cell->command;
ent->exitward = exitward;
if (!circ->testing_cell_stats)
circ->testing_cell_stats = smartlist_new();
smartlist_add(circ->testing_cell_stats, ent);
cell_command_queue_append(queue, cell->command);
}
cell_queue_append(queue, copy);
}
......@@ -2283,14 +2176,6 @@ cell_queue_clear(cell_queue_t *queue)
}
TOR_SIMPLEQ_INIT(&queue->head);
queue->n = 0;
if (queue->insertion_times) {
while (queue->insertion_times->first) {
insertion_time_elem_t *elem = queue->insertion_times->first;
queue->insertion_times->first = elem->next;
mp_pool_release(elem);
}
tor_free(queue->insertion_times);
}
}
/** Extract and return the cell at the head of <b>queue</b>; return NULL if
......@@ -2311,9 +2196,7 @@ cell_queue_pop(cell_queue_t *queue)
size_t
packed_cell_mem_cost(void)
{
return sizeof(packed_cell_t) + MP_POOL_ITEM_OVERHEAD +
get_options()->CellStatistics ?
(sizeof(insertion_time_elem_t)+MP_POOL_ITEM_OVERHEAD) : 0;
return sizeof(packed_cell_t) + MP_POOL_ITEM_OVERHEAD;
}
/** Check whether we've got too much space used for cells. If so,
......@@ -2443,6 +2326,17 @@ set_streams_blocked_on_circ(circuit_t *circ, channel_t *chan,
return n;
}
/** Extract the command from a packed cell. */
static uint8_t
packed_cell_get_command(const packed_cell_t *cell, int wide_circ_ids)
{
if (wide_circ_ids) {
return get_uint8(cell->body+4);
} else {
return get_uint8(cell->body+2);
}
}
/** Pull as many cells as possible (but no more than <b>max</b>) from the
* queue of the first active circuit on <b>chan</b>, and write them to
* <b>chan</b>-&gt;outbuf. Return the number of cells written. Advance
......@@ -2504,55 +2398,30 @@ channel_flush_from_first_active_circuit(channel_t *chan, int max)
/* Calculate the exact time that this cell has spent in the queue. */
if (get_options()->CellStatistics ||
get_options()->TestingEnableCellStatsEvent) {
uint32_t msec_waiting;
struct timeval tvnow;
uint32_t flushed;
uint32_t cell_waiting_time;
insertion_time_queue_t *it_queue = queue->insertion_times;
tor_gettimeofday_cached(&tvnow);
flushed = (uint32_t)((tvnow.tv_sec % SECONDS_IN_A_DAY) * 100L +
(uint32_t)tvnow.tv_usec / (uint32_t)10000L);
if (!it_queue || !it_queue->first) {
log_info(LD_GENERAL, "Cannot determine insertion time of cell. "
"Looks like the CellStatistics option was "
"recently enabled.");
} else {
insertion_time_elem_t *elem = it_queue->first;
cell_waiting_time =
(uint32_t)((flushed * 10L + SECONDS_IN_A_DAY * 1000L -
elem->insertion_time * 10L) %
(SECONDS_IN_A_DAY * 1000L));
#undef SECONDS_IN_A_DAY
elem->counter--;
if (elem->counter < 1) {
it_queue->first = elem->next;
if (elem == it_queue->last)
it_queue->last = NULL;
mp_pool_release(elem);
}
if (get_options()->CellStatistics && !CIRCUIT_IS_ORIGIN(circ)) {
or_circ = TO_OR_CIRCUIT(circ);
or_circ->total_cell_waiting_time += cell_waiting_time;
or_circ->processed_cells++;
}
if (get_options()->TestingEnableCellStatsEvent) {
uint8_t command;
if (cell_command_queue_pop(&command, queue) < 0) {
log_info(LD_GENERAL, "Cannot determine command of cell. "
"Looks like the CELL_STATS event was "
"recently enabled.");
} else {
testing_cell_stats_entry_t *ent =
tor_malloc_zero(sizeof(testing_cell_stats_entry_t));
ent->command = command;
ent->waiting_time = (unsigned int)cell_waiting_time / 10;
ent->removed = 1;
if (circ->n_chan == chan)
ent->exitward = 1;
if (!circ->testing_cell_stats)
circ->testing_cell_stats = smartlist_new();
smartlist_add(circ->testing_cell_stats, ent);
}
}
msec_waiting = ((uint32_t)tv_to_msec(&tvnow)) - cell->inserted_time;
if (get_options()->CellStatistics && !CIRCUIT_IS_ORIGIN(circ)) {
or_circ = TO_OR_CIRCUIT(circ);
or_circ->total_cell_waiting_time += msec_waiting;
or_circ->processed_cells++;
}
if (get_options()->TestingEnableCellStatsEvent) {
uint8_t command = packed_cell_get_command(cell, chan->wide_circ_ids);
testing_cell_stats_entry_t *ent =
tor_malloc_zero(sizeof(testing_cell_stats_entry_t));
ent->command = command;
ent->waiting_time = msec_waiting / 10;
ent->removed = 1;
if (circ->n_chan == chan)
ent->exitward = 1;
if (!circ->testing_cell_stats)
circ->testing_cell_stats = smartlist_new();
smartlist_add(circ->testing_cell_stats, ent);
}
}
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment