ucs_log_func_rc_t
ucs_log_default_handler(const char *file, unsigned line, const char *function,
ucs_log_level_t level, const char *prefix,
const char *message, va_list ap)
{
size_t buffer_size = ucs_config_memunits_get(ucs_global_opts.log_buffer_size,
256, 2048);
const char *short_file;
struct timeval tv;
size_t length;
char *buf;
char *valg_buf;
if (!ucs_log_enabled(level) && (level != UCS_LOG_LEVEL_PRINT)) {
return UCS_LOG_FUNC_RC_CONTINUE;
}
buf = ucs_alloca(buffer_size + 1);
buf[buffer_size] = 0;
strncpy(buf, prefix, buffer_size);
length = strlen(buf);
vsnprintf(buf + length, buffer_size - length, message, ap);
short_file = strrchr(file, '/');
short_file = (short_file == NULL) ? file : short_file + 1;
gettimeofday(&tv, NULL);
if (level <= ucs_global_opts.log_level_trigger) {
ucs_handle_error(ucs_log_level_names[level], "%13s:%-4u %s: %s",
short_file, line, ucs_log_level_names[level], buf);
} else if (RUNNING_ON_VALGRIND) {
valg_buf = ucs_alloca(buffer_size + 1);
snprintf(valg_buf, buffer_size,
"[%lu.%06lu] %16s:%-4u %-4s %-5s %s\n", tv.tv_sec, tv.tv_usec,
short_file, line, "UCX", ucs_log_level_names[level], buf);
VALGRIND_PRINTF("%s", valg_buf);
} else if (ucs_log_initialized) {
fprintf(ucs_log_file,
"[%lu.%06lu] [%s:%-5d:%d] %16s:%-4u %-4s %-5s %s\n",
tv.tv_sec, tv.tv_usec, ucs_log_hostname, ucs_log_pid,
ucs_log_get_thread_num(), short_file, line, "UCX",
ucs_log_level_names[level], buf);
} else {
fprintf(stdout,
"[%lu.%06lu] %16s:%-4u %-4s %-5s %s\n",
tv.tv_sec, tv.tv_usec, short_file, line,
"UCX", ucs_log_level_names[level], buf);
}
/* flush the log file if the log_level of this message is fatal or error */
if (level <= UCS_LOG_LEVEL_ERROR) {
ucs_log_flush();
}
return UCS_LOG_FUNC_RC_CONTINUE;
}
void ucs_log_fatal_error(const char *fmt, ...)
{
size_t buffer_size = ucs_global_opts.log_buffer_size;
FILE *stream = stderr;
char *buffer, *p;
va_list ap;
int ret;
buffer = ucs_alloca(buffer_size + 1);
p = buffer;
/* Print hostname:pid */
snprintf(p, buffer_size, "[%s:%-5d:%d] ", ucs_log_hostname, ucs_log_pid,
get_thread_num());
buffer_size -= strlen(p);
p += strlen(p);
/* Print rest of the message */
va_start(ap, fmt);
vsnprintf(p, buffer_size, fmt, ap);
va_end(ap);
buffer_size -= strlen(p);
p += strlen(p);
/* Newline */
snprintf(p, buffer_size, "\n");
/* Flush stderr, and write the message directly to the pipe */
fflush(stream);
ret = write(fileno(stream), buffer, strlen(buffer));
(void)ret;
}
/* For RNDV request send regular eager packet with IBV_SEND_WITH_IMM and
* imm_value = 0. Receiver will handle such message as rndv request. */
ucs_status_t uct_rc_verbs_ep_tag_rndv_request(uct_ep_h tl_ep, uct_tag_t tag,
const void* header,
unsigned header_length)
{
uct_rc_verbs_ep_t *ep = ucs_derived_of(tl_ep, uct_rc_verbs_ep_t);
uct_rc_verbs_iface_t *iface = ucs_derived_of(tl_ep->iface,
uct_rc_verbs_iface_t);
void *tm_hdr = ucs_alloca(iface->tm.eager_hdr_size);
uint32_t app_ctx;
struct ibv_send_wr wr;
UCT_CHECK_LENGTH(header_length + iface->tm.eager_hdr_size, 0,
iface->verbs_common.config.max_inline, "tag_short");
UCT_RC_CHECK_RES(&iface->super, &ep->super);
wr.sg_list = iface->verbs_common.inl_sge;
wr.num_sge = 2;
wr.opcode = IBV_WR_SEND_WITH_IMM;
wr.next = NULL;
uct_rc_verbs_tag_imm_data_pack(&(wr.imm_data), &app_ctx, 0ul);
uct_rc_verbs_iface_fill_inl_tag_sge(iface, tm_hdr, tag,
header, header_length, app_ctx);
uct_rc_verbs_ep_post_send(iface, ep, &wr, IBV_SEND_INLINE);
return UCS_OK;
}
ucs_status_ptr_t uct_rc_verbs_ep_tag_rndv_zcopy(uct_ep_h tl_ep, uct_tag_t tag,
const void *header,
unsigned header_length,
const uct_iov_t *iov,
size_t iovcnt,
uct_completion_t *comp)
{
uct_rc_verbs_ep_t *ep = ucs_derived_of(tl_ep, uct_rc_verbs_ep_t);
uct_rc_verbs_iface_t *iface = ucs_derived_of(tl_ep->iface,
uct_rc_verbs_iface_t);
void *hdr = ucs_alloca(iface->tm.rndv_hdr_size);
uct_ib_device_t *dev = uct_ib_iface_device(&iface->super.super);
uint32_t op_index;
UCT_CHECK_PARAM_PTR(iovcnt <= 1ul,
"Wrong iovcnt in uct_rc_verbs_ep_tag_rndv_zcopy %lu",
iovcnt);
UCT_CHECK_PARAM_PTR(header_length <= IBV_DEVICE_TM_CAPS(dev, max_rndv_priv_size),
"Invalid hdr len in uct_rc_verbs_ep_tag_rndv_zcopy %u",
header_length);
UCT_CHECK_PARAM_PTR((header_length + iface->tm.rndv_hdr_size) <=
iface->verbs_common.config.max_inline,
"Invalid RTS len in uct_rc_verbs_ep_tag_rndv_zcopy %u",
header_length + iface->tm.rndv_hdr_size);
op_index = uct_rc_verbs_iface_tag_get_op_id(iface, comp);
uct_rc_verbs_iface_fill_inl_rndv_sge(iface, hdr, tag, op_index,
((uct_ib_mem_t*)iov->memh)->mr->rkey,
iov->buffer, uct_iov_get_length(iov),
header, header_length);
uct_rc_verbs_ep_post_send(iface, ep, &iface->inl_am_wr, IBV_SEND_INLINE);
return (ucs_status_ptr_t)((uint64_t)op_index);
}
unsigned uct_rc_verbs_iface_post_recv_always(uct_rc_iface_t *iface, unsigned max)
{
struct ibv_recv_wr *bad_wr;
uct_ib_recv_wr_t *wrs;
unsigned count;
int ret;
wrs = ucs_alloca(sizeof *wrs * max);
count = uct_ib_iface_prepare_rx_wrs(&iface->super, &iface->rx.mp,
wrs, max);
if (ucs_unlikely(count == 0)) {
return 0;
}
UCT_IB_INSTRUMENT_RECORD_RECV_WR_LEN("uct_rc_iface_post_recv_always",
&wrs[0].ibwr);
ret = ibv_post_srq_recv(iface->rx.srq, &wrs[0].ibwr, &bad_wr);
if (ret != 0) {
ucs_fatal("ibv_post_srq_recv() returned %d: %m", ret);
}
iface->rx.available -= count;
return count;
}
ucs_status_t uct_rc_verbs_ep_tag_eager_short(uct_ep_h tl_ep, uct_tag_t tag,
const void *data, size_t length)
{
uct_rc_verbs_ep_t *ep = ucs_derived_of(tl_ep, uct_rc_verbs_ep_t);
uct_rc_verbs_iface_t *iface = ucs_derived_of(tl_ep->iface,
uct_rc_verbs_iface_t);
void *tm_hdr = ucs_alloca(iface->tm.eager_hdr_size);
UCT_CHECK_LENGTH(length + iface->tm.eager_hdr_size, 0,
iface->verbs_common.config.max_inline, "tag_short");
UCT_RC_CHECK_RES(&iface->super, &ep->super);
uct_rc_verbs_iface_fill_inl_tag_sge(iface, tm_hdr, tag, data, length, 0);
uct_rc_verbs_ep_post_send(iface, ep, &iface->inl_am_wr, IBV_SEND_INLINE);
return UCS_OK;
}
ucs_status_t ucs_async_dispatch_timerq(ucs_timer_queue_t *timerq,
ucs_time_t current_time)
{
size_t max_timers, num_timers = 0;
int *expired_timers;
ucs_timer_t *timer;
max_timers = ucs_max(1, ucs_timerq_size(timerq));
expired_timers = ucs_alloca(max_timers * sizeof(*expired_timers));
ucs_timerq_for_each_expired(timer, timerq, current_time, {
expired_timers[num_timers++] = timer->id;
if (num_timers >= max_timers) {
break; /* Keep timers which we don't have room for in the queue */
}
})
return ucs_async_dispatch_handlers(expired_timers, num_timers);
void __ucs_abort(const char *file, unsigned line, const char *function,
const char *message, ...)
{
size_t buffer_size = ucs_global_opts.log_buffer_size;
const char *short_file;
char *buffer;
va_list ap;
buffer = ucs_alloca(buffer_size + 1);
va_start(ap, message);
vsnprintf(buffer, buffer_size, message, ap);
va_end(ap);
short_file = strrchr(file, '/');
short_file = (short_file == NULL) ? file : short_file + 1;
ucs_log_fatal_error("%13s:%-4u %s", short_file, line, buffer);
ucs_log_flush();
ucs_debug_cleanup();
ucs_handle_error();
abort();
}
static UCS_F_NOINLINE void
uct_ud_verbs_iface_post_recv_always(uct_ud_verbs_iface_t *iface, int max)
{
struct ibv_recv_wr *bad_wr;
uct_ib_recv_wr_t *wrs;
unsigned count;
int ret;
wrs = ucs_alloca(sizeof *wrs * max);
count = uct_ib_iface_prepare_rx_wrs(&iface->super.super, &iface->super.rx.mp,
wrs, max);
if (count == 0) {
return;
}
ret = ibv_post_recv(iface->super.qp, &wrs[0].ibwr, &bad_wr);
if (ret != 0) {
ucs_fatal("ibv_post_recv() returned %d: %m", ret);
}
iface->super.rx.available -= count;
}