<html>
    <head>
      <base href="https://bugs.llvm.org/">
    </head>
    <body><table border="1" cellspacing="0" cellpadding="8">
        <tr>
          <th>Bug ID</th>
          <td><a class="bz_bug_link 
          bz_status_NEW "
   title="NEW - Missed inlining causes significat slowdown (C-ray case study)"
   href="https://bugs.llvm.org/show_bug.cgi?id=42968">42968</a>
          </td>
        </tr>

        <tr>
          <th>Summary</th>
          <td>Missed inlining causes significat slowdown (C-ray case study)
          </td>
        </tr>

        <tr>
          <th>Product</th>
          <td>libraries
          </td>
        </tr>

        <tr>
          <th>Version</th>
          <td>trunk
          </td>
        </tr>

        <tr>
          <th>Hardware</th>
          <td>PC
          </td>
        </tr>

        <tr>
          <th>OS</th>
          <td>Linux
          </td>
        </tr>

        <tr>
          <th>Status</th>
          <td>NEW
          </td>
        </tr>

        <tr>
          <th>Severity</th>
          <td>enhancement
          </td>
        </tr>

        <tr>
          <th>Priority</th>
          <td>P
          </td>
        </tr>

        <tr>
          <th>Component</th>
          <td>Interprocedural Optimizations
          </td>
        </tr>

        <tr>
          <th>Assignee</th>
          <td>unassignedbugs@nondot.org
          </td>
        </tr>

        <tr>
          <th>Reporter</th>
          <td>david.bolvansky@gmail.com
          </td>
        </tr>

        <tr>
          <th>CC</th>
          <td>llvm-bugs@lists.llvm.org
          </td>
        </tr></table>
      <p>
        <div>
        <pre>This is case study for C-ray benchmark, but it is not so unrealistic for other
real word code. In C-ray's hot loop there is a call to a quite big function
'ray_sphere'. Clang does not inline it, GCC does. GCC's code is much faster
(see below).

So in this case, Inliner should be enhanced with some sort of heuristic so it
will realise that inlining of 'ray_sphere' is profitable since most of the
calculations on ray are loop invariant and will be hoisted.

Tested on Intel Haswell.

'make' - GCC 9
./c-ray-mt -t 8 -s 800x400 -r 1 -i sphfract -o output.ppm
c-ray-mt v1.1
Rendering took: 0 seconds (518 milliseconds)

'make' - Clang 9
./c-ray-mt -t 8 -s 800x400 -r 1 -i sphfract -o output.ppm
c-ray-mt v1.1
Rendering took: 0 seconds (609 milliseconds)


Added __attribute((always_inline)) to ray_sphere:
GCC 9:
./c-ray-mt -t 8 -s 800x400 -r 1 -i sphfract -o output.ppm
c-ray-mt v1.1
Rendering took: 0 seconds (514 milliseconds)


 ./c-ray-mt -t 8 -s 800x400 -r 1 -i sphfract -o output.ppm
c-ray-mt v1.1
Rendering took: 0 seconds (413 milliseconds)


As we can see, a significant win:
609 -> 413 milliseconds


There is also some haswell codegen issue, since with -march=haswell:
Clang 9
 ./c-ray-mt -t 8 -s 800x400 -r 1 -i sphfract -o output.ppm
c-ray-mt v1.1
Rendering took: 0 seconds (403 milliseconds)


GCC 9
 ./c-ray-mt -t 8 -s 800x400 -r 1 -i sphfract -o output.ppm
c-ray-mt v1.1
Rendering took: 0 seconds (371 milliseconds)</pre>
        </div>
      </p>


      <hr>
      <span>You are receiving this mail because:</span>

      <ul>
          <li>You are on the CC list for the bug.</li>
      </ul>
    </body>
</html>