itkFFTWGlobalConfiguration.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkFFTWGlobalConfiguration_h
#define itkFFTWGlobalConfiguration_h

#include "itkObject.h"
//NOTE:  Need to have at least one itk include before
//       the next defines in order to have ITK_USE_FFTWF,ITK_USE_FFTWD defined
#if defined(ITK_USE_FFTWF) || defined(ITK_USE_FFTWD)

#include "ITKFFTExport.h"
#include <mutex>
#include "itkSingletonMacro.h"
#include "itksys/SystemTools.hxx"
#include "itksys/SystemInformation.hxx"
#if defined( ITK_USE_CUFFTW )
#include "cufftw.h"
#else
#include "fftw3.h"
#endif
#include <algorithm>
#include <cctype>

struct FFTWGlobalConfigurationGlobals;

//* The fftw utilities help control the various strategies
//available for controlling optimizations for the FFTW library.
//
//Environmental variables:
//ITK_FFTW_PLAN_RIGOR   - Defines how aggressive the generation of
//                             wisdom should be.
//ITK_FFTW_READ_WISDOM_CACHE  - Defines if a wisdom file cache should
//                              be read if found.  (it is "On" by default)
//ITK_FFTW_WRITE_WISDOM_CACHE  - Defines if generated wisdom file cache
//                               should be written (it is "Off" by default)
//ITK_FFTW_WISDOM_CACHE_BASE - Defines the base directory where the
//                             fftw wisdom cache will be placed,
//                             this is intended to be used with auto-
//                             generated cache file names
//ITK_FFTW_WISDOM_CACHE_FILE - Defines the full name of the cache
//                             file to be generated.  If this is
//                             set, then ITK_FFTW_WISDOM_CACHE_BASE
//                             is ignored.
//
// The above behaviors can also be controlled by the application.
//

namespace itk
{
struct FFTWGlobalConfigurationGlobals;

#ifdef _WIN32
#define FFTWPathSep "\\"
#else
#define FFTWPathSep "/"
#endif

class ITKFFT_EXPORT WisdomFilenameGeneratorBase
{
  public:
    //The baseCacheDirectory from which to build the cache hierarchy
    virtual std::string GenerateWisdomFilename(const std::string &baseCacheDirectory) const = 0;
    WisdomFilenameGeneratorBase();
    virtual ~WisdomFilenameGeneratorBase();
  private:
};

class ITKFFT_EXPORT ManualWisdomFilenameGenerator:
  public WisdomFilenameGeneratorBase
{
  public:
    ManualWisdomFilenameGenerator(std::string wfn);
    void SetWisdomFilename(const std::string &wfn);
    std::string GenerateWisdomFilename(const std::string &baseCacheDirectory ) const override;
  private:
    std::string m_WisdomFilename;
};

class ITKFFT_EXPORT SimpleWisdomFilenameGenerator: public WisdomFilenameGeneratorBase
{
  public:
    std::string GenerateWisdomFilename(const std::string &baseCacheDirectory) const override;
};

class ITKFFT_EXPORT HostnameWisdomFilenameGenerator: public WisdomFilenameGeneratorBase
{
  public:
  std::string GenerateWisdomFilename(const std::string &baseCacheDirectory) const override;
};

class ITKFFT_EXPORT HardwareWisdomFilenameGenerator: public WisdomFilenameGeneratorBase
{
public:
    HardwareWisdomFilenameGenerator();

  std::string GenerateWisdomFilename(const std::string &baseCacheDirectory) const override;

  void SetUseOSName(const bool flag);
  void SetUseOSRelease(const bool flag);
  void SetUseOSVersion(const bool flag);
  void SetUseOSPlatform(const bool flag);
  void SetUseOSBitSize(const bool flag);
  void SetUseNumberOfProcessors(const bool flag);
  void SetUseVendorString(const bool flag);
  void SetUseTypeID(const bool flag);
  void SetUseFamilyID(const bool flag);
  void SetUseModelID(const bool flag);
  void SetUseSteppingCode(const bool flag);

  bool GetUseOSName() const;
  bool GetUseOSRelease() const;
  bool GetUseOSVersion() const;
  bool GetUseOSPlatform() const;
  bool GetUseOSBitSize() const;
  bool GetUseNumberOfProcessors() const;
  bool GetUseVendorString() const;
  bool GetUseTypeID() const;
  bool GetUseFamilyID() const;
  bool GetUseModelID() const;
  bool GetUseSteppingCode() const;

private:
    bool m_UseOSName;
    bool m_UseOSRelease;
    bool m_UseOSVersion;
    bool m_UseOSPlatform;
    bool m_UseOSBitSize;
    bool m_UseNumberOfProcessors;
    bool m_UseVendorString;
    bool m_UseVendorID;
    bool m_UseTypeID;
    bool m_UseFamilyID;
    bool m_UseModelID;
    bool m_UseSteppingCode;
};

class ITKFFT_EXPORT FFTWGlobalConfiguration
  : public Object
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(FFTWGlobalConfiguration);

  using Self = FFTWGlobalConfiguration;
  using Superclass = Object;
  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;
  using MutexType = std::mutex;

  itkTypeMacro(FFTWGlobalConfiguration, Object);

  static std::mutex & GetLockMutex();

  static void SetNewWisdomAvailable( const bool & v );
  static bool GetNewWisdomAvailable();

  static void SetPlanRigor( const int & v );

  static int GetPlanRigor();
  static void SetPlanRigor( const std::string & name );

  static int GetPlanRigorValue( const std::string & name );

  static std::string GetPlanRigorName( const int & value );

  static void SetReadWisdomCache( const bool & v );
  static bool GetReadWisdomCache();

  static void SetWriteWisdomCache( const bool & v );
  static bool GetWriteWisdomCache();

  static void SetWisdomCacheBase( const std::string & v );
  static std::string GetWisdomCacheBase();

  static void SetWisdomFilenameGenerator( WisdomFilenameGeneratorBase *wfg);

  static std::string GetWisdomFileDefaultBaseName();

  static bool ImportWisdomFileDouble( const std::string &fname );
  static bool ExportWisdomFileDouble( const std::string &fname );

  static bool ImportWisdomFileFloat( const std::string &fname );
  static bool ExportWisdomFileFloat( const std::string &fname );

  static bool ImportDefaultWisdomFileDouble();
  static bool ExportDefaultWisdomFileDouble();

  static bool ImportDefaultWisdomFileFloat();
  static bool ExportDefaultWisdomFileFloat();

  static bool ImportDefaultWisdomFile();
  static bool ExportDefaultWisdomFile();

private:
  FFTWGlobalConfiguration(); //This will process env variables
  ~FFTWGlobalConfiguration() override; //This will write cache file if requested.

  static Pointer GetInstance();

  itkGetGlobalDeclarationMacro(FFTWGlobalConfigurationGlobals, PimplGlobals);


  itkFactorylessNewMacro(Self);

  static FFTWGlobalConfigurationGlobals *m_PimplGlobals;

  std::mutex           m_Lock;
  bool                          m_NewWisdomAvailable;
  int                           m_PlanRigor;
  bool                          m_WriteWisdomCache;
  bool                          m_ReadWisdomCache;
  std::string                   m_WisdomCacheBase;
  //m_WriteWisdomCache Controls the behavior of default
  //wisdom file creation policies.
  WisdomFilenameGeneratorBase * m_WisdomFilenameGenerator;
};
}
#endif
#endif