CudaGlobalMasterClient.h

Go to the documentation of this file.

#ifndef CUDAGLOBALMASTERCLIENT_H
#define CUDAGLOBALMASTERCLIENT_H

#include "CudaUtils.h"
#include "NamdTypes.h"
#include <memory>
#include <string>
#include <vector>

class CudaGlobalMasterServer;
class Lattice;
class SubmitReduction;
class Molecule;
class SimParameters;
class Controller;
class ScriptTcl;

// Use inline namespace to force the user to recompile if we change the interface
// and increase the version. (see https://www.foonathan.net/2018/11/inline-namespaces/)
namespace CudaGlobalMaster {
  inline namespace CUDAGM_NS {
    class CudaGlobalMasterClient
        : public std::enable_shared_from_this<CudaGlobalMasterClient> {
    #if (defined(NAMD_CUDA) || defined(NAMD_HIP)) && defined(NODEGROUP_FORCE_REGISTER)
    public:
      CudaGlobalMasterClient() {}
      virtual ~CudaGlobalMasterClient();
      virtual void initialize(
        const std::vector<std::string>& arguments,
        int deviceID, cudaStream_t stream);
      virtual void setStep(int64_t step) { m_step = step; }
      void setMaster(std::shared_ptr<CudaGlobalMasterServer> master) {
        m_master = master;
      }
      void subscribe(std::shared_ptr<CudaGlobalMasterServer> master);
      void unsubscribe();
      std::string name() { return m_name; }
      virtual void onBuffersUpdated() {}
      virtual void calculate() {}
      virtual bool requestedAtomsChanged() = 0;
      virtual bool requestedTotalForcesAtomsChanged() = 0;
      virtual bool requestedForcedAtomsChanged() = 0;
      virtual bool requestUpdateAtomPositions() = 0;
      virtual bool requestUpdateAtomTotalForces() = 0;
      virtual bool requestUpdateForcedAtoms() = 0;
      virtual bool requestUpdateMasses() = 0;
      virtual bool requestUpdateCharges() = 0;
      virtual bool requestUpdateLattice() = 0;
      virtual bool requestUpdateTransforms() { return false; }
      virtual bool requestUpdateVelocities() { return false; }
      virtual double *getAppliedForces() const = 0;
      virtual double *getPositions() = 0;
      virtual float *getMasses() = 0;
      virtual float *getCharges() = 0;
      virtual double *getTotalForces() = 0;
      virtual double *getLattice() = 0;
      virtual char *getTransforms() { return nullptr; }
      virtual double *getVelocities() { return nullptr; }
      virtual int updateFromTCLCommand(const std::vector<std::string>& arguments);
      virtual std::string getTCLUpdateResult();
      bool tclAvailable() const;
      void finishReductions(bool doEnergy, bool doVirial, SubmitReduction *reduction);
      virtual const std::vector<AtomID> &getRequestedAtoms() const = 0;
      virtual const std::vector<AtomID> &getRequestedTotalForcesAtoms() const = 0;
      virtual const std::vector<AtomID> &getRequestedForcedAtoms() const = 0;

    protected:
      virtual cudaStream_t getStream() = 0;
      virtual bool hasEnergy() const { return true; }
      virtual double getEnergy() const { return 0; }
      virtual bool hasVirial() const { return false; }
      virtual cudaTensor getVirial() const { return cudaTensor{0}; };
      virtual bool hasExtForce() const { return false; }
      virtual Vector getExtForce() const { return Vector{0}; };
      virtual bool useDefaultExtForceAndVirial() const { return true; };
      SimParameters* getSimParameters() const;
      Molecule* getMolecule() const;
      const Controller* getController() const;
      ScriptTcl* getScript();

      // APIs for future use for replica exchange
      bool replica_enabled() const;
      int replica_index() const;
      int num_replicas() const;
      void replica_comm_barrier();
      int replica_comm_recv(char* msg_data, int buf_len, int src_rep);
      int replica_comm_send(char* msg_data, int msg_len, int dest_rep);

    protected:
      std::weak_ptr<CudaGlobalMasterServer> m_master;
      std::string m_name;
      int m_device_id;
      int64_t m_step;
      cudaTensor *m_d_ExtVirial;
      Vector *m_d_ExtForce;
      cudaTensor *m_h_virial;
      Vector *m_h_ExtForce;
    #else
    public:
      CudaGlobalMasterClient();
    #endif // (defined(NAMD_CUDA) || defined(NAMD_HIP)) && defined(NODEGROUP_FORCE_REGISTER)
    };
  }
}

#endif // CUDAGLOBALMASTERCLIENT_H