| __ammasso_buffer | |
| __ammasso_private_data | |
| __ammasso_stats | |
| __ammasso_tailer | |
| __ammasso_token | |
| __ammasso_token_description | |
| __cmi_idle_state | |
| __context_block | |
| __dma_list_entry | DMAListEntry : A structure that contains a single entry of a DMA list |
| __simdia_vec_f | |
| __simdia_vec_i | |
| __simdia_vec_lf | |
| __SPE_DATA | |
| __SPE_MESSAGE | |
| __SPE_NOTIFY | |
| __spe_thread | An SPE Thread structures which is Used to maintain information about a particular SPE thread that is running on an SPE |
| __work_request | WorkRequest is used to keep track of and access outstanding work requests |
| __wr_group | WRGroup is used to specify a collection of Work Requests |
| _ArrInitMsg | |
| _btreenode | |
| _bucket_list_t | |
| _ccd_callback | Structure to hold the requisites for a callback |
| _ccd_cblist | A list of callbacks stored as an array and handled like a list |
| _ccd_cblist_elem | An element (a single callback) in a list of callbacks |
| _CkCacheUserData | |
| _CkErrStream | |
| _CkFuture | |
| _ckGroupID | |
| _CkOStream | |
| _CkOutStream | |
| _CkSectionInfoStruct | Structure that holds info relevant to the use of an array/group section |
| _CkSectionInfoStruct::section_type | Info needed by the section comm managers |
| _CkSectionInfoStruct::section_type::commlibInfo | |
| _CkSectionInfoStruct::section_type::sec_mcast | |
| _ckSemaID | |
| _CmiObjId | |
| _CreateStatCollMsg | |
| _dllnode | |
| _DMsg | |
| _DummyMsg | |
| _group_list_t | |
| _GroupInfo | |
| _heap_info | |
| _hostnameMsg | |
| _insert_ret_val | |
| _LDCommDesc | |
| _LDObjid | |
| _LDObjKey | |
| _LDOMid | |
| _list | |
| _nodeTopoMsg | |
| _ObjectID | |
| _ObjectID::s_array | |
| _pageentry | |
| _PencilArrayInfo | |
| _PencilBlock | |
| _PencilType | |
| _PersistentDestoryMsg | |
| _PersistentReqGrantedMsg | |
| _PersistentRequestMsg | |
| _procInfo | |
| _rankMsg | |
| _RedMsg | |
| _RefineChkMsg | |
| _RefineMsg | |
| _roatom< dtype > | |
| _Slot | Struct Slot contains all of the information about a malloc buffer except for the contents of its memory |
| _slotblock | |
| _slotmsg | |
| _slotset | |
| _SlotStack | |
| _speedmsg | |
| _StatCollMsg | |
| _tree_t | |
| AAMLearner | |
| AAPLearner | |
| PUP::able | |
| PUP::able::PUP_ID | |
| xi::AccelBlock | |
| MSA::accum< T, D > | |
| MSA::accum_cache_line< T > | |
| MSA::Accumulable< MSA > | |
| adapt | |
| adapt2 | |
| adapt3 | |
| adapt4 | |
| adapt5 | |
| adaptAdj | |
| adaptAdjMsg | |
| addElemMsg | A message to pack all data to tell a remote chunk to add an element |
| addGhostElemMsg | A message to tell a remote chunk to add a ghost element (all data is packed) |
| addNodeMsg | A message to pack all the data needed to tell a remote chunk to add a new node |
| AddressMsg | |
| ADIO_cb_name_arrayD | |
| ADIO_Fcntl_t | |
| ADIOI_Access | |
| ADIOI_Async | |
| ADIOI_FileD | |
| ADIOI_Fl_node | |
| ADIOI_Fns_struct | |
| ADIOI_Hints_struct | |
| ADIOI_Malloc_async_ptr | |
| ADIOI_Malloc_req_ptr | |
| ADIOI_Req_n | |
| ADIOI_RequestD | |
| adjacency_t | |
| adjElem | |
| adjNode | |
| adjReply | |
| adjRequest | |
| Agent | |
| Agent::_Elem | |
| alloc_struct | |
| AllocTable2d< T > | A heap-allocatable, resizable BasicTable2d |
| allocVector | Tiny, silly utility class for dynamically allocating vectors |
| AllreduceMgr | |
| AllToAllHdr | |
| ampi | |
| ampiCommStruct | |
| AmpiComplex | |
| AmpiCounters | |
| AmpiMsg | |
| AmpiOtherElement | Our local representation of another AMPI array element |
| ampiParent | |
| AmpiRequest | Represents an MPI request that has been initiated using Isend, Irecv, Ialltoall, Send_init, etc |
| AmpiRequestList | Special CkVec<AmpiRequest*> for AMPI. Most code copied from cklist.h |
| AmpiSeqQ | |
| ampiSplitKey | |
| ampiWorlds | This group is used to broadcast the MPI_COMM_UNIVERSE communicators |
| AmrCoordinator | |
| AmrUserData | |
| armci_giov_t | |
| Armci_Note | |
| ArmciMsg | |
| ArmciStridedMsg | |
| ArmciVirtualProcessor | |
| xi::Array | |
| ArrayElement | An array element is a chare that lives inside the array |
| ArrayElement_initInfo | |
| ArrayElementT< T > | An ArrayElementT is a utility class where you are constrained to a "thisIndex" of some fixed-sized type T |
| arrayMapInfo | Class used to store the dimensions of the array and precalculate numChares, binSize and other values for the DefaultArrayMap -- ASB |
| ArrayPtrT< T > | Smart pointer-to-new[]'d array-of-T |
| arrInfo | |
| PUP::as_bytes< T > | Traits class: decide if the type T can be safely pupped as raw bytes |
| ATAReq | |
| ATAReq::Request | |
| balanceData | |
| BalanceSpecs | |
| barrier | |
| BaseLB | Base class for all LB strategies |
| BaseLB::LDStats | Passed to the virtual functions Strategy( |
| BaseLB::ProcStats | |
| BasicTable2d< T > | This is a simple 2D table |
| bbox3d | |
| BCapplier | Wrapper for user matrix-vector multiply that applies "essential" boundary conditions |
| BGLTorusManager | |
| BGPTorusManager | |
| BinEntry | Bin entry record CPU time in an interval |
| BitVec | |
| BitVectorIterator< T > | |
| block | |
| block_header_ | |
| blockDim | |
| BlockLB | |
| blockLoc | |
| BlockMap | |
| blockSpan | |
| boolMsg | A Message to encapsulate a boolean |
| Boomarray< T > | |
| BQueue | Class to handle the boundaries of child partitions |
| BroadcastStrategy | Broadcast strategy for charm++ programs using the net version |
| BThreshold | |
| bucket_t | |
| Ck::IO::buffer | |
| buffer | |
| BufferedLocalLogHeader | |
| bufferT< T > | |
| Builtin_kvs | |
| xi::BuiltinType | |
| Bulk_Adapt | Provides high level adaptivity operations |
| BulkAdapt | This shadow array is attached to a partition to perform bulk adaptivity |
| BV_Set | |
| MSA::cache_line< T > | |
| callBack | Class for user-specified callback |
| callbackMsg | |
| callSystemStruct | Used to ship around system calls |
| CancelList | A list of event cancellations |
| cancelMsg | Cancellation message |
| CancelNode | A single event cancellation |
| CBase_ampi | |
| CBase_ampiParent | |
| CBase_ampiWorlds | |
| CBase_BaseLB | |
| CBase_BThreshold | |
| CBase_CkCacheManager | |
| CBase_ckcallback_group | |
| CBase_ckcallback_main | |
| CBase_CkCheckpointMgr | |
| CBase_CkMemCheckPT | |
| CBase_collideMgr | |
| CBase_collideVoxel | |
| CBase_ComlibManagerMain | |
| CBase_CompletionDetector | |
| CBase_controlPointMain | |
| CBase_controlPointManager | |
| CBase_CpdPython | |
| CBase_CpdPythonGroup | |
| CBase_femMeshModify | |
| CBase_idaStarGroup | |
| CBase_idaStarWorker | |
| CBase_KMeansBOC | |
| CBase_LineFFTArray | |
| CBase_liveVizGroup | |
| CBase_liveVizPollArray | |
| CBase_LV3D0_Manager | |
| CBase_LV3D_Array | |
| CBase_LV3D_PerfManager | |
| CBase_Manager | |
| CBase_MBlockChunk | |
| CBase_MeshStreamer | |
| CBase_MeshStreamerClient | |
| CBase_MSA_CacheGroup | |
| CBase_MSA_PageArray | |
| CBase_NormalLineArray | |
| CBase_NormalRealSlabArray | |
| CBase_NormalSlabArray | |
| CBase_ParFUMShadowArray | |
| CBase_pathHistoryMain | |
| CBase_pathHistoryManager | |
| CBase_PythonCCS | |
| CBase_receiver | |
| CBase_redistributor2D | |
| CBase_SearchConductor | |
| CBase_SearchNode | |
| CBase_sim | |
| CBase_SlabArray | |
| CBase_SparseSlabArray | |
| CBase_syncReductionMgr | |
| CBase_TCharm | |
| CBase_threadCollideMgr | |
| CBase_TraceControlPointsBOC | |
| CBase_TraceProjectionsBOC | |
| CBase_TraceSimpleBOC | |
| CBase_TraceSummaryBOC | |
| CBase_TraceTauBOC | |
| CBase_TraceUtilizationBOC | |
| CBaseT1< Parent, CProxy_Derived > | |
| CBaseT2< Parent1, Parent2, CProxy_Derived > | |
| CBaseT3< Parent1, Parent2, Parent3, CProxy_Derived > | |
| CBaseT4< Parent1, Parent2, Parent3, Parent4, CProxy_Derived > | |
| CBaseT5< Parent1, Parent2, Parent3, Parent4, Parent5, CProxy_Derived > | |
| CBaseT6< Parent1, Parent2, Parent3, Parent4, Parent5, Parent6, CProxy_Derived > | |
| CBaseT7< Parent1, Parent2, Parent3, Parent4, Parent5, Parent6, Parent7, CProxy_Derived > | |
| CBaseT8< Parent1, Parent2, Parent3, Parent4, Parent5, Parent6, Parent7, Parent8, CProxy_Derived > | |
| CBaseT9< Parent1, Parent2, Parent3, Parent4, Parent5, Parent6, Parent7, Parent8, Parent9, CProxy_Derived > | |
| ccd_cond_callbacks | Lists of conditional callbacks that are maintained by the scheduler |
| ccd_heap_elem | Structure used to manage callbacks in a heap |
| ccd_periodic_callbacks | List of periodic callbacks maintained by the scheduler |
| CCounter | |
| CCS_AUTH_clients | |
| CCS_RAND_state | |
| CcsDelayedReply_struct | |
| CcsHandlerRec | |
| CcsImplHeader | |
| CcsMessageHeader | |
| CcsSec_secretKey | |
| CcsSecAttr | |
| CcsSecMan | |
| CcsServer | |
| CDep | This class hides all the details of dependencies between when blocks and entries |
| Cell | |
| Cell1D | |
| Cell2D | |
| Cell3D | |
| CentralLB | |
| CentralLB::FutureModel | |
| xi::CEntry | |
| Cfuture_data_s | |
| Cfuture_s | |
| CfutureValue_s | |
| cgSolver | Iterative Linear Solver: Conjugate Gradient method |
| xi::Chare | |
| Chare | The base class of all parallel objects in Charm++, including Array Elements, Groups, and NodeGroups |
| ChareInfo | Represents a class of Chares (or array or group elements) |
| ChareMlogData | This file includes the definition of the class for storing the meta data associdated with the message logging protocol |
| Charisma | |
| CharismaGraph | |
| CharismaInPort | |
| CharismaOutPort | |
| CharmMessageHolder | Class managing Charm++ messages in the communication library |
| CharmStrategy | All Charm++ communication library strategies should inherit from CharmStrategy, rather than inheriting from class Strategy (or one of its subclasses) |
| CheckpointBarrierMsg | |
| CheckPointDataMsg | |
| ChildInitMsg | |
| ChInfiAddr | |
| ChMessage | |
| ChMessageHeader | |
| ChMessageInt_t | |
| ChMessageLong_t | |
| ChNodeinfo | |
| chpt< StateType > | Templated checkpointing class derived from rep |
| ChSingleNodeinfo | |
| chunk | |
| chunk::elemHeap | |
| ChunkInfo | |
| chunkList | |
| chunkListMsg | A message to return data about the chunks that share/ghost a node/element |
| chunkMsg | |
| ChunkMulticastStrategy | |
| ChunkPipeTreeMulticastStrategy | A strategy that sends along a tree with user specified branching factor |
| ChunkRingMulticastStrategy | A strategy that sends along a ring through the destination processors |
| ChunkTreeMulticastStrategy | A strategy that sends along a tree with user specified branching factor |
| CircQueueStruct | The simple version of pcqueue has dropped the function of being expanded if the queue is full |
| CkArgMsg | CkArgMsg is passed to the mainchare's constructor |
| CkArray | |
| CkArrayBroadcaster | This arrayListener is in charge of delivering broadcasts to the array |
| CkArrayCheckPTMessage | |
| CkArrayCheckPTReqMessage | |
| CkArrayElementMigrateMessage | This is the message type used to actually send a migrating array element |
| CkArrayElementRangeIterator< T > | Count array elements going by until they reach this range (lo to hi), then start passing them to dest |
| CkArrayID | |
| CkArrayIndex | Actual array index class intended for regular use |
| CkArrayIndex1D | Simple ArrayIndex classes: the key is just integer indices |
| CkArrayIndex2D | |
| CkArrayIndex3D | |
| CkArrayIndex4D | |
| CkArrayIndex5D | |
| CkArrayIndex6D | |
| CkArrayIndexBase | Base class for array index objects used in charm |
| CkArrayIndexBitVec | |
| CkArrayIndexCharisma | |
| CkArrayIndexT< object > | A slightly more complex array index: the key is an object whose size is fixed at compile time |
| CkArrayListener | |
| CkArrayMap | The "map" is used by the array manager to map an array index to a home processor number |
| CkArrayMessage | |
| CkArrayOptions | Arguments for array creation: |
| CkArrayReducer | This arrayListener is in charge of performing reductions on the array |
| CkArrayReductionMgr | |
| CkArrayThreadListener | |
| CkArrMgr | Abstract superclass of all array manager objects |
| CkAxes3d | X, Y, and Z axes: a right-handed frame, used for navigation |
| CkBbox3d | |
| CkBitVector | |
| CkCacheArrayCounter | |
| CkCacheEntry | |
| CkCacheEntryType | |
| CkCacheFillMsg | |
| CkCacheManager | |
| CkCacheRequestMsg | |
| CkCacheRequestorData | |
| CkCacheStatistics | |
| CkCallback | |
| CkCallback::callbackData | |
| CkCallback::callbackData::s_array | |
| CkCallback::callbackData::s_c1fn | |
| CkCallback::callbackData::s_ccsReply | |
| CkCallback::callbackData::s_cfn | |
| CkCallback::callbackData::s_chare | |
| CkCallback::callbackData::s_group | |
| CkCallback::callbackData::s_section | |
| CkCallback::callbackData::s_thread | |
| ckcallback_group | |
| ckcallback_main | |
| CkCallbackPython | |
| CkCallbackResumeThread | Convenience class: a thread-suspending callback |
| CkCcsRequestMsg | Message sent from CCS to callbacks |
| CkChareID | |
| CkCheckpointInit | |
| CkCheckpointMgr | There is only one Checkpoint Manager in the whole system |
| CkCheckPTInfo | |
| CkCompactVec< T > | |
| ckcomplex | |
| CkConditional | |
| CkCoreState | All the state that's useful to have on the receive side in the Charm Core (ck.C) |
| CkCppInterpreter | An interpreter for C++ code |
| CkDataMsg | Very generic message type: contains a bunch of bytes |
| CkDataSegHeader | |
| CkDelegateData | Per-proxy data storage for delegation |
| CkDelegateMgr | Message delegation support, where you send a message via a proxy normally, but the message ends up routed via this special delegateMgr group |
| CkDiskCheckPTInfo | |
| CkDll | Abstraction for a DLL (Dynamically Linked Library) that is linked in to the running program |
| CkElementEvacuate | |
| CkElementInformHome | |
| CkErrStream | |
| CkFixedViewable | This trivial viewable always shows a fixed quadview, regardless of the viewpoint--that is, it's just a single, fixed-texture polygon |
| CkGroupCallbackMsg | |
| CkGroupInitCallback | |
| CkGroupReadyCallback | |
| CkHalfspace3d | |
| CkHashtable | A resize-on-demand extensible hashtable |
| CkHashtableAdaptorT< T > | A useful adaptor class for using basic (memory only) types like int, short, char, etc |
| CkHashtableIterator | |
| CkHashtableLayout | Describes the in-memory layout of a hashtable entry |
| CkHashtableT< KEY, OBJ > | |
| CkHashtableTslow< KEY, OBJ > | This class provides a thin typesafe layer over the (unsafe) CkHashtable above |
| CkImageCompressor | Performs a simple zero-encoding of blank image pixels at each end of the image scanlines |
| CkIndex2D | |
| CkIndex3D | |
| CkIndex4D | |
| CkIndex5D | |
| CkIndex6D | |
| CkIndex_ArrayBase | |
| CkIndex_Group | |
| CkIndexMax | |
| CkInPort< d > | |
| CkInPortArray< d > | |
| CkInPortMsg< d > | |
| CkInPortString | |
| CkInPortVoid | |
| CkInStream | |
| CkInterestSet | Describes a set of "interest points": 3d locations in space that lie on important object features |
| CkInterestViewable | A CkInterestViewable is a viewable whose reprojection (view coherence) is characterized by a set of "interest points" |
| CkLBArgs | |
| CkLBOptions | |
| CkListString | |
| CkLocation | The "data" class passed to a CkLocIterator, which refers to a bound glob of array elements |
| CkLocIterator | This interface describes the destination for an iterator over the locations in an array |
| CkLocMgr | A group which manages the location of an indexed set of migratable objects |
| CkLocMgr::ManagerRec | |
| CkLocRec | A CkLocRec is our local representation of an array element |
| CkLocRec_aging | This is the abstract superclass of arrayRecs that keep track of their age, and eventually expire |
| CkLocRec_buffering | Buffers messages until record is replaced in the hash table, then delivers all messages to the replacing record |
| CkLocRec_dead | Represents a deleted array element (and prevents re-use) |
| CkLocRec_local | Represents a local array element |
| CkLocRec_remote | Represents a remote array element |
| CkMagicNumber< T > | |
| CkMagicNumber_impl | A tiny class for detecting heap corruption |
| CkMapsInit | |
| CkMarshalledCLBStatsMessage | |
| CkMarshalledMessage | |
| CkMarshalledNLBStatsMessage | |
| CkMarshallMsg | |
| CkMatrix3d | A 4x4 matrix |
| CkMcastBaseMsg | CkMcastBaseMsg is the base class for all multicast messages |
| CkMemCheckPT | |
| CkMemCheckPTInfo | |
| CkMemCheckPTInit | |
| CkMessage | |
| CkMessageDetailRecorder | |
| CkMessageDetailReplay | |
| CkMessageRecorder | |
| CkMessageReplay | |
| CkMessageWatcher | Message watcher: for record/replay support |
| CkMigratable | |
| CkMigratable_initInfo | This tiny class is used to convey information to the newly created CkMigratable object when its constructor is called |
| CkMigratableList | Stores a list of array elements |
| CkMigratableListT< T > | A typed version of the above |
| CkMigrateMessage | |
| CkMsgQ< MSG > | |
| CkMulticastMgr | A multicast manager group that is a CkDelegateMgr |
| CkMulticastMgr::IndexPos | Internal class for the (array index, location) pair |
| CkMultiPool< type > | CkMultiPool allows the user to have both a default queue, and specific queues from which to allocate |
| CkNodeReductionMgr | |
| CkNoncopyable | |
| CkObjectMsgQ | |
| CkObjectRangeIterator< T > | Count charm++ objects going by until they reach this range (lo to hi), then start passing them to dest |
| CkObjID | |
| CkOStream | |
| CkOutPort< d > | |
| CkOutPortArray< d > | |
| CkOutPortMsg< d > | |
| CkOutPortString | |
| CkOutPortVoid | |
| CkOutStream | |
| CkPagedVector< T > | An array that is broken up into "pages" which are separately allocated |
| CkPointer< T > | |
| CkPool< type, sz > | CkPool has one single static queue per processor that maintains the already allocated buffers |
| CkPoolQueue< type > | A queue for CkMultiPool, templated with the type it handles, and the number of objects allocated in a single chunk |
| CkProcCheckPTMessage | |
| ckptClientStruct | |
| CkPupAblePtr< T > | Helper for smart pointer classes: copy a PUP::able pointer |
| CkPupAblePtrVec< T > | A vector of pointers-to-subclasses of a PUP::able parent |
| CkPupAllocatePtr< T > | Helper for smart pointer classes: allocate a new copy when pup'd |
| CkPupAlwaysAllocatePtr< T > | Helper for smart pointer classes: allocate a new copy when pup'd |
| CkPupPtrVec< T, PUP_PTR > | A vector of zero-initialized heap-allocated objects of type T |
| CkQ< T > | A single-ended FIFO queue |
| CkQdMsg | |
| CkQuadView | The simplest kind of CkView: a single, flat quadrilateral OpenGL texture |
| CkRay | A start point and a direction |
| CkRect | |
| CkReduction | |
| CkReduction::setElement | |
| CkReductionClientBundle | Tiny utility class used by CkReductionClientAdaptor-- lets us keep backward compatability with the old C-style interface |
| CkReductionMgr | |
| CkReductionMsg | |
| CkReductionNumberMsg | |
| CkReference< T > | |
| CkReferenceCounted | |
| CkRegisteredInfo< T > | This class stores registered entities, like EntryInfo's, in a linear list indexed by index ("idx") |
| CkSampleT< real, ret > | CkSampleT represents a statistical "sample" of some data values |
| CkSectionID | A class that holds complete info about an array/group section |
| CkSectionInfo | |
| CkSema | |
| CkSemaPool | |
| CkSequence< T > | Data Structure to store a sequence of any type, typically int, short, long etc |
| CkSequenceFactory< T > | Factory that creates different kinds of CkSequences |
| CkSequenceInternal< T > | Interface(Abstract class) for the Internal implementation of the CkSequence |
| CkSequenceIterator< T > | Iterates over the elements in the CkSequence |
| CkSequenceIteratorInternal< T > | Interface(Abstract Class) for the Internal implementation of the Iterator |
| CkShortStr | |
| CkSkipInitialization | "Flag" class: do not initialize this object |
| CkSparseContiguousReducer< T > | |
| CkSparseReducer1D< T > | |
| CkSparseReducer2D< T > | |
| CkSparseReducer3D< T > | |
| CkSTLHelper< T > | |
| CkThrCallArg | |
| CkThresholdTimer | Time a sequence of operations, printing out the names and times of any operations that exceed a threshold |
| CkTwoDoubles | |
| CkTwoFloats | |
| CkVec< T > | A typesafe, automatically growing array |
| CkVector3dT< real > | |
| CkVerboseListener | |
| CkView | A CkView is a texture image that can stand in for a CkViewable |
| CkViewable | An object that can be "viewed"-- turned into an image |
| CkViewableID | A CkViewableID uniquely identifies a CkViewable across processors |
| CkViewConsumer | A CkViewConsumer accepts CkView's from viewables |
| CkViewpoint | Describes a method for converting universe locations to screen pixels and back again: a projection matrix |
| CkViewPrioHolder | Holds a view in the priority heap |
| CkViewPrioSorter | Stores a set of view messages:
- Sorts outgoing views by priority
|
| CkZeroPtr< T, PUP_PTR > | A not-so-smart smart pointer type: just zero initialized |
| CLA | This little list of CLA's holds the argument descriptions until it's safe to print them--it's needed because the net- versions don't have printf until they're pretty well started |
| xi::ClassDeclaration | |
| CLBStatsMsg | |
| CldMap | Map object-- use seed load balancer |
| CldNeighborData | |
| CldProcInfo_s | |
| CldProcPriorInfo_s | |
| CldSlavePriorInfo_s | |
| CldToken_s | |
| Cluster_Data_T | |
| CMessage__ArrInitMsg | |
| CMessage__CreateStatCollMsg | |
| CMessage__DMsg | |
| CMessage__DummyMsg | |
| CMessage__RedMsg | |
| CMessage__RefineChkMsg | |
| CMessage__RefineMsg | |
| CMessage__StatCollMsg | |
| CMessage_adaptAdjMsg | |
| CMessage_addElemMsg | |
| CMessage_addGhostElemMsg | |
| CMessage_addNodeMsg | |
| CMessage_AddressMsg | |
| CMessage_AmpiMsg | |
| CMessage_ArmciMsg | |
| CMessage_ArmciStridedMsg | |
| CMessage_BalanceSpecs | |
| CMessage_boolMsg | |
| CMessage_callBack | |
| CMessage_callbackMsg | |
| CMessage_cancelMsg | |
| CMessage_ChildInitMsg | |
| CMessage_chunkListMsg | |
| CMessage_chunkMsg | |
| CMessage_CkArgMsg | |
| CMessage_CkArrayCheckPTMessage | |
| CMessage_CkArrayCheckPTReqMessage | |
| CMessage_CkArrayElementMigrateMessage | |
| CMessage_CkCacheFillMsg | |
| CMessage_CkCacheRequestMsg | |
| CMessage_CkCcsRequestMsg | |
| CMessage_CkDataMsg | |
| CMessage_CkGroupCallbackMsg | |
| CMessage_CkMarshallMsg | |
| CMessage_CkMessage | |
| CMessage_CkProcCheckPTMessage | |
| CMessage_CkReductionMsg | |
| CMessage_CkReductionNumberMsg | |
| CMessage_ComlibDummyMsg | |
| CMessage_ComlibMulticastMsg | |
| CMessage_controlPointMsg | |
| CMessage_cookieMsg | |
| CMessage_coordMsg | |
| CMessage_countMsg | |
| CMessage_destMsg | |
| CMessage_double2Msg | |
| CMessage_doubleMsg | |
| CMessage_elemDataMsg | |
| CMessage_entDataMsg | |
| CMessage_eventMsg | |
| CMessage_faceMsg | |
| CMessage_femMeshModMsg | |
| CMessage_FEMMeshMsg | |
| CMessage_FileReadyMsg | |
| CMessage_findgsMsg | |
| CMessage_flip23request | |
| CMessage_flip23response | |
| CMessage_flip32request | |
| CMessage_flip32response | |
| CMessage_FP | |
| CMessage_FutureInitMsg | |
| CMessage_GVTMsg | |
| CMessage_int2Msg | |
| CMessage_intMsg | |
| CMessage_KMeansStatsMessage | |
| CMessage_KSeedsMessage | |
| CMessage_KSelectionMessage | |
| CMessage_LBMigrateMsg | |
| CMessage_LBVectorMigrateMsg | |
| CMessage_LEsplitMsg | |
| CMessage_LEsplitResult | |
| CMessage_LineFFTGridMsg | |
| CMessage_liveVizRequestMsg | |
| CMessage_LoadReport | |
| CMessage_localStatSummary | |
| CMessage_lockArcMsg | |
| CMessage_lockChunksMsg | |
| CMessage_lockMsg | |
| CMessage_lockResult | |
| CMessage_longestMsg | |
| CMessage_LV3D0_ViewMsg | |
| CMessage_LV3D_RenderMsg | |
| CMessage_LV3D_ViewpointMsg | |
| CMessage_MBlockDataMsg | |
| CMessage_meshMsg | |
| CMessage_MeshStreamerMessage | |
| CMessage_multicastGrpMsg | |
| CMessage_multicastSetupMsg | |
| CMessage_NeighborMsg | |
| CMessage_nodeMsg | |
| CMessage_nodeVoteMsg | |
| CMessage_objListMsg | |
| CMessage_pathInformationMsg | |
| CMessage_PoolInitMsg | |
| CMessage_prioBcMsg | |
| CMessage_prioMsg | |
| CMessage_receiverMsg | |
| CMessage_redistributor2DMsg | |
| CMessage_refMsg | |
| CMessage_removeElemMsg | |
| CMessage_removeGhostElemMsg | |
| CMessage_removeSharedNodeMsg | |
| CMessage_SearchNodeMsg | |
| CMessage_searchResults | |
| CMessage_SendFFTMsg | |
| CMessage_sharedNodeMsg | |
| CMessage_splitOutMsg | |
| CMessage_splitResponse | |
| CMessage_StartUpMsg | |
| CMessage_TCharmInitMsg | |
| CMessage_TempoMessage | |
| CMessage_threeNodeMsg | |
| CMessage_updateAttrsMsg | |
| CMessage_UpdateMsg | |
| CMessage_updateMsg | |
| CMessage_verifyghostsendMsg | |
| CMessage_WSLBStatsMsg | |
| cmi_cpu_idlerec | |
| CMI_VMI_Barrier_Message_T | |
| CMI_VMI_Charmrun_Message_Header_T | |
| CMI_VMI_Charmrun_Nodeblock_Message_T | |
| CMI_VMI_Charmrun_Register_Message_T | |
| CMI_VMI_Cluster_Mapping_Message_T | |
| CMI_VMI_Connect_Message_T | |
| CMI_VMI_Credit_Message_T | |
| CMI_VMI_CRM_Nodeblock_Message_T | |
| CMI_VMI_CRM_Register_Message_T | |
| CMI_VMI_Eager_Short_Slot_Footer_T | |
| CMI_VMI_Envelope | |
| CMI_VMI_Envelope_sattribs | |
| CMI_VMI_Envelope_utype | |
| CMI_VMI_Envelope_utype::s_array | |
| CMI_VMI_Envelope_utype::s_chare | |
| CMI_VMI_Envelope_utype::s_group | |
| CMI_VMI_Envelope_utype::s_roData | |
| CMI_VMI_Envelope_utype::s_roMsg | |
| CMI_VMI_Grid_Object_T | |
| CMI_VMI_Handle_T | |
| CMI_VMI_Latency_Vector_Reply_Message_T | |
| CMI_VMI_Latency_Vector_Request_Message_T | |
| CMI_VMI_Memory_Chunk_T | |
| CMI_VMI_Persistent_Request_Message_T | |
| CMI_VMI_Process_T | |
| CMI_VMI_Publish_Message_T | |
| CMI_VMI_Receive_Handle_Eager_Long_T | |
| CMI_VMI_Receive_Handle_Eager_Short_T | |
| CMI_VMI_Receive_Handle_RDMAGet_T | |
| CMI_VMI_Receive_Handle_T | |
| CMI_VMI_Send_Handle_Eager_Long_T | |
| CMI_VMI_Send_Handle_Eager_Short_T | |
| CMI_VMI_Send_Handle_RDMABroadcast_T | |
| CMI_VMI_Send_Handle_RDMAGet_T | |
| CMI_VMI_Send_Handle_Stream_T | |
| CMI_VMI_Send_Handle_T | |
| CmiCb | |
| CmiChunkHeader | This header goes before each chunk of memory allocated with CmiAlloc |
| CmiFragmentHeader | |
| CmiHandlerInfo | |
| CmiIdleLock | |
| CmiIdleState | |
| CmiIsomallocBlock | |
| CmiIsomallocBlockList | |
| CmiMemorySMPSeparation_t | This data type is at least one cache line of padding, used to avoid cache line thrashing on SMP systems |
| CmiMultipleSendHeader | |
| CmiNodeStateStruct | |
| CmiNotifyCommThdMsg | |
| CmiReduction | |
| CmiRMA | |
| CmiRMAMsg | |
| CmiStateStruct | |
| CmiTmpBuf_t | |
| cmkquad | |
| CmmEntryStruct | |
| CmmTableStruct | |
| CMsgBuffer | |
| CMsgCallback | |
| CMsgCallbackQ | |
| coarsenData | |
| coarsenResults | |
| collapseData | |
| collideClient | |
| CollideGrid3d | Map real world (x,y,z) coordinates to integer (i,j,k) grid indices |
| CollideLoc3d | |
| collideMgr | |
| CollideObjConsumer | |
| CollideObjID | |
| CollideObjRec | |
| CollideOctant | |
| collideVoxel | |
| Collision | |
| CollisionAggregator | |
| CollisionList | |
| CombinedMessage | |
| ComboCentLB | |
| comID | Used between RouterStrategy and Router(s) to pass some information: a RouterStrategy passes its comID to the Router it uses, so the second have some knowledge of the containing strategy |
| comlibAgent | |
| ComlibArrayInfo | Array strategy helper class |
| ComlibComRec | Old class that is no longer used |
| ComlibDelegateData | This class is used by ComlibManager (the delegator manager) as its delegated data |
| ComlibDummyMsg | Dummy message to be sent in case there are no messages to send |
| ComlibElementIterator | Implementation of CkLocIterator to get all the local elements from a specified processor |
| ComlibGlobalStats | |
| ComlibGroupInfo | |
| ComlibLearner | Communication library learner which takes a strategy or a list of strategies as input along with the communication pattern of the objects belonging to those strategies and returns new strategies to replace the input strategies |
| ComlibLocalStats | Old class that is no longer used |
| ComlibManager | The main group doing the management of all the charm system |
| ComlibManagerMain | A mainchare, used to initialize the comlib framework at the program startup |
| ComlibMulticastIndexCount | Structure used to hold a count of the indeces associated to each pe in a multicast message |
| ComlibMulticastMsg | A class for multicast messages that contains the user message as well as a list of all destination indices and corresponding PEs |
| ComlibNodeGroupInfo | |
| ComlibRectSectionHashObject | |
| ComlibSectionHashKey | Hash key that lets a strategy access a section id data structure given the source processor and the MaxSectionId on that processor |
| ComlibSectionHashObject | Holds information about a strategy, in case it is used multiple times All this information is derived from the incoming messages |
| ComlibSectionInfo | Helps a communication library strategy manage array sections, creating unique identifiers for sections, and parsing messages |
| CommLB | |
| CompletionDetector | |
| Component | |
| compressedBuffer | A class that reads/writes a buffer out of different types of data |
| computeInfo | |
| con | |
| ConcreteElement | Class to encapsulate a single actual element's nodes |
| ConcreteElementNodeData | Class to encapsulate an element with nodes and node-centered data |
| ConcreteLocalElement | Provides access to a local element |
| ConcreteNetworkElement | Provides access to an element received off the network |
| ConditionalList | |
| ConfigurableRRMap | |
| ConfigurableRRMapLoader | A class responsible for parsing the command line arguments for the PE to extract the format string passed in with +ConfigurableRRMap |
| conndata | |
| xi::Construct | |
| xi::ConstructList | |
| contributorInfo | Node Group Reductions added by Sayantan This thing is extremely similar to the guy above |
| controldef | |
| ControlPoint::ControlPointAssociatedArray | |
| ControlPoint::ControlPointAssociatedEntry | |
| ControlPoint::ControlPointAssociation | |
| controlPointMain | A mainchare that is used just to create our controlPointManager group at startup |
| controlPointManager | |
| controlPointMsg | A message used for signaling changes in control point values |
| ConvComlibManager | Converse interface to handle all the Comlib strategies registered in the Converse of Charm++ program |
| ConvQdMsg | |
| ConvQdState | |
| cookieMsg | |
| coord | |
| coordMsg | |
| countAdjustment | |
| CountLogPool | Counter log pool this implements functions for TraceCounter but that needed to be performed on a node-level |
| countMsg | |
| COverDep | This class hides all of the details of dependencies between overlap blocks and when blocks |
| xi::CParsedFile | |
| CPath | |
| CpdList_arrayElementNames | Coarse: examine array element names |
| CpdList_arrayElements | Detailed: examine array element data |
| CpdList_introspect | |
| CpdList_localQ | |
| CpdList_message | |
| CpdList_msgStack | |
| CpdList_object | Examine a single object identified by the id passed in the request and return its type and memory data |
| CpdList_objectNames | Examine all the objects on the server returning the name |
| CpdListAccessor | A CpdListAccessor responds to CCS requests for a single CpdList |
| CpdListAccessor_c | |
| CpdListItemsRequest | When a CCS client asks for some data in a CpdList, the system generates this struct to describe the range of items the client asked for (the items are numbered lo to hi-1), as well as store any extra data the CCS client passed in |
| CpdPersistentChecker | |
| CpdPython | |
| CpdPythonArrayIterator | |
| CpdPythonGroup | |
| CpdSimpleListAccessor | A typical CpdList accessor: length is stored at some fixed location in memory, path is a constant string, and the pup routine is completely random-access |
| CpmDestinationEnq | |
| CpmDestinationSend | |
| CpmDestinationStruct | |
| CpmDestinationThreadSize | |
| CpmHeader | |
| CProxy | A proxy is a local handle to a remote object |
| CProxy_ArrayBase | This class is a wrapper around a CkArrayIndex and ArrayID, used by array element proxies |
| CProxy_Group | |
| CProxy_NodeGroup | |
| Cpthread_attr_s | |
| Cpthread_cleanup_s | |
| Cpthread_cond_s | |
| Cpthread_condattr_s | |
| Cpthread_key_s | |
| Cpthread_mutex_s | |
| Cpthread_mutexattr_s | |
| Cpthread_once_t | |
| Cpthread_s | |
| CpuTopology | |
| Converse::Cpv< d > | |
| CsdSchedulerState_t | |
| xi::CStateVar | |
| CtgGlobalList | Keeps a list of global variables |
| CtgGlobalList::CtgRec | |
| CtgGlobalStruct | |
| CthProcInfo | |
| CthThreadBase | |
| CthThreadListener | |
| CthThreadStruct | |
| CthThreadToken | |
| xi::CToken | |
| CurrentLocationMsg | |
| CWebModeStats | This "usage" section keeps track of percent of wall clock time spent actually processing messages on each processor |
| CWhenTrigger | |
| D3GridRouter | |
| DebugEntryInfo | |
| DebugPersistentCheck | |
| DebugRecursiveEntry | |
| DefaultArrayMap | The default map object -- This does blocked mapping in the general case and calls the round-robin procNum for the dynamic insertion case -- ASB |
| DefaultEntry< T, PUP_EVERY_ELEMENT > | This is the interface used to perform the accumulate operation on an Entry |
| DefaultFunction | |
| DefaultListEntry< T, PUP_EVERY_ELEMENT > | |
| deq_struct | A double ended queue of void* pointers stored in a circular buffer, with internal space for 4 entries |
| destMsg | Used to specify a destination processor to migrate to during load balancing |
| DgramAck | |
| DgramHeader | |
| DimexRouter | |
| DirectMulticastStrategy | Send the multicast by sending once directly to each processor owning destination elements |
| directPollingQNodeStruct | |
| PUP::disk | |
| double2Msg | A message to encapsulate two doubles |
| DoubleDouble | |
| DoubleInt | |
| doubleMsg | |
| DType | |
| DummyLB | |
| DummyMigrationMsg | |
| DummyMsg | |
| dynChunk | A dynamic (growing) representation of a chunk |
| EachToManyMulticastStrategy | The EachToManyMulticast Strategy optimizes all-to-all communication |
| edegreedef | |
| edge | |
| Edge | |
| edgedef | |
| EdgeListType | |
| edgeRef | |
| elemDataMsg | |
| element | Tetrahedral mesh element |
| Element_Bucket | Type for sorted element storage while awaiting adaptivity |
| Element_Bucket::elemEntry | This is a bucket data structure used to sort elements |
| ElementCaller | |
| ElementCheckpointer | |
| ElementDestoryer | |
| ElementDestroyer | |
| ElementDistributor | |
| ElementPacker | |
| ElemID | A reference to an element |
| ElemList< T > | |
| elemList | |
| elemRef | |
| eltset | |
| entDataMsg | A message that packs all data for a node/element |
| entityPackList | |
| xi::Entry | |
| EntryInfo | Represents a single entry method or constructor |
| xi::EntryList | |
| envelope | The class envelope defines a Charm++ message's header |
| envelope::s_attribs | |
| envelope::u_type | This union stores the type-specific message information |
| envelope::u_type::s_array | |
| envelope::u_type::s_chare | |
| envelope::u_type::s_group | |
| envelope::u_type::s_roData | |
| envelope::u_type::s_roMsg | |
| EqHeap | Heap structure to store events in unexecuted portion of event queue |
| PUP::er | |
| evacMsg | |
| Event | Record to store all info about an event in eventQueue |
| eventID | Unique identifier for a POSE event |
| eventMsg | All user event messages inherit from this |
| EventMsgPool | |
| eventQueue | The event queue |
| ExplicitDgramStruct | |
| externalBCpatch | |
| extrudeMethod | |
| faceMsg | |
| faceReceiver | Receives faces from the wire |
| faceSender | Sends faces across the wire to one destination |
| faceSet | |
| FastArrayMap | A fast map for chare arrays which do static insertions and promise NOT to do late insertions -- ASB |
| FEM_Adapt | Provides primitive mesh modification functions |
| FEM_Adapt_Algs | Provides high level adaptivity operations (by calling the primitive operations repetitively) |
| FEM_Adapt_Algs::elemHeap | This is a heap data structure used to sort elements |
| FEM_AdaptL | Provides primitive mesh modification functions (involves atomic locking/unlocking) |
| FEM_Attribute | Describes an FEM entity's "attribute"--a user-visible, user-settable 2D table |
| FEM_chunk | A collection of meshes on one processor |
| FEM_Comm_Holder | We want the FEM_Comm/IDXL_Side's to be accessible to *both* FEM routines (via these data structures) and IDXL routines (via an idxl->addStatic registration) |
| FEM_Elem_Conn_Checker | This checker verifies that FEM_Elem::conn's entries are valid node indices |
| FEM_ElemAdj_Layer | This stores the types of faces for each element type |
| FEM_ElemAdj_Layer::elemAdjInfo | |
| FEM_Entity | Describes an entire class of "entities"--nodes, elements, or sparse data records |
| FEM_Entity_numberer | Reassemble entities based on their global numbers |
| FEM_Entity_Types< T > | This class describes several different types of a certain kind of entity |
| FEM_Ghost_Layer | Describes a single layer of ghost elements |
| FEM_Ghost_Layer::elemGhostInfo | |
| FEM_Ghost_Region | Describes a way to grow a set of ghosts |
| FEM_Ghost_Stencil | Describes a set of required adjacent elements for this kind of element, stored as an explicit adjacency list |
| Checker | |
| FEM_Initial_Symmetries | |
| FEM_Interpolate | Interface for solution transfer operations |
| FEM_Interpolate::ElementArgs | The input formation for an element interpolate(copy) operation |
| FEM_Interpolate::NodalArgs | The input information for a nodal interpolate operation |
| FEM_lock | There is one fem_lock associated with every FEM_Mesh: Chunk Lock (no longer in use) |
| FEM_lockN | There is one fem_lock associated with every node (locks on elements are not required) |
| FEM_Mesh | A FEM_Mesh is a collection of entities |
| FEM_Mesh_list | |
| FEM_Mesh_Output | |
| FEM_Mesh_Partition_List | |
| FEM_MUtil | A utility class with helper functions for adaptivity |
| FEM_MUtil::tuple | Data structure to remember mappings from oldnode to newnode yet to be updated |
| FEM_Node | FEM_Node is a type of FEM_Entity, which refers to nodes |
| FEM_Operation_Data | |
| FEM_Partition | Describes all the data needed for partitioning a mesh |
| FEM_Refine_Operation_Data | |
| FEM_Sparse_Elem_Checker | This checker makes sure FEM_Sparse::elem's two element indices (element type, element index) are valid |
| FEM_Sym_Desc | Describes one kind of symmetry condition |
| FEM_Sym_Linear | Describes a linear-periodic (space shift) symmetry: |
| FEM_Sym_List | Describes all the different kinds of symmetries that apply to this mesh |
| FEM_T_List< T > | Keeps a list of dynamically-allocated T objects, indexed by a user-carried, persistent "int" |
| FEM_Userdata_item | Describes one piece of generic unassociated mesh data |
| FEM_Userdata_list | Describes all the unassociated data in a mesh |
| FEMchunk | FEM global data object |
| femMeshModify | The shadow array attached to a fem chunk to perform all communication during adaptivity |
| femMeshModMsg | Message to initialize 'numChunks' and 'chunkIdx' of femMeshModify on all chunks |
| FEMMeshMsg | A message to encapsulate a mesh pointer and a tcharm pointer |
| field_t | |
| fifo_queue | |
| Ck::IO::FileInfo | |
| Ck::IO::FileReadyMsg | |
| findgsMsg | A message that packs the indices of a bunch of chunks (used for ghost send) |
| fixedBufferT< T > | |
| fixedConcreteElement | Testing stub for GenericElement |
| fixedlength_bitvector< NUM_BITS > | Fast, fixed-size bitvector class |
| FKeyValueType | |
| flip23request | |
| flip23response | |
| flip32request | |
| flip32response | |
| FloatFloat | |
| FloatInt | |
| FourLevelTree | |
| FP | |
| FPQueueType | |
| PUP::fromDisk | |
| PUP::fromMem | |
| fromProjectionsFile | |
| PUP::fromTextFile | |
| PUP::fromzDisk | |
| funcData | |
| xi::FuncType | |
| Future_s | |
| FutureBOC | |
| FutureInitMsg | |
| FutureMain | |
| FutureMessageStruct | |
| FutureState | |
| GenericElement | Class to encapsulate all element-type specific methods |
| ghostdata | Structure for storing the ghost layers |
| gk_delayed_msgs | |
| GPUReq | |
| Graph | |
| graph | |
| GraphBFTLB | |
| graphdef | |
| GraphPartLB | |
| GraphRouter | A generalized virtual topology based router |
| GreedyAgentLB | |
| GreedyAgentLB::HeapData | |
| GreedyCommLB | |
| GreedyLB | |
| GreedyLB::HeapData | |
| GridCommLB | |
| GridCommRefineLB | |
| GridHybridLB | |
| GridHybridSeedLB | |
| GridMetisLB | |
| GridRouter | |
| xi::Group | |
| Group | |
| GroupDef | |
| GroupIdxArray< dtype > | |
| growableBufferT< T > | |
| GVT | GVT chare group for estimating GVT |
| GVTMsg | Message to send GVT estimate back to PVT |
| MSA::handle< T, D > | |
| hash2_t | |
| hash_t | |
| hashCache< n > | |
| hashCache1< KEY, OBJ > | |
| Hashnode | |
| Hashnode::tupledata | |
| HashQueueT< KEY, OBJ > | |
| HbmLB | |
| HbmLB::LevelData | |
| HbmLB::MigrationRecord | |
| heapIterator | |
| HeapNode | Structure for storing events on a heap |
| heapRecord | |
| hIterator | |
| hRecord | |
| HybridBaseLB | |
| HybridBaseLB::LevelData | |
| HybridBaseLB::MigrationRecord | |
| HybridLB | |
| HypercubeRouter | Dimensional Exchange (Hypercube) based router |
| HypercubeTopology | |
| HypercubeTree | |
| ibudstruct | |
| idaStarGroup | |
| idaStarWorker | |
| idleTimeContainer | A container that stores idle time statistics (min/max/avg etc.) |
| IDXL | IDXL: A two-way communication list |
| IDXL_Chunk | IDXL_Chunk exists for just two reasons:
- To do communication on IDXL's--the idxl_recv method
|
| IDXL_Comm | IDXL_Comm is the implementation of the user type IDXL_Comm |
| IDXL_Comm::msg_t | This class represents an MPI send or receive operation |
| IDXL_Comm::sto_t | This class represents one communication operation: a send/sum or send/recv |
| IDXL_Identity_Map | |
| IDXL_Layout | This class represents the layout of a user data structure in user memory |
| IDXL_Layout_List | Keeps a list of dynamically-allocated IDXL_Layout objects: |
| IDXL_List | IDXL_List lists the entities we share with one other chunk |
| IDXL_Map | Map an entity to its IDXL_Rec |
| IDXL_Print_Map | |
| IDXL_Share | IDXL_Share describes how one entity is shared with one other chunk |
| IDXL_Side | IDXL_Side describes all the shared entities for a given communication direction |
| IFEM_Solve_shared_comm | Interface between the basic "matrix-style" interface expected by the ILSI solvers, the FEM framework, and the local matrix-multiply function passed in by the user |
| iget_token_struct | |
| IGetControlClass | |
| ignoreAdd | |
| ILSI_Comm | An ILSI_Comm is an ILSI_Solver's interface to the (parallel) problem matrix and communication system |
| ILSI_Param | This struct gives the input and output parameters for an IDXL_Solver |
| ImageData | |
| ImageData::ImageHeader | This header is stored as the first thing in our buffer |
| ImageData::LineHeader | Describes a row of image data |
| imageHeader | |
| imageUnit | |
| impl_LV3D_Array | |
| ImplicitDgramStruct | |
| xi::IncludeFile | |
| infiAddr | Represents a qp used to send messages to another node There is one for each remote node |
| infiBuffer | |
| infiBufferedBcastPoolStruct | |
| infiBufferedBcastStruct | |
| infiBufferPool | At the moment it is a simple pool with just a list of buffers TODO; extend it to make it an element in a linklist of pools |
| infiCmiChunkHeaderStruct | |
| infiCmiChunkMetaDataStruct | |
| infiCmiChunkPool | |
| infiContext | |
| infiDirectHandleStruct | |
| infiDirectHandleTableStruct | |
| infiDirectRequestPacket | |
| infiDirectUserHandle | |
| infiIncTokenAckPacket | |
| infiOtherNodeData | |
| infiPacketHeader | |
| infiPacketStruct | |
| infiRdmaPacket | |
| InfoRecord | |
| InfoStruct | |
| xi::InitCall | |
| InitCallTable | |
| instrumentedData | Stores and manipulate all known instrumented phases. One instance of this exists on each PE in its local controlPointManager |
| instrumentedPhase | Stores data for a phase (a time range in which a single set of control point values is used) |
| int2Msg | A message to encapsulate two integers |
| intdual | |
| internalBCpatch | |
| IntInt | |
| intMsg | A message to encapsulate an integer |
| IRecvListEntry | |
| IReq | |
| IrrGroup | |
| Iterator | |
| std::iterator_traits< Iterator > | |
| std::std::iterator_traits< T * > | |
| KeyKeyValueType | |
| KeyvalNode | |
| KeyvalPair | |
| KeyValueType | |
| killPortStruct | |
| KLevelTree | |
| KMeansBOC | |
| KMeansStatsMessage | |
| KSeedsMessage | |
| KSelectionMessage | |
| KVType | |
| l2g_t | This class describes a local-to-global index mapping, used in FEM_Print |
| LBCommData | |
| LBCommTable | |
| LBDatabase | |
| LBDatabase::LastLBInfo | |
| LBDB | |
| LBDB::batsyncer | |
| LBDB::MigrateCB | |
| LBDB::MigrationDoneCB | |
| LBDB::PredictCB | |
| LBDB::StartLBCB | |
| LBDBInit | |
| LBDBRegistry | |
| LBDBRegistry::LBDBEntry | |
| LBgroup | |
| LBInfo | |
| LBMachineUtil | |
| LBMigrateMsg | Message contains the migration decision from LB strategies |
| LBObj | |
| lbObjectNode | |
| lbObjects | |
| LBOM | |
| LBPredictorFunction | |
| LBProfit | Module which determines if a load balancing cycle is profitable |
| LBSimulation | |
| LBStepMsg | |
| LBstrategy | |
| LBTopo_graph | |
| LBTopo_graph_nc< dimension > | |
| LBTopo_mesh3d | |
| LBTopo_ring | |
| LBTopo_smp_n< ppn > | |
| LBTopo_torus2d | |
| LBTopo_torus3d | |
| LBTopo_torus_nd< dimension > | |
| LBTopology | |
| LBTopoVec | |
| LBVectorMigrateMsg | |
| LDBarrierClient | |
| LDBarrierReceiver | |
| LDCallbacks | |
| LDCommData | |
| LDHandle | |
| LDObjData | |
| LDObjHandle | |
| LDObjStats | |
| LDOMHandle | |
| LeakSearchInfo | |
| LEsplitMsg | |
| LEsplitResult | |
| linearOffsetMatcher | |
| LineFFTArray | Main Pencil FFT Chare Array |
| LineFFTGrid | The Grid structures which describes the points being sent |
| LineFFTGridMsg | |
| LineFFTinfo | |
| LineFFTInfo | Startup consturction info for the line fft array element |
| listNode | |
| ListNodeType | |
| liveVizConfig | LiveVizConfig describes the type of images available from this parallel server--images may be color or greyscale, be pushed to the client or pulled, and may come from a set of 3d axes or be simply 2d |
| liveVizGroup | |
| liveVizPollArray | |
| liveVizRequest | A liveVizRequest describes the basics of a client image request |
| liveVizRequest3d | Additional 3D data associated with a 3D LiveViz request |
| liveVizRequestMsg | |
| loadmsg | |
| loadmsg_s | |
| LoadReport | |
| loc | |
| LocalBarrier | |
| LocalBarrier::client | |
| LocalBarrier::receiver | |
| LocalElementCounter | |
| LocalMessageLog | Log entry for local messages, can also be sent as a message |
| LocalMessageLogAck | |
| localStat | Group to gather stats on each PE separately |
| localStatSummary | Message to gather local stats from all PEs for printing |
| Location | |
| LocationID | |
| lockArcMsg | |
| lockChunksMsg | This is a message which packs all the chunk indices together |
| lockMsg | |
| lockQueueEntry | |
| LockRegion | Class that represent a region that is being locked |
| lockResult | |
| LogEntry | Log entry in trace projection |
| LogPool | Log pool in trace projection |
| LongdoubleInt | |
| longestMsg | |
| LongInt | |
| LV3D0_ClientManager | Generic superclass for client managers |
| LV3D0_ClientManager_toClient | A LV3D0_ClientManager buffers up outgoing views before they're requested by, and sent off to, a client |
| LV3D0_ClientManager_toMaster | A LV3D0_ClientManager that buffers up outgoing views for delivery to the master processor |
| LV3D0_Manager | The LV3D0_Manager group stores up outgoing views before they're sent off to clients |
| LV3D0_ViewMsg | This message is used to pack up and ship views from where they're computed to the master processor, where they're accumulated for CCS transport to the client |
| LV3D1_Map | |
| LV3D1_ServerMgr | Manager for a LV3D_Array |
| LV3D_Array | This array holds all the visible objects in one liveViz3d computation |
| LV3D_PerfManager | |
| lv3d_qdState | |
| LV3D_RenderMsg | This message is used to prioritize rendering requests |
| LV3D_ServerMgr | Represents a set of impostors available for updates |
| LV3D_Universe | This is the class that represents the entire viewable domain |
| LV3D_Universe_Table | Private class that stores object data for the universe client side |
| LV3D_ViewpointMsg | This message is sent every time a client viewpoint changes |
| PUP::machineInfo | |
| xi::MacroDefinition | |
| main | |
| xi::MainChare | |
| MainInfo | Describes a mainchare's constructor. These are all executed at startup |
| mallinfo | |
| malloc_bin | |
| malloc_chunk | |
| malloc_par | |
| malloc_state | |
| Ck::IO::Manager | Class to mediate IO operations between Charm++ application code and underlying filesystems |
| marshallNewHeapCopy< T > | Unmarshall into a heap-allocated copy |
| matchingDest | |
| Mgc::Math | |
| Matrix | Matrix class with some fundmental operations |
| matrixdef | |
| MaxEntry< T, minVal, PUP_EVERY_ELEMENT > | |
| maxHeap | |
| MBlockChunk | |
| MBlockChunk::bc_t | |
| MBlockChunk::update_t | |
| MBlockDataMsg | |
| MBlockSetupCookie | |
| McastDest | |
| mCastEntry | Cookie for an array section |
| mCastPacket | |
| McastSrc | |
| PUP::mem | |
| xi::Member | |
| xi::MemberList | |
| memBuf | |
| MemEntry | A representant of a memory operation |
| memoryBuffer | |
| MemoryPool | |
| mempool_type | |
| memRegion_t | |
| MergeablePathHistory | Augments the PathHistory in the envelope with the other necessary information from the envelope |
| meshChunk | Manages the on-the-wire mesh format when sending or receiving tet mesh chunks |
| meshChunk::header_t | |
| meshdef | |
| MeshElem | This class is an MSA Entity |
| MeshElem::ElemInfo | |
| MeshElem::NodeInfo | |
| MeshElemItr | Element Iterator |
| MeshFacet | A type for a facet |
| MeshFacetItr | Facet Iterator |
| MeshLocation | |
| MeshModel | A mesh model is roughly equivalent to a ParFUM FEM_Mesh object |
| MeshModelDevice | A MeshModelDevice contains structures for use by CUDA kernels |
| meshMsg | |
| MeshNodeElemItr | Node->Element adjacency Iterator |
| MeshNodeItr | Node Iterator |
| meshState | |
| MeshStreamer< dtype > | |
| MeshStreamerClient< dtype > | |
| MeshStreamerMessage< dtype > | |
| MeshStreamingHeader | Passed along with every row message header in the first iteration of the MesgStreamingStrategy |
| xi::Message | |
| MessageHolder | An abstract data structure that holds a converse message and which can be buffered by the communication library Message holder is a wrapper around a message |
| MetisLB | |
| MigrateInfo | Migration decision for an obj |
| MigrationNotice | |
| MigrationNoticeAck | |
| MigrationRecord | |
| minHeap | |
| MlogEntry | Entry in a message log |
| mm | |
| MSA::modifiable_cache_line< T > | |
| xi::Module | |
| xi::ModuleList | |
| mpi_comm_worlds | |
| MPI_Status | |
| mpiPostRecvList | |
| MPIR_Info | |
| MSA::MSA1D< ENTRY, ENTRY_OPS_CLASS, ENTRIES_PER_PAGE > | The MSA1D class is a handle to a distributed shared array of items of data type ENTRY |
| MSA::MSA2D< ENTRY, ENTRY_OPS_CLASS, ENTRIES_PER_PAGE, ARRAY_LAYOUT > | |
| MSA::MSA3D< ENTRY, ENTRY_OPS_CLASS, ENTRIES_PER_PAGE > | The MSA3D class is a handle to a distributed shared array of items of data type ENTRY |
| MSA_CacheGroup< ENTRY_TYPE, ENTRY_OPS_CLASS, ENTRIES_PER_PAGE > | |
| MSA_CacheGroup< ENTRY_TYPE, ENTRY_OPS_CLASS, ENTRIES_PER_PAGE >::writebounds_t | |
| MSA::MSA_InvalidHandle | |
| MSA_Listener | Listens for some event on a page or set of pages |
| MSA_Listeners | Keeps a list of MSA_Listeners |
| MSA_Page_StateT< ENTRY, ENTRIES_PER_PAGE > | Stores all housekeeping information about a cached copy of a page: everything but the actual page data |
| MSA_PageArray< ENTRY_TYPE, ENTRY_OPS_CLASS, ENTRIES_PER_PAGE > | |
| MSA_PageReplacementPolicy< ENTRY_TYPE, ENTRIES_PER_PAGE > | Class vmPageReplacementPolicy Abstract base class providing the interface to the various page replacement policies available for use with an MSA |
| MSA_PageT< ENTRY, MERGER, ENTRIES_PER_PAGE > | Holds the typed data for one MSA page |
| MSA_Thread_Listener | Resumes a thread once all needed pages have arrived |
| MSA_WriteSpan_t | Stores a list of indices to be written out |
| MSA::MSAAccum< MSA > | |
| MSA::MSAHandle< MSA > | |
| MsaHashtable | |
| MsaHashtable::Add | |
| MsaHashtable::Read | |
| MSA::MSARead< MSA > | |
| MSA::MSAWrite< MSA > | |
| msg_list | |
| MsgHeap | |
| MsgInfo | Represents one type of Message |
| MsgPool | |
| msgstruct | |
| xi::MsgVar | |
| xi::MsgVarList | |
| MulticastAgent | |
| MulticastAgent::MInfo | |
| multicastGrpMsg | Message send in spanning tree |
| multicastSetupMsg | Multicast tree setup message |
| MulticastStrategy | Abstract parent class for multicast strategies |
| MultiMsg | |
| MultiRingMulticastStrategy | Multicast strategy that sends the data using two rings |
| myGlobals | |
| MyHierarchyTree | |
| MyHmbHierarchyTree | |
| Name | |
| xi::NamedType | |
| NborBaseLB | |
| NborBaseLB::LDStats | |
| NeighborCommLB | |
| NeighborLB | |
| NeighborMsg | |
| NestedEvent | |
| NetFEM_doubleField | |
| NetFEM_elems | |
| NetFEM_flavor | |
| NetFEM_format | |
| NetFEM_item | |
| NetFEM_nodes | |
| NetFEM_state | |
| NetFEM_update | |
| NetFEM_update_vtk | |
| NetFEM_updatePackage | |
| NLBStatsMsg | |
| NList | |
| ControlPoint::NoControlPointAssociation | |
| node | A node in the mesh with a 3D double coordinate |
| NodeElem | |
| xi::NodeGroup | |
| NodeGroup | |
| nodeMsg | |
| nodeRef | |
| Nodes | |
| nodeVoteMsg | |
| cg3d::NonManifoldException | Under OSL_CG3D_DEBUG, this exception is thrown by ~Volume3dDest: |
| NormalFFTinfo | |
| NormalLineArray | |
| NormalRealSlabArray | |
| NormalSlabArray | |
| nrinfodef | |
| Null_vector | |
| NullLB | NullLB is inherited from BaseLB |
| NumberedVec< T > | Map (user-assigned) numbers to T's |
| Object_Data_T | |
| ObjectHeap | |
| ObjectRecord | |
| ObjectToken | |
| ObjGraph | |
| ObjGraph::Edge | |
| ObjGraph::Node | |
| objListMsg | |
| objListMsg::returnReceipt | |
| ObjLoadGreater | |
| objRef | |
| OneTimeDimensionOrderedMulticastStrategy | A strategy that does dimension ordered sending of messages |
| OneTimeMulticastStrategy | The simplest multicast strategy |
| OneTimeNodeTreeMulticastStrategy | A node-aware strategy that sends along a node-based tree with user specified branching factor |
| OneTimeNodeTreeRingMulticastStrategy | A node-aware strategy that sends along a node-based tree with user specified branching factor |
| OneTimeRingMulticastStrategy | A strategy that sends along a ring through the destination processors |
| OneTimeTopoTreeMulticastStrategy | A strategy that uses the topo-aware spanning tree builder to send msgs down a spanning tree that is constructed in a network-topology aware manner if such info is available |
| OneTimeTreeMulticastStrategy | A strategy that sends along a tree with user specified branching factor |
| opt | |
| opt2 | |
| opt3 | |
| Ck::IO::Options | |
| OrbLB | |
| OrbLB::ComputeLoad | |
| OrbLB::Partition | |
| OrbLB::VecArray | |
| orientation | |
| Origin | |
| OtherNodeStruct | |
| OutgoingMsgRec | |
| OutgoingMsgStruct | |
| overheadContainer | A container that stores overhead statistics (min/max/avg etc.) |
| MSA::owner< T, D > | |
| ParallelSolver | |
| parallelSurfaceTransfer_c | |
| parallelTransfer_c | |
| xi::Parameter | |
| xi::ParamList | |
| ParFUM_collider | ParFUM Collision Interface File |
| ParFUMShadowArray | |
| partconndata | Structure to store connectivity data after the global element partition has been returned by parmetis |
| PartitionList | |
| PartitionRecord | |
| patch | |
| patchReader | |
| pathfixlist | |
| PathHistory | A class that is used to track the entry points and other information about a critical path as a charm++ program executes |
| PathHistoryEnvelope | A class that is used to track the entry points and other information about a critical path as a charm++ program executes |
| pathHistoryMain | A mainchare that is used just to create a group at startup |
| pathHistoryManager | |
| PathHistoryTableEntry | Stores information about the critical path in the table on each PE |
| pathInformationMsg | A message containing information about a path of entry method invocations. This contains an array of PathHistoryTableEntry objects |
| PCQueueStruct | |
| PE_Data_T | |
| peAddr | |
| peinfo | |
| PendingMsgStruct | |
| PendingSentMsgStruct | |
| xi::perElemGenC< T, U, A > | Apply fn_ on each Construct in the list l, passing it arg as the target |
| PersistentReq | |
| PersReq | |
| PeTable | |
| PhasebyArrayLB | |
| PhaseEntry | Phase entry for trace summary |
| PhaseTable | Table of PhaseEntry |
| PipeBcastHashKey | The hash key for indexing incoming fragmented messages while waiting to reassemble them |
| PipeBcastHashObj | The message in reassembling |
| PipeBcastInfo | Header used to split messages for the pipelining |
| PipeBroadcastConverse | PipeBroadcastConverse streams broadcast messages to all processors, and delivers them using the "deliver" method |
| PipeBroadcastStrategy | Strategy that performs a broadcast over an entire group or array of chares |
| PipelineHashKey | |
| PipelineHashObj | |
| PipelineInfo | |
| PipelineStrategy | |
| cg3d::Planar3d | A convex planar polyhedron, with its vertices scattered in 3D |
| cg3d::Planar3dDest | Send clipped segments of a face to here |
| Mgc::Plane | |
| Plane3D | |
| Point_2< T > | |
| Point_3< T > | |
| cg3d::PointSet3d | A dynamic pointset, with each point marked with the halfspaces it contains |
| Pool | |
| PoolInitMsg | |
| Port | |
| pose | Coordinator of simulation initialization, start and termination |
| POSE_Config | |
| ppdef | |
| PQueueType | |
| xi::Prefix | |
| PrefixRouter | Prefix router to avoid contention on m,n-tree networks |
| xi::Printable | |
| prio_struct | Stores a variable bit length priority |
| prioBcMsg | Prioritized int msg; used to force GVT calculations |
| prioLockStruct | |
| prioMsg | Prioritized null msg; used to sort Step calls |
| prioq_struct | A priority queue, implemented as a heap of prioqelt_struct buckets (each bucket represents a single priority value and contains a deque of void* pointers) |
| prioqelt_struct | A bucket in a priority queue which contains a deque(storing the void* pointers) and references to other buckets in the hash table |
| priormsg_s | |
| PrioStreaming | Class that streams messages the same way as StreamingStrategy, but adding a bypass for high priority messages to be flushed immediately |
| PrismMesh | |
| PrismMesh::conn_t | Connectivity: 0-based node indices around our prism |
| problem | |
| ProcArray | |
| processorInfo | |
| ProcInfo | |
| ProcLoadGreater | |
| ProcLoadGreaterIndex | |
| ProcState | |
| ProductEntry< T, PUP_EVERY_ELEMENT > | |
| progress_t | |
| PropMap | A proportional map object-- tries to map more objects to faster processors and fewer to slower processors |
| ptinfo | |
| xi::PtrType | |
| ptvectorlist | |
| PUP_cmiAllocSizer | The current test for this code is in src/ck-com/MsgPacker.C I will later port CmiMultipleSend |
| PUP_fmt | A PUP_fmt inserts a 1-byte data format code before each pup'd data item |
| PUP_fromCmiAllocMem | |
| PUP_fromPagedDisk | |
| PUP_pagedDisk | |
| pup_pagetable | |
| PUP_regEntry | |
| PUP_toCmiAllocMem | |
| PUP_toNetwork4_pack | |
| PUP_toNetwork4_sizer | |
| PUP_toNetwork4_unpack | |
| PUP_toNetwork_pack | |
| PUP_toNetwork_sizer | |
| PUP_toNetwork_unpack | |
| PUP_toPagedDisk | |
| xi::PUPableClass | |
| pupCheckRec | |
| PVT | PVT chare group for computing local processor virtual time |
| pvtObjectNode | A pvtObjects entry for storing poser data |
| pvtObjects | List to hold records of posers registered with a PVT branch |
| PxshmContext | |
| PxshmSendQ | |
| PythonAbstract | |
| PythonCCS | |
| PythonExecute | |
| PythonFinished | |
| PythonIterator | |
| PythonObject | |
| PythonPrint | |
| PythonReplyInt | |
| PythonReplyString | |
| PythonStruct | |
| Q | |
| QdCallback | |
| QdCommMsg | |
| QdMsg | |
| QdState | |
| Queue_struct | A set of 3 queues: a positive priority prioq_struct, a negative priority prioq_struct, and a zero priority deq_struct |
| RandCentLB | |
| RandomIterator< T > | Iterator for the RandomSequence |
| RandomSequence< T > | |
| Ray3D | |
| MSA::read< T, D > | |
| ReadFileMap | This map can be used for topology aware mapping when the mapping is provided through a file -- ASB |
| readonly< dtype > | |
| xi::Readonly | |
| readonlybase | |
| ReadonlyInfo | Describes a readonly global variable |
| ReadonlyMsgInfo | Describes a readonly message |
| readytoexectoken_s | |
| RecBipartLB | |
| RecBisectBfLB | |
| ReceivedTNData | |
| receiver | |
| receiver::_tblEntry | |
| receiverMsg | |
| RectMulticastStrategy | Main class for multicast strategies |
| recvBuffer | The simplest multicast strategy |
| redistributor2D | A chare group that can redistribute user data arrays. It is used by binding it to a user's Chare Array |
| redistributor2DMsg | A message containing a chunk of a data array used when redistributing to a different set of active chares |
| reduction | |
| reductionInfo | Information about the status of reductions proceeding along a given section |
| xi::ReferenceType | |
| refineClient | The user inherits from this class to receive "split" calls, and to be informed when the refinement is complete |
| RefineCommLB | |
| refineData | |
| RefineKLB | |
| RefineLB | |
| Refiner | |
| RefinerApprox | |
| RefinerComm | |
| RefinerComm::CommTable | |
| RefinerComm::Messages | |
| refineResults | |
| refineResults::resRec | |
| RefineSwapLB | |
| RefineSwapLB::HeapData | |
| RefineTopoLB | |
| refMsg | |
| RegionID | |
| removeElemMsg | A message to tell a remote chunk to remove an element |
| removeGhostElemMsg | A message to tell a remote chunk to remove a ghost element and some IDXL list entries |
| removeSharedNodeMsg | A message to tell a remote chunk to remove a shared node |
| rep | Base representation class |
| replacedeleteData | |
| reqmsg | |
| requestmsg_s | |
| ResendData | |
| ResendRequest | |
| RestartProcessorData | |
| RestartRequest | Struct to request a particular action during restart |
| RestoredLocalMap | Class for storing metadata of local messages |
| resultsCoarsenClient | |
| resultsRefineClient | |
| RetainedMigratedObject | |
| rinfodef | |
| RingMulticastStrategy | Multicast Strategy that sends a multicast in a ring: the source processor send a message only to its following neighbour, which propagates it forward to its neighbour, and so on |
| RMAPutMsg | |
| rngen_ | |
| roarray< dtype, len > | |
| romsg< dtype > | |
| RotateLB | |
| Router | Base class for routers |
| RouterStrategy | Class that calls Krishnan's routers from the new Comlib |
| RRMap | |
| RTH_Locals | All the local variables for RTH routines are stored in subclasses of this type |
| RTH_Runtime | Describes everything associated with a flow of control-- execution stack, objects, and other housekeeping |
| RTH_StackFrame | Describes everything you need to resume execution: a function, a program counter, and local variables |
| RunDescriptor | |
| SafePool< T > | |
| savedViewRecord | |
| xi::Scope | |
| ScotchLB | |
| ScotchRefineLB | |
| ScotchTopoLB | |
| xi::SdagConstruct | |
| SearchConductor | |
| SearchGroup | |
| SearchNode | |
| SearchNodeMsg | |
| searchResults | |
| SectionLocation | |
| PUP::seekBlock | |
| seg1dT< T > | |
| SendFFTMsg | |
| sendState | Describes the outgoing mesh |
| seq | |
| SequentialSolver | |
| serial_comm | An ILSI_Comm that holds a single, serial, dense matrix |
| serialCollideClient | |
| SerialTree | |
| Set | |
| SHA1_hash_t | |
| cg3d::Shape3d | A convex 3D shape, described either as a set of convex planar faces or the intersection of a set of halfspaces |
| sharedBufData | |
| sharedBufHeader | This struct is used as the first portion of a shared memory region, followed by data |
| sharedNodeMsg | A message used to tell a remote chunk to add a shared node |
| short_envelope | |
| ShortInt | |
| sim | Poser wrapper base class |
| simplexScheme | A class that implements the Nelder Mead Simplex Optimization Algorithm |
| single | |
| PUP::sizer | |
| PUP::sizerText | |
| Skipped_Event | Class for storing data of events skipped while checkpointing (for sequential simulation) |
| skt_ip_t | |
| SlabArray | |
| Slot | |
| slot_header_ | |
| slotOP | |
| SNToTicket | Class that maps SN (sequence numbers) to TN (ticket numbers) for a particular object |
| Solver | |
| SpanningTree | Added by Abhinav class for computing the parent and children of a processor |
| topo::SpanningTreeStrategy< Iterator, ValueType > | The spanning tree build strategy interface |
| topo::SpanningTreeStrategy_3dTorus_minBytesHops< Iterator, ValueType > | A concrete tree builder for use on machines with a 3D Torus topology |
| topo::topo::SpanningTreeStrategy_3dTorus_minBytesHops< Iterator, SpanningTreeVertex > | Partial specialization when input is a container of SpanningTreeVertices |
| topo::topo::SpanningTreeStrategy_3dTorus_minBytesHops< Iterator, vtxType > | Partial specialization when input is a container of vtxTypes |
| topo::SpanningTreeStrategy_3dTorus_minHops< Iterator, ValueType > | A concrete tree builder for use on machines with a 3D Torus topology |
| topo::topo::SpanningTreeStrategy_3dTorus_minHops< Iterator, SpanningTreeVertex > | Partial specialization for scenario for a container of SpanningTreeVertices |
| topo::topo::SpanningTreeStrategy_3dTorus_minHops< Iterator, vtxType > | Partial specialization for scenario when a container of vtxTypes is input |
| topo::SpanningTreeStrategy_nodeAware_minBytes< Iterator, ValueType > | A concrete tree builder that is aware of cpu topology (ie, node aware) while constructing spanning trees |
| topo::topo::SpanningTreeStrategy_nodeAware_minBytes< Iterator, SpanningTreeVertex > | Partial specialization when input is a container of SpanningTreeVertices |
| topo::SpanningTreeStrategy_nodeAware_minGens< Iterator, ValueType > | A concrete tree builder that is aware of cpu topology (ie, node aware) while constructing spanning trees |
| topo::topo::SpanningTreeStrategy_nodeAware_minGens< Iterator, SpanningTreeVertex > | Partial specialization for the scenario of a container of SpanningTreeVertices |
| topo::SpanningTreeStrategy_topoUnaware< Iterator, ValueType > | A concrete tree builder that is NOT topology aware |
| topo::topo::SpanningTreeStrategy_topoUnaware< Iterator, SpanningTreeVertex > | Partial specialization when input is a container of SpanningTreeVertices |
| topo::SpanningTreeVertex | Contains indices to direct children |
| sparseRec1D< T > | |
| sparseRec2D< T > | |
| sparseRec3D< T > | |
| SparseSlabArray | |
| SpawnedEvent | List to store records of events spawned by a certain event |
| spec | |
| splitOutMsg | |
| splitResponse | |
| splitter | Splitter is a big utility class used to separate an FEM_Mesh into pieces |
| SRentry | An entry for storing the number of sends and recvs at a timestamp |
| SReq | |
| SRtable | A table for storing the number of sends and recvs at a timestamp |
| SSEDouble | |
| SSEFloat | |
| stack_node | |
| StartUpMsg | |
| StatCollector | |
| StateBase | |
| StateStack | |
| Stats | |
| stats | |
| stats::op_sentry | Sentry class: wraps timing of one operation, including save/restore for nested operations |
| stats::op_t | Describes a particular operation, such as a kind of drawing |
| stats::stats | Sums up the time taken by each operation |
| StatTable | Track statistics for all entry points |
| StatTable::Statistics | Struct to maintain statistics |
| stl_destination_mgr | |
| StoredCheckpoint | |
| strat | Base synchronization strategy class |
| Strategy | Class that defines the entry methods that a Converse level strategy must define |
| StrategyTableEntry | Information about each instance of a strategy |
| StrategyWrapper | Enables a list of strategies to be stored in a message through the PUPable framework |
| StreamingMessage | The header prepended to combine messages by StreamingStrategy and derived classes |
| StreamingStrategy | |
| StridedIterator< T > | |
| StridedSequence< T > | |
| StrideInfo< T > | |
| StringPool | |
| StrKey | |
| SumEntryInfo | Info for each entry |
| SumLogPool | Summary log pool |
| SumLogPool::MarkEntry | Mark entry for trace summary |
| SuperBlock | SuperBlock holds the actual memory block that is allocated in blk |
| surfProgress_t | |
| symlist | |
| symtab | |
| syncReductionMgr | |
| SystemLoad | |
| SysvshmContext | |
| SysvshmSendQ | |
| TableEntry | |
| taskGraphArray | |
| taskGraphSolver | |
| taskStruct | |
| TCharm | |
| TCharm::TCharmSemaphore | |
| TCharm::ThreadInfo | |
| TCharm::UserData | |
| TCHARM_Thread_options | |
| TCharmAPIRoutine | |
| TCharmClient1D | |
| TCharmInitMsg | |
| TCharmMain | |
| TCharmTraceLibList | |
| TeamLB | |
| TempAwareGreedyLB | |
| TempAwareGreedyLB::HeapData | |
| xi::Template | |
| Tempo | |
| TempoArray | |
| TempoChare | |
| TempoGroup | |
| TempoMessage | |
| xi::TEntity | |
| cg3d::Tet3d | A 4-node tetrahedron |
| TetMesh | A 3d tetrahedral mesh |
| TetMesh::conn_t | |
| tetMeshChunk | Manages the on-the-wire mesh format when sending or receiving tet mesh chunks |
| tetMeshChunk::header_t | |
| TetMeshElement | Provides ConcreteElement interface for one element of the TetMesh class |
| Mgc::Tetrahedron | |
| Mgc::TetrahedronConsumer | Accept a tetrahedron for further processing |
| Mgc::TetrahedronVolumeConsumer | Sums up volume of tetrahedra passed to it |
| tetReceiver | Receives tets from the wire |
| tetSender | Sends tets across the wire to one destination |
| xi::TFunc | |
| threadCollide | Threaded collision client array--provides interface between threadCollideMgr and API routines |
| threadCollideMgr | Threaded collision group--collects collisions as they come from voxels, and sends the collisions to the source chunks |
| ThreeLevelTree | |
| threeNodeMsg | |
| Ticket | |
| TicketReply | |
| TicketRequest | |
| TimeBucket | TimeBucket associates a time range with (a) large block(s) of memory |
| TimePool | |
| xi::TList< T > | |
| xi::TList< T >::Elem | |
| TListCMsgBuffer | |
| TListCWhenTrigger | |
| tlsseg_t | |
| tm_topology_t | |
| xi::TName | |
| PUP::toDisk | |
| TokenPool | |
| PUP::toMem | |
| TopElement | A type for a node |
| TopElemItr | Element Iterator |
| TopFacet | A type for a facet |
| TopFacetItr | Facet Iterator |
| TopModel | A tops model is roughly equivalent to a ParFUM FEM_Mesh object |
| TopModelDevice | include <cutil.h> |
| TopNodeElemItr | Node->Element adjacency Iterator |
| TopNodeItr | Node Iterator |
| TopoCentLB | |
| TopoCentLB::HeapNode | |
| TopoCentLB::PartGraph | |
| TopoCentLB::PartGraph::Node | |
| TopoLB | |
| TopologyAgent | |
| TopologyDescriptor | |
| TopoManager | |
| toProjectionsFile | |
| toProjectionsGZFile | |
| PUP::toText | |
| PUP::toTextFile | |
| PUP::toTextUtil | |
| PUP::tozDisk | |
| xi::TParam | |
| xi::TParamList | |
| xi::TParamType | |
| xi::TParamVal | |
| TProcessedLog | |
| Trace | |
| TraceArray | Array of Traces modules, every event raised will go through every Trace module |
| TraceBluegene | |
| TraceControlPoints | An instrumentation module making use of the tracing framework hooks provided in Charm++ |
| TraceControlPointsBOC | |
| TraceControlPointsInit | |
| TraceCore | |
| TraceCoreEvent | |
| TraceCounter | For each processor, TraceCounter calculates mean, stdev, etc of CPU performance counters for each entry point |
| TraceCounter::CounterArg | CounterArg is a linked list of strings that allows processing of command line args |
| TraceEntry | |
| TraceLogger | |
| TraceMemory | Class to trace all memory related events |
| TraceProjections | Class for recording trace projections events |
| TraceProjectionsBOC | |
| TraceProjectionsInit | |
| TraceProjector | |
| TraceSimple | TraceSimple is a template for an instrumentation module making use of the tracing framework hooks provided in Charm++ |
| TraceSimpleBOC | |
| TraceSimpleInit | |
| TraceSummary | Class for recording trace summary events |
| TraceSummaryBOC | |
| TraceSummaryInit | |
| TraceTau | TraceTau is a template for an instrumentation module making use of the tracing framework hooks provided in Charm++ |
| TraceTauBOC | |
| TraceTauInit | |
| TraceThreadListener | |
| TraceUtilization | |
| TraceUtilizationBOC | |
| TraceUtilizationInit | A main chare that can create the BOC/group |
| topo::impl::TreeBoundingBoxOn3dTorus< Iterator > | Utility class to partition the bounding box of a spanning (sub)tree on a 3D mesh machine and divide that into the necessary number of branches |
| topo::impl::TreeBoundingBoxOn3dTorus< Iterator >::lessThan | Configure a lessThan functor to compare vertices |
| TreeMatchLB | |
| TreeRouter | |
| Triangle3DElement | Provides ConcreteElement interface for one element of the TriangularSurfaceMesh class |
| TriangleSurfaceMesh | |
| TriangleSurfaceMesh::conn_t | Connectivity: 0-based node indices around our triangle |
| xi::TType | |
| tupleTable | |
| xi::TVar | |
| xi::TVarList | |
| TwoLevelTree | |
| xi::Type | |
| xi::TypeList | |
| uJcontext_stack_t | Describes the stack for a uJcontext flow of control |
| uJcontext_t | Represents a uJcontext flow of control |
| unionFind | |
| unionFindDest | |
| UniqElemList< T > | |
| updateAttrsMsg | A message that packs all attributes for a node |
| updateData | |
| updateMsg | |
| UpdateMsg | Message to send info to GVT |
| used_header_ | |
| xi::UsingScope | |
| UsrEvent | |
| xi::Value | |
| xi::ValueList | |
| vecStruct | |
| vector2d | |
| Mgc::Vector3 | |
| Vector_2< Type > | |
| Vector_3< Type > | Some basic geometric data types |
| VectorMigrateInfo | |
| vedegreedef | |
| verbosematchingDest | |
| VerboseProgress_t | |
| VerboseSurfProgress_t | |
| VerifyAckMsg | |
| verifyghostsendMsg | A message to verify if the IDXL entries for a node/element on one chunk is consistent with another chunk |
| Vertex | |
| Vertex_helper | Class to contain additional data about the vertices in object graph |
| VertexRecord | |
| VerticesListType | |
| VidBlock | A set of "Virtual ChareID"'s |
| vmLRUReplacementPolicy< ENTRY_TYPE, ENTRIES_PER_PAGE > | Class vmLRUPageReplacementPolicy This class provides the functionality of least recently used page replacement policy |
| vmNRUReplacementPolicy< ENTRY_TYPE, ENTRIES_PER_PAGE > | Class vmNRUPageReplacementPolicy This class provides the functionality of not-recently-used page replacement policy |
| cg3d::Volume3dDest | Compute the volume of the shape bounded by these faces |
| voxelAggregator | |
| vprocData | |
| vpwgtdef | |
| vrinfodef | |
| topo::impl::vtxEqual | Hack for PGI and Fujitsu STLport-using compilers because of their incorrect implementation of an STL routine |
| waitqd_QDChare | |
| win_obj | |
| WinStruct | |
| workspacedef | |
| PUP::wrap_er | "Wrapped" PUP::er: forwards requests to another PUP::er |
| MSA::Writable< ENTRY > | |
| MSA::write< T, D > | |
| MSA::write_cache_line< T > | |
| WSLB | |
| WSLB::LDStats | |
| WSLBStatsMsg | |
| ck::impl::XArraySectionReducer | Helper class to complete the last step in a cross-array reduction |
| PUP::xlater | |
| XpmemContext | |
| XpmemSendQ | |
| xi::XStr | |
| XT3TorusManager | |
| XTTorusManager | |
| PUP::zdisk | |
1.5.5