1. 04 Jan, 2018 3 commits
  2. 02 Jan, 2018 1 commit
  3. 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
  4. 12 Jul, 2017 1 commit
  5. 31 May, 2017 1 commit
  6. 26 May, 2017 1 commit
  7. 14 Feb, 2017 1 commit
  8. 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
  9. 23 Sep, 2016 1 commit
  10. 27 Jun, 2016 1 commit
  11. 04 May, 2016 1 commit
  12. 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
  13. 21 Sep, 2015 1 commit
  14. 13 Aug, 2015 1 commit
  15. 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
  16. 21 May, 2015 1 commit
  17. 16 Jan, 2015 1 commit
    • 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
  18. 08 Oct, 2014 1 commit
  19. 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