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 "itkSimpleFastMutexLock.h"

#include "itksys/SystemTools.hxx"
#include "itksys/SystemInformation.hxx"
#include "fftw3.h"
#include <algorithm>
#include <cctype>

//* 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
{
#ifdef _WIN32
#define FFTWPathSep "\\"
#else
#define FFTWPathSep "/"
#endif

class 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 ManualWisdomFilenameGenerator: public WisdomFilenameGeneratorBase
{
  public:
    ManualWisdomFilenameGenerator(const std::string wfn): m_WisdomFilename(wfn) { };
    void SetWisdomFilename(const std::string wfn)
      {
      this->m_WisdomFilename=wfn;
      }
    virtual std::string GenerateWisdomFilename(const std::string itkNotUsed(baseCacheDirectory) ) const ITK_OVERRIDE
      {
       return this->m_WisdomFilename;
      }
  private:
    std::string m_WisdomFilename;
};

class SimpleWisdomFilenameGenerator: public WisdomFilenameGeneratorBase
{
  public:
    virtual std::string GenerateWisdomFilename(const std::string baseCacheDirectory) const ITK_OVERRIDE
      {
       return baseCacheDirectory+FFTWPathSep+".itksimple.wisdom";
      }
};

class HostnameWisdomFilenameGenerator: public WisdomFilenameGeneratorBase
{
  public:
    virtual std::string GenerateWisdomFilename(const std::string baseCacheDirectory) const ITK_OVERRIDE
      {

      itksys::SystemInformation hostInfo;
      hostInfo.RunOSCheck();
      return baseCacheDirectory+FFTWPathSep + ".itkwisdomfftw"+FFTWPathSep+".itk_"+hostInfo.GetHostname()+".wisdom";
      }
};

class HardwareWisdomFilenameGenerator: public WisdomFilenameGeneratorBase
{
public:
    HardwareWisdomFilenameGenerator():
      m_UseOSName(true),
      m_UseOSRelease(false),
      m_UseOSVersion(false),
      m_UseOSPlatform(true),
      m_UseOSBitSize(true),
      m_UseNumberOfProcessors(true),
      m_UseVendorString(true),
      m_UseVendorID(false),
      m_UseTypeID(true),
      m_UseFamilyID(true),
      m_UseModelID(true),
      m_UseSteppingCode(true)
    {}

    virtual std::string GenerateWisdomFilename(const std::string baseCacheDirectory) const ITK_OVERRIDE
      {
      //Now build the hardware string by system interogation
      itksys::SystemInformation hardwareInfo;
      hardwareInfo.RunCPUCheck();
      hardwareInfo.RunOSCheck();
      hardwareInfo.RunMemoryCheck();
      std::stringstream OSD("");

      if( this->m_UseOSName )
        {
        OSD << hardwareInfo.GetOSName() << "_";
        }
      if( this->m_UseOSRelease )
        {
        OSD << hardwareInfo.GetOSRelease() << "_";
        }
      if( this->m_UseOSVersion )
        {
        OSD << hardwareInfo.GetOSVersion() << "_";
        }
      if( this->m_UseOSPlatform )
        {
        OSD << hardwareInfo.GetOSPlatform() << "_";
        }
      if( this->m_UseOSBitSize )
        {
        const char * const bitsizeString=( hardwareInfo.Is64Bits() ) ? "64_":"32_";
        OSD << bitsizeString;
        }
      if( this->m_UseNumberOfProcessors )
        {
        OSD << hardwareInfo.GetNumberOfLogicalCPU() <<"x"<< hardwareInfo.GetNumberOfPhysicalCPU() << "_";
        }
      if( this->m_UseVendorString )
        {
        OSD << hardwareInfo.GetVendorString() << "_";
        }
      if( this->m_UseVendorID )
        {
        OSD << hardwareInfo.GetVendorID() << "_";
        }
      if( this->m_UseTypeID )
        {
        OSD << hardwareInfo.GetTypeID() << "_";
        }
      if( this->m_UseFamilyID )
        {
        OSD << hardwareInfo.GetFamilyID() << "_";
        }
      if( this->m_UseModelID )
        {
        OSD << hardwareInfo.GetModelID() << "_";
        }
      if( this->m_UseSteppingCode )
        {
        OSD << hardwareInfo.GetSteppingCode();
        }
      OSD << ".wisdom";
      std::string noSpaceStr=OSD.str();
      //Now remove spaces
      noSpaceStr.erase(std::remove_if(noSpaceStr.begin(), noSpaceStr.end(),::isspace), noSpaceStr.end());
      return baseCacheDirectory + FFTWPathSep + ".itkwisdomfftw" + FFTWPathSep + noSpaceStr;
      }
    void SetUseOSName(const bool flag) { this->m_UseOSName=flag; }
    void SetUseOSRelease(const bool flag) { this->m_UseOSRelease=flag; }
    void SetUseOSVersion(const bool flag) { this->m_UseOSVersion=flag; }
    void SetUseOSPlatform(const bool flag) { this->m_UseOSPlatform=flag; }
    void SetUseOSBitSize(const bool flag) { this->m_UseOSBitSize=flag; }
    void SetUseNumberOfProcessors(const bool flag) { this->m_UseNumberOfProcessors=flag; }
    void SetUseVendorString(const bool flag) { this->m_UseVendorString=flag; }
    void SetUseTypeID(const bool flag) { this->m_UseTypeID=flag; }
    void SetUseFamilyID(const bool flag) { this->m_UseFamilyID=flag; }
    void SetUseModelID(const bool flag) { this->m_UseModelID=flag; }
    void SetUseSteppingCode(const bool flag) { this->m_UseSteppingCode=flag; }

    bool GetUseOSName() const { return this->m_UseOSName; }
    bool GetUseOSRelease() const { return this->m_UseOSRelease; }
    bool GetUseOSVersion() const { return this->m_UseOSVersion; }
    bool GetUseOSPlatform() const { return this->m_UseOSPlatform; }
    bool GetUseOSBitSize() const { return this->m_UseOSBitSize; }
    bool GetUseNumberOfProcessors() const { return this->m_UseNumberOfProcessors; }
    bool GetUseVendorString() const { return this->m_UseVendorString; }
    bool GetUseTypeID() const { return this->m_UseTypeID; }
    bool GetUseFamilyID() const { return this->m_UseFamilyID; }
    bool GetUseModelID() const { return this->m_UseModelID; }
    bool GetUseSteppingCode() const { return this->m_UseSteppingCode; }

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 FFTWGlobalConfiguration: public Object
{
public:

  typedef FFTWGlobalConfiguration    Self;
  typedef Object                     Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;
  typedef SimpleFastMutexLock        MutexType;

  itkTypeMacro(FFTWGlobalConfiguration, Object);

  static SimpleFastMutexLock & GetLockMutex()
  {
    return GetInstance()->m_Lock;
  }

  static void SetNewWisdomAvailable( const bool & v )
  {
    GetInstance()->m_NewWisdomAvailable = v;
  }
  static bool GetNewWisdomAvailable()
  {
    return GetInstance()->m_NewWisdomAvailable;
  }

  static void SetPlanRigor( const int & v )
  {
    // use that method to check the value
    GetPlanRigorName( v );
    GetInstance()->m_PlanRigor = v;
  }

  static int GetPlanRigor()
  {
    return GetInstance()->m_PlanRigor;
  }
  static void SetPlanRigor( const std::string & name )
  {
    SetPlanRigor( GetPlanRigorValue( name ) );
  }

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

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

  static void SetReadWisdomCache( const bool & v )
  {
    GetInstance()->m_ReadWisdomCache = v;
  }

  static bool GetReadWisdomCache()
  {
    return GetInstance()->m_ReadWisdomCache;
  }

  static void SetWriteWisdomCache( const bool & v )
  {
    GetInstance()->m_WriteWisdomCache = v;
  }

  static bool GetWriteWisdomCache()
  {
    return GetInstance()->m_WriteWisdomCache;
  }

  static void SetWisdomCacheBase( const std::string & v )
  {
    GetInstance()->m_WisdomCacheBase = v;
  }

  static std::string GetWisdomCacheBase()
  {
    return GetInstance()->m_WisdomCacheBase;
  }

  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();

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

  static Pointer GetInstance();

  itkFactorylessNewMacro(Self);

  FFTWGlobalConfiguration(const Self &); //purposely not implemented
  void operator=(const Self &); //purposely not implemented

  static Pointer                m_Instance;
  static SimpleFastMutexLock    m_CreationLock;

  SimpleFastMutexLock           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