ProcessorPrivate.C File Reference

#include "ProcessorPrivate.h"
#include "Debug.h"
#include "InfoStream.h"

Go to the source code of this file.

Functions
	CkpvDeclare (AtomMap *, AtomMap_instance)
	CkpvDeclare (BroadcastMgr *, BroadcastMgr_instance)
	CkpvDeclare (CollectionMaster *, CollectionMaster_instance)
	CkpvDeclare (CollectionMgr *, CollectionMgr_instance)
	CkpvDeclare (LdbCoordinator *, LdbCoordinator_instance)
	CkpvDeclare (Node *, Node_instance)
	CkpvDeclare (PatchMap *, PatchMap_instance)
	CkpvDeclare (PatchMgr *, PatchMgr_instance)
	CkpvDeclare (ProxyMgr *, ProxyMgr_instance)
	CkpvDeclare (ReductionMgr *, ReductionMgr_instance)
	CkpvDeclare (GlobalGPUMgr *, GlobalGPUMgr_instance)
	CkpvDeclare (SynchronousCollectives *, SynchronousCollectives_instance)
	CkpvDeclare (SequencerCUDA *, SequencerCUDA_instance)
	CkpvDeclare (PatchMgr *, PatchMap_patchMgr)
	CkpvDeclare (BOCgroup, BOCclass_group)
	CkpvDeclare (Communicate *, comm)
	CkpvDeclare (Sync *, Sync_instance)
	CkpvDeclare (infostream, iout_obj)
	CkpvDeclare (int, recv_data_idx)
	CkpvDeclare (int, recv_ack_idx)
	CkpvDeclare (int, recv_bcast_idx)
	CkpvDeclare (int, recv_red_idx)
	CkpvDeclare (int, recv_eval_command_idx)
	CkpvDeclare (int, recv_eval_result_idx)
	CkpvDeclare (int, recv_replica_dcd_init_idx)
	CkpvDeclare (int, recv_replica_dcd_data_idx)
	CkpvDeclare (int, recv_replica_dcd_ack_idx)
void	initializeReplicaConverseHandlers ()
void	ProcessorPrivateInit (void)

Function Documentation

CkpvDeclare() [1/27]

CkpvDeclare	(	AtomMap *	,
		AtomMap_instance
	)

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

CkpvDeclare() [2/27]

CkpvDeclare	(	BroadcastMgr *	,
		BroadcastMgr_instance
	)

CkpvDeclare() [3/27]

CkpvDeclare	(	CollectionMaster *	,
		CollectionMaster_instance
	)

CkpvDeclare() [4/27]

CkpvDeclare	(	CollectionMgr *	,
		CollectionMgr_instance
	)

CkpvDeclare() [5/27]

CkpvDeclare	(	LdbCoordinator *	,
		LdbCoordinator_instance
	)

CkpvDeclare() [6/27]

CkpvDeclare	(	Node *	,
		Node_instance
	)

CkpvDeclare() [7/27]

CkpvDeclare	(	PatchMap *	,
		PatchMap_instance
	)

CkpvDeclare() [8/27]

CkpvDeclare	(	PatchMgr *	,
		PatchMgr_instance
	)

CkpvDeclare() [9/27]

CkpvDeclare	(	ProxyMgr *	,
		ProxyMgr_instance
	)

CkpvDeclare() [10/27]

CkpvDeclare	(	ReductionMgr *	,
		ReductionMgr_instance
	)

CkpvDeclare() [11/27]

CkpvDeclare	(	GlobalGPUMgr *	,
		GlobalGPUMgr_instance
	)

CkpvDeclare() [12/27]

CkpvDeclare	(	SynchronousCollectives *	,
		SynchronousCollectives_instance
	)

CkpvDeclare() [13/27]

CkpvDeclare	(	SequencerCUDA *	,
		SequencerCUDA_instance
	)

CkpvDeclare() [14/27]

CkpvDeclare	(	PatchMgr *	,
		PatchMap_patchMgr
	)

CkpvDeclare() [15/27]

CkpvDeclare	(	BOCgroup	,
		BOCclass_group
	)

CkpvDeclare() [16/27]

CkpvDeclare	(	Communicate *	,
		comm
	)

CkpvDeclare() [17/27]

CkpvDeclare	(	Sync *	,
		Sync_instance
	)

CkpvDeclare() [18/27]

CkpvDeclare	(	infostream	,
		iout_obj
	)

CkpvDeclare() [19/27]

CkpvDeclare	(	int	,
		recv_data_idx
	)

CkpvDeclare() [20/27]

CkpvDeclare	(	int	,
		recv_ack_idx
	)

CkpvDeclare() [21/27]

CkpvDeclare	(	int	,
		recv_bcast_idx
	)

CkpvDeclare() [22/27]

CkpvDeclare	(	int	,
		recv_red_idx
	)

CkpvDeclare() [23/27]

CkpvDeclare	(	int	,
		recv_eval_command_idx
	)

CkpvDeclare() [24/27]

CkpvDeclare	(	int	,
		recv_eval_result_idx
	)

CkpvDeclare() [25/27]

CkpvDeclare	(	int	,
		recv_replica_dcd_init_idx
	)

CkpvDeclare() [26/27]

CkpvDeclare	(	int	,
		recv_replica_dcd_data_idx
	)

CkpvDeclare() [27/27]

CkpvDeclare	(	int	,
		recv_replica_dcd_ack_idx
	)

initializeReplicaConverseHandlers()

void initializeReplicaConverseHandlers

(

)

Definition at line 252 of file DataExchanger.C.

References recvAck(), recvBcast(), recvData(), recvEvalCommand(), recvEvalResult(), recvRed(), recvReplicaDcdAck(), recvReplicaDcdData(), and recvReplicaDcdInit().

Referenced by ProcessorPrivateInit().

                                         {
  CkpvInitialize(int, recv_data_idx);
  CkpvInitialize(int, recv_ack_idx);
  CkpvInitialize(int, recv_bcast_idx);
  CkpvInitialize(int, recv_red_idx);
  CkpvInitialize(int, recv_eval_command_idx);
  CkpvInitialize(int, recv_eval_result_idx);
  CkpvInitialize(int, recv_replica_dcd_init_idx);
  CkpvInitialize(int, recv_replica_dcd_data_idx);
  CkpvInitialize(int, recv_replica_dcd_ack_idx);

  CkpvAccess(recv_data_idx) = CmiRegisterHandler((CmiHandler)recvData);                   
  CkpvAccess(recv_ack_idx) = CmiRegisterHandler((CmiHandler)recvAck);                     
  CkpvAccess(recv_red_idx) = CmiRegisterHandler((CmiHandler)recvRed);                     
  CkpvAccess(recv_bcast_idx) = CmiRegisterHandler((CmiHandler)recvBcast);                 
  CkpvAccess(recv_eval_command_idx) = CmiRegisterHandler((CmiHandler)recvEvalCommand);    
  CkpvAccess(recv_eval_result_idx) = CmiRegisterHandler((CmiHandler)recvEvalResult);      
  CkpvAccess(recv_replica_dcd_init_idx) = CmiRegisterHandler((CmiHandler)recvReplicaDcdInit);
  CkpvAccess(recv_replica_dcd_data_idx) = CmiRegisterHandler((CmiHandler)recvReplicaDcdData);
  CkpvAccess(recv_replica_dcd_ack_idx) = CmiRegisterHandler((CmiHandler)recvReplicaDcdAck);

#if CMK_IMMEDIATE_MSG && CMK_SMP && ! ( CMK_MULTICORE || CMK_SMP_NO_COMMTHD )
  int sleep_commthd_idx = CmiRegisterHandler((CmiHandler)recvSleepCommthdMsg);
  if ( CkMyPe() == 0 && CkNumNodes() == 1 ) {
    CkPrintf("Charm++ communication thread will sleep due to single-process run.\n");
    SleepCommthdMsg *msg = (SleepCommthdMsg *)malloc(sizeof(SleepCommthdMsg));
    CmiSetHandler(msg, sleep_commthd_idx);
    CmiBecomeImmediate(msg);
    CmiPushImmediateMsg(msg);
  }
#endif
}

ProcessorPrivateInit()

void ProcessorPrivateInit

(

void

)

Definition at line 66 of file ProcessorPrivate.C.

References initializeReplicaConverseHandlers().

Referenced by all_init().

{
  CkpvInitialize(AtomMap*, AtomMap_instance);
  CkpvAccess(AtomMap_instance) = 0;
  CkpvInitialize(BroadcastMgr*, BroadcastMgr_instance);
  CkpvAccess(BroadcastMgr_instance) = 0;
  CkpvInitialize(CollectionMaster*, CollectionMaster_instance);
  CkpvAccess(CollectionMaster_instance) = 0;
  CkpvInitialize(CollectionMgr*, CollectionMgr_instance);
  CkpvAccess(CollectionMgr_instance) = 0;
  CkpvInitialize(LdbCoordinator*, LdbCoordinator_instance);
  CkpvAccess(LdbCoordinator_instance) = 0;
  CkpvInitialize(Node*, Node_instance);
  CkpvAccess(Node_instance) = 0;

  CkpvInitialize(PatchMap*, PatchMap_instance);
  CkpvAccess(PatchMap_instance) = 0;
  CkpvInitialize(PatchMgr*, PatchMgr_instance);
  CkpvAccess(PatchMgr_instance) = 0;
  CkpvInitialize(ProxyMgr*, ProxyMgr_instance);
  CkpvAccess(ProxyMgr_instance) = 0;
  CkpvInitialize(ReductionMgr*, ReductionMgr_instance);
  CkpvAccess(ReductionMgr_instance) = 0;
  CkpvInitialize(PatchMgr*, PatchMap_patchMgr);
  CkpvAccess(PatchMap_patchMgr) = 0;
  CkpvInitialize(BOCgroup, BOCclass_group);
  CkpvAccess(BOCclass_group).dataExchanger.setZero();
  CkpvInitialize(Communicate*, comm);
  CkpvAccess(comm) = 0;
  CkpvInitialize(Sync*, Sync_instance);
  CkpvAccess(Sync_instance) = 0;
  CkpvInitialize(infostream, iout_obj);
  initializeReplicaConverseHandlers();

#if defined(NAMD_CUDA) || defined(NAMD_HIP)
  CkpvInitialize(GlobalGPUMgr*, GlobalGPUMgr_instance);
  CkpvAccess(GlobalGPUMgr_instance) = 0;
  CkpvInitialize(SynchronousCollectives*, SynchronousCollectives_instance);
  CkpvAccess(SynchronousCollectives_instance) = 0;
  CkpvInitialize(SequencerCUDA*, SequencerCUDA_instance);
  CkpvAccess(SequencerCUDA_instance) = 0;
#endif

#ifdef PROCTRACE_DEBUG
  CkpvInitialize(DebugFileTrace*, DebugFileTrace_instance);
  CkpvAccess(DebugFileTrace_instance) = 0;
#endif

#ifdef NODEGROUP_FORCE_REGISTER
  CkpvInitialize(ComputeGlobalResultsMsg*, ComputeGlobalResultsMsg_instance);
  CkpvAccess(ComputeGlobalResultsMsg_instance) = nullptr;
#endif

}