1. 05 May, 2022 3 commits
  2. 04 May, 2022 2 commits
  3. 03 May, 2022 1 commit
    • Kenneth Moreland's avatar
      Remove inline from PointTransform methods to be exported · d3de36f4
      Kenneth Moreland authored
      When `PointTransform` was converted to the new filter structure, some of
      the methods that were moved from .hxx to .cxx (and therefore compiled in
      a library) were still marked as `inline`. This caused the compiler to
      not compile the function into the library if it was not used. Fix the
      problem by removing the `inline` modifier to the method implementations.
      d3de36f4
  4. 21 Apr, 2022 5 commits
  5. 20 Apr, 2022 1 commit
  6. 19 Apr, 2022 1 commit
  7. 12 Apr, 2022 1 commit
    • Kenneth Moreland's avatar
      Fix deprecated method export · 60e6b3ec
      Kenneth Moreland authored
      The deprecated class `vtkm::filter::MeshQuality` contained a private
      method that was referenced in its inlined constructor. The problem was
      that this private method was compiled in the `vtkm_filter_mesh_info`
      library but not properly exported. Fix this by adding an export to the
      class.
      60e6b3ec
  8. 11 Apr, 2022 1 commit
  9. 07 Apr, 2022 4 commits
  10. 05 Apr, 2022 1 commit
  11. 01 Apr, 2022 1 commit
  12. 31 Mar, 2022 1 commit
  13. 30 Mar, 2022 4 commits
  14. 29 Mar, 2022 2 commits
  15. 28 Mar, 2022 5 commits
    • Kenneth Moreland's avatar
      Turn off inlining of Variant::CastAndCall for HIP · 62e509c0
      Kenneth Moreland authored
      The current implementation of the AMD HIP compiler adds default compiler
      flags to attempt to inline everything possible. This is wrecking havoc
      with the `Variant::CastAndCall` function, whose implementation has one
      or more large switch statements with each case calling a different
      potentially inline function. In some parts of the VTK-m code, this is
      dragging the compilation on for days as it tries to resolve a
      `Variant::CastAndCall` within a `Variant::CastAndCall`. This will
      probably need to be addressed in the compiler, but meanwhile we will
      force the inlining to be turned off for the function called by
      `Variant::CastAndCall`. It is unclear if this will result in some extra
      runtime overhead, but the change is worth it to get reasonable compile
      times.
      
      Thanks to Nick Curtis for tracking this down and providing the solution.
      62e509c0
    • Kenneth Moreland's avatar
      Modify Variant CastAndCall to have fewer cases in its switch · 6afff755
      Kenneth Moreland authored
      The previous implementation of `Variant`'s `CastAndCall` generated a
      switch statement with 20 cases (plus a default) regardless of how many
      types were handled by the `Variant` (with the excess doing nothing
      useful). This reduced the amount of code, but caused the compiler to
      have to build many more instructions (and optimize for them). This in
      turn lead to large compile times and unnecessary large libraries/
      executables.
      
      This change makes a different function to use for `CastAndCall` so that
      the number of cases in the switch matches exactly the number of types in
      the `Variant`'s union.
      
      Because the size of VariantImplDetail.h was getting large, I also
      reduced the maximum expansions for the code. This does not seem to
      negatively affect compile time, and I doubt it will have an noticible
      difference in running time (when in release mode).
      
      I also modified some other parts of this code to match the expansion
      without making unnecessary defaults.
      6afff755
    • Kenneth Moreland's avatar
      Merge topic 'gradient-instantiations' · e0924b65
      Kenneth Moreland authored and Kitware Robot's avatar Kitware Robot committed
      18461d67 Add a unique symbol to InstantiationTemplate.cxx.in
      61a44887 Update vtkm_add_instantiations documentation
      1c1881d5 Declare methods for instances out of line
      13de2b73 Protect gradient instantiations from ambiguity
      f4de1d8e Compile instantiations of the gradient filter
      6eb9c987
      
       Add generalized instantiation
      
      Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
      Acked-by: Vicente Bolea's avatarVicente Bolea <vicente.bolea@kitware.com>
      Merge-request: !2742
      e0924b65
    • Vicente Bolea's avatar
      Merge topic 'add-readme-link-doxygen' · 129e5128
      Vicente Bolea authored and Kitware Robot's avatar Kitware Robot committed
      978789e6
      
       README: Add doxygen links for nightly
      
      Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
      Acked-by: Kenneth Moreland's avatarKenneth Moreland <morelandkd@ornl.gov>
      Merge-request: !2745
      129e5128
    • Kenneth Moreland's avatar
      Add a unique symbol to InstantiationTemplate.cxx.in · 18461d67
      Kenneth Moreland authored
      A compiler or linker may give an error if a .cxx file is empty (that is,
      declares no symbols). This can happen if an instantiation declaration
      gets removed during the compile either through preprocessor macros or
      SFINAE.
      
      To protect against this, declare a simple integer with a unique symbol
      in each instantiation file. The overhead is very small and will prevent
      compile/link errors.
      18461d67
  16. 23 Mar, 2022 6 commits
    • Vicente Bolea's avatar
      README: Add doxygen links for nightly · 978789e6
      Vicente Bolea authored
      978789e6
    • Kenneth Moreland's avatar
      61a44887
    • Kenneth Moreland's avatar
      Declare methods for instances out of line · 1c1881d5
      Kenneth Moreland authored
      For the templated methods that we are precompiling instances for, do not
      put their implementation inside of the class declaration. The problem is
      that if you define a method inside of a class, it is implicitly inline.
      If it is inline, a compiler might choose to compile it even if an
      external symbol exists.
      1c1881d5
    • Kenneth Moreland's avatar
      Protect gradient instantiations from ambiguity · 13de2b73
      Kenneth Moreland authored
      It appears that some compilers treat template instances different than
      calling a template. For example, if you have
      
      ```cpp
      template <typename T, typename U>
      void Foo(T t, U u);
      
      template <typename T>
      void Foo(T t, int u);
      
      template void Foo(int t, int u);
      ```
      
      that some compilers will complain that the instance is ambiguous because
      it matches both versions of Foo even though the second one is the one
      that is called (unless you specifically declare template parameters).
      
      This is what happend with the gradient instances. Fix the problem by
      wrapping the "ambiguous" cases to be called by a simple, single
      templated function.
      13de2b73
    • Kenneth Moreland's avatar
      Compile instantiations of the gradient filter · f4de1d8e
      Kenneth Moreland authored
      When the gradient filter was moved over to the new filter structure, it
      lost its instantiations. This is a problem because the gradient filter,
      which compresses a lot of the code into single worklet calls for
      efficiency, is one of the longest to compile filters.
      
      This commit restores the instantiations with the updated instantiation
      functionality. This breaks up the code into many translation units that
      can be compiled simultaneously and thus not hold up the entire compile
      on one process.
      f4de1d8e
    • Kenneth Moreland's avatar
      Add generalized instantiation · 6eb9c987
      Kenneth Moreland authored
      Recently, an instantiation method was added to the VTK-m configuration
      files to set up a set of source files that compile instances of a template.
      This allows the template instances to be compiled exactly once in separate
      build files.
      
      However, the implementation made the assumption that the instantiations
      were happening for VTK-m filters. Now that the VTK-m filters are being
      redesigned, this assumption is broken.
      
      Thus, the instantiation code has been redesigned to be more general. It can
      now be applied to code within the new filter structure. It can also be
      applied anywhere else in the VTK-m source code.
      6eb9c987
  17. 21 Mar, 2022 1 commit