static void handle_notification(void *arg)
{
struct lmp_endpoint *ep = arg;
errval_t err;
do { // consume messages
struct lmp_recv_msg msg = LMP_RECV_MSG_INIT;
err = lmp_endpoint_recv(ep, &msg.buf, NULL);
if (err_is_ok(err)) {
if(msg.buf.msglen == 1) {
domainid_t domid = msg.words[0];
// XXX: This is done by spawnd now
if (domid != 0) {
debug_printf("Dispatcher with domain ID %"PRIuDOMAINID" exited\n",
domid);
}
} else if(msg.buf.msglen == sizeof(struct RAM) / sizeof(uintptr_t) + 1) {
#ifndef __arm__
//defined(__x86_64__) || defined(__i386__)
union rammsg {
uintptr_t msgwords[LMP_MSG_LENGTH];
struct RAM ram;
} *u;
u = (union rammsg *)&msg.words;
/* printf("%s.%d: RAM cap deleted, base = %" PRIxGENPADDR ", bits = %u\n", */
/* disp_name(), disp_get_core_id(), ram->base, ram->bits); */
err = reclaim_memory(u->ram.base, u->ram.bits);
if(err_is_fail(err)) {
DEBUG_ERR(err, "reclaim_memory");
}
#else
/* XXX: Disabling memory reclamation on ARM. I
* couldn't get the compiler to accept the above code
* due to strict aliasing restrictions. I do believe
* though that the above is according to the C99
* spec. Please help fix it, so that it can be
* enabled.
*/
#endif
} else {
printf("%s: Unknown kernel notification of length %zu received\n",
disp_name(), msg.buf.msglen);
}
} else if (err_no(err) != LIB_ERR_NO_LMP_MSG) {
DEBUG_ERR(err, "unexpected error from lmp_endpoint_recv");
}
} while(err_is_ok(err));
// re-register
struct event_closure cl = {
.handler = handle_notification,
.arg = arg,
};
err = lmp_endpoint_register(ep, get_default_waitset(), cl);
assert(err_is_ok(err));
}
size_t _starpu_allocate_interface(starpu_data_handle handle, void *interface, uint32_t dst_node)
{
unsigned attempts = 0;
size_t allocated_memory;
_starpu_data_allocation_inc_stats(dst_node);
#ifdef STARPU_USE_ALLOCATION_CACHE
/* perhaps we can directly reuse a buffer in the free-list */
uint32_t footprint = _starpu_compute_data_footprint(handle);
STARPU_TRACE_START_ALLOC_REUSE(dst_node);
if (try_to_find_reusable_mem_chunk(dst_node, handle, footprint))
{
_starpu_allocation_cache_hit(dst_node);
return 0;
}
STARPU_TRACE_END_ALLOC_REUSE(dst_node);
#endif
do {
STARPU_ASSERT(handle->ops);
STARPU_ASSERT(handle->ops->allocate_data_on_node);
STARPU_TRACE_START_ALLOC(dst_node);
allocated_memory = handle->ops->allocate_data_on_node(interface, dst_node);
STARPU_TRACE_END_ALLOC(dst_node);
if (!allocated_memory) {
/* XXX perhaps we should find the proper granularity
* not to waste our cache all the time */
size_t data_size = _starpu_data_get_size(handle);
STARPU_TRACE_START_MEMRECLAIM(dst_node);
reclaim_memory(dst_node, 2*data_size);
STARPU_TRACE_END_MEMRECLAIM(dst_node);
}
} while(!allocated_memory && attempts++ < 2);
return allocated_memory;
}
