Esempio n. 1
0
double ResDtSolid(struct fe1d *p, matrix *guess, Elem1D *elem,
                  double x, int f1, int f2)
{
    double T = TINIT,
           C = 0,
           Ci, Ea, E, lambda, sigma, term1;
    int i;
    basis *b;
    b = p->b;

    solution *s;
    s = CreateSolution(p->t, p->dt, guess);

    for(i=0; i<b->n; i++) {
        Ci = EvalSoln1D(p, CVAR, elem, s, valV(elem->points, i));
        Ci = uscaleTemp(p->chardiff, Ci);

        C += Ci;
    }

    Ea += EA(C, T);
    E += E1(C, T);
    lambda += LAMBDA(C, T);
    sigma += STRESS(C, T);

    term1 = lambda*(Ea+E) * b->phi[f1](x)*b->phi[f2](x) / IMap1D(p, elem, x);
    free(s);
    return term1;
}
Esempio n. 2
0
static ssize_t
fd_recv(struct stream *stream, void *buffer, size_t n)
{
    struct stream_fd *s = stream_fd_cast(stream);
    ssize_t retval;

    if (STRESS(stream_flaky_recv)) {
        return -EIO;
    }

    retval = read(s->fd, buffer, n);
    return retval >= 0 ? retval : -errno;
}
Esempio n. 3
0
double ResFSolid(struct fe1d *p, matrix *guess, Elem1D *elem, double x, int f1, int a)
{
    double T = TINIT,
           C = 0,
           Cp = 0,
           Ci, Cpi, lambda, sigma, sigmap, DsigmaDt;
    int i;
    solution *s, *sp;
    basis *b;

    b = p->b;
    s = CreateSolution(p->t, p->dt, guess);
    sp = FetchSolution(p, p->t-1);

    for(i=0; i<b->n; i++) {
        Ci = EvalSoln1D(p, CVAR, elem, s, valV(elem->points, i));
        Ci = uscaleTemp(p->chardiff, Ci);

        if(p->t > 1) {
            Cpi = EvalSoln1D(p, CVAR, elem, sp, valV(elem->points, i));
            Cpi = uscaleTemp(p->chardiff, Cpi);
        } else {
            Cpi = Ci;
        }

        C += Ci;
        Cp += Cpi;
    }

    lambda += LAMBDA(C, T);
    sigma += STRESS(C, T);
    sigmap += STRESS(Cp, T);

    DsigmaDt = (sigma-sigmap)/p->dt;
    free(s);
    return sigma - lambda*DsigmaDt;
}
Esempio n. 4
0
static ssize_t
fd_send(struct stream *stream, const void *buffer, size_t n)
{
    struct stream_fd *s = stream_fd_cast(stream);
    ssize_t retval;

    if (STRESS(stream_flaky_send)) {
        return -EIO;
    }

    retval = write(s->fd, buffer, n);
    return (retval > 0 ? retval
            : retval == 0 ? -EAGAIN
            : -errno);
}
Esempio n. 5
0
static int
nl_sock_recv__(struct nl_sock *sock, struct ofpbuf *buf, bool wait)
{
    /* We can't accurately predict the size of the data to be received.  The
     * caller is supposed to have allocated enough space in 'buf' to handle the
     * "typical" case.  To handle exceptions, we make available enough space in
     * 'tail' to allow Netlink messages to be up to 64 kB long (a reasonable
     * figure since that's the maximum length of a Netlink attribute). */
    struct nlmsghdr *nlmsghdr;
    uint8_t tail[65536];
    struct iovec iov[2];
    struct msghdr msg;
    ssize_t retval;

    assert(buf->allocated >= sizeof *nlmsghdr);
    ofpbuf_clear(buf);

    iov[0].iov_base = buf->base;
    iov[0].iov_len = buf->allocated;
    iov[1].iov_base = tail;
    iov[1].iov_len = sizeof tail;

    memset(&msg, 0, sizeof msg);
    msg.msg_iov = iov;
    msg.msg_iovlen = 2;

    do {
        retval = recvmsg(sock->fd, &msg, wait ? 0 : MSG_DONTWAIT);
    } while (retval < 0 && errno == EINTR);

    if (retval < 0) {
        int error = errno;
        if (error == ENOBUFS) {
            /* Socket receive buffer overflow dropped one or more messages that
             * the kernel tried to send to us. */
            COVERAGE_INC(netlink_overflow);
        }
        return error;
    }

    if (msg.msg_flags & MSG_TRUNC) {
        VLOG_ERR_RL(&rl, "truncated message (longer than %zu bytes)",
                    sizeof tail);
        return E2BIG;
    }

    nlmsghdr = buf->data;
    if (retval < sizeof *nlmsghdr
        || nlmsghdr->nlmsg_len < sizeof *nlmsghdr
        || nlmsghdr->nlmsg_len > retval) {
        VLOG_ERR_RL(&rl, "received invalid nlmsg (%zd bytes < %zu)",
                    retval, sizeof *nlmsghdr);
        return EPROTO;
    }

    if (STRESS(netlink_overflow)) {
        return ENOBUFS;
    }

    buf->size = MIN(retval, buf->allocated);
    if (retval > buf->allocated) {
        COVERAGE_INC(netlink_recv_jumbo);
        ofpbuf_put(buf, tail, retval - buf->allocated);
    }

    log_nlmsg(__func__, 0, buf->data, buf->size, sock->protocol);
    COVERAGE_INC(netlink_received);

    return 0;
}