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; }