Beispiel #1
0
/*-----------------------------------------------------------------------------
 * dt_in_back_ex
 *---------------------------------------------------------------------------*/
void
dt_in_back_ex(BUFFER_CB *buf, uint32_t src_spu, SPU_ADDRESS src_buf_data,
              uint32_t num_bytes)
{
  OUT_DTCB out_dtcb;

#if CHECK
  // Validate buffer alignment.
  pcheck(((src_buf_data & CACHE_MASK) == 0) && (num_bytes != 0));

  // Debug tail pointer should be synchronized.
  assert(buf->otail == buf->tail);
  // Make sure back of buffer is free. *-in is allowed.
  check(buf->back_action == BUFFER_ACTION_NONE);

#if !DT_ALLOW_UNALIGNED
  // Make sure data is aligned on qword boundary.
  pcheck((num_bytes & QWORD_MASK) == 0);
  check((buf->tail & QWORD_MASK) == 0);
#endif

  // Make sure enough space is available. head and tail must be off by at least
  // 1 and cannot be non-zero offsets in the same qword.
  check(((buf->head - (buf->head & QWORD_MASK ? : 1) - buf->tail) &
           buf->mask) >= num_bytes);
#endif

  // Set up description of region in destination buffer that source SPU will
  // write to. Data/space in source/destination buffers must have same offset
  // within cache line (128 bytes) - destination buffer does not automatically
  // adjust pointers if empty.
  out_dtcb.head = buf->tail;
  out_dtcb.tail = (buf->tail + num_bytes) & buf->mask;
  // Reserve space for data to be transferred.
  IF_CHECK(buf->otail = out_dtcb.tail);

#if DT_ALLOW_UNALIGNED
  IF_CHECK(buf->back_action = BUFFER_ACTION_IN);

  // Save transfer size.
  buf->in_back_buffered_bytes = num_bytes;
#else
  buf->tail = out_dtcb.tail;
#endif

  // Write transfer info to source SPU.
  write64((uint64_t *)buf_get_dt_field_addr(spu_addr(src_spu, src_buf_data),
                                            front_in_dtcb),
          out_dtcb.data);
}
Beispiel #2
0
/*-----------------------------------------------------------------------------
 * dt_out_front_ex
 *---------------------------------------------------------------------------*/
void
dt_out_front_ex(BUFFER_CB *buf, uint32_t dest_spu, SPU_ADDRESS dest_buf_data,
                uint32_t num_bytes)
{
  OUT_DTCB out_dtcb;

#if CHECK
  // Validate alignment.
  pcheck(((dest_buf_data & CACHE_MASK) == 0) && (num_bytes != 0));

  // Debug head pointer should be synchronized.
  assert(buf->ihead == buf->head);
  // Make sure front of buffer is free. out-out is disallowed.
  check((buf->front_action == BUFFER_ACTION_NONE) &&
        (buf->back_action != BUFFER_ACTION_OUT));
  // Make sure enough data is available.
  check(((buf->tail - buf->head) & buf->mask) >= num_bytes);
#endif

  // Set up source buffer's head/tail pointers for region to be transferred.
  out_dtcb.head = buf->head;
  out_dtcb.tail = (buf->head + num_bytes) & buf->mask;
  buf->head = out_dtcb.tail;
  IF_CHECK(buf->ihead = buf->head);

  // Write transfer info to destination SPU.
  write64((uint64_t *)buf_get_dt_field_addr(spu_addr(dest_spu, dest_buf_data),
                                            back_in_dtcb),
          out_dtcb.data);
}
Beispiel #3
0
static t_block		*block_initial(t_block **start, const int fd)
{
	t_block			*temp;

	temp = *start;
	while (temp && temp->fd != fd)
		temp = temp->next;
	if (!temp)
	{
		IF_CHECK(temp = (t_block *)ft_memalloc(sizeof(t_block)));
		temp->fd = fd;
		IF_CHECK(temp->str = ft_strnew(0));
		temp->next = (t_block *)*start;
		*start = temp;
	}
	return (temp);
}
Beispiel #4
0
/*-----------------------------------------------------------------------------
 * ppu_finish_dt_out_front
 *---------------------------------------------------------------------------*/
static INLINE void
ppu_finish_dt_out_front(PPU_DT_PARAMS *cmd)
{
  BUFFER_CB *buf = cmd->buf;

  buf->head = (buf->head + cmd->num_bytes) & buf->mask;
  IF_CHECK(buf->front_action = BUFFER_ACTION_NONE);
}
Beispiel #5
0
END_SPU_COMMAND

