ssize_t sock_comm_send(struct sock_conn *conn, const void *buf, size_t len)
{
ssize_t ret, used;
if (len >= SOCK_COMM_THRESHOLD) {
used = rbused(&conn->outbuf);
if (used == sock_comm_flush(conn)) {
return sock_comm_send_socket(conn, buf, len);
} else {
return 0;
}
}
if (rbavail(&conn->outbuf) < len) {
ret = sock_comm_flush(conn);
if (ret <= 0)
return 0;
}
ret = MIN(rbavail(&conn->outbuf), len);
rbwrite(&conn->outbuf, buf, ret);
rbcommit(&conn->outbuf);
SOCK_LOG_INFO("buffered %lu\n", ret);
return ret;
}
ssize_t sock_comm_flush(struct sock_conn *conn)
{
ssize_t ret1, ret2 = 0;
size_t endlen, len, xfer_len;
len = rbused(&conn->outbuf);
endlen = conn->outbuf.size - (conn->outbuf.rcnt & conn->outbuf.size_mask);
xfer_len = MIN(len, endlen);
ret1 = sock_comm_send_socket(conn, conn->outbuf.buf +
(conn->outbuf.rcnt & conn->outbuf.size_mask),
xfer_len);
if (ret1 > 0)
conn->outbuf.rcnt += ret1;
if (ret1 == xfer_len && xfer_len < len) {
ret2 = sock_comm_send_socket(conn, conn->outbuf.buf +
(conn->outbuf.rcnt & conn->outbuf.size_mask),
len - xfer_len);
if (ret2 > 0)
conn->outbuf.rcnt += ret2;
else
ret2 = 0;
}
return (ret1 > 0) ? ret1 + ret2 : 0;
}
ssize_t sock_comm_peek(struct sock_conn *conn, void *buf, size_t len)
{
sock_comm_recv_buffer(conn);
if (rbused(&conn->inbuf) >= len) {
rbpeek(&conn->inbuf, buf, len);
return len;
}
return 0;
}
static ssize_t sock_cq_sreadfrom(struct fid_cq *cq, void *buf, size_t count,
fi_addr_t *src_addr, const void *cond, int timeout)
{
int ret = 0;
size_t threshold;
struct sock_cq *sock_cq;
uint64_t start_ms = 0, end_ms = 0;
ssize_t cq_entry_len, avail;
sock_cq = container_of(cq, struct sock_cq, cq_fid);
if (rbused(&sock_cq->cqerr_rb))
return -FI_EAVAIL;
cq_entry_len = sock_cq->cq_entry_size;
if (sock_cq->attr.wait_cond == FI_CQ_COND_THRESHOLD)
threshold = MIN((uintptr_t) cond, count);
else
threshold = count;
if (sock_cq->domain->progress_mode == FI_PROGRESS_MANUAL) {
if (timeout >= 0) {
start_ms = fi_gettime_ms();
end_ms = start_ms + timeout;
}
do {
sock_cq_progress(sock_cq);
fastlock_acquire(&sock_cq->lock);
avail = rbfdused(&sock_cq->cq_rbfd);
if (avail)
ret = sock_cq_rbuf_read(sock_cq, buf,
MIN(threshold, avail / cq_entry_len),
src_addr, cq_entry_len);
fastlock_release(&sock_cq->lock);
if (ret == 0 && timeout >= 0) {
if (fi_gettime_ms() >= end_ms)
return -FI_EAGAIN;
}
} while (ret == 0);
} else {
ret = rbfdwait(&sock_cq->cq_rbfd, timeout);
if (ret > 0) {
fastlock_acquire(&sock_cq->lock);
ret = 0;
avail = rbfdused(&sock_cq->cq_rbfd);
if (avail)
ret = sock_cq_rbuf_read(sock_cq, buf,
MIN(threshold, avail / cq_entry_len),
src_addr, cq_entry_len);
fastlock_release(&sock_cq->lock);
}
}
return (ret == 0 || ret == -FI_ETIMEDOUT) ? -FI_EAGAIN : ret;
}
static ssize_t sock_cq_readerr(struct fid_cq *cq, struct fi_cq_err_entry *buf,
uint64_t flags)
{
struct sock_cq *sock_cq;
ssize_t ret;
sock_cq = container_of(cq, struct sock_cq, cq_fid);
if (sock_cq->domain->progress_mode == FI_PROGRESS_MANUAL)
sock_cq_progress(sock_cq);
fastlock_acquire(&sock_cq->lock);
if (rbused(&sock_cq->cqerr_rb) >= sizeof(struct fi_cq_err_entry)) {
rbread(&sock_cq->cqerr_rb, buf, sizeof(*buf));
ret = 1;
} else {
ret = -FI_EAGAIN;
}
fastlock_release(&sock_cq->lock);
return ret;
}
ssize_t sock_cq_readerr(struct fid_cq *cq, struct fi_cq_err_entry *buf,
size_t len, uint64_t flags)
{
ssize_t num_read;
struct sock_cq *sock_cq;
sock_cq = container_of(cq, struct sock_cq, cq_fid);
if(len < sizeof(struct fi_cq_err_entry))
return -FI_ETOOSMALL;
num_read = 0;
fastlock_acquire(&sock_cq->lock);
while(rbused(&sock_cq->cqerr_rb) >= sizeof(struct fi_cq_err_entry)) {
rbread(&sock_cq->cqerr_rb,
(char*)buf +sizeof(struct fi_cq_err_entry) * num_read,
sizeof(struct fi_cq_err_entry));
num_read++;
}
fastlock_release(&sock_cq->lock);
return num_read;
}
ssize_t sock_comm_recv(struct sock_conn *conn, void *buf, size_t len)
{
int ret = 0;
ssize_t used, read_len;
used = rbused(&conn->inbuf);
if (used == 0) {
ret = sock_comm_recv_socket(conn, buf, len);
sock_comm_recv_buffer(conn);
return ret;
}
read_len = MIN(len, used);
rbread(&conn->inbuf, buf, read_len);
if (len > used) {
ret = sock_comm_recv_socket(conn, (char*) buf + used, len - used);
if (ret <= 0)
ret = 0;
sock_comm_recv_buffer(conn);
}
SOCK_LOG_INFO("read from buffer: %lu\n", ret + read_len);
return ret + read_len;
}
