1. 09 Sep, 2021 2 commits
  2. 08 Sep, 2021 6 commits
  3. 02 Sep, 2021 9 commits
    • Kenneth Moreland's avatar
      Merge topic 'arrayhandle-mutable-const' · c4949636
      Kenneth Moreland authored
      a2a8dcdf
      
       Allow a `const ArrayHandle` to be reallocated
      Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
      Acked-by: Li-Ta Lo's avatarLi-Ta Lo <ollie@lanl.gov>
      Merge-request: !2570
      c4949636
    • Abhishek Yenpure's avatar
      Merge topic 'warpX-streams' · 3fe41d7a
      Abhishek Yenpure authored
      8704ff25 Removing host/device being called from device warning
      f0d267e8
      
       Adding WarpX particle advection streamlines
      Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
      Merge-request: !2569
      3fe41d7a
    • Nickolas Davis's avatar
      Merge topic 'cuda-runtime-device-config' · a2e2d563
      Nickolas Davis authored
      5530d86e update cuda examples to use RuntimeDeviceConfiguration
      eaba4072 Call GetRuntimeConfiguration before GetRuntimeDeviceTracker in Initialize
      9730de80 remove cudaGetDevice calls, favor runtime device config
      adac415f
      
       implement cuda runtime device configuraton
      Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
      Acked-by: Kenneth Moreland's avatarKenneth Moreland <morelandkd@ornl.gov>
      Merge-request: !2565
      a2e2d563
    • Kenneth Moreland's avatar
      Allow a `const ArrayHandle` to be reallocated · a2a8dcdf
      Kenneth Moreland authored
      Previously, the `Allocate` method of `ArrayHandle` was _not_ declared as
      `const`. Likewise, the methods that depended on `Allocate`, namely
      `ReleaseResources` and `PrepareForOutput` were also not declared `const`.
      The main consequence of this was that if an `ArrayHandle` were passed as a
      constant reference argument to a method (e.g. `const ArrayHandle<T>& arg`),
      then the array could not be reallocated.
      
      This seems right at first blush. However, we have changed these methods to
      be `const` so that you can in fact reallocate the `ArrayHandle`. This is
      because the `ArrayHandle` is in principle a pointer to an array pointer.
      Such a structure in C will allow you to change the pointer to the array,
      and so in this context it makes sense for `ArrayHandle` to support that as
      well.
      
      Although this distinction will certainly be confusing to users, we think
      this change is correct for a variety of reasons.
      
        1. This change makes the behavior of `ArrayHandle` consistent with the
           behavior of `UnknownArrayHandle`. The latter needed this behavior to
           allow `ArrayHandle`s to be passed as output arguments to methods that
           get automatically converted to `UnknownArrayHandle`.
        2. Before this change, a `const ArrayHandle&` was still multible is many
           way. In particular, it was possible to change the data in the array
           even if the array could not be resized. You could still call things
           like `WritePortal` and `PrepareForInOut`. The fact that you could
           change it for some things and not others was confusing. The fact that
           you could call `PrepareForInOut` but not `PrepareForOutput` was doubly
           confusing.
        3. Passing a value by constant reference should be the same, from the
           calling code's perspective, as passing by value. Although the function
           can change an argument passed by value, that change is not propogated
           back to the calling code. However, in the case of `ArrayHandle`,
           calling by value would allow the array to be reallocated from the
           calling side whereas a constant reference would prevent that. This
           change makes the two behaviors consistent.
        4. The supposed assurance that the `ArrayHandle` would not be reallocated
           was easy to break even accidentally. If the `ArrayHandle` was assigned
           to another `ArrayHandle` (for example as a class' member or wrapped
           inside of an `UnknownArrayHandle`), then the array was free to be
           reallocated.
      a2a8dcdf
    • Kenneth Moreland's avatar
      Merge topic 'array-copy-const-ref' · 40f26ff4
      Kenneth Moreland authored
      e7409347
      
       Allow ArrayCopy into const ref of UnknownArrayHandle
      Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
      Acked-by: Li-Ta Lo's avatarLi-Ta Lo <ollie@lanl.gov>
      Merge-request: !2568
      40f26ff4
    • Nickolas Davis's avatar
      5530d86e
    • Nickolas Davis's avatar
    • Nickolas Davis's avatar
      9730de80
    • Nickolas Davis's avatar
      adac415f
  4. 01 Sep, 2021 8 commits
  5. 31 Aug, 2021 2 commits
    • Kenneth Moreland's avatar
      Suppress exception when mapping field of unknown type · 546dd608
      Kenneth Moreland authored
      By default, the `FilterDataSet` class will iterate over all fields and
      use `CastAndCall` on each one to call the subclass' mapping function
      with the appropriate array type.
      
      This only works if the array is of a known type. If it is not
      `CastAndCall` throws an exception. However, having the entire filter
      exception out just because one field cannot be converted does not make
      sense. Instead, catch the exception, log a warning, and drop the field.
      546dd608
    • James Kress's avatar
      0e6228bb
  6. 30 Aug, 2021 1 commit
  7. 26 Aug, 2021 2 commits
  8. 24 Aug, 2021 3 commits
  9. 23 Aug, 2021 5 commits
  10. 20 Aug, 2021 1 commit
    • Kenneth Moreland's avatar
      Fix condition in RuntimeDeviceConfiguration · c89d7093
      Kenneth Moreland authored
      `RuntimeDeviceConfiguration` is supposed to log a warning if a specific
      device returns a non-success status other than simply an invalid option.
      However, the condition was wrong and warnings never happened.
      c89d7093
  11. 19 Aug, 2021 1 commit