DeviceAdapterAlgorithm.h

Go to the documentation of this file.

//============================================================================
//  The contents of this file are covered by the Viskores license. See
//  LICENSE.txt for details.
//
//  By contributing to this file, all contributors agree to the Developer
//  Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.txt.
//============================================================================
 
//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//============================================================================
#ifndef viskores_cont_DeviceAdapterAlgorithm_h
#define viskores_cont_DeviceAdapterAlgorithm_h
 
#include <viskores/Types.h>
 
#include <viskores/cont/DeviceAdapterTag.h>
#include <viskores/cont/Logging.h>
 
 
#ifdef _WIN32
#include <sys/timeb.h>
#include <sys/types.h>
#else // _WIN32
#include <limits.h>
#include <sys/time.h>
#include <unistd.h>
#endif
 
namespace viskores
{
namespace cont
{
 
template <class DeviceAdapterTag>
struct DeviceAdapterAlgorithm
#ifdef VISKORES_DOXYGEN_ONLY
{
  template <typename IndicesStorage>
  VISKORES_CONT static viskores::Id BitFieldToUnorderedSet(
    const viskores::cont::BitField& bits,
    viskores::cont::ArrayHandle<Id, IndicesStorage>& indices);
 
  template <typename T, typename U, class CIn, class COut>
  VISKORES_CONT static void Copy(const viskores::cont::ArrayHandle<T, CIn>& input,
                                 viskores::cont::ArrayHandle<U, COut>& output);
 
  template <typename T, typename U, class CIn, class CStencil, class COut>
  VISKORES_CONT static void CopyIf(const viskores::cont::ArrayHandle<T, CIn>& input,
                                   const viskores::cont::ArrayHandle<U, CStencil>& stencil,
                                   viskores::cont::ArrayHandle<T, COut>& output);
 
  template <typename T, typename U, class CIn, class CStencil, class COut, class UnaryPredicate>
  VISKORES_CONT static void CopyIf(const viskores::cont::ArrayHandle<T, CIn>& input,
                                   const viskores::cont::ArrayHandle<U, CStencil>& stencil,
                                   viskores::cont::ArrayHandle<T, COut>& output,
                                   UnaryPredicate unary_predicate);
 
  template <typename T, typename U, class CIn, class COut>
  VISKORES_CONT static bool CopySubRange(const viskores::cont::ArrayHandle<T, CIn>& input,
                                         viskores::Id inputStartIndex,
                                         viskores::Id numberOfElementsToCopy,
                                         viskores::cont::ArrayHandle<U, COut>& output,
                                         viskores::Id outputIndex = 0);
 
  VISKORES_CONT static viskores::Id CountSetBits(const viskores::cont::BitField& bits);
 
  VISKORES_CONT static void Fill(viskores::cont::BitField& bits, bool value, viskores::Id numBits);
  VISKORES_CONT static void Fill(viskores::cont::BitField& bits, bool value);
  template <typename WordType>
  VISKORES_CONT static void Fill(viskores::cont::BitField& bits,
                                 WordType word,
                                 viskores::Id numBits);
  template <typename WordType>
  VISKORES_CONT static void Fill(viskores::cont::BitField& bits, WordType word);
 
  template <typename T, typename S>
  VISKORES_CONT static void Fill(viskores::cont::ArrayHandle<T, S>& array, const T& value);
  template <typename T, typename S>
  VISKORES_CONT static void Fill(viskores::cont::ArrayHandle<T, S>& array,
                                 const T& value,
                                 const viskores::Id numValues);
 
  template <typename T, class CIn, class CVal, class COut>
  VISKORES_CONT static void LowerBounds(const viskores::cont::ArrayHandle<T, CIn>& input,
                                        const viskores::cont::ArrayHandle<T, CVal>& values,
                                        viskores::cont::ArrayHandle<viskores::Id, COut>& output);
 
  template <typename T, class CIn, class CVal, class COut, class BinaryCompare>
  VISKORES_CONT static void LowerBounds(const viskores::cont::ArrayHandle<T, CIn>& input,
                                        const viskores::cont::ArrayHandle<T, CVal>& values,
                                        viskores::cont::ArrayHandle<viskores::Id, COut>& output,
                                        BinaryCompare binary_compare);
 
  template <class CIn, class COut>
  VISKORES_CONT static void LowerBounds(
    const viskores::cont::ArrayHandle<viskores::Id, CIn>& input,
    viskores::cont::ArrayHandle<viskores::Id, COut>& values_output);
 
  template <typename T, typename U, class CIn>
  VISKORES_CONT static U Reduce(const viskores::cont::ArrayHandle<T, CIn>& input, U initialValue);
 
  template <typename T, typename U, class CIn, class BinaryFunctor>
  VISKORES_CONT static U Reduce(const viskores::cont::ArrayHandle<T, CIn>& input,
                                U initialValue,
                                BinaryFunctor binary_functor);
 
  template <typename T,
            typename U,
            class CKeyIn,
            class CValIn,
            class CKeyOut,
            class CValOut,
            class BinaryFunctor>
  VISKORES_CONT static void ReduceByKey(const viskores::cont::ArrayHandle<T, CKeyIn>& keys,
                                        const viskores::cont::ArrayHandle<U, CValIn>& values,
                                        viskores::cont::ArrayHandle<T, CKeyOut>& keys_output,
                                        viskores::cont::ArrayHandle<U, CValOut>& values_output,
                                        BinaryFunctor binary_functor);
 
  template <typename T, class CIn, class COut>
  VISKORES_CONT static T ScanInclusive(const viskores::cont::ArrayHandle<T, CIn>& input,
                                       viskores::cont::ArrayHandle<T, COut>& output);
 
 
  template <typename T, class CIn, class COut, class BinaryFunctor>
  VISKORES_CONT static T ScanInclusive(const viskores::cont::ArrayHandle<T, CIn>& input,
                                       viskores::cont::ArrayHandle<T, COut>& output,
                                       BinaryFunctor binary_functor);
 
  template <typename T,
            typename U,
            typename KIn,
            typename VIn,
            typename VOut,
            typename BinaryFunctor>
  VISKORES_CONT static void ScanInclusiveByKey(const viskores::cont::ArrayHandle<T, KIn>& keys,
                                               const viskores::cont::ArrayHandle<U, VIn>& values,
                                               viskores::cont::ArrayHandle<U, VOut>& values_output,
                                               BinaryFunctor binary_functor);
 
  template <typename T, typename U, typename KIn, typename VIn, typename VOut>
  VISKORES_CONT static void ScanInclusiveByKey(const viskores::cont::ArrayHandle<T, KIn>& keys,
                                               const viskores::cont::ArrayHandle<U, VIn>& values,
                                               viskores::cont::ArrayHandle<U, VOut>& values_output);
 
  template <typename T, class CIn, class COut>
  VISKORES_CONT static T ScanExclusive(const viskores::cont::ArrayHandle<T, CIn>& input,
                                       viskores::cont::ArrayHandle<T, COut>& output);
 
  template <typename T, class CIn, class COut, class BinaryFunctor>
  VISKORES_CONT static T ScanExclusive(const viskores::cont::ArrayHandle<T, CIn>& input,
                                       viskores::cont::ArrayHandle<T, COut>& output,
                                       BinaryFunctor binaryFunctor,
                                       const T& initialValue)
 
    
    template <typename T,
              typename U,
              typename KIn,
              typename VIn,
              typename VOut,
              class BinaryFunctor>
    VISKORES_CONT static void ScanExclusiveByKey(const viskores::cont::ArrayHandle<T, KIn>& keys,
                                                 const viskores::cont::ArrayHandle<U, VIn>& values,
                                                 viskores::cont::ArrayHandle<U, VOut>& output,
                                                 const U& initialValue,
                                                 BinaryFunctor binaryFunctor);
 
  template <typename T, typename U, class KIn, typename VIn, typename VOut>
  VISKORES_CONT static void ScanExclusiveByKey(const viskores::cont::ArrayHandle<T, KIn>& keys,
                                               const viskores::cont::ArrayHandle<U, VIn>& values,
                                               viskores::cont::ArrayHandle<U, VOut>& output);
 
  template <typename T, class CIn, class COut>
  VISKORES_CONT static void ScanExtended(const viskores::cont::ArrayHandle<T, CIn>& input,
                                         viskores::cont::ArrayHandle<T, COut>& output);
 
  template <typename T, class CIn, class COut, class BinaryFunctor>
  VISKORES_CONT static void ScanExtended(const viskores::cont::ArrayHandle<T, CIn>& input,
                                         viskores::cont::ArrayHandle<T, COut>& output,
                                         BinaryFunctor binaryFunctor,
                                         const T& initialValue);
 
  template <class Functor>
  VISKORES_CONT static void Schedule(Functor functor, viskores::Id numInstances);
 
  template <class Functor, class IndiceType>
  VISKORES_CONT static void Schedule(Functor functor, viskores::Id3 rangeMax);
 
  template <typename T, class Storage>
  VISKORES_CONT static void Sort(viskores::cont::ArrayHandle<T, Storage>& values);
 
  template <typename T, class Storage, class BinaryCompare>
  VISKORES_CONT static void Sort(viskores::cont::ArrayHandle<T, Storage>& values,
                                 BinaryCompare binary_compare);
 
  template <typename T, typename U, class StorageT, class StorageU>
  VISKORES_CONT static void SortByKey(viskores::cont::ArrayHandle<T, StorageT>& keys,
                                      viskores::cont::ArrayHandle<U, StorageU>& values);
 
  template <typename T, typename U, class StorageT, class StorageU, class BinaryCompare>
  VISKORES_CONT static void SortByKey(viskores::cont::ArrayHandle<T, StorageT>& keys,
                                      viskores::cont::ArrayHandle<U, StorageU>& values,
                                      BinaryCompare binary_compare)
 
    
    VISKORES_CONT static void Synchronize();
 
  template <typename T,
            typename U,
            typename V,
            typename StorageT,
            typename StorageU,
            typename StorageV,
            typename BinaryFunctor>
  VISKORES_CONT static void Transform(const viskores::cont::ArrayHandle<T, StorageT>& input1,
                                      const viskores::cont::ArrayHandle<U, StorageU>& input2,
                                      viskores::cont::ArrayHandle<V, StorageV>& output,
                                      BinaryFunctor binaryFunctor);
 
  template <typename T, class Storage>
  VISKORES_CONT static void Unique(viskores::cont::ArrayHandle<T, Storage>& values);
 
  template <typename T, class Storage, class BinaryCompare>
  VISKORES_CONT static void Unique(viskores::cont::ArrayHandle<T, Storage>& values,
                                   BinaryCompare binary_compare);
 
  template <typename T, class CIn, class CVal, class COut>
  VISKORES_CONT static void UpperBounds(const viskores::cont::ArrayHandle<T, CIn>& input,
                                        const viskores::cont::ArrayHandle<T, CVal>& values,
                                        viskores::cont::ArrayHandle<viskores::Id, COut>& output);
 
  template <typename T, class CIn, class CVal, class COut, class BinaryCompare>
  VISKORES_CONT static void UpperBounds(const viskores::cont::ArrayHandle<T, CIn>& input,
                                        const viskores::cont::ArrayHandle<T, CVal>& values,
                                        viskores::cont::ArrayHandle<viskores::Id, COut>& output,
                                        BinaryCompare binary_compare);
 
  template <class CIn, class COut>
  VISKORES_CONT static void UpperBounds(
    const viskores::cont::ArrayHandle<viskores::Id, CIn>& input,
    viskores::cont::ArrayHandle<viskores::Id, COut>& values_output);
};
#else  // VISKORES_DOXYGEN_ONLY
  ;
#endif //VISKORES_DOXYGEN_ONLY
 
template <class DeviceAdapterTag>
class DeviceAdapterTimerImplementation
{
public:
  struct TimeStamp
  {
    viskores::Int64 Seconds;
    viskores::Int64 Microseconds;
  };
  VISKORES_CONT DeviceAdapterTimerImplementation() { this->Reset(); }
 
