1. 07 Apr, 2021 5 commits
  2. 06 Apr, 2021 1 commit
  3. 05 Apr, 2021 3 commits
  4. 02 Apr, 2021 6 commits
    • Vicente Bolea's avatar
      Add release notes for v1.6.0 · 4e94d830
      Vicente Bolea authored
      4e94d830
    • Vicente Bolea's avatar
      Merge commit 'd2d1c854' into update-to-1.6.0-rc1 · 9d345733
      Vicente Bolea authored
      * commit 'd2d1c854': (1346 commits)
        extend the default clipping plane
        Fix unintended cast in TBB Reduce's return value
        follow coding conventions
        make scalar normilization consistent across rendering
        correct a potential divide by zero
        Do not assume CUDA reduce operator is unary
        Fix casting issues in TBB functors
        Add casts to FunctorsGeneral.h
        Allow for different types in basic type operators
        kick the builds
        Cleanup per review.
        Fixes per review
        Add ArrayHandleSOA to default
        Disallow references in Variant
        Be more conservative about is_trivial support
        Removed two TODO comments after verifying parameters
        Port bug fix from distributed to augmented contour tree filter
        Fix hang in distributed contour tree
        more missing sstream headers
        add another missing header
        ...
      9d345733
    • Robert Maynard's avatar
    • Kenneth Moreland's avatar
      Check that all execution objects are trivially copyable · 294a30fd
      Kenneth Moreland authored
      When the dispatcher does it's "transport" phase, it returns an
      "execution object", but this object is held in the control environment
      (on the host) although it may point to resources in the execution
      environment (on the device). For this object to get from host to device,
      it must be trivially copyable. If it is not, compile and/or runtime
      errors could occur. So force this condition with a static assert.
      294a30fd
    • Kenneth Moreland's avatar
      Have VTKM_IS_TRIVIAL* macros show types better · bd5b84fa
      Kenneth Moreland authored
      Changed the definition of `VTKM_IS_TRIVIAL`,
      `VTKM_IS_TRIVIALLY_COPYABLE` and the like to use internal structs to do
      the static assert rather than have them do the static assert themselves.
      This makes the compiler more likely to tell you the actual type being
      checked rather. (At least, this was the case on my clang compiler.)
      bd5b84fa
    • Kenneth Moreland's avatar
      Make ArrayPortalRecombineVec trivially copyable · 3813fb51
      Kenneth Moreland authored
      Using this internal class is a bit tricky because it requires a pointer
      to a C array that is expected to contain portals. Both the C array and
      the portals must be defined for the expected device. This is already
      handled by the associated Storage. Assuming all of this holds, make sure
      the `ArrayPortalRecombineVec` is trivially copyable. This is a
      requirement for passing objects to the execution environment.
      3813fb51
  5. 01 Apr, 2021 2 commits
  6. 31 Mar, 2021 5 commits
  7. 30 Mar, 2021 9 commits
    • Kenneth Moreland's avatar
    • Kenneth Moreland's avatar
    • Kenneth Moreland's avatar
      Add padding to Grid struct in CellLocatorTwoLevel · 9816c422
      Kenneth Moreland authored
      There appears to be a bug in CUDA 9.2 where if you have a class that
      contains a struct that itself has to have padding in the middle for
      alignment purposes and you then put that class in a union with other
      classes, it seems like that padding can cause problems with other
      objects in the union.
      9816c422
    • Kenneth Moreland's avatar
      Support copying a Variant to itself · e480fd7a
      Kenneth Moreland authored
      e480fd7a
    • Kenneth Moreland's avatar
      Make connectivity structures trivially copyable · d2d9ba33
      Kenneth Moreland authored
      It always worked to trivially copy these classes, but the compiler did
      not think so because copy constructors were defined. Change these
      constructors to be default so that the compler can properly check
      triviality.
      d2d9ba33
    • Kenneth Moreland's avatar
      Avoid is_trivially_copyable on VariantUnion · cad5dc7b
      Kenneth Moreland authored
      For some reason some versions of the CUDA compiler would return true for
      `is_trivially_copyable` on a `VariantUnion` even when the types of the
      union caused the copy constructor to get deleted.
      
      Solve the problem by using `AllTriviallyCopyable` instead of directly
      caling `is_trivially_copyable` on the union.
      cad5dc7b
    • Kenneth Moreland's avatar
      Use specialized class instead of function overload for Variant::Get · cb60401a
      Kenneth Moreland authored
      Nvcc was having troubles resolving the return type of the overloaded
      function to get a value out of a `VariantUnion`. Replace the
      implementation with a class with specializations. This is more verbose,
      but easier on the compiler.
      cb60401a
    • Kenneth Moreland's avatar
      Use a union in Variant for safe type punning · c9bcdd01
      Kenneth Moreland authored
      Create a `VaraintUnion` that is an actual C++ `union` to store the data
      in a `Variant`.
      
      You may be asking yourself, why not just use an `std::aligned_union`
      rather than a real union type? That was our first implementation, but
      the problem is that the `std::aligned_union` reference needs to be
      recast to the actual type. Typically you would do that with
      `reinterpret_cast`. However, doing that leads to undefined behavior. The
      C++ compiler assumes that 2 pointers of different types point to
      different memory (even if it is clear that they are set to the same
      address). That means optimizers can remove code because it "knows" that
      data in one type cannot affect data in another type. To safely change
      the type of an `std::aligned_union`, you really have to do an
      `std::memcpy`. This is problematic for types that cannot be trivially
      copied. Another problem is that we found that device compilers do not
      optimize the memcpy as well as most CPU compilers. Likely, memcpy is
      used much less frequently on GPU devices.
      c9bcdd01
    • Kenneth Moreland's avatar
      Fix types used for coordinates in ArrayRangeCompute · 26d5168b
      Kenneth Moreland authored
      Was using scalar types for `ArrayRangeCompute` for storage of types like
      Cartesian product. It should be `Vec3` types.
      26d5168b
  8. 29 Mar, 2021 2 commits
    • Kenneth Moreland's avatar
      Merge topic 'what-in-error' · d7c6ffbd
      Kenneth Moreland authored
      eadaf06f
      
       Set what string in Error::SetMessage
      Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
      Acked-by: Nickolas Davis's avatarNickolas Davis <nadavi@sandia.gov>
      Merge-request: !2451
      d7c6ffbd
    • Kenneth Moreland's avatar
      Set what string in Error::SetMessage · eadaf06f
      Kenneth Moreland authored
      `vtkm::cont::Error` inherits from `std::exception`. As such, it has a
      special `what` string that reports an error message in a standard way.
      This is particularly useful when a `vtkm::cont::Error` exception remains
      uncaught because the system will print the `what` string before
      crashing.
      
      Unfortunately, the `what` string was only being set in the `Error`
      constructor that took a message. That is a problem for subclasses like
      `ErrorCuda` that used the default constructor and then used
      `SetMessage`. The `what` string did not get set in this case.
      
      Change the behavior to capture the stack trace in the default
      constructor and update the `what` string if a subclass uses
      `SetMessage`.
      eadaf06f
  9. 26 Mar, 2021 1 commit
  10. 25 Mar, 2021 4 commits
  11. 24 Mar, 2021 2 commits