Esempio n. 1
0
static boolean
ilo_get_query_result(struct pipe_context *pipe, struct pipe_query *query,
                     boolean wait, union pipe_query_result *result)
{
   struct ilo_context *ilo = ilo_context(pipe);
   struct ilo_query *q = ilo_query(query);

   if (q->active)
      return false;

   if (q->bo) {
      if (intel_bo_has_reloc(ilo->cp->bo, q->bo))
         ilo_cp_flush(ilo->cp, "syncing for queries");

      if (!wait && intel_bo_is_busy(q->bo))
         return false;

      query_info[q->type].process(ilo, q);
   }

   if (result)
      serialize_query_data(q->type, &q->data, (void *) result);

   return true;
}
Esempio n. 2
0
void
ilo_3d_pipeline_emit_rectlist(struct ilo_3d_pipeline *p,
                              const struct ilo_blitter *blitter)
{
   const int max_len = ilo_3d_pipeline_estimate_size(p,
         ILO_3D_PIPELINE_RECTLIST, blitter);

   if (max_len > ilo_cp_space(p->cp))
      ilo_cp_flush(p->cp, "out of space");

   while (true) {
      struct ilo_builder_snapshot snapshot;

      /* we will rewind if aperture check below fails */
      ilo_builder_batch_snapshot(&p->cp->builder, &snapshot);

      handle_invalid_batch_bo(p, false);

      p->emit_rectlist(p, blitter);

      if (!ilo_builder_validate(&p->cp->builder, 0, NULL)) {
         /* rewind */
         ilo_builder_batch_restore(&p->cp->builder, &snapshot);

         /* flush and try again */
         if (!ilo_cp_empty(p->cp)) {
            ilo_cp_flush(p->cp, "out of aperture");
            continue;
         }
      }

      break;
   }

   ilo_3d_pipeline_invalidate(p, ILO_3D_PIPELINE_INVALIDATE_HW);
}
Esempio n. 3
0
static void
ilo_flush(struct pipe_context *pipe,
          struct pipe_fence_handle **f,
          unsigned flags)
{
   struct ilo_context *ilo = ilo_context(pipe);

   ilo_cp_flush(ilo->cp,
         (flags & PIPE_FLUSH_END_OF_FRAME) ? "frame end" : "user request");

   if (f) {
      *f = (struct pipe_fence_handle *)
         ilo_fence_create(pipe->screen, ilo->last_cp_bo);
   }
}
Esempio n. 4
0
/**
 * Emit context states and 3DPRIMITIVE.
 */
bool
ilo_3d_pipeline_emit_draw(struct ilo_3d_pipeline *p,
                          const struct ilo_context *ilo,
                          int *prim_generated, int *prim_emitted)
{
   bool success;

   if (ilo->dirty & ILO_DIRTY_SO &&
       ilo->so.enabled && !ilo->so.append_bitmask) {
      /*
       * We keep track of the SVBI in the driver, so that we can restore it
       * when the HW context is invalidated (by another process).  The value
       * needs to be reset when stream output is enabled and the targets are
       * changed.
       */
      p->state.so_num_vertices = 0;

      /* on GEN7+, we need SOL_RESET to reset the SO write offsets */
      if (p->dev->gen >= ILO_GEN(7))
         ilo_cp_set_one_off_flags(p->cp, INTEL_EXEC_GEN7_SOL_RESET);
   }


   while (true) {
      struct ilo_builder_snapshot snapshot;

      /* we will rewind if aperture check below fails */
      ilo_builder_batch_snapshot(&p->cp->builder, &snapshot);

      handle_invalid_batch_bo(p, false);

      /* draw! */
      p->emit_draw(p, ilo);

      if (ilo_builder_validate(&ilo->cp->builder, 0, NULL)) {
         success = true;
         break;
      }

      /* rewind */
      ilo_builder_batch_restore(&p->cp->builder, &snapshot);

      if (ilo_cp_empty(p->cp)) {
         success = false;
         break;
      }
      else {
         /* flush and try again */
         ilo_cp_flush(p->cp, "out of aperture");
      }
   }

   if (success) {
      const int num_verts =
         u_vertices_per_prim(u_reduced_prim(ilo->draw->mode));
      const int max_emit =
         (p->state.so_max_vertices - p->state.so_num_vertices) / num_verts;
      const int generated =
         u_reduced_prims_for_vertices(ilo->draw->mode, ilo->draw->count);
      const int emitted = MIN2(generated, max_emit);

      p->state.so_num_vertices += emitted * num_verts;

      if (prim_generated)
         *prim_generated = generated;

      if (prim_emitted)
         *prim_emitted = emitted;
   }

   p->invalidate_flags = 0x0;

   return success;
}