  VISKORES_CONT void Reset()
  {
    this->StartReady = false;
    this->StopReady = false;
  }
 
  VISKORES_CONT void Start()
  {
    this->Reset();
    this->StartTime = this->GetCurrentTime();
    this->StartReady = true;
  }
 
  VISKORES_CONT void Stop()
  {
    this->StopTime = this->GetCurrentTime();
    this->StopReady = true;
  }
 
  VISKORES_CONT bool Started() const { return this->StartReady; }
 
  VISKORES_CONT bool Stopped() const { return this->StopReady; }
 
  VISKORES_CONT bool Ready() const { return true; }
 
  VISKORES_CONT viskores::Float64 GetElapsedTime() const
  {
    assert(this->StartReady);
    if (!this->StartReady)
    {
      VISKORES_LOG_S(
        viskores::cont::LogLevel::Error,
        "Start() function should be called first then trying to call GetElapsedTime().");
      return 0;
    }
 
    TimeStamp startTime = this->StartTime;
    TimeStamp stopTime = this->StopReady ? this->StopTime : this->GetCurrentTime();
 
    viskores::Float64 elapsedTime;
    elapsedTime = viskores::Float64(stopTime.Seconds - startTime.Seconds);
    elapsedTime += (viskores::Float64(stopTime.Microseconds - startTime.Microseconds) /
                    viskores::Float64(1000000));
 
    return elapsedTime;
  }
 
  VISKORES_CONT TimeStamp GetCurrentTime() const
  {
    viskores::cont::DeviceAdapterAlgorithm<DeviceAdapterTag>::Synchronize();
 
    TimeStamp retval;
#ifdef _WIN32
    timeb currentTime;
    ::ftime(&currentTime);
    retval.Seconds = currentTime.time;
    retval.Microseconds = 1000 * currentTime.millitm;
#else
    timeval currentTime;
    gettimeofday(&currentTime, nullptr);
    retval.Seconds = currentTime.tv_sec;
    retval.Microseconds = currentTime.tv_usec;
#endif
    return retval;
  }
 
  bool StartReady;
  bool StopReady;
  TimeStamp StartTime;
  TimeStamp StopTime;
};
 
template <class DeviceAdapterTag>
class DeviceAdapterRuntimeDetector
{
public:
#ifdef VISKORES_DOXYGEN_ONLY
  VISKORES_CONT bool Exists() const;
#endif
};
 
template <typename DeviceTag>
class DeviceTaskTypes;
}
} // namespace viskores::cont
 
#endif //viskores_cont_DeviceAdapterAlgorithm_h