nihilist/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-11-30 23:53:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

Make preferred_chunk_size nonstatic, and add a prefix to it

Browse Source
This commit is contained in:
Nick Mathewson 2017-09-05 14:15:38 -04:00
parent 4bac93ba5d
commit c0b9f594b6
3 changed files with 15 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/common/buffers.c
View File

@ -173,8 +173,8 @@ chunk_grow(chunk_t *chunk, size_t sz)
/** Return the allocation size we'd like to use to hold <b>target</b> /** Return the allocation size we'd like to use to hold <b>target</b>
* bytes. */ * bytes. */
STATIC size_t size_t
preferred_chunk_size(size_t target) buf_preferred_chunk_size(size_t target)
{ {
tor_assert(target <= SIZE_T_CEILING - CHUNK_OVERHEAD); tor_assert(target <= SIZE_T_CEILING - CHUNK_OVERHEAD);
if (CHUNK_ALLOC_SIZE(target) >= MAX_CHUNK_ALLOC) if (CHUNK_ALLOC_SIZE(target) >= MAX_CHUNK_ALLOC)
@ -228,7 +228,7 @@ buf_pullup(buf_t *buf, size_t bytes, const char **head_out, size_t *len_out)
size_t newsize; size_t newsize;
/* We need to grow the chunk. */ /* We need to grow the chunk. */
chunk_repack(buf->head); chunk_repack(buf->head);
newsize = CHUNK_SIZE_WITH_ALLOC(preferred_chunk_size(capacity)); newsize = CHUNK_SIZE_WITH_ALLOC(buf_preferred_chunk_size(capacity));
newhead = chunk_grow(buf->head, newsize); newhead = chunk_grow(buf->head, newsize);
tor_assert(newhead->memlen >= capacity); tor_assert(newhead->memlen >= capacity);
if (newhead != buf->head) { if (newhead != buf->head) {
@ -344,7 +344,7 @@ buf_t *
buf_new_with_capacity(size_t size) buf_new_with_capacity(size_t size)
{ {
buf_t *b = buf_new(); buf_t *b = buf_new();
b->default_chunk_size = preferred_chunk_size(size); b->default_chunk_size = buf_preferred_chunk_size(size);
return b; return b;
} }
@ -469,7 +469,7 @@ buf_add_chunk_with_capacity(buf_t *buf, size_t capacity, int capped)
} else if (capped && CHUNK_ALLOC_SIZE(capacity) > MAX_CHUNK_ALLOC) { } else if (capped && CHUNK_ALLOC_SIZE(capacity) > MAX_CHUNK_ALLOC) {
chunk = chunk_new_with_alloc_size(MAX_CHUNK_ALLOC); chunk = chunk_new_with_alloc_size(MAX_CHUNK_ALLOC);
} else { } else {
chunk = chunk_new_with_alloc_size(preferred_chunk_size(capacity)); chunk = chunk_new_with_alloc_size(buf_preferred_chunk_size(capacity));
} }
chunk->inserted_time = (uint32_t)monotime_coarse_absolute_msec(); chunk->inserted_time = (uint32_t)monotime_coarse_absolute_msec();

2
src/common/buffers.h
View File

@ -67,7 +67,7 @@ void buf_pullup(buf_t *buf, size_t bytes,
#ifdef TOR_UNIT_TESTS #ifdef TOR_UNIT_TESTS
buf_t *buf_new_with_data(const char *cp, size_t sz); buf_t *buf_new_with_data(const char *cp, size_t sz);
#endif #endif
ATTR_UNUSED STATIC size_t preferred_chunk_size(size_t target); size_t buf_preferred_chunk_size(size_t target);
#define DEBUG_CHUNK_ALLOC #define DEBUG_CHUNK_ALLOC
/** A single chunk on a buffer. */ /** A single chunk on a buffer. */

18
src/test/test_buffers.c
View File

@ -783,17 +783,17 @@ test_buffers_chunk_size(void *arg)
(void)arg; (void)arg;
const int min = 256; const int min = 256;
const int max = 65536; const int max = 65536;
tt_uint_op(preferred_chunk_size(3), OP_EQ, min); tt_uint_op(buf_preferred_chunk_size(3), OP_EQ, min);
tt_uint_op(preferred_chunk_size(25), OP_EQ, min); tt_uint_op(buf_preferred_chunk_size(25), OP_EQ, min);
tt_uint_op(preferred_chunk_size(0), OP_EQ, min); tt_uint_op(buf_preferred_chunk_size(0), OP_EQ, min);
tt_uint_op(preferred_chunk_size(256), OP_EQ, 512); tt_uint_op(buf_preferred_chunk_size(256), OP_EQ, 512);
tt_uint_op(preferred_chunk_size(65400), OP_EQ, max); tt_uint_op(buf_preferred_chunk_size(65400), OP_EQ, max);
/* Here, we're implicitly saying that the chunk header overhead is /* Here, we're implicitly saying that the chunk header overhead is
* between 1 and 100 bytes. 24..48 would probably be more accurate. */ * between 1 and 100 bytes. 24..48 would probably be more accurate. */
tt_uint_op(preferred_chunk_size(65536), OP_GT, 65536); tt_uint_op(buf_preferred_chunk_size(65536), OP_GT, 65536);
tt_uint_op(preferred_chunk_size(65536), OP_LT, 65536+100); tt_uint_op(buf_preferred_chunk_size(65536), OP_LT, 65536+100);
tt_uint_op(preferred_chunk_size(165536), OP_GT, 165536); tt_uint_op(buf_preferred_chunk_size(165536), OP_GT, 165536);
tt_uint_op(preferred_chunk_size(165536), OP_LT, 165536+100); tt_uint_op(buf_preferred_chunk_size(165536), OP_LT, 165536+100);
done: done:
; ;
} }