Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Mesa 3-D graphics library
  3.  *
  4.  * Copyright (C) 2012-2013 LunarG, Inc.
  5.  *
  6.  * Permission is hereby granted, free of charge, to any person obtaining a
  7.  * copy of this software and associated documentation files (the "Software"),
  8.  * to deal in the Software without restriction, including without limitation
  9.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10.  * and/or sell copies of the Software, and to permit persons to whom the
  11.  * Software is furnished to do so, subject to the following conditions:
  12.  *
  13.  * The above copyright notice and this permission notice shall be included
  14.  * in all copies or substantial portions of the Software.
  15.  *
  16.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21.  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22.  * DEALINGS IN THE SOFTWARE.
  23.  *
  24.  * Authors:
  25.  *    Chia-I Wu <olv@lunarg.com>
  26.  */
  27.  
  28. #include "toy_compiler.h"
  29. #include "toy_helpers.h"
  30. #include "toy_legalize.h"
  31. #include "toy_optimize.h"
  32. #include "ilo_shader_internal.h"
  33.  
  34. struct cs_compile_context {
  35.    struct ilo_shader *shader;
  36.    const struct ilo_shader_variant *variant;
  37.  
  38.    struct toy_compiler tc;
  39.  
  40.    int first_free_grf;
  41.    int last_free_grf;
  42.  
  43.    int num_grf_per_vrf;
  44.  
  45.    int first_free_mrf;
  46.    int last_free_mrf;
  47. };
  48.  
  49. /**
  50.  * Compile the shader.
  51.  */
  52. static bool
  53. cs_compile(struct cs_compile_context *ccc)
  54. {
  55.    struct toy_compiler *tc = &ccc->tc;
  56.    struct ilo_shader *sh = ccc->shader;
  57.  
  58.    toy_compiler_legalize_for_ra(tc);
  59.    toy_compiler_optimize(tc);
  60.    toy_compiler_allocate_registers(tc,
  61.          ccc->first_free_grf,
  62.          ccc->last_free_grf,
  63.          ccc->num_grf_per_vrf);
  64.    toy_compiler_legalize_for_asm(tc);
  65.  
  66.    if (tc->fail) {
  67.       ilo_err("failed to legalize FS instructions: %s\n", tc->reason);
  68.       return false;
  69.    }
  70.  
  71.    if (ilo_debug & ILO_DEBUG_CS) {
  72.       ilo_printf("legalized instructions:\n");
  73.       toy_compiler_dump(tc);
  74.       ilo_printf("\n");
  75.    }
  76.  
  77.    if (true) {
  78.       sh->kernel = toy_compiler_assemble(tc, &sh->kernel_size);
  79.    } else {
  80.       static const uint32_t microcode[] = {
  81.          /* fill in the microcode here */
  82.          0x0, 0x0, 0x0, 0x0,
  83.       };
  84.       const bool swap = true;
  85.  
  86.       sh->kernel_size = sizeof(microcode);
  87.       sh->kernel = MALLOC(sh->kernel_size);
  88.  
  89.       if (sh->kernel) {
  90.          const int num_dwords = sizeof(microcode) / 4;
  91.          const uint32_t *src = microcode;
  92.          uint32_t *dst = (uint32_t *) sh->kernel;
  93.          int i;
  94.  
  95.          for (i = 0; i < num_dwords; i += 4) {
  96.             if (swap) {
  97.                dst[i + 0] = src[i + 3];
  98.                dst[i + 1] = src[i + 2];
  99.                dst[i + 2] = src[i + 1];
  100.                dst[i + 3] = src[i + 0];
  101.             }
  102.             else {
  103.                memcpy(dst, src, 16);
  104.             }
  105.          }
  106.       }
  107.    }
  108.  
  109.    if (!sh->kernel) {
  110.       ilo_err("failed to compile CS: %s\n", tc->reason);
  111.       return false;
  112.    }
  113.  
  114.    if (ilo_debug & ILO_DEBUG_CS) {
  115.       ilo_printf("disassembly:\n");
  116.       toy_compiler_disassemble(tc->dev, sh->kernel, sh->kernel_size, false);
  117.       ilo_printf("\n");
  118.    }
  119.  
  120.    return true;
  121. }
  122.  
  123. static void
  124. cs_dummy(struct cs_compile_context *ccc)
  125. {
  126.    struct toy_compiler *tc = &ccc->tc;
  127.    struct toy_dst header;
  128.    struct toy_src r0, desc;
  129.    struct toy_inst *inst;
  130.  
  131.    header = tdst_ud(tdst(TOY_FILE_MRF, ccc->first_free_mrf, 0));
  132.    r0 = tsrc_ud(tsrc(TOY_FILE_GRF, 0, 0));
  133.  
  134.    inst = tc_MOV(tc, header, r0);
  135.    inst->exec_size = GEN6_EXECSIZE_8;
  136.    inst->mask_ctrl = GEN6_MASKCTRL_NOMASK;
  137.  
  138.    desc = tsrc_imm_mdesc(tc, true, 1, 0, true,
  139.          GEN6_MSG_TS_RESOURCE_SELECT_NO_DEREF |
  140.          GEN6_MSG_TS_REQUESTER_TYPE_ROOT |
  141.          GEN6_MSG_TS_OPCODE_DEREF);
  142.  
  143.    tc_SEND(tc, tdst_null(), tsrc_from(header), desc, GEN6_SFID_SPAWNER);
  144. }
  145.  
  146. static bool
  147. cs_setup(struct cs_compile_context *ccc,
  148.          const struct ilo_shader_state *state,
  149.          const struct ilo_shader_variant *variant)
  150. {
  151.    memset(ccc, 0, sizeof(*ccc));
  152.  
  153.    ccc->shader = CALLOC_STRUCT(ilo_shader);
  154.    if (!ccc->shader)
  155.       return false;
  156.  
  157.    ccc->variant = variant;
  158.  
  159.    toy_compiler_init(&ccc->tc, state->info.dev);
  160.  
  161.    ccc->tc.templ.access_mode = GEN6_ALIGN_1;
  162.    ccc->tc.templ.qtr_ctrl = GEN6_QTRCTRL_1H;
  163.    ccc->tc.templ.exec_size = GEN6_EXECSIZE_16;
  164.    ccc->tc.rect_linear_width = 8;
  165.  
  166.    ccc->first_free_grf = 1;
  167.    ccc->last_free_grf = 127;
  168.  
  169.    /* m0 is reserved for system routines */
  170.    ccc->first_free_mrf = 1;
  171.    ccc->last_free_mrf = 15;
  172.  
  173.    /* instructions are compressed with GEN6_EXECSIZE_16 */
  174.    ccc->num_grf_per_vrf = 2;
  175.  
  176.    if (ilo_dev_gen(ccc->tc.dev) >= ILO_GEN(7)) {
  177.       ccc->last_free_grf -= 15;
  178.       ccc->first_free_mrf = ccc->last_free_grf + 1;
  179.       ccc->last_free_mrf = ccc->first_free_mrf + 14;
  180.    }
  181.  
  182.    ccc->shader->in.start_grf = 1;
  183.    ccc->shader->dispatch_16 = true;
  184.  
  185.    /* INPUT */
  186.    ccc->shader->bt.const_base = 0;
  187.    ccc->shader->bt.const_count = 1;
  188.  
  189.    /* a GLOBAL */
  190.    ccc->shader->bt.global_base = 1;
  191.    ccc->shader->bt.global_count = 1;
  192.  
  193.    ccc->shader->bt.total_count = 2;
  194.  
  195.    return true;
  196. }
  197.  
  198. /**
  199.  * Compile the compute shader.
  200.  */
  201. struct ilo_shader *
  202. ilo_shader_compile_cs(const struct ilo_shader_state *state,
  203.                       const struct ilo_shader_variant *variant)
  204. {
  205.    struct cs_compile_context ccc;
  206.  
  207.    ILO_DEV_ASSERT(state->info.dev, 7, 7.5);
  208.  
  209.    if (!cs_setup(&ccc, state, variant))
  210.       return NULL;
  211.  
  212.    cs_dummy(&ccc);
  213.  
  214.    if (!cs_compile(&ccc)) {
  215.       FREE(ccc.shader);
  216.       ccc.shader = NULL;
  217.    }
  218.  
  219.    toy_compiler_cleanup(&ccc.tc);
  220.  
  221.    return ccc.shader;
  222. }
  223.