static void inline frbwrite(lirc_t l)
{
/* simple noise filter */
static lirc_t pulse=0L,space=0L;
static unsigned int ptr=0;
if(ptr>0 && (l&PULSE_BIT))
{
pulse+=l&PULSE_MASK;
if(pulse>250)
{
rbwrite(space);
rbwrite(pulse|PULSE_BIT);
ptr=0;
pulse=0;
}
return;
}
if(!(l&PULSE_BIT))
{
if(ptr==0)
{
if(l>20000)
{
space=l;
ptr++;
return;
}
}
else
{
if(l>20000)
{
space+=pulse;
if(space>PULSE_MASK) space=PULSE_MASK;
space+=l;
if(space>PULSE_MASK) space=PULSE_MASK;
pulse=0;
return;
}
rbwrite(space);
rbwrite(pulse|PULSE_BIT);
ptr=0;
pulse=0;
}
}
rbwrite(l);
}
int sock_cq_report_error(struct sock_cq *cq, struct sock_pe_entry *entry,
size_t olen, int err, int prov_errno, void *err_data)
{
int ret;
struct fi_cq_err_entry err_entry;
fastlock_acquire(&cq->lock);
if (rbavail(&cq->cqerr_rb) < sizeof(err_entry)) {
ret = -FI_ENOSPC;
goto out;
}
err_entry.err = err;
err_entry.olen = olen;
err_entry.err_data = err_data;
err_entry.len = entry->data_len;
err_entry.prov_errno = prov_errno;
err_entry.flags = entry->flags;
err_entry.data = entry->data;
err_entry.tag = entry->tag;
err_entry.op_context = (void *) (uintptr_t) entry->context;
if (entry->type == SOCK_PE_RX)
err_entry.buf = (void *) (uintptr_t) entry->pe.rx.rx_iov[0].iov.addr;
else
err_entry.buf = (void *) (uintptr_t) entry->pe.tx.tx_iov[0].src.iov.addr;
rbwrite(&cq->cqerr_rb, &err_entry, sizeof(err_entry));
rbcommit(&cq->cqerr_rb);
ret = 0;
out:
fastlock_release(&cq->lock);
return ret;
}
static ssize_t _sock_cq_write(struct sock_cq *cq, fi_addr_t addr,
const void *buf, size_t len)
{
ssize_t ret;
fastlock_acquire(&cq->lock);
if (rbfdavail(&cq->cq_rbfd) < len) {
ret = -FI_ENOSPC;
SOCK_LOG_ERROR("Not enough space in CQ\n");
goto out;
}
rbwrite(&cq->addr_rb, &addr, sizeof(addr));
rbcommit(&cq->addr_rb);
rbfdwrite(&cq->cq_rbfd, buf, len);
rbfdcommit(&cq->cq_rbfd);
ret = len;
if (cq->signal)
sock_wait_signal(cq->waitset);
out:
fastlock_release(&cq->lock);
return ret;
}
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;
}
static inline void sock_cq_copy_overflow_list(struct sock_cq *cq, size_t count)
{
ssize_t i;
struct sock_cq_overflow_entry_t *overflow_entry;
for (i = 0; i < count && !dlist_empty(&cq->overflow_list); i++) {
overflow_entry = container_of(cq->overflow_list.next,
struct sock_cq_overflow_entry_t,
entry);
rbwrite(&cq->addr_rb, &overflow_entry->addr, sizeof(fi_addr_t));
rbcommit(&cq->addr_rb);
rbfdwrite(&cq->cq_rbfd, &overflow_entry->cq_entry[0], overflow_entry->len);
rbfdcommit(&cq->cq_rbfd);
dlist_remove(&overflow_entry->entry);
free(overflow_entry);
}
}
static ssize_t _sock_cq_writeerr(struct sock_cq *cq,
struct fi_cq_err_entry *buf, size_t len)
{
ssize_t ret;
fastlock_acquire(&cq->lock);
if(rbavail(&cq->cqerr_rb) < len) {
ret = -FI_ENOSPC;
goto out;
}
rbwrite(&cq->cqerr_rb, buf, len);
rbcommit(&cq->cqerr_rb);
ret = len;
out:
fastlock_release(&cq->lock);
return ret;
}
static ssize_t _sock_cq_write(struct sock_cq *cq, fi_addr_t addr,
const void *buf, size_t len)
{
ssize_t ret;
struct sock_cq_overflow_entry_t *overflow_entry;
fastlock_acquire(&cq->lock);
if (rbfdavail(&cq->cq_rbfd) < len) {
SOCK_LOG_ERROR("Not enough space in CQ\n");
overflow_entry = calloc(1, sizeof(*overflow_entry) + len);
if (!overflow_entry) {
ret = -FI_ENOSPC;
goto out;
}
memcpy(&overflow_entry->cq_entry[0], buf, len);
overflow_entry->len = len;
overflow_entry->addr = addr;
dlist_insert_tail(&overflow_entry->entry, &cq->overflow_list);
ret = len;
goto out;
}
rbwrite(&cq->addr_rb, &addr, sizeof(addr));
rbcommit(&cq->addr_rb);
rbfdwrite(&cq->cq_rbfd, buf, len);
if (cq->domain->progress_mode == FI_PROGRESS_MANUAL)
rbcommit(&cq->cq_rbfd.rb);
else
rbfdcommit(&cq->cq_rbfd);
ret = len;
if (cq->signal)
sock_wait_signal(cq->waitset);
out:
fastlock_release(&cq->lock);
return ret;
}
static ssize_t _sock_cq_write(struct sock_cq *cq, fi_addr_t addr,
const void *buf, size_t len)
{
ssize_t ret;
fastlock_acquire(&cq->lock);
if(rbfdavail(&cq->cq_rbfd) < len) {
ret = -FI_ENOSPC;
goto out;
}
rbfdwrite(&cq->cq_rbfd, buf, len);
rbfdcommit(&cq->cq_rbfd);
ret = len;
rbwrite(&cq->addr_rb, &addr, sizeof(fi_addr_t));
rbcommit(&cq->addr_rb);
out:
fastlock_release(&cq->lock);
return ret;
}