PoolingDelivery.hpp

/*
 * PoolingDelivery.hpp
 *
 *  Created on: Aug 24, 2017
 *      Author: Pete Schultz
 */

#ifndef POOLINGDELIVERY_HPP_
#define POOLINGDELIVERY_HPP_

#include "components/ImpliedWeightsPair.hpp"
#include "components/PatchSize.hpp"
#include "delivery/BaseDelivery.hpp"
#include "layers/PoolingIndexLayer.hpp"
#ifdef PV_USE_CUDA
#include "cudakernels/CudaPoolingDeliverKernel.hpp"
#endif // PV_USE_CUDA

namespace PV {

class PoolingDelivery : public BaseDelivery {
  protected:
   virtual void ioParam_pvpatchAccumulateType(enum ParamsIOFlag ioFlag);

   virtual void ioParam_updateGSynFromPostPerspective(enum ParamsIOFlag ioFlag);

   // This doxygen comment may not be as edifying as it appears.
   void ioParam_needPostIndexLayer(enum ParamsIOFlag ioFlag);

   void ioParam_postIndexLayerName(enum ParamsIOFlag ioFlag); // End of list of PoolingDelivery parameters.

  public:
   enum AccumulateType { UNDEFINED, MAXPOOLING, SUMPOOLING, AVGPOOLING };

   PoolingDelivery(char const *name, HyPerCol *hc);

   virtual ~PoolingDelivery();

   void setConnectionData(ConnectionData *connectionData);

   virtual void deliver() override;

   virtual bool isAllInputReady() override;

   AccumulateType getAccumulateType() const { return mAccumulateType; }

   PoolingIndexLayer *getPostIndexLayer() const { return mPostIndexLayer; }

   static AccumulateType parseAccumulateTypeString(char const *typestring);

  protected:
   PoolingDelivery();

   int initialize(char const *name, HyPerCol *hc);

   virtual void setObjectType() override;

   virtual int ioParamsFillGroup(enum ParamsIOFlag ioFlag) override;

   virtual Response::Status
   communicateInitInfo(std::shared_ptr<CommunicateInitInfoMessage const> message) override;

#ifdef PV_USE_CUDA
   virtual Response::Status
   setCudaDevice(std::shared_ptr<SetCudaDeviceMessage const> message) override;
#endif // PV_USE_CUDA

   virtual Response::Status allocateDataStructures() override;

   void initializeDeliverKernelArgs();

   void allocateThreadGSyn();

   void deliverPostsynapticPerspective();

   void deliverPresynapticPerspective();

   void clearGateIdxBuffer();

#ifdef PV_USE_CUDA
   void deliverGPU();
#endif // PV_USE_CUDA

   // Data members
  protected:
   AccumulateType mAccumulateType      = UNDEFINED;
   char *mPvpatchAccumulateTypeString  = nullptr;
   bool mUpdateGSynFromPostPerspective = false;

   PatchSize *mPatchSize            = nullptr;
   ImpliedWeightsPair *mWeightsPair = nullptr;

   bool mNeedPostIndexLayer           = false;
   char *mPostIndexLayerName          = nullptr;
   PoolingIndexLayer *mPostIndexLayer = nullptr;

   std::vector<std::vector<float>> mThreadGSyn;
   std::vector<std::vector<float>> mThreadGateIdxBuffer;
#ifdef PV_USE_CUDA
   PVCuda::CudaPoolingDeliverKernel *mRecvKernel = nullptr; // Cuda kernel for updating GSyn
#endif // PV_USE_CUDA

}; // end class PoolingDelivery

} // end namespace PV

#endif // POOLINGDELIVERY_HPP_