1. 13 Sep, 2017 1 commit
  2. 26 Aug, 2017 3 commits
  3. 20 May, 2017 1 commit
  4. 15 May, 2017 1 commit
  5. 15 Mar, 2017 1 commit
  6. 28 Feb, 2017 2 commits
  7. 17 Feb, 2017 2 commits
  8. 10 Dec, 2016 2 commits
  9. 05 Oct, 2016 1 commit
    • Samuel Pitoiset's avatar
      skip the 'GL >= x.y' line if present · 73217dee
      Samuel Pitoiset authored
      shaderdb runner fails at parsing shader_test files when the first
      line inside the require block is not 'GLSL >= x.y'. This just skips
      the GL version requirement which is actually unused and allows to
      compile +164 shaders from piglit.
      73217dee
  10. 13 Sep, 2016 1 commit
  11. 18 Aug, 2016 1 commit
  12. 15 Aug, 2016 1 commit
  13. 27 Jul, 2016 2 commits
    • Kenneth Graunke's avatar
      run: Mark shaders with only one stage as separable. · f7f9e22f
      Kenneth Graunke authored
      There are a couple cases where a single shader might happen:
      
      - compute shaders
        (only one stage, no inputs and outputs; separable shouldn't matter)
      - vertex shaders with transform feedback
        (we want to retain outputs, but transform feedback varyings are
         specified via the API, not the shader - setting SSO fixes this)
      - old shader_test files captured before we started adding "SSO ENABLED".
      
      In any case, it seems harmless or beneficial to enable SSO for all
      .shader_test files containing a single shader.
      
      Based on a patch by Marek.
      
      v2: Ignore VP/FP shaders.
      Acked-by: Ilia Mirkin's avatarIlia Mirkin <imirkin@alum.mit.edu>
      Acked-by: default avatarTimothy Arceri <timothy.arceri@collabora.com>
      f7f9e22f
    • Kenneth Graunke's avatar
      run: Add separate shader objects support. · aa14141c
      Kenneth Graunke authored
      With this patch, if a .shader_test file contains
      
          [require]
          ...
          SSO ENABLED
      
      then we'll use glCreateShaderProgramv to create each shader, so that
      they're compiled as separate shader objects.  This prevents the linker
      from removing unused inputs and outputs.  Drivers may also choose to lay
      out interfaces of SSO programs differently, resulting in different code.
      
      v2:
      - Actually initialize use_separate_shader_objects
      - Fix memcmp length parameter (thanks to Matt)
      
      v3:
      - Search for "SSO ENABLED" instead of "GL_ARB_separate_shader_objects",
        to match what Timothy did in shader_runner.
      - Use GL_PROGRAM_SEPARABLE (suggested by Tapani).  This allows
        multi-stage SSO programs to optimize internal interfaces, while
        still making the end-stages separable.
      
      v4:
      - Go back to glCreateShaderProgramv.  Timothy pointed out that Piglit's
        shader_runner compiles each shader separately, and wouldn't optimize
        interfaces between programs.  I want to preserve the same semantics
        between both .shader_test file processors.  Today, it looks like
        multi-stage SSO programs are pretty uncommon (typically every stage
        is separable), so we'll punt on solving that until later.
      Acked-by: Ilia Mirkin's avatarIlia Mirkin <imirkin@alum.mit.edu>
      Acked-by: default avatarTimothy Arceri <timothy.arceri@collabora.com>
      aa14141c
  14. 25 Jul, 2016 1 commit
  15. 02 Jul, 2016 1 commit
  16. 04 Mar, 2016 1 commit
  17. 26 Jan, 2016 1 commit
  18. 09 Jan, 2016 1 commit
  19. 02 Dec, 2015 1 commit
    • Rob Clark's avatar
      Set more env-var's in run.c · 5241a199
      Rob Clark authored
      Simplify the instructions a bit by setting all the potentially needed
      environment variables in run.c itself.
      
      Made very trivially more complex by the fact that all of the gallium
      drivers are using u_debug stuff, so one env var contains potentially
      multiple flags.  We don't want to clobber any other flags that are set
      so we simply append.
      Reviewed-by: Kenneth Graunke's avatarKenneth Graunke <kenneth@whitecape.org>
      5241a199
  20. 09 Nov, 2015 2 commits
  21. 27 May, 2015 1 commit
  22. 19 May, 2015 1 commit
  23. 13 Apr, 2015 3 commits
  24. 28 Mar, 2015 3 commits
  25. 19 Mar, 2015 2 commits
  26. 21 Jan, 2015 1 commit
    • Kenneth Graunke's avatar
      run: Print which shaders were being processed when crashing. · d8bff3de
      Kenneth Graunke authored
      If the driver hits an assertion failure and aborts, the runner will die,
      which can be hard to debug.  This patch makes the runner catch SIGABRT
      and SIGSEGV and and print out a list of shaders each thread was
      processing before it terminates.
      
       => CRASHED <= while processing these shaders:
      
          shaders/foo/1936.shader_test
          shaders/foo/9991.shader_test
          shaders/foo/1832.shader_test
      
      v2: Handle SIGSEGV too, since SIGABRT doesn't catch real crashes (such
          as null pointer dereferences).  Call _exit() to avoid continuing.
          Use write() in the signal handler since fputs() is not signal safe.
          According to an Austin Group bug tracker entry, strlen() is signal
          safe, so using it should be fine.
      d8bff3de
  27. 16 Jan, 2015 1 commit
  28. 09 Dec, 2014 1 commit
    • Matt Turner's avatar
      Add a new runner, written in C. · c6a13041
      Matt Turner authored
      Whereas run.py runs piglit's shader_runner binary to compile each shader
      individually and parses the output of INTEL_DEBUG=fs,vs,gs to find the
      number of instructions and loops, this runner compiles all of the
      shaders from a single process and uses output from GL_KHR_debug to get
      the information we want.
      
      It uses EGL and GBM (and render nodes) to create a GL display and uses
      libepoxy for GL function pointer management.
      
      It creates one thread per-CPU using OpenMP, each of which compiles
      shaders in parallel. It creates two OpenGL contexts, one core context
      and one compatibility context and switches between them as needed.
      
      run.py is able to compile all of the GLSL shaders in shader-db
      (including the closed portion) in about 300 seconds on my quad-core
      Haswell. This program can do the same in 90 seconds.
      
      Profiling shows that it's largely limited by malloc performance, and
      preloading jemalloc (LD_PRELOAD=/usr/lib64/libjemalloc.so.1) reduces the
      execution time to about 80 seconds.
      c6a13041