static void
our_memcpy_vs_libc(void)
{
/* Compare our memcpy with libc memcpy.
* XXX: Should compare on more sizes, especially small ones.
*/
size_t alloc_size = 20 * 1024;
int loop_count = 100 * 1000;
void *src = global_heap_alloc(alloc_size HEAPACCT(ACCT_OTHER));
void *dst = global_heap_alloc(alloc_size HEAPACCT(ACCT_OTHER));
int i;
memcpy_t glibc_memcpy = (memcpy_t) dlsym(RTLD_NEXT, "memcpy");
uint64 our_memcpy_start, our_memcpy_end, our_memcpy_time;
uint64 libc_memcpy_start, libc_memcpy_end, libc_memcpy_time;
memset(src, -1, alloc_size);
memset(dst, 0, alloc_size);
our_memcpy_start = query_time_millis();
for (i = 0; i < loop_count; i++) {
memcpy(src, dst, alloc_size);
}
our_memcpy_end = query_time_millis();
libc_memcpy_start = query_time_millis();
for (i = 0; i < loop_count; i++) {
glibc_memcpy(src, dst, alloc_size);
}
libc_memcpy_end = query_time_millis();
global_heap_free(src, alloc_size HEAPACCT(ACCT_OTHER));
global_heap_free(dst, alloc_size HEAPACCT(ACCT_OTHER));
our_memcpy_time = our_memcpy_end - our_memcpy_start;
libc_memcpy_time = libc_memcpy_end - libc_memcpy_start;
print_file(STDERR, "our_memcpy_time: "UINT64_FORMAT_STRING"\n",
our_memcpy_time);
print_file(STDERR, "libc_memcpy_time: "UINT64_FORMAT_STRING"\n",
libc_memcpy_time);
/* We could assert that we're not too much slower, but that's a recipe for
* flaky failures when the suite is run on shared VMs or in parallel.
*/
}
HANDLE WINAPI
redirect_RtlCreateHeap(ULONG flags, void *base, size_t reserve_sz,
size_t commit_sz, void *lock, void *params)
{
if (IF_CLIENT_INTERFACE_ELSE(INTERNAL_OPTION(privlib_privheap), true)) {
/* We don't want to waste space by letting a Heap be created
* and not used so we nop this. We need to return something
* here, and distinguish a nop-ed from real in Destroy, so we
* allocate a token block.
*/
LOG(GLOBAL, LOG_LOADER, 2, "%s "PFX"\n", __FUNCTION__, base);
return (HANDLE) global_heap_alloc(1 HEAPACCT(ACCT_LIBDUP));
} else
return RtlCreateHeap(flags, base, reserve_sz, commit_sz, lock, params);
}
void *
wrapped_dr_alloc(ULONG flags, SIZE_T size)
{
byte *mem;
ASSERT(sizeof(size_t) >= HEAP_ALIGNMENT);
size += sizeof(size_t);
mem = global_heap_alloc(size HEAPACCT(ACCT_LIBDUP));
if (mem == NULL) {
/* FIXME: support HEAP_GENERATE_EXCEPTIONS (xref PR 406742) */
ASSERT_NOT_REACHED();
return NULL;
}
*((size_t *)mem) = size;
if (TEST(HEAP_ZERO_MEMORY, flags))
memset(mem + sizeof(size_t), 0, size - sizeof(size_t));
return (void *) (mem + sizeof(size_t));
}
void
fragment_thread_init(dcontext_t *dcontext)
{
/* we allocate per_thread_t in the global heap solely for self-protection,
* even when turned off, since even with a lot of threads this isn't a lot of
* pressure on the global heap
*/
per_thread_t *pt;
/* don't initialize un-needed data for hotp_only & thin_client.
* FIXME: could set htable initial sizes to 0 for all configurations, instead.
* per_thread_t is pretty big, so we avoid it, though it costs us checks for
* hotp_only in the islinking-related routines.
*/
if (RUNNING_WITHOUT_CODE_CACHE())
return;
pt = (per_thread_t *)global_heap_alloc(sizeof(per_thread_t) HEAPACCT(ACCT_OTHER));
dcontext->fragment_field = (void *) pt;
framgment_reset_init(dcontext);
}
static void
print_all_ldt(void)
{
int i, bytes;
/* can't fit 64K on our stack */
raw_ldt_entry_t *ldt = global_heap_alloc(sizeof(raw_ldt_entry_t) * LDT_ENTRIES
HEAPACCT(ACCT_OTHER));
/* make sure our struct size jives w/ ldt.h */
ASSERT(sizeof(raw_ldt_entry_t) == LDT_ENTRY_SIZE);
memset(ldt, 0, sizeof(*ldt));
bytes = modify_ldt_syscall(0, (void *)ldt, sizeof(raw_ldt_entry_t) * LDT_ENTRIES);
LOG(GLOBAL, LOG_ALL, 3, "read %d bytes, should == %d * %d\n",
bytes, sizeof(raw_ldt_entry_t), LDT_ENTRIES);
ASSERT(bytes == 0 /* no ldt entries */ ||
bytes == sizeof(raw_ldt_entry_t) * LDT_ENTRIES);
for (i = 0; i < bytes/sizeof(raw_ldt_entry_t); i++) {
if (((ldt[i].base3124<<24) | (ldt[i].base2316<<16) | ldt[i].base1500) != 0) {
LOG(GLOBAL, LOG_ALL, 1, "ldt at index %d:\n", i);
print_raw_ldt(&ldt[i]);
}
}
global_heap_free(ldt, sizeof(raw_ldt_entry_t) * LDT_ENTRIES HEAPACCT(ACCT_OTHER));
}