/*-----------------------------------------------------------------------------
 * spu_filter_unload
 *---------------------------------------------------------------------------*/
DECLARE_SPU_COMMAND(filter_unload, FILTER_UNLOAD,
                    SPU_ADDRESS filt)
{
  cmd->filt = spu_lsa(g->spu_id, filt);
  IF_CHECK(cmd->detach_only = FALSE);

  cmd->state = 0;
}
Beispiel #6
0
END_SPU_COMMAND

/*-----------------------------------------------------------------------------
 * spu_filter_run
 *---------------------------------------------------------------------------*/
DECLARE_SPU_COMMAND(filter_run, FILTER_RUN,
                    SPU_ADDRESS filt, uint32_t iters, uint32_t loop_iters)
{
  cmd->filt = spu_lsa(g->spu_id, filt);
  cmd->iters = iters;
  cmd->loop_iters = loop_iters;

  IF_CHECK(cmd->state = 0);
}
Beispiel #7
0
/*-----------------------------------------------------------------------------
 * finish_dt_in_back_ex_tail
 *---------------------------------------------------------------------------*/
void
finish_dt_in_back_ex_tail(BUFFER_CB *buf)
{
  uint32_t ua_bytes;

  check(buf->back_action == BUFFER_ACTION_IN);
  ua_bytes = buf->tail & QWORD_MASK;

  if ((ua_bytes != 0) && (buf->in_back_buffered_bytes >= ua_bytes)) {
    vec_stvrx(vec_lvrx(ua_bytes, &buf->back_in_dtcb_2.ua_data),
              buf->tail, (uint8_t *)buf->data);
  }

  IF_CHECK(buf->back_action = BUFFER_ACTION_NONE);
}
Beispiel #8
0
/*-----------------------------------------------------------------------------
 * ppu_finish_dt_in_back
 *---------------------------------------------------------------------------*/
static INLINE void
ppu_finish_dt_in_back(PPU_DT_PARAMS *cmd)
{
  BUFFER_CB *buf = cmd->buf;
#if DT_ALLOW_UNALIGNED
  uint32_t tail_offset = buf->tail & QWORD_MASK;

  // Write unaligned data to buffer.
  if (tail_offset != 0) {
    vec_stvlx(vec_lvlx(tail_offset, &buf->back_in_dtcb.ua_data),
              buf->tail, (uint8_t *)buf->data);
  }
#endif

  buf->tail = (buf->tail + cmd->num_bytes) & buf->mask;
  IF_CHECK(buf->back_action = BUFFER_ACTION_NONE);
}
Beispiel #9
0
/*-----------------------------------------------------------------------------
 * dt_out_front
 *---------------------------------------------------------------------------*/
void
dt_out_front(BUFFER_CB *buf, uint32_t dest_spu, SPU_ADDRESS dest_buf_data,
             uint32_t num_bytes, uint32_t spu_cmd_id, uint32_t tag)
{
  OUT_DTCB out_dtcb;
  PPU_DT_PARAMS *cmd;

#if CHECK
  // Validate alignment.
  pcheck(((dest_buf_data & CACHE_MASK) == 0) && (num_bytes != 0));

  // Debug head pointer should be synchronized.
  assert(buf->ihead == buf->head);
  // Make sure front of buffer is free. out-out is disallowed.
  check((buf->front_action == BUFFER_ACTION_NONE) &&
        (buf->back_action != BUFFER_ACTION_OUT));
  buf->front_action = BUFFER_ACTION_OUT;
  // Make sure enough data is available.
  check(((buf->tail - buf->head) & buf->mask) >= num_bytes);
#endif

  // Set up source buffer's head/tail pointers for region to be transferred.
  out_dtcb.head = buf->head;
  out_dtcb.tail = (buf->head + num_bytes) & buf->mask;
  IF_CHECK(buf->ihead = out_dtcb.tail);

  // Set data transfer to wait on the SPU command ID. This must be done before
  // writing transfer info to SPU.
  cmd = ppu_dt_wait_spu(dest_spu, spu_cmd_id, tag);
  cmd->type = PPU_CMD_DT_OUT_FRONT;
  cmd->buf = buf;
  cmd->num_bytes = num_bytes;

  // Write transfer info to destination SPU.
  write64((uint64_t *)buf_get_dt_field_addr(spu_addr(dest_spu, dest_buf_data),
                                            back_in_dtcb),
          out_dtcb.data);
}