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