1. 23 Feb, 2018 2 commits
  2. 30 Jan, 2018 1 commit
    • luz.paz's avatar
      Misc. typos · 80b11afa
      luz.paz authored
      Found via `codespell -q 3` via downstream VTK
      80b11afa
  3. 28 Nov, 2017 1 commit
  4. 25 Sep, 2017 1 commit
  5. 22 Sep, 2017 1 commit
    • Kenneth Moreland's avatar
      Fix many warnings from doxygen · 52060f52
      Kenneth Moreland authored
      There are still some warnings left:
      
      * Some text in markdown files are incorrectly picked up as
        doxygen commands
      * ArrayPortalTransform weirdly inherits from a specialized
        version of itself. It's technically correct C++ code, but
        gives doxygen fits.
      52060f52
  6. 20 Sep, 2017 1 commit
    • Kenneth Moreland's avatar
      Update copyright for Sandia · c3a3184d
      Kenneth Moreland authored
      Sandia National Laboratories recently changed management from the
      Sandia Corporation to the National Technology & Engineering Solutions
      of Sandia, LLC (NTESS). The copyright statements need to be updated
      accordingly.
      c3a3184d
  7. 26 May, 2017 1 commit
  8. 25 May, 2017 1 commit
  9. 18 May, 2017 1 commit
  10. 24 Feb, 2017 1 commit
  11. 14 Feb, 2017 1 commit
  12. 10 Jan, 2017 1 commit
    • Kenneth Moreland's avatar
      Fix warnings about assignment operators not being generated · f23ff9fa
      Kenneth Moreland authored
      For some reason when VTK-m was being compiled as an accelerator in VTK,
      Visual Studio 2013 gave a bunch of warnings about not being able to generate
      assignment operators for many classes. This happened for classes with a
      const ivar that could not be automatically set. (Automatic copy constructors
      are fine on this count.) I'm not sure why these warnings did not happen
      when just compiling VTK-m, nor am I sure why they were generated at all as
      no code actually used the copy constructors.
      
      This commit fixes the problems by adding a private declaration for assignment
      operators that cannot be automatically created. No implementation is
      provided, nor should any be needed.
      f23ff9fa
  13. 16 Nov, 2016 1 commit
    • Kenneth Moreland's avatar
      Remove exports for header-only functions/methods · fdaccc22
      Kenneth Moreland authored
      Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and
      EXEC_CONT.) Remove the inline from these macros so that they can be
      applied to everything, including implementations in a library.
      
      Because inline is not declared in these modifies, you have to add the
      keyword to functions and methods where the implementation is not inlined
      in the class.
      fdaccc22
  14. 29 Sep, 2016 1 commit
  15. 23 Sep, 2016 1 commit
  16. 31 Aug, 2016 1 commit
  17. 04 May, 2016 1 commit
  18. 19 Jan, 2016 1 commit
    • Robert Maynard's avatar
      Perform less unnecessary copies when deducing a worklets parameters. · c1560e2d
      Robert Maynard authored
      One of the causes of the large library size and slow compile times has been
      that vtkm has been creating unnecessary copies when not needed. When the
      objects being copied use shared_ptr this causes a bloom in library size. I
      presume this bloom is caused by the atomic increment/decrement that is
      required by shared_ptr.
      
      For testing I used the following example:
      ```
      struct ExampleFieldWorklet : public vtkm::worklet::WorkletMapField
      {
        typedef void ControlSignature( FieldIn<>, FieldIn<>, FieldIn<>,
                                       FieldOut<>, FieldOut<>, FieldOut<> );
        typedef void ExecutionSignature( _1, _2, _3, _4, _5, _6 );
      
        template<typename T, typename U, typename V>
        VTKM_EXEC_EXPORT
        void operator()( const vtkm::Vec< T, 3 > & vec,
                         const U & scalar1,
                         const V& scalar2,
                         vtkm::Vec<T, 3>& out_vec,
                         U& out_scalar1,
                         V& out_scalar2 ) const
        {
          out_vec = vec * scalar1;
          out_scalar1 = scalar1 + scalar2;
          out_scalar2 = scalar2;
        }
      
        template<typename T, typename U, typename V, typename W, typename X, typename Y>
        VTKM_EXEC_EXPORT
        void operator()( const T & vec,
                         const U & scalar1,
                         const V& scalar2,
                         W& out_vec,
                         X& out_scalar,
                         Y& ) const
        {
        //no-op
        }
      };
      
      int main(int argc, char** argv)
      {
        std::vector< vtkm::Vec<vtkm::Float32, 3> > inputVec;
        std::vector< vtkm::Int32 > inputScalar1;
        std::vector< vtkm::Float64 > inputScalar2;
      
        vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleV =
          vtkm::cont::make_ArrayHandle(inputVec);
      
        vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleS1 =
          vtkm::cont::make_ArrayHandle(inputVec);
      
        vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleS2 =
          vtkm::cont::make_ArrayHandle(inputVec);
      
        vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleOV;
        vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleOS1;
        vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleOS2;
      
        std::cout << "Making 3 output DynamicArrayHandles " << std::endl;
        vtkm::cont::DynamicArrayHandle out1(handleOV), out2(handleOS1), out3(handleOS2);
      
        typedef vtkm::worklet::DispatcherMapField<ExampleFieldWorklet> DispatcherType;
      
        std::cout << "Invoking ExampleFieldWorklet" << std::endl;
        DispatcherType dispatcher;
      
        dispatcher.Invoke(handleV, handleS1, handleS2, out1, out2, out3);
      
      }
      ```
      
      Original vtkm would generate a binary of size 4684kb and would perform 91
      ArrayHandle copies or assignments. With this branch the binary size is
      reduced to 2392kb and will perform 36 copies or assignments.
      c1560e2d
  19. 21 Oct, 2015 1 commit
  20. 21 Sep, 2015 1 commit
  21. 13 Aug, 2015 1 commit
  22. 30 Jul, 2015 1 commit
    • Kenneth Moreland's avatar
      Always disable conversion warnings when including boost header files · 21b3b318
      Kenneth Moreland authored
      On one of my compile platforms, GCC was giving conversion warnings from
      any boost include that was not wrapped in pragmas to disable conversion
      warnings. To make things easier and more robust, I created a pair of
      macros, VTKM_BOOST_PRE_INCLUDE and VTKM_BOOST_POST_INCLUDE, that should
      be wrapped around any #include of a boost header file.
      21b3b318
  23. 21 Jul, 2015 1 commit
    • Robert Maynard's avatar
      Remove the usage of enable_if from method signatures to reduce binary size. · 4156130e
      Robert Maynard authored
      Using enable_if/disable_if as a return type has a negative impact on
      binary size compared to use a boost::true/false_type as a method parameter.
      
      For comparison the WorkletTests_TBB sees a 6-7% reduction in binary size when
      compiled with O3.
      
      Origin WorkletTests_TBB size details:
      __TEXT  __DATA  __OBJC  others  dec hex
      2363392 49152 0 4297793536  4300206080  1004ff000
      
      Updated WorkletTests_TBB size details:
      __TEXT  __DATA  __OBJC  others  dec hex
      2215936 49152 0 4297568256  4299833344  1004a4000
      4156130e
  24. 06 Jul, 2015 1 commit
    • Kenneth Moreland's avatar
      Fix compiler directives for icc · 4fc36267
      Kenneth Moreland authored
      The Intel icc compiler tries to pretend it is gcc, but it sometimes
      behaves differently. Add more explicit checks for what compiler is
      being used.
      4fc36267
  25. 15 Jun, 2015 1 commit
  26. 21 May, 2015 1 commit
  27. 16 Jan, 2015 2 commits
    • Kenneth Moreland's avatar
      FunctionInterface Append and Replace methods control environment only · dcf16790
      Kenneth Moreland authored
      They were declared as in both control and execution, but this would
      cause problems when the FunctionInterface contained objects that could
      only be copied in the control environment. Using these methods probably
      only makes sense in the control environment anyway. (They are a bit
      heavyweight to use in an inner loop of the execution environment.)
      dcf16790
    • Kenneth Moreland's avatar
      Add index tags to FunctionInterface features. · 37dac920
      Kenneth Moreland authored
      The functors in the ForEach, StaticTransform, and DynamicTransform
      methods sometimes can use the index of the parameter that they are
      operating on. This can be a helpful diagnostic in compile and run-time
      errors. It is also helpful when linking parameters from one
      FunctionInterface with those of another.
      
      This new features are now replacing implementations using the Zip
      functionality that was removed earlier. The implementation is actually
      simplified a bit.
      37dac920
  28. 12 Jan, 2015 1 commit
  29. 09 Dec, 2014 1 commit
    • Kenneth Moreland's avatar
      Documentation fixes. · a6622aee
      Kenneth Moreland authored
      Fix documentation comments in FunctionInterface.h and some declarations
      that are only for documentation in DeviceAdapterAlgorithm.h.
      a6622aee
  30. 12 Nov, 2014 1 commit
  31. 10 Nov, 2014 1 commit
  32. 21 Oct, 2014 1 commit
    • Kenneth Moreland's avatar
      Add basic dispatcher functionality. · 53a454fe
      Kenneth Moreland authored
      These changes support the implementation of DispatcherBase. This class
      provides the basic functionality for calling an Invoke method in the
      control environment, transferring data to the execution environment,
      scheduling threads in the execution environment, pulling data for each
      calling of the worklet method, and actually calling the worklet.
      53a454fe
  33. 16 Oct, 2014 1 commit
    • Kenneth Moreland's avatar
      Add ability to zip function interface objects. · b78688f4
      Kenneth Moreland authored
      The zip capability allows you to parameter-wise combine two
      FunctionInterface objects. The result is another FunctionInterface with
      each parameter a Pair containing the respective values of the two
      inputs.
      
      Being able to zip allows you to do transforms and invokes on data that
      is divided among multiple function interface objects.
      b78688f4
  34. 15 Oct, 2014 1 commit
    • Kenneth Moreland's avatar
      Add Fetch class · 79399c21
      Kenneth Moreland authored
      The Fetch class is responsible for moving data in and out of some
      collection in the execution environment. The Fetch class is templated
      with a pair of tags (the type of fetch and the aspect) that control the
      mechanism used for the fetch.
      79399c21
  35. 08 Oct, 2014 2 commits
    • Kenneth Moreland's avatar
      Add IdComponent and other base types with explicit widths · cbe6284b
      Kenneth Moreland authored
      In preparation for supporting base types with more widths, add typedefs
      for the base types with explicit widths (number of bits).
      
      Also added a IdComponent type that should be used for indices for
      components into tuples and vectors. There now should be no reason to use
      "int" inside of VTK-m code (especially for indexing). This change cleans
      up many of the int types that were used throughout.
      cbe6284b
    • Kenneth Moreland's avatar
      Fix wrapper macros around FunctionInterface header files · ddf630da
      Kenneth Moreland authored
      The header wrapper macros in all the FunctionInterface header files
      declared the function interface to be in the cont package, which is
      wrong.
      ddf630da
  36. 25 Jun, 2014 1 commit
    • Kenneth Moreland's avatar
      Replace Boost preprocessor iteration with macro expansion tool · 5fb7f638
      Kenneth Moreland authored
      This commit removes the usage of the boost preprocessor library to
      iteratively generate templates with a variable number of parameters. It
      is replaced with a template that is expanded by running it through the
      pyexpander macro processing tool (http://pyexpander.sourceforge.net).
      
      One reason for this change is to make the code easier to read. In
      particular, it is difficult to understand compiler errors when they
      occur deep within an iterating macro. Another reason for this change is
      that the Intel compiler currently has a bug that breaks with the boost
      preprocessor library.
      
      One issue with this approach is that the macro expansion is not part of
      the build process. Although open, pyexpander is not a tool most
      developers will have readily installed on their system. Thus, if you
      want to make changes to any of the macro code, you have to make sure
      pyexpander is installed, then make changes to the input files, then
      manually run pyexpander from the command line.
      5fb7f638
  37. 20 Jun, 2014 1 commit