vtkProcessModule.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkProcessModule_h
#define vtkProcessModule_h
 
#include "vtkNew.h" // needed for vtkNew
#include "vtkObject.h"
#include "vtkRemotingCoreModule.h" //needed for exports
#include "vtkSmartPointer.h"       // needed for vtkSmartPointer.
 
#include <string> // for std::string
 
class vtkInformation;
class vtkMultiProcessController;
class vtkNetworkAccessManager;
class vtkProcessModuleInternals;
class vtkSession;
class vtkSessionIterator;
class vtkThreadedCallbackQueue;
 
class VTKREMOTINGCORE_EXPORT vtkProcessModule : public vtkObject
{
public:
  static vtkProcessModule* New();
  vtkTypeMacro(vtkProcessModule, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum ProcessTypes
  {
    PROCESS_CLIENT,        /* Capable of connecting to remote server or self.
                      Cannot run in Parallel */
    PROCESS_SERVER,        /* data-server+render-server */
    PROCESS_DATA_SERVER,   /* data-server */
    PROCESS_RENDER_SERVER, /* render-server */
    PROCESS_BATCH,         /* Capable of running in parallel with root node acting as client.
                      Cannot connect to remote server */
    PROCESS_INVALID = -1,
  };
 
  enum ServerFlags
  {
    DATA_SERVER = 0x01,
    DATA_SERVER_ROOT = 0x02,
    RENDER_SERVER = 0x04,
    RENDER_SERVER_ROOT = 0x08,
    SERVERS = DATA_SERVER | RENDER_SERVER,
    CLIENT = 0x10,
    CLIENT_AND_SERVERS = DATA_SERVER | CLIENT | RENDER_SERVER
  };
 
  static ProcessTypes GetProcessType();
  static unsigned int GetProcessTypeAsInt()
  {
    return static_cast<unsigned int>(vtkProcessModule::GetProcessType());
  }
 
  void UpdateProcessType(ProcessTypes newType, bool dontKnowWhatImDoing = true);
 
  //********** PROCESS INITIALIZATION/CLEANUP API *****************************
 
  static bool Initialize(ProcessTypes type, int& argc, char**& argv);
 
  static bool Finalize();
 
  //********** SESSION MANAGEMENT API *****************************
 
  vtkIdType RegisterSession(vtkSession*);
 
 
  bool UnRegisterSession(vtkIdType sessionID);
  bool UnRegisterSession(vtkSession* session);
 
 
  vtkGetMacro(EventCallDataSessionId, vtkIdType);
 
  vtkSession* GetSession(vtkIdType);
 
  vtkIdType GetSessionID(vtkSession*);
 
  vtkSessionIterator* NewSessionIterator();
 
  vtkSession* GetActiveSession();
 
  vtkSession* GetSession();
 
 
  vtkGetMacro(MultipleSessionsSupport, bool);
  vtkSetMacro(MultipleSessionsSupport, bool);
  vtkBooleanMacro(MultipleSessionsSupport, bool);
 
  //********** ACCESSORS FOR VARIOUS HELPERS *****************************
 
  static vtkProcessModule* GetProcessModule();
 
  //********** ACCESSORS FOR VARIOUS HELPERS *****************************
 
 
  vtkGetObjectMacro(NetworkAccessManager, vtkNetworkAccessManager);
  void SetNetworkAccessManager(vtkNetworkAccessManager*);
 
  vtkMultiProcessController* GetGlobalController();
 
  int GetNumberOfLocalPartitions();
 
  int GetPartitionId();
 
  bool IsMPIInitialized();
 
 
  vtkGetMacro(ReportInterpreterErrors, bool);
  vtkSetMacro(ReportInterpreterErrors, bool);
  vtkBooleanMacro(ReportInterpreterErrors, bool);
 
  static bool GetSymmetricMPIMode();
 
  const std::string& GetProgramPath() const { return this->ProgramPath; }
  const std::string& GetSelfDir() const { return this->SelfDir; }
 
 
  static void SetDefaultMinimumGhostLevelsToRequestForStructuredPipelines(int);
  static int GetDefaultMinimumGhostLevelsToRequestForStructuredPipelines();
  static void SetDefaultMinimumGhostLevelsToRequestForUnstructuredPipelines(int);
  static int GetDefaultMinimumGhostLevelsToRequestForUnstructuredPipelines();
 
  static int GetNumberOfGhostLevelsToRequest(vtkInformation* outInfo);
 
  vtkThreadedCallbackQueue* GetCallbackQueue();
 
protected:
  vtkProcessModule();
  ~vtkProcessModule() override;
 
 
  void PushActiveSession(vtkSession*);
  void PopActiveSession(vtkSession*);
 
  friend class vtkSession;
 
  vtkNetworkAccessManager* NetworkAccessManager;
 
  vtkIdType MaxSessionId;
 
  void SetExecutablePath(const std::string& path);
 
  vtkProcessModuleInternals* Internals;
 
  // vtkSessionIterator needs access to vtkInternals to be able to iterate over
  // the sessions efficiently.
  friend class vtkSessionIterator;
 
  bool ReportInterpreterErrors;
 
private:
  vtkProcessModule(const vtkProcessModule&) = delete;
  void operator=(const vtkProcessModule&) = delete;
 
  void DetermineExecutablePath(int argc, char** argv);
 
  // Helper to initialize Python environment. This doesn't initialize Python
  // but simply sets up the environment so when Python is initialized, it can
  // find ParaView modules. This does nothing if not build with Python support.
  bool InitializePythonEnvironment();
 
  static ProcessTypes ProcessType;
 
  // Set to true in Initialize if Finalize() should cleanup MPI.
  static bool FinalizeMPI;
 
  // Set to true in InitializePythonEnvironment() if Finalize() should cleanup
  // Python.
  static bool FinalizePython;
 
  static vtkSmartPointer<vtkProcessModule> Singleton;
  static vtkSmartPointer<vtkMultiProcessController> GlobalController;
 
  bool MultipleSessionsSupport;
 
  vtkIdType EventCallDataSessionId;
 
  std::string ProgramPath;
  std::string SelfDir;
 
  static int DefaultMinimumGhostLevelsToRequestForStructuredPipelines;
  static int DefaultMinimumGhostLevelsToRequestForUnstructuredPipelines;
};
 
#endif // vtkProcessModule_h