void emit_trampoline(struct compilation_unit *cu,
void *call_target,
struct jit_trampoline *trampoline)
{
struct buffer *buf = trampoline->objcode;
jit_text_lock();
buf->buf = jit_text_ptr();
/* Store FP and LR */
encode_stm(buf, 0b0100100000000000);
/* Setup the frame pointer to point to the current frame */
encode_setup_fp(buf, 4);
/* Pass the address of cu to magic_trampoline in R0 and call it */
encode_setup_trampoline(buf, (unsigned long)cu, (unsigned long)call_target);
/* Call the function whose address is is returned by magic trampoline */
encode_emit_branch_link(buf);
/*
* Setup the stack frame to the previous value
* before entering the frame
*/
encode_restore_sp(buf, 4);
encode_ldm(buf, 0b1000100000000000);
jit_text_reserve(buffer_offset(buf));
jit_text_unlock();
}
static inline void sca_rx(card_t *card, port_t *port, pkt_desc __iomem *desc,
u16 rxin)
{
struct net_device *dev = port->netdev;
struct sk_buff *skb;
u16 len;
u32 buff;
len = readw(&desc->len);
skb = dev_alloc_skb(len);
if (!skb) {
dev->stats.rx_dropped++;
return;
}
buff = buffer_offset(port, rxin, 0);
memcpy_fromio(skb->data, card->rambase + buff, len);
skb_put(skb, len);
#ifdef DEBUG_PKT
printk(KERN_DEBUG "%s RX(%i):", dev->name, skb->len);
debug_frame(skb);
#endif
dev->stats.rx_packets++;
dev->stats.rx_bytes += skb->len;
skb->protocol = hdlc_type_trans(skb, dev);
netif_receive_skb(skb);
}
static void record_delete(char *buf, long len, bool move_after)
{
struct change *change = buffer->cur_change;
BUG_ON(!len);
BUG_ON(!buf);
if (change_merge == prev_change_merge) {
if (change_merge == CHANGE_MERGE_DELETE) {
xrenew(change->buf, change->del_count + len);
memcpy(change->buf + change->del_count, buf, len);
change->del_count += len;
free(buf);
return;
}
if (change_merge == CHANGE_MERGE_ERASE) {
xrenew(buf, len + change->del_count);
memcpy(buf + len, change->buf, change->del_count);
change->del_count += len;
free(change->buf);
change->buf = buf;
change->offset -= len;
return;
}
}
change = new_change();
change->offset = buffer_offset();
change->del_count = len;
change->move_after = move_after;
change->buf = buf;
}
long numpy_iexpr<Arg>::buffer_offset(long index, utils::int_<N>)
{
auto &&arg_shape = arg.shape();
_shape[value - N] = arg_shape[value - N + 1];
return buffer_offset(index * arg_shape[value - N + 1],
utils::int_<N - 1>());
}
static void sca_init_port(port_t *port)
{
card_t *card = port->card;
u16 dmac_rx = get_dmac_rx(port), dmac_tx = get_dmac_tx(port);
int transmit, i;
port->rxin = 0;
port->txin = 0;
port->txlast = 0;
for (transmit = 0; transmit < 2; transmit++) {
u16 buffs = transmit ? card->tx_ring_buffers
: card->rx_ring_buffers;
for (i = 0; i < buffs; i++) {
pkt_desc __iomem *desc = desc_address(port, i, transmit);
u16 chain_off = hd_desc_offset(port, i + 1, transmit);
u32 buff_off = buffer_offset(port, i, transmit);
writel(chain_off, &desc->cp);
writel(buff_off, &desc->bp);
writew(0, &desc->len);
writeb(0, &desc->stat);
}
}
/* DMA disable - to halt state */
sca_out(0, DSR_RX(port->chan), card);
sca_out(0, DSR_TX(port->chan), card);
/* software ABORT - to initial state */
sca_out(DCR_ABORT, DCR_RX(port->chan), card);
sca_out(DCR_ABORT, DCR_TX(port->chan), card);
/* current desc addr */
sca_outl(hd_desc_offset(port, 0, 0), dmac_rx + CDAL, card);
sca_outl(hd_desc_offset(port, card->tx_ring_buffers - 1, 0),
dmac_rx + EDAL, card);
sca_outl(hd_desc_offset(port, 0, 1), dmac_tx + CDAL, card);
sca_outl(hd_desc_offset(port, 0, 1), dmac_tx + EDAL, card);
/* clear frame end interrupt counter */
sca_out(DCR_CLEAR_EOF, DCR_RX(port->chan), card);
sca_out(DCR_CLEAR_EOF, DCR_TX(port->chan), card);
/* Receive */
sca_outw(HDLC_MAX_MRU, dmac_rx + BFLL, card); /* set buffer length */
sca_out(0x14, DMR_RX(port->chan), card); /* Chain mode, Multi-frame */
sca_out(DIR_EOME, DIR_RX(port->chan), card); /* enable interrupts */
sca_out(DSR_DE, DSR_RX(port->chan), card); /* DMA enable */
/* Transmit */
sca_out(0x14, DMR_TX(port->chan), card); /* Chain mode, Multi-frame */
sca_out(DIR_EOME, DIR_TX(port->chan), card); /* enable interrupts */
sca_set_carrier(port);
netif_napi_add(port->netdev, &port->napi, sca_poll, NAPI_WEIGHT);
}
void moving_in_buffer(size_t old_offset, size_t new_offset) {
const osmium::OSMObject& object = m_members_buffer.get<osmium::OSMObject>(old_offset);
auto& mmv = member_meta(object.type());
auto range = std::equal_range(mmv.begin(), mmv.end(), osmium::relations::MemberMeta(object.id()));
for (auto it = range.first; it != range.second; ++it) {
assert(it->buffer_offset() == old_offset);
it->set_buffer_offset(new_offset);
}
}
static inline void sca_rx(card_t *card, port_t *port, pkt_desc *desc, u16 rxin)
{
struct net_device *dev = port_to_dev(port);
struct net_device_stats *stats = hdlc_stats(dev);
struct sk_buff *skb;
u16 len;
u32 buff;
#ifndef ALL_PAGES_ALWAYS_MAPPED
u32 maxlen;
u8 page;
#endif
len = readw(&desc->len);
skb = dev_alloc_skb(len);
if (!skb) {
stats->rx_dropped++;
return;
}
buff = buffer_offset(port, rxin, 0);
#ifndef ALL_PAGES_ALWAYS_MAPPED
page = buff / winsize(card);
buff = buff % winsize(card);
maxlen = winsize(card) - buff;
openwin(card, page);
if (len > maxlen) {
memcpy_fromio(skb->data, winbase(card) + buff, maxlen);
openwin(card, page + 1);
memcpy_fromio(skb->data + maxlen, winbase(card), len - maxlen);
} else
#endif
memcpy_fromio(skb->data, winbase(card) + buff, len);
#if !defined(PAGE0_ALWAYS_MAPPED) && !defined(ALL_PAGES_ALWAYS_MAPPED)
/* select pkt_desc table page back */
openwin(card, 0);
#endif
skb_put(skb, len);
#ifdef DEBUG_PKT
printk(KERN_DEBUG "%s RX(%i):", dev->name, skb->len);
debug_frame(skb);
#endif
stats->rx_packets++;
stats->rx_bytes += skb->len;
skb->mac.raw = skb->data;
skb->dev = dev;
skb->dev->last_rx = jiffies;
skb->protocol = hdlc_type_trans(skb, dev);
netif_rx(skb);
}
static void record_replace(char *deleted, long del_count, long ins_count)
{
struct change *change;
BUG_ON(del_count && !deleted);
BUG_ON(!del_count && deleted);
BUG_ON(!del_count && !ins_count);
change = new_change();
change->offset = buffer_offset();
change->ins_count = ins_count;
change->del_count = del_count;
change->buf = deleted;
}
static void simple_free_urb(struct urb *urb)
{
unsigned long offset = buffer_offset(urb->transfer_buffer);
if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
usb_free_coherent(
urb->dev,
urb->transfer_buffer_length + offset,
urb->transfer_buffer - offset,
urb->transfer_dma - offset);
else
kfree(urb->transfer_buffer - offset);
usb_free_urb(urb);
}
static int check_guard_bytes(struct usbtest_dev *tdev, struct urb *urb)
{
u8 *buf = urb->transfer_buffer;
u8 *guard = buf - buffer_offset(buf);
unsigned i;
for (i = 0; guard < buf; i++, guard++) {
if (*guard != GUARD_BYTE) {
ERROR(tdev, "guard byte[%d] %d (not %d)\n",
i, *guard, GUARD_BYTE);
return -EINVAL;
}
}
return 0;
}
static void record_insert(long len)
{
struct change *change = buffer->cur_change;
BUG_ON(!len);
if (change_merge == prev_change_merge && change_merge == CHANGE_MERGE_INSERT) {
BUG_ON(change->del_count);
change->ins_count += len;
return;
}
change = new_change();
change->offset = buffer_offset();
change->ins_count = len;
}
int Map::Construct() {
vertex_buffer_.description.bind_flags = D3D11_BIND_VERTEX_BUFFER;
vertex_buffer_.description.usage = D3D11_USAGE_DEFAULT;
vertex_buffer_.description.byte_width = sizeof( graphics::shape::Vertex ) * width_ * height_ * 4 * layer_count_;
vertex_buffer_.description.cpu_access_flags = 0;
context_->DestroyBuffer(vertex_buffer_);
context_->CreateBuffer(vertex_buffer_,NULL);
for (int i=0;i<layer_count_;++i) {
layers[i]->Initialize(this,width_,height_,tile_width_,tile_height_);
layers[i]->set_buffer_offset(buffer_offset(i));
layers[i]->Construct();
}
return S_OK;
}
static void assert_emit_insn(unsigned char *expected,
unsigned long expected_size,
struct insn *insn)
{
struct basic_block *bb;
struct buffer *buf;
bb = alloc_basic_block(NULL, 0, 1);
bb_add_insn(bb, insn);
buf = alloc_buffer();
emit_body(bb, buf);
assert_int_equals(expected_size, buffer_offset(buf));
assert_mem_equals(expected, buffer_ptr(buf), expected_size);
free_basic_block(bb);
free_buffer(buf);
}
static inline void sca_rx(card_t *card, port_t *port, pkt_desc __iomem *desc,
u16 rxin)
{
struct net_device *dev = port_to_dev(port);
struct sk_buff *skb;
u16 len;
u32 buff;
u32 maxlen;
u8 page;
len = readw(&desc->len);
skb = dev_alloc_skb(len);
if (!skb) {
dev->stats.rx_dropped++;
return;
}
buff = buffer_offset(port, rxin, 0);
page = buff / winsize(card);
buff = buff % winsize(card);
maxlen = winsize(card) - buff;
openwin(card, page);
if (len > maxlen) {
memcpy_fromio(skb->data, winbase(card) + buff, maxlen);
openwin(card, page + 1);
memcpy_fromio(skb->data + maxlen, winbase(card), len - maxlen);
} else
memcpy_fromio(skb->data, winbase(card) + buff, len);
#ifndef PAGE0_ALWAYS_MAPPED
openwin(card, 0);
#endif
skb_put(skb, len);
#ifdef DEBUG_PKT
printk(KERN_DEBUG "%s RX(%i):", dev->name, skb->len);
debug_frame(skb);
#endif
dev->stats.rx_packets++;
dev->stats.rx_bytes += skb->len;
skb->protocol = hdlc_type_trans(skb, dev);
netif_rx(skb);
}
void
emit_trampoline(struct compilation_unit *cu, void *target_addr, struct jit_trampoline *t)
{
struct buffer *b = t->objcode;
jit_text_lock();
b->buf = jit_text_ptr();
/* Allocate memory on the stack */
emit(b, stwu(1, -16, 1));
/* Save LR on stack */
emit(b, mflr(0));
emit(b, stw(0, 0, 1));
/* Pass pointer to 'struct compilation_unit' as first argument */
emit(b, lis(3, ptr_high(cu)));
emit(b, ori(3, 3, ptr_low(cu)));
/* Then call 'target_addr' */
emit(b, lis(0, ptr_high(target_addr)));
emit(b, ori(0, 0, ptr_low(target_addr)));
emit(b, mtctr(0));
emit(b, bctrl());
/* Restore LR from stack */
emit(b, lwz(0, 0, 1));
emit(b, mtlr(0));
/* Free memory on stack */
emit(b, addi(1, 1, 16));
/* Finally jump to the compiled method */
emit(b, mtctr(3));
emit(b, bctr());
jit_text_reserve(buffer_offset(b));
jit_text_unlock();
}
void emit_insn(struct buffer *buf, struct basic_block *bb, struct insn *insn)
{
insn->mach_offset = buffer_offset(buf);
insn_encode(insn, buf, bb);
}
static void sca_init_port(port_t *port)
{
card_t *card = port_to_card(port);
int transmit, i;
port->rxin = 0;
port->txin = 0;
port->txlast = 0;
#ifndef PAGE0_ALWAYS_MAPPED
openwin(card, 0);
#endif
for (transmit = 0; transmit < 2; transmit++) {
u16 dmac = transmit ? get_dmac_tx(port) : get_dmac_rx(port);
u16 buffs = transmit ? card->tx_ring_buffers
: card->rx_ring_buffers;
for (i = 0; i < buffs; i++) {
pkt_desc __iomem *desc = desc_address(port, i, transmit);
u16 chain_off = desc_offset(port, i + 1, transmit);
u32 buff_off = buffer_offset(port, i, transmit);
writew(chain_off, &desc->cp);
writel(buff_off, &desc->bp);
writew(0, &desc->len);
writeb(0, &desc->stat);
}
/* DMA disable - to halt state */
sca_out(0, transmit ? DSR_TX(phy_node(port)) :
DSR_RX(phy_node(port)), card);
/* software ABORT - to initial state */
sca_out(DCR_ABORT, transmit ? DCR_TX(phy_node(port)) :
DCR_RX(phy_node(port)), card);
/* current desc addr */
sca_out(0, dmac + CPB, card); /* pointer base */
sca_outw(desc_offset(port, 0, transmit), dmac + CDAL, card);
if (!transmit)
sca_outw(desc_offset(port, buffs - 1, transmit),
dmac + EDAL, card);
else
sca_outw(desc_offset(port, 0, transmit), dmac + EDAL,
card);
/* clear frame end interrupt counter */
sca_out(DCR_CLEAR_EOF, transmit ? DCR_TX(phy_node(port)) :
DCR_RX(phy_node(port)), card);
if (!transmit) { /* Receive */
/* set buffer length */
sca_outw(HDLC_MAX_MRU, dmac + BFLL, card);
/* Chain mode, Multi-frame */
sca_out(0x14, DMR_RX(phy_node(port)), card);
sca_out(DIR_EOME | DIR_BOFE, DIR_RX(phy_node(port)),
card);
/* DMA enable */
sca_out(DSR_DE, DSR_RX(phy_node(port)), card);
} else { /* Transmit */
/* Chain mode, Multi-frame */
sca_out(0x14, DMR_TX(phy_node(port)), card);
/* enable underflow interrupts */
sca_out(DIR_BOFE, DIR_TX(phy_node(port)), card);
}
}
sca_set_carrier(port);
}
static void sca_init_port(port_t *port)
{
card_t *card = port_to_card(port);
int transmit, i;
port->rxin = 0;
port->txin = 0;
port->txlast = 0;
#ifndef PAGE0_ALWAYS_MAPPED
openwin(card, 0);
#endif
for (transmit = 0; transmit < 2; transmit++) {
u16 dmac = transmit ? get_dmac_tx(port) : get_dmac_rx(port);
u16 buffs = transmit ? card->tx_ring_buffers
: card->rx_ring_buffers;
for (i = 0; i < buffs; i++) {
pkt_desc __iomem *desc = desc_address(port, i, transmit);
u16 chain_off = desc_offset(port, i + 1, transmit);
u32 buff_off = buffer_offset(port, i, transmit);
writew(chain_off, &desc->cp);
writel(buff_off, &desc->bp);
writew(0, &desc->len);
writeb(0, &desc->stat);
}
sca_out(0, transmit ? DSR_TX(phy_node(port)) :
DSR_RX(phy_node(port)), card);
sca_out(DCR_ABORT, transmit ? DCR_TX(phy_node(port)) :
DCR_RX(phy_node(port)), card);
sca_out(0, dmac + CPB, card);
sca_outw(desc_offset(port, 0, transmit), dmac + CDAL, card);
if (!transmit)
sca_outw(desc_offset(port, buffs - 1, transmit),
dmac + EDAL, card);
else
sca_outw(desc_offset(port, 0, transmit), dmac + EDAL,
card);
sca_out(DCR_CLEAR_EOF, transmit ? DCR_TX(phy_node(port)) :
DCR_RX(phy_node(port)), card);
if (!transmit) {
sca_outw(HDLC_MAX_MRU, dmac + BFLL, card);
sca_out(0x14, DMR_RX(phy_node(port)), card);
sca_out(DIR_EOME | DIR_BOFE, DIR_RX(phy_node(port)),
card);
sca_out(DSR_DE, DSR_RX(phy_node(port)), card);
} else {
sca_out(0x14, DMR_TX(phy_node(port)), card);
sca_out(DIR_BOFE, DIR_TX(phy_node(port)), card);
}
}
sca_set_carrier(port);
}
static int return_audio_frame(AVFilterContext *ctx)
{
AVFilterLink *link = ctx->outputs[0];
FifoContext *s = ctx->priv;
AVFilterBufferRef *head = s->root.next->buf;
AVFilterBufferRef *buf_out;
int ret;
if (!s->buf_out &&
head->audio->nb_samples >= link->request_samples &&
calc_ptr_alignment(head) >= 32) {
if (head->audio->nb_samples == link->request_samples) {
buf_out = head;
queue_pop(s);
} else {
buf_out = avfilter_ref_buffer(head, AV_PERM_READ);
if (!buf_out)
return AVERROR(ENOMEM);
buf_out->audio->nb_samples = link->request_samples;
buffer_offset(link, head, link->request_samples);
}
} else {
int nb_channels = av_get_channel_layout_nb_channels(link->channel_layout);
if (!s->buf_out) {
s->buf_out = ff_get_audio_buffer(link, AV_PERM_WRITE,
link->request_samples);
if (!s->buf_out)
return AVERROR(ENOMEM);
s->buf_out->audio->nb_samples = 0;
s->buf_out->pts = head->pts;
s->allocated_samples = link->request_samples;
} else if (link->request_samples != s->allocated_samples) {
av_log(ctx, AV_LOG_ERROR, "request_samples changed before the "
"buffer was returned.\n");
return AVERROR(EINVAL);
}
while (s->buf_out->audio->nb_samples < s->allocated_samples) {
int len = FFMIN(s->allocated_samples - s->buf_out->audio->nb_samples,
head->audio->nb_samples);
av_samples_copy(s->buf_out->extended_data, head->extended_data,
s->buf_out->audio->nb_samples, 0, len, nb_channels,
link->format);
s->buf_out->audio->nb_samples += len;
if (len == head->audio->nb_samples) {
avfilter_unref_buffer(head);
queue_pop(s);
if (!s->root.next &&
(ret = ff_request_frame(ctx->inputs[0])) < 0) {
if (ret == AVERROR_EOF) {
av_samples_set_silence(s->buf_out->extended_data,
s->buf_out->audio->nb_samples,
s->allocated_samples -
s->buf_out->audio->nb_samples,
nb_channels, link->format);
s->buf_out->audio->nb_samples = s->allocated_samples;
break;
}
return ret;
}
head = s->root.next->buf;
} else {
buffer_offset(link, head, len);
}
}
buf_out = s->buf_out;
s->buf_out = NULL;
}
return ff_filter_samples(link, buf_out);
}
numpy_iexpr<Arg>::numpy_iexpr(
typename std::remove_reference<Arg>::type &&arg, long index)
: arg(std::move(arg)), buffer(arg.buffer)
{
buffer += buffer_offset(index, utils::int_<value>());
}
static int return_audio_frame(AVFilterContext *ctx)
{
AVFilterLink *link = ctx->outputs[0];
FifoContext *s = ctx->priv;
AVFrame *head = s->root.next ? s->root.next->frame : NULL;
AVFrame *out;
int ret;
/* if head is NULL then we're flushing the remaining samples in out */
if (!head && !s->out)
return AVERROR_EOF;
if (!s->out &&
head->nb_samples >= link->request_samples &&
calc_ptr_alignment(head) >= 32) {
if (head->nb_samples == link->request_samples) {
out = head;
queue_pop(s);
} else {
out = av_frame_clone(head);
if (!out)
return AVERROR(ENOMEM);
out->nb_samples = link->request_samples;
buffer_offset(link, head, link->request_samples);
}
} else {
int nb_channels = av_get_channel_layout_nb_channels(link->channel_layout);
if (!s->out) {
s->out = ff_get_audio_buffer(link, link->request_samples);
if (!s->out)
return AVERROR(ENOMEM);
s->out->nb_samples = 0;
s->out->pts = head->pts;
s->allocated_samples = link->request_samples;
} else if (link->request_samples != s->allocated_samples) {
av_log(ctx, AV_LOG_ERROR, "request_samples changed before the "
"buffer was returned.\n");
return AVERROR(EINVAL);
}
while (s->out->nb_samples < s->allocated_samples) {
int len;
if (!s->root.next) {
ret = ff_request_frame(ctx->inputs[0]);
if (ret == AVERROR_EOF) {
av_samples_set_silence(s->out->extended_data,
s->out->nb_samples,
s->allocated_samples -
s->out->nb_samples,
nb_channels, link->format);
s->out->nb_samples = s->allocated_samples;
break;
} else if (ret < 0)
return ret;
if (!s->root.next)
return 0;
}
head = s->root.next->frame;
len = FFMIN(s->allocated_samples - s->out->nb_samples,
head->nb_samples);
av_samples_copy(s->out->extended_data, head->extended_data,
s->out->nb_samples, 0, len, nb_channels,
link->format);
s->out->nb_samples += len;
if (len == head->nb_samples) {
av_frame_free(&head);
queue_pop(s);
} else {
buffer_offset(link, head, len);
}
}
out = s->out;
s->out = NULL;
}
return ff_filter_frame(link, out);
}
numpy_iexpr<Arg>::numpy_iexpr(Arg const &arg, long index)
: arg(arg), buffer(arg.buffer)
{
buffer += buffer_offset(index, utils::int_<value>());
}
