| __attribute__ | |
| __simdia_vec_f | |
| __simdia_vec_i | |
| __simdia_vec_lf | |
| _ackEntryMethodMsg | |
| _affMsg | |
| _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 | NodeCacheEntry represents the entry for a remote node that is requested by the chares on a processor |
| _CkErrStream | |
| _CkFuture | |
| _ckGroupID | |
| _CkOStream | |
| _CkOutStream | |
| _ckSemaID | |
| _cma_src_buffer_info | |
| _cmi_common_rdma_info | |
| _cmi_rdma_direct_ack | |
| _CmiObjId | |
| _converseRdmaMsg | |
| _CreateStatCollMsg | |
| _dllnode | |
| _DMsg | |
| _DummyMsg | |
| _group_list_t | |
| _GroupInfo | |
| _hostnameMsg | |
| _insert_ret_val | |
| _LDCommData | |
| _LDCommDesc | |
| _LDObjKey | |
| _LDOMid | |
| _list | |
| _nodeTopoMsg | |
| _ObjectID | |
| _ObjectID::s_array | |
| _pageentry | |
| _PencilArrayInfo | |
| _PencilBlock | |
| _PencilType | |
| _PersistentDestroyMsg | |
| _PersistentReqGrantedMsg | |
| _PersistentRequestMsg | |
| _ppc_atomic_mutex_t | |
| _ppc_atomic_t | |
| _ppcatomicq | |
| _ppcatomicstate | |
| _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 | |
| _statsHeader | |
| _topoDoneMsg | |
| _tree_t | |
| _WarningMsg | |
| 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 | |
| AdaptiveLB | |
| 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_AIO_req_str | |
| ADIOI_BGL_ConfInfo_t | |
| ADIOI_BGL_fs_s | |
| ADIOI_BGL_ProcInfo_t | |
| ADIOI_Datarep | |
| ADIOI_FileD | |
| ADIOI_Fl_node | |
| ADIOI_Fns_struct | |
| ADIOI_Hints_struct | |
| ADIOI_Offlen | |
| ADIOI_PVFS2_fs_s | |
| 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 | |
| Amm< T, N > | |
| AmmEntry< T > | |
| amount_and_extra_data_t | |
| AMPI_FuncPtr_Transport | |
| ampiCommStruct | |
| AmpiComplex | |
| AmpiDoubleComplex | |
| AmpiLongDoubleComplex | |
| AmpiMsgPool | |
| AmpiOpHeader | |
| AmpiOtherElement | Our local representation of another AMPI array element |
| AmpiRequest | Represents an MPI request that has been initiated using Isend, Irecv, Ialltoall, Send_init, etc |
| AmpiRequestList | |
| AmpiRequestPool | |
| ampiSplitKey | |
| ampiTopology | |
| ampiWorlds | This group is used to broadcast the MPI_COMM_UNIVERSE communicators |
| AmrCoordinator | |
| AmrUserData | |
| armci_giov_t | |
| Armci_Note | |
| ArmciMsg | |
| ArmciStridedMsg | |
| ArmciVirtualProcessor | |
| Builder::Array | |
| xi::Array | |
| ArrayBase | |
| ArrayDataItem< dtype, itype > | |
| 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 |
| ArrayElemExt | |
| ArrayIDHasher | |
| ck::ArrayIndexCompressor | |
| ArrayMapExt | |
| arrayMapInfo | Class used to store the dimensions of the array and precalculate numChares, binSize and other values for the DefaultArrayMap -- ASB |
| ArrayMeshStreamer< dtype, itype, ClientType, RouterType, EntryMethod > | |
| ArrayMeshStreamer< dtype, itype, ClientType, RouterType, EntryMethod >::DataItemHandle | |
| 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 |
| xi::AstChildren< Child > | |
| xi::AstNode | |
| atom | |
| 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 |
| BGQTorusManager | |
| bin_tree_storage_t | |
| bin_tree_t | |
| BinEntry | Bin entry record CPU time in an interval |
| BitVec | |
| BitVectorIterator< T > | |
| block | |
| block_header | |
| xi::BlockConstruct | |
| blockDim | |
| BlockLB | |
| blockLoc | |
| BlockMap | |
| blockSpan | |
| boolMsg | A Message to encapsulate a boolean |
| Boomarray< T > | |
| BQueue | Class to handle the boundaries of child partitions |
| bracket_elem_t | |
| BThreshold | |
| bucket_t | |
| SDAG::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 > | |
| call_migration_constructor< T, has_migration_constructor > | |
| call_migration_constructor< T, false > | |
| call_migration_constructor< T, true > | |
| 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 |
| xi::CaseConstruct | |
| xi::CaseListConstruct | |
| CBase | Base case for the infrastructure to recursively handle inheritance through CBase_foo from anything that implements X::pup() |
| CBase_AdaptiveLB | |
| CBase_ampi | |
| CBase_ampiParent | |
| CBase_ampiWorlds | |
| CBase_ArrayMeshStreamer | |
| CBase_Barrier | |
| CBase_BaseLB | |
| CBase_BlockLB | |
| CBase_BThreshold | |
| CBase_CentralLB | |
| CBase_CkCacheManager | |
| CBase_ckcallback_group | |
| CBase_ckcallback_main | |
| CBase_CkCheckpointMgr | |
| CBase_CkMemCheckPT | |
| CBase_collideMgr | |
| CBase_collideVoxel | |
| CBase_ComboCentLB | |
| CBase_CommAwareRefineLB | |
| CBase_CommLB | |
| CBase_CompletionDetector | |
| CBase_controlPointMain | |
| CBase_controlPointManager | |
| CBase_CpdPython | |
| CBase_CpdPythonGroup | |
| CBase_Director | |
| CBase_DistBaseLB | |
| CBase_DistributedLB | |
| CBase_DummyLB | |
| CBase_femMeshModify | |
| CBase_FuncCkLoop | |
| CBase_FuncSingleHelper | |
| CBase_GraphBFTLB | |
| CBase_GraphPartLB | |
| CBase_GreedyAgentLB | |
| CBase_GreedyCommLB | |
| CBase_GreedyLB | |
| CBase_GreedyRefineLB | |
| CBase_GridCommLB | |
| CBase_GridCommRefineLB | |
| CBase_GridHybridLB | |
| CBase_GridHybridSeedLB | |
| CBase_GridMetisLB | |
| CBase_GroupChunkMeshStreamer | |
| CBase_GroupMeshStreamer | |
| CBase_HbmLB | |
| CBase_HierarchicalLB | |
| CBase_HybridBaseLB | |
| CBase_HybridLB | |
| CBase_idaStarGroup | |
| CBase_idaStarWorker | |
| CBase_KMeansBOC | |
| CBase_LiveVizBoundElement | |
| CBase_liveVizGroup | |
| CBase_liveVizPollArray | |
| CBase_LV3D0_Manager | |
| CBase_LV3D_Array | |
| CBase_LV3D_PerfManager | |
| CBase_Manager | |
| CBase_Map | |
| CBase_MBlockChunk | |
| CBase_MeshStreamer | |
| CBase_MeshStreamerClient | |
| CBase_MetaBalancer | |
| CBase_MetaBalancerRedn | |
| CBase_MetisLB | |
| CBase_mpi_main | |
| CBase_MSA_CacheGroup | |
| CBase_MSA_PageArray | |
| CBase_NborBaseLB | |
| CBase_NeighborCommLB | |
| CBase_NeighborLB | |
| CBase_NodeLevelLB | |
| CBase_NormalLineArray | |
| CBase_NormalRealSlabArray | |
| CBase_NormalSlabArray | |
| CBase_NullLB | |
| CBase_OrbLB | |
| CBase_ParFUMShadowArray | |
| CBase_pathHistoryMain | |
| CBase_pathHistoryManager | |
| CBase_PhasebyArrayLB | |
| CBase_PythonCCS | |
| CBase_RandCentLB | |
| CBase_RecBipartLB | |
| CBase_RecBisectBfLB | |
| CBase_receiver | |
| CBase_redistributor2D | |
| CBase_RefineCommLB | |
| CBase_RefineKLB | |
| CBase_RefineLB | |
| CBase_RefineSwapLB | |
| CBase_RefineTopoLB | |
| CBase_RotateLB | |
| CBase_ScotchLB | |
| CBase_ScotchRefineLB | |
| CBase_ScotchTopoLB | |
| CBase_SearchConductor | |
| CBase_SearchNode | |
| CBase_sim | |
| CBase_SlabArray | |
| CBase_SparseSlabArray | |
| CBase_syncReductionMgr | |
| CBase_TCharm | |
| CBase_TeamLB | |
| CBase_TempAwareCommLB | |
| CBase_TempAwareGreedyLB | |
| CBase_TempAwareRefineLB | |
| CBase_threadCollideMgr | |
| CBase_TopoCentLB | |
| CBase_TopoLB | |
| CBase_TraceControlPointsBOC | |
| CBase_TraceProjectionsBOC | |
| CBase_TraceSimpleBOC | |
| CBase_TraceSummaryBOC | |
| CBase_TraceTauBOC | |
| CBase_TraceUtilizationBOC | |
| CBase_TreeMatchLB | |
| CBase_WriteSession | |
| CBase_WSLB | |
| CBase_ZoltanLB | |
| 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 |
| SDAG::CCounter | |
| CCS_AUTH_clients | |
| CCS_RAND_state | |
| CcsDelayedReply_struct | |
| CcsHandlerRec | |
| CcsImplHeader | |
| CcsMessageHeader | |
| CcsSec_secretKey | |
| CcsSecAttr | |
| CcsSecMan | |
| CcsServer | |
| Cell | |
| Cell1D | |
| Cell2D | |
| Cell3D | |
| center_of_mass | |
| CentralLB | |
| CentralLB::FutureModel | |
| xi::CEntry | |
| Cfuture_data_s | |
| Cfuture_s | |
| CfutureValue_s | |
| cgSolver | Iterative Linear Solver: Conjugate Gradient method |
| Builder::Chare | |
| 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 |
| CharmNotifyMsg | |
| CheckpointBarrierMsg | |
| CheckPointDataMsg | |
| ChildInitMsg | |
| ChildLoadInfo | |
| ChInfiAddr | |
| ChMessage | |
| ChMessageHeader | |
| ChMessageInt_t | |
| ChMessageLong_t | |
| ChNodeinfo | |
| chpt< StateType > | Templated checkpointing class derived from rep |
| ChSingleNodeinfo | |
| chunk | |
| chunk::elemHeap | |
| ChunkDataItem | |
| chunkList | |
| chunkListMsg | A message to return data about the chunks that share/ghost a node/element |
| chunkMsg | |
| ChunkOutOfOrderBuffer | |
| ChunkReceiveBuffer | |
| 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 | |
| CkArrayCreatedMsg | |
| 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 | |
| CkArrayIndex2D | |
| CkArrayIndex3D | |
| CkArrayIndex4D | |
| CkArrayIndex5D | |
| CkArrayIndex6D | |
| CkArrayIndexBase | Base class for array index objects used in charm |
| CkArrayIndexBitVec | |
| 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 |
| CkArrayThreadListener | |
| CkAxes3d | X, Y, and Z axes: a right-handed frame, used for navigation |
| CkBbox3d | |
| CkBitVector | |
| CkCacheArrayCounter | |
| CkCacheEntry< CkCacheKey > | |
| CkCacheEntryType< CkCacheKey > | |
| CkCacheFillMsg< CkCacheKey > | |
| CkCacheManager< CkCacheKey > | |
| CkCacheRequestMsg< CkCacheKey > | |
| CkCacheRequestorData< CkCacheKey > | |
| 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 |
| CkCheckpointStatusMsg | |
| CkCheckPTEntry | |
| 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 |
| CkCreateArrayAsyncMsg | |
| CkDataMsg | Very generic message type: contains a bunch of bytes |
| CkDataSegHeader | |
| CkDDT | |
| CkDDT_DataType | |
| CkDDT_HIndexed | |
| CkDDT_HIndexed_Block | |
| CkDDT_Vector | |
| 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 | |
| CkExtContributeInfo | |
| 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 | |
| CkIndex_ArrayBase | |
| CkIndex_Group | |
| CkInsertIdxMsg | |
| 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 |
| CkLocRec | A CkLocRec is our local representation of an array element |
| CkMagicNumber< T > | |
| CkMagicNumber_impl | A tiny class for detecting heap corruption |
| CkMapsInit | |
| CkMarshalledCLBStatsMessage | |
| CkMarshalledMessage | |
| CkMarshalledNLBStatsMessage | |
| CkMarshallMsg | |
| CkMatrix3d | A 4x4 matrix |
| CkMcastBaseMsg | |
| CkMemCheckPT | |
| CkMemCheckPTInfo | |
| CkMessage | CkMessage is the superclass of all Charm++ messages |
| 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 |
| CkMigrateMessage | |
| CkMsgQ< MSG > | |
| CkMulticastMgr | A multicast manager group that is a CkDelegateMgr |
| CkNcpyBuffer | |
| CkNcpyBufferPost | |
| CkNodeReductionMgr | One CkReductionMgr runs a non-overlapping set of reductions |
| 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 | |
| CkOutStream | |
| CkPagedVector< T > | An array that is broken up into "pages" which are separately allocated |
| CkPointer< T > | |
| 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::reducerStruct | |
| CkReduction::setElement | |
| CkReduction::statisticsElement | |
| CkReduction::tupleElement | |
| CkReductionClientBundle | Tiny utility class used by CkReductionClientAdaptor-- lets us keep backward compatability with the old C-style interface |
| CkReductionInactiveMsg | |
| CkReductionMgr | |
| CkReductionMsg | |
| CkReductionNumberMsg | |
| CkReference< T > | |
| CkReferenceCounted | |
| CkRegisteredInfo< T > | This class stores registered entities, like EntryInfo's, in a linear list indexed by index ("idx") |
| ckrinfo_t | |
| 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 | Contains array/group ID for a section, and state information for CkMulticast to manage the section |
| CkSectionInfo::CkSectionInfoStruct | For now we still need to encapsulate CkSectionInfo's data in a separate CkSectionInfoStruct because it is used in ckcallback inside a union, and C++03 doesn't support placing objects with non-trivial constructors in unions |
| 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 netlrts- versions don't have printf until they're pretty well started |
| xi::ClassDeclaration | |
| CLBStatsMsg | |
| CldMap | Map object-- use seed load balancer |
| CldNeighborData_s | |
| CldProcInfo_s | |
| CldProcPriorInfo_s | |
| CldSlavePriorInfo_s | |
| CldToken_s | |
| client | |
| SDAG::Closure | |
| 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_CharmNotifyMsg | |
| CMessage_ChildInitMsg | |
| CMessage_chunkListMsg | |
| CMessage_chunkMsg | |
| CMessage_CkArgMsg | |
| CMessage_CkArrayCheckPTMessage | |
| CMessage_CkArrayCheckPTReqMessage | |
| CMessage_CkArrayCreatedMsg | |
| CMessage_CkArrayElementMigrateMessage | |
| CMessage_CkCacheFillMsg | |
| CMessage_CkCacheRequestMsg | |
| CMessage_CkCcsRequestMsg | |
| CMessage_CkCheckpointStatusMsg | |
| CMessage_CkCreateArrayAsyncMsg | |
| CMessage_CkDataMsg | |
| CMessage_CkGroupCallbackMsg | |
| CMessage_CkMarshallMsg | |
| CMessage_CkMessage | |
| CMessage_CkProcCheckPTMessage | |
| CMessage_CkReductionInactiveMsg | |
| CMessage_CkReductionMsg | |
| CMessage_CkReductionNumberMsg | |
| CMessage_controlPointMsg | |
| CMessage_cookieMsg | |
| CMessage_coordMsg | |
| CMessage_countMsg | |
| CMessage_destMsg | |
| CMessage_DestroyNotifyMsg | |
| 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_HelperNotifyMsg | |
| CMessage_int2Msg | |
| CMessage_intMsg | |
| CMessage_KMeansStatsMessage | |
| CMessage_KSeedsMessage | |
| CMessage_KSelectionMessage | |
| CMessage_LBMigrateMsg | |
| CMessage_LBScatterMsg | |
| CMessage_LBVectorMigrateMsg | |
| CMessage_LEsplitMsg | |
| CMessage_LEsplitResult | |
| 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_SessionCommitMsg | |
| CMessage_SessionReadyMsg | |
| CMessage_sharedNodeMsg | |
| CMessage_splitOutMsg | |
| CMessage_splitResponse | |
| CMessage_StartUpMsg | |
| CMessage_TCharmInitMsg | |
| CMessage_threeNodeMsg | |
| CMessage_updateAttrsMsg | |
| CMessage_UpdateMsg | |
| CMessage_updateMsg | |
| CMessage_verifyghostsendMsg | |
| CMessage_WSLBStatsMsg | |
| cmi_cpu_idlerec | |
| CmiChunkHeader | This header goes before each chunk of memory allocated with CmiAlloc |
| CmiFragmentHeader | |
| CmiHandlerInfo | |
| CmiHwlocTopology | |
| CmiIdleLock | |
| CmiIdleState | |
| CmiIsomallocBlock | |
| CmiIsomallocBlockList | |
| CmiMainFnArg_s | |
| CmiMemAllocHdr_ppcq_t | |
| CmiMemUsageStruct | |
| CmiMultipleSendHeader | |
| CmiNodeStateStruct | |
| CmiNotifyCommThdMsg | |
| CmiReduction | |
| CmiSpanningTreeInfo | |
| CmiStateStruct | |
| CmiTmpBuf_t | |
| CmmEntryStruct | |
| CmmTableStruct | |
| cnbr_t | |
| 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 | |
| ComboCentLB | |
| comlibAgent | |
| CommAwareRefineLB | |
| CommAwareRefineLB::HeapData | |
| CommAwareRefineLB::ObjLoadGreater | |
| CommAwareRefineLB::ObjPeCommInfo | |
| CommAwareRefineLB::PeCommInfo | |
| CommAwareRefineLB::ProcCommGreater | |
| CommAwareRefineLB::ProcLoadGreater | |
| CommLB | |
| CompareRankDist | |
| CompletionDetector | |
| CompletionStatus | |
| 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 | |
| Builder::ConsEntry | |
| Builder::SDAG::Construct | |
| xi::Construct | |
| xi::ConstructList | |
| xi::ConstType | |
| SDAG::Continuation | |
| contributorInfo | Some data classes used by both ckreductionmgr and cknodereductionmgr |
| 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 |
| converseNotifyMsg | |
| ConvQdMsg | |
| ConvQdState | |
| cookieMsg | |
| coord | |
| coordMsg | |
| CountLogPool | Counter log pool this implements functions for TraceCounter but that needed to be performed on a node-level |
| countMsg | |
| 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< T > | 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_s | |
| CpmDestinationSend_s | |
| CpmDestinationStruct | |
| CpmDestinationThreadSize_s | |
| 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 | |
| CProxyElement_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 > | |
| crashedrank | |
| CsdSchedulerState_t | |
| SDAG::CSpeculator | |
| xi::CStateVar | |
| CtgGlobalList | Keeps a list of global variables |
| CtgGlobalList::CtgRec | |
| CtgGlobalStruct | |
| CthProcInfo_s | |
| CthThreadBase | |
| CthThreadListener | |
| CthThreadStruct | |
| CthThreadToken | |
| xi::CToken | |
| ctrl_t | |
| CurLoopInfo | |
| CurrentLocationMsg | |
| CWebModeStats | This "usage" section keeps track of percent of wall clock time spent actually processing messages on each processor |
| data_t | |
| rfmodel::DataMatrix | |
| 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 > | |
| SDAG::Dependency | |
| 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 |
| DestroyNotifyMsg | |
| Determinant | Struct to store the determinant of a particular message |
| Ck::IO::impl::Director | |
| PUP::disk | |
| DistBaseLB | |
| DistBaseLB::LDStats | |
| DistributedLB | |
| DistributeObjectMsg | |
| DLOOP_Dataloop | |
| DLOOP_Dataloop_blockindexed | |
| DLOOP_Dataloop_common | |
| DLOOP_Dataloop_contig | |
| DLOOP_Dataloop_indexed | |
| DLOOP_Dataloop_stackelm | |
| DLOOP_Dataloop_struct | |
| DLOOP_Dataloop_vector | |
| DLOOP_Segment | |
| double2Msg | A message to encapsulate two doubles |
| DoubleDouble | |
| DoubleInt | |
| doubleMsg | |
| DType | |
| DummyLB | |
| DummyMigrationMsg | |
| dynChunk | A dynamic (growing) representation of a chunk |
| Edge | |
| edge | |
| 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 | |
| ElementDestroyer | |
| ElementDistributor | |
| ElementPacker | |
| ElemID | A reference to an element |
| ElemList< T > | |
| elemList | |
| elemRef | |
| xi::EllipsisType | |
| Builder::SDAG::Else | |
| xi::ElseConstruct | |
| eltset | |
| xi::EncapState | |
| entDataMsg | A message that packs all data for a node/element |
| entityPackList | |
| Builder::Entry | |
| xi::Entry | |
| EntryInfo | Represents a single entry method or constructor |
| xi::EntryList | |
| Builder::EntryType | |
| envelope | |
| envelope::envelopeSizeHelper | |
| 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 |
| externalBCpatch | |
| extrudeMethod | |
| faceMsg | |
| faceReceiver | Receives faces from the wire |
| faceSender | Sends faces across the wire to one destination |
| faceSet | |
| false_type | |
| 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::File | |
| Builder::File | |
| Ck::IO::impl::FileInfo | |
| Ck::IO::FileReadyMsg | |
| final | |
| findgsMsg | A message that packs the indices of a bunch of chunks (used for ghost send) |
| ck::FixedArrayIndexCompressor | |
| fixedBufferT< T > | |
| fixedConcreteElement | Testing stub for GenericElement |
| fixedlength_bitvector< NUM_BITS > | Fast, fixed-size bitvector class |
| flatten_state | |
| flip23request | |
| flip23response | |
| flip32request | |
| flip32response | |
| FloatFloat | |
| FloatInt | |
| Builder::SDAG::For | |
| Builder::SDAG::ForAll | |
| SDAG::ForallClosure | |
| xi::ForallConstruct | |
| xi::ForConstruct | |
| rfmodel::ForestModel | |
| FourLevelTree | |
| FP | |
| FreeMPMCNodePoolStruct | |
| FreeNodePoolStruct | |
| PUP::fromDisk | |
| PUP::fromMem | |
| fromProjectionsFile | |
| PUP::fromTextFile | |
| PUP::fromzDisk | |
| FuncCkLoop | |
| FuncSingleHelper | |
| xi::FuncType | |
| Future_s | |
| FutureBOC | |
| FutureInitMsg | |
| FutureMain | |
| FutureState | |
| GenericElement | Class to encapsulate all element-type specific methods |
| Builder::GenList< Elem, List > | |
| Builder::GenListLineNo< Elem, List > | |
| ghostdata | Structure for storing the ghost layers |
| gk_graph_t | |
| gk_HTable_t | |
| gk_i2cc2i_t | |
| gk_mcore_t | |
| gk_mop_t | |
| gk_option | The structure that stores the information about the command-line options |
| gk_seq_t | |
| gk_str_t | |
| gk_StringMap_t | |
| gk_Tokens_t | |
| GPUReq | |
| graph | |
| Graph | |
| graph_t | |
| GraphBFTLB | |
| GraphPartLB | |
| GreedyAgentLB | |
| GreedyAgentLB::HeapData | |
| GreedyCommLB | |
| GreedyLB | |
| GreedyLB::HeapData | |
| GreedyLB::ObjLoadGreater | |
| GreedyLB::ProcLoadGreater | |
| GreedyRefineLB | |
| GreedyRefineLB::GObj | |
| GreedyRefineLB::GProc | |
| GreedyRefineLB::ObjLoadGreater | |
| GreedyRefineLB::PHeap | |
| GreedyRefineLB::Solution | |
| greq_class_desc | |
| GridCommLB | |
| GridCommRefineLB | |
| GridHybridLB | |
| GridHybridSeedLB | |
| GridMetisLB | |
| Builder::Group | |
| xi::Group | |
| Group | |
| GroupChunkMeshStreamer< dtype, ClientType, RouterType, EntryMethod > | |
| GroupDef_s | |
| GroupDepNum | |
| GroupExt | Lightweight object to support chares defined outside of the C/C++ runtime Relays messages to appropiate external chare |
| GroupIdxArray< dtype > | |
| GroupMeshStreamer< dtype, ClientType, RouterType, EntryMethod > | |
| groupStruct | |
| growableBufferT< T > | |
| GVT | GVT chare group for estimating GVT |
| GVTMsg | Message to send GVT estimate back to PVT |
| MSA::handle< T, D > | |
| charmxx::has_pup_member< T, > | |
| charmxx::charmxx::has_pup_member< T, cpp17::void_t< decltype(std::declval< T >().pup(std::declval< PUP::er & >()))>> | |
| hash2_t | |
| std::std::hash< CmiUInt16 > | |
| hash_t | |
| hashCache< n > | |
| hashCache1< KEY, OBJ > | |
| Hashnode | |
| Hashnode::tupledata | |
| HashQueueT< KEY, OBJ > | |
| HbmLB | |
| HbmLB::LevelData | |
| HbmLB::MigrationRecord | |
| heap_node_t | |
| heap_t | |
| heapIterator | |
| HeapNode | Structure for storing events on a heap |
| heapRecord | |
| HelperNotifyMsg | |
| HGRAPH_DATA | |
| HierarchicalLB | |
| HierLBTypes | |
| hilbert_pair | |
| HilbertArrayMap | |
| hIterator | |
| hRecord | |
| HybridBaseLB | |
| HybridBaseLB::LevelData | |
| HybridBaseLB::MigrationRecord | |
| HybridLB | |
| HypercubeTree | |
| 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 |
| Builder::SDAG::If | |
| xi::IfConstruct | |
| 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 | |
| imaxdiv_t | |
| impl_LV3D_Array | |
| xi::IncludeFile | |
| IndexHasher | |
| infiCmiChunkHeaderHelper | |
| infiCmiChunkHeaderStruct | |
| InfoRecord | |
| InfoStruct | |
| Builder::InitCall | |
| 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 | |
| xi::IntExprConstruct | |
| IntInt | |
| intMsg | A message to encapsulate an integer |
| IRecvListEntry | |
| IrrGroup | |
| charmxx::is_array_proxy< T > | Check if `T` is a Charm++ proxy for an array chare |
| type | |
| charmxx::is_bound_array< T, > | Check if `T` is a Charm++ bound array |
| charmxx::bind_to >>< T > | |
| charmxx::is_chare_proxy< T > | Check if `T` is a Charm++ proxy for a chare |
| charmxx::is_group_proxy< T > | Check if `T` is a Charm++ proxy for a group chare |
| charmxx::is_node_group_proxy< T > | Check if `T` is a Charm++ proxy for a node group chare |
| charmxx::is_pupable< T, U > | |
| PUP::details::is_pupable< T, U > | |
| charmxx::charmxx::is_pupable< T, cpp17::void_t< decltype(std::declval< PUP::er & >()|std::declval< T & >())>> | |
| PUP::details::PUP::details::is_pupable< T, void_t< decltype(std::declval< T >().pup(std::declval< PUP::er & >()))>> | |
| IsDerivedFrom< D, B > | |
| IsDerivedFrom< D, B >::No | |
| IsDerivedFrom< D, B >::Yes | |
| isparams_t | |
| Iterator | |
| std::iterator_traits< Iterator > | |
| std::std::iterator_traits< T * > | |
| KeyvalNode | |
| KeyvalPair | |
| killPortStruct | |
| KLevelTree | |
| KMeansBOC | |
| KMeansStatsMessage | |
| KSeedsMessage | |
| KSelectionMessage | |
| l2g_t | This class describes a local-to-global index mapping, used in FEM_Print |
| large_block_header | |
| LBCommData | |
| LBCommTable | |
| LBDatabase | |
| LBDatabase::LastLBInfo | |
| LBDB | |
| LBDB::batsyncer | |
| LBDB::LBObjEntry | |
| 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 | |
| LBObjUserData | |
| LBOM | |
| LBPredictorFunction | |
| LBProfit | Module which determines if a load balancing cycle is profitable |
| LBScatterMsg | |
| 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 | |
| LBUserDataLayout | |
| LBVectorMigrateMsg | |
| LDBarrierClient | |
| LDBarrierReceiver | |
| LDCallbacks | |
| LDCommDescComp | |
| LDHandle | |
| LDObjData | |
| LDObjHandle | |
| LDObjStats | |
| LDOMHandle | |
| LeakSearchInfo | |
| LEsplitMsg | |
| LEsplitResult | |
| linearOffsetMatcher | |
| LineFFTinfo | |
| listNode | |
| LiveVizBoundElement | |
| 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 | |
| LocalBroadcaster< dtype, ClientType, EntryMethod > | |
| LocalElementCounter | |
| localStat | Group to gather stats on each PE separately |
| localStatSummary | Message to gather local stats from all PEs for printing |
| Location | |
| 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 | |
| loopChunkMsg | |
| 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 |
| LZ4_stream_t_internal | |
| LZ4_stream_u | |
| LZ4_streamDecode_t_internal | |
| LZ4_streamDecode_u | |
| PUP::machineInfo | |
| xi::MacroDefinition | |
| main | |
| xi::MainChare | |
| Builder::MainChare | |
| MainchareExt | Lightweight object to support mainchares defined outside of the C/C++ runtime |
| MainInfo | Describes a mainchare's constructor. These are all executed at startup |
| PUP::details::make_void< Ts > | |
| mallinfo | |
| malloc_chunk | |
| malloc_params | |
| malloc_segment | |
| malloc_state | |
| malloc_tree_chunk | |
| Ck::IO::impl::Manager | |
| Ck::IO::impl::Map | |
| marshallNewHeapCopy< T > | Unmarshall into a heap-allocated copy |
| matchingDest | |
| Mgc::Math | |
| Matrix | Matrix class with some fundmental operations |
| 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 | |
| memBuf | |
| MemElementPacker | |
| 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 |
| mesh_t | |
| meshChunk | Manages the on-the-wire mesh format when sending or receiving tet mesh chunks |
| meshChunk::header_t | |
| 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 |
| MeshRouter< Derived > | |
| meshState | |
| MeshStreamer< dtype > | |
| MeshStreamerClient< dtype > | |
| MeshStreamerMessage< dtype > | |
| Builder::Message | |
| xi::Message | |
| Builder::MessageVar | |
| MetaBalancer | |
| MetaBalancer::AdaptiveData | |
| MetaBalancer::AdaptiveLBInfo | |
| MetaBalancer::AdaptiveLBStructure | |
| MetaBalancer::AdaptiveMetaBalancer | |
| MetaBalancerRedn | |
| MetaLBInit | |
| MetisLB | |
| MigrateDecision | |
| MigrateInfo | Migration decision for an obj |
| MigrationNotice | |
| MigrationNoticeAck | |
| MigrationRecord | |
| minHeap | |
| MlogEntry | Entry in a message log |
| rfmodel::Model | |
| MSA::modifiable_cache_line< T > | |
| xi::Module | |
| Builder::Module | |
| Builder::ModuleEntity | |
| MPI_F08_status | |
| mpi_main | |
| MPI_Status | |
| MPICtrlMsgEntry | |
| MPIO_Datatype_s | |
| MPIO_File_ds_params | |
| MPIO_File_ib_params | |
| MPIO_iovec | |
| mpiPostRecvList | |
| MPIR_Info | |
| MPMCDataNodeStruct | |
| MPMCQueueStruct | |
| MPSCQueueStruct | |
| 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 | |
| SDAG::MsgClosure | |
| MsgHeap | |
| MsgInfo | Represents one type of Message |
| MsgPool | |
| conv::msgQ< P > | Charm Message Queue: Holds msg pointers and returns the next message to execute on a PE |
| xi::MsgVar | |
| xi::MsgVarList | |
| MulticastAgent | |
| MulticastAgent::MInfo | |
| multicastGrpMsg | Message send in spanning tree |
| multicastSetupMsg | Multicast tree setup message |
| MultiMsg_s | |
| mutex_t | |
| myGlobals | |
| MyHierarchyTree | |
| MyHmbHierarchyTree | |
| xi::NamedEllipsisType | |
| xi::NamedType | |
| NborBaseLB | |
| NborBaseLB::LDStats | |
| NcpyBcastAckInfo | |
| NcpyBcastInterimAckInfo | |
| NcpyBcastRecvPeerAckInfo | |
| NcpyBcastRootAckInfo | |
| NcpyEmBufferInfo | |
| NcpyEmInfo | |
| NcpyROBcastAckInfo | |
| NcpyROBcastBuffAckInfo | |
| ncpystruct | |
| 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 |
| NodeAwareMeshRouter | |
| NodeElem | |
| xi::NodeGroup | |
| NodeGroup | |
| Builder::NodeGroup | |
| NodeLevelLB | |
| nodeMsg | |
| nodeRef | |
| Nodes | |
| nodeVoteMsg | |
| cg3d::NonManifoldException | Under OSL_CG3D_DEBUG, this exception is thrown by ~Volume3dDest: |
| NormalFFTinfo | |
| NormalLineArray | |
| NormalRealSlabArray | |
| NormalSlabArray | |
| nrinfo_t | |
| 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 | |
| ObjGraphTemp | |
| ck::ObjID | The basic element identifier |
| objListMsg | |
| objListMsg::returnReceipt | |
| objRef | |
| xi::OListConstruct | |
| open_status_s | |
| opt | |
| opt2 | |
| opt3 | |
| options | |
| Ck::IO::Options | Note: The values in options are not currently a stable or working interface |
| OrbLB | |
| OrbLB::ComputeLoad | |
| OrbLB::Partition | |
| OrbLB::VecArray | |
| orientation | |
| OrigFn | |
| Origin | |
| OutgoingMsgRec | |
| overheadContainer | A container that stores overhead statistics (min/max/avg etc.) |
| Builder::SDAG::Overlap | |
| xi::OverlapConstruct | |
| MSA::owner< T, D > | |
| ParallelSolver | |
| parallelSurfaceTransfer_c | |
| parallelTransfer_c | |
| xi::Parameter | |
| Builder::Parameter | |
| xi::ParamList | |
| params_t | |
| ParFUM_collider | ParFUM Collision Interface File |
| ParFUMShadowArray | |
| partconndata | Structure to store connectivity data after the global element partition has been returned by parmetis |
| PartitionInfo | |
| PartitionList | |
| PartitionRecord | |
| patch | |
| patchReader | |
| 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 | The beginning of definitions for simple pcqueue |
| pdbf | |
| PE_Data_T | |
| peAddr | |
| peinfo | |
| xi::details::perElemC< T, U > | Apply fn_ on each non-NULL element in the list l |
| xi::details::perElemGen2C< T, U, A > | Apply fn_ on each Construct in the list l, passing it arg as the target |
| xi::details::perElemGenC< T, U, A > | Apply fn_ on each Construct in the list l, passing it arg as the target |
| PersistentReq | |
| PhasebyArrayLB | |
| PhaseEntry | Phase entry for trace summary |
| PhaseTable | Table of PhaseEntry |
| 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 | |
| pose | Coordinator of simulation initialization, start and termination |
| POSE_Config | |
| ppdeffind | |
| 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 | |
| PrismMesh | |
| PrismMesh::conn_t | Connectivity: 0-based node indices around our prism |
| problem | |
| ProcArray | |
| ProcArrayTemp | |
| processorInfo | |
| ProcInfo | |
| 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 |
| pthread_mlock_t | |
| Builder::PtrType | |
| xi::PtrType | |
| 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 | |
| re_backref_cache_entry | |
| re_charset_t | |
| re_dfa_t | |
| re_dfastate_t | |
| re_fail_stack_ent_t | |
| re_fail_stack_t | |
| re_match_context_t | |
| re_node_set | |
| re_pattern_buffer | |
| re_registers | |
| re_sift_context_t | |
| re_state_table_entry | |
| re_string_t | |
| re_sub_match_last_t | |
| re_sub_match_top_t | |
| re_token_t | |
| MSA::read< T, D > | |
| ReadFileMap | This map can be used for topology aware mapping when the mapping is provided through a file -- ASB |
| xi::Readonly | |
| readonly< dtype > | |
| Builder::Readonly | |
| readonlybase | |
| ReadOnlyExt | Supports readonlies outside of the C/C++ runtime. See README.charm4py |
| ReadonlyInfo | Describes a readonly global variable |
| ReadonlyMsgInfo | Describes a readonly message |
| readytoexectoken_s | |
| RecBipartLB | |
| RecBisectBfLB | |
| ReceivedDetData | |
| ReceivedTNData | |
| receiver | |
| receiver::_tblEntry | |
| receiverMsg | |
| PUP::reconstruct | A utility to let classes avoid default construction when they're about to be unpacked, by defining a constructor that takes a value of type PUP::reconstruct |
| recursive_pup_impl< T, automatic > | |
| recursive_pup_impl< MeshStreamer< dtype, RouterType >, 1 > | |
| recursive_pup_impl< T, 0 > | |
| recursive_pup_impl< T, 1 > | |
| RecvCtrlMsgEntry | |
| 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 | |
| RefinerTemp | |
| RefineSwapLB | |
| RefineSwapLB::HeapData | |
| RefineSwapLB::ObjLoadGreater | |
| RefineSwapLB::ProcLoadGreater | |
| RefineSwapLB::ProcLoadGreaterIndex | |
| RefineTopoLB | |
| refMsg | |
| RegionID | |
| regmatch_t | |
| RemoveDeterminantsHeader | Struct for the header of the removeDeterminants handler |
| 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 | |
| PUP::requires_impl< B > | |
| PUP::PUP::requires_impl< false > | |
| ResendData | |
| ResendRequest | |
| RestartProcessorData | |
| RestartRequest | Struct to request a particular action during restart |
| RestoredLocalMap | Class for storing metadata of local messages |
| resultsCoarsenClient | |
| resultsRefineClient | |
| RetainedMigratedObject | |
| rngen_ | |
| roarray< dtype, len > | |
| romsg< dtype > | |
| RotateLB | |
| Route | |
| RRMap | |
| RSSN | Class that stores all received-sender-sequence-numbers (rssn) from another object |
| RunDescriptor | |
| xi::RValueReferenceType | |
| xi::rwentry | |
| ck::impl::s_attribs | |
| s_pathfixlist | |
| s_ppdef | |
| SafePool< T > | |
| savedViewRecord | |
| xi::Scope | |
| ScotchLB | |
| ScotchRefineLB | |
| ScotchTopoLB | |
| xi::SdagCollection | |
| xi::SdagConCall< T > | |
| xi::xi::SdagConCall< void > | |
| xi::SdagConstruct | |
| xi::SdagEntryConstruct | |
| SearchConductor | |
| SearchGroup | |
| SearchNode | |
| SearchNodeMsg | |
| searchResults | |
| SectionLocation | |
| PUP::seekBlock | |
| seg1dT< T > | |
| SendFFTMsg | |
| sendState | Describes the outgoing mesh |
| Builder::SDAG::SEntry | |
| seq | |
| Builder::SDAG::Sequence | |
| SequentialSolver | |
| Builder::SDAG::Serial | |
| serial_comm | An ILSI_Comm that holds a single, serial, dense matrix |
| serialCollideClient | |
| xi::SerialConstruct | |
| SerialTree | |
| Ck::IO::Session | |
| Ck::IO::SessionCommitMsg | |
| Ck::IO::SessionReadyMsg | |
| 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 |
| ShortInt | |
| sim | Poser wrapper base class |
| SimpleMeshRouter | |
| 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 | |
| xi::SListConstruct | |
| 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 |
| SpanningTreeGenerator< Iterator > | Abstract class (interface) to generate a spanning tree from a set of pes or logical (Charm++) nodes |
| 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 |
| SRtable | A table for storing the number of sends and recvs at a timestamp |
| SSEDouble | |
| SSEFloat | |
| ST_RecursivePartition< Iterator > | This strategy is phynode aware, and can form a tree of pes or logical nodes |
| ST_RecursivePartition< Iterator >::PhyNode< Iterator > | |
| ST_RecursivePartition< Iterator >::PhyNodeCompare< Iterator > | |
| StartUpMsg | |
| StatCollector | |
| state_array_t | |
| 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 | |
| StoreDeterminantsHeader | Struct for the header of the storeDeterminants handler |
| strat | Base synchronization strategy class |
| 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 | |
| syncReductionMgr | |
| SystemLoad | |
| TableEntry | |
| taskGraphArray | |
| taskGraphSolver | |
| TaskQueueStruct | |
| taskStruct | |
| TCharm | |
| TCharm::TCharmSemaphore | |
| TCharm::ThreadInfo | |
| TCharm::UserData | |
| TCHARM_Thread_options | |
| TCharmClient1D | |
| TCharmInitMsg | |
| TCharmMain | |
| TCharmTraceLibList | |
| TeamLB | |
| TempAwareCommLB | |
| TempAwareCommLB::HeapData | |
| TempAwareCommLB::ObjLoadGreater | |
| TempAwareCommLB::ObjPeCommInfo | |
| TempAwareCommLB::PeCommInfo | |
| TempAwareCommLB::ProcCommGreater | |
| TempAwareCommLB::ProcLoadGreater | |
| TempAwareGreedyLB | |
| TempAwareGreedyLB::HeapData | |
| TempAwareGreedyLB::ObjLoadGreater | |
| TempAwareGreedyLB::ProcLoadGreater | |
| TempAwareRefineLB | |
| TempAwareRefineLB::HeapData | |
| xi::Template | |
| PUP::detail::TemporaryObjectHolder< T, b > | |
| PUP::detail::PUP::detail::TemporaryObjectHolder< T, false > | |
| PUP::detail::PUP::detail::TemporaryObjectHolder< T, true > | |
| xi::TEntity | |
| test_param_t | |
| test_params_t | |
| 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 | Structure for a ticket assigned to a particular message |
| TicketReply | |
| TicketRequest | |
| TimeBucket | TimeBucket associates a time range with (a) large block(s) of memory |
| TimePool | |
| tlsseg | |
| 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 | |
| TopologyRequest | |
| 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 |
| TramBroadcastInstance< CkArrayIndex > | |
| TramBroadcastInstance< CkArrayIndex1D > | |
| TramBroadcastInstance< CkArrayIndex2D > | |
| TramBroadcastInstance< CkArrayIndex3D > | |
| TramBroadcastInstance< CkArrayIndex4D > | |
| TramBroadcastInstance< CkArrayIndex5D > | |
| TramBroadcastInstance< CkArrayIndex6D > | |
| xi::TramInfo | |
| transfer_t | |
| SDAG::TransportableBigSimLog | |
| 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 | |
| TreeMatchLB::ObjLoadGreater | |
| TreeMatchLB::ProcLoadGreater | |
| rfmodel::TreeModel | |
| Triangle3DElement | Provides ConcreteElement interface for one element of the TriangularSurfaceMesh class |
| TriangleSurfaceMesh | |
| TriangleSurfaceMesh::conn_t | Connectivity: 0-based node indices around our triangle |
| true_type | |
| xi::TType | |
| xi::TTypeEllipsis | |
| tupleTable | |
| xi::TVar | |
| xi::TVarList | |
| TwoLevelTree | |
| Builder::Type | |
| xi::Type | |
| Builder::TypeBase | |
| xi::TypeList | |
| ck::impl::u_type | These structures store the type-specific message information |
| ck::impl::u_type::s_array | |
| ck::impl::u_type::s_chare | |
| ck::impl::u_type::s_group | |
| ck::impl::u_type::s_roData | |
| ck::impl::u_type::s_roMsg | |
| uFcontext_stack_t | |
| uFcontext_t | |
| 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 | |
| uvw_t | |
| Builder::Value | |
| xi::Value | |
| xi::ValueList | |
| vector2d | |
| Mgc::Vector3 | |
| Vector_2< Type > | |
| Vector_3< Type > | Some basic geometric data types |
| VectorMigrateInfo | |
| 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 |
| view_state | |
| VirtualRouter< Derived > | |
| vkrinfo_t | |
| 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 |
| vnbr_t | |
| cg3d::Volume3dDest | Compute the volume of the shape bounded by these faces |
| voxelAggregator | |
| topo::impl::vtxEqual | Hack for PGI and Fujitsu STLport-using compilers because of their incorrect implementation of an STL routine |
| waitqd_QDChare | |
| xi::WhenConstruct | |
| Builder::SDAG::WhenTemp< T > | |
| Builder::SDAG::While | |
| xi::WhileConstruct | |
| win32_mlock_t | |
| win_obj | |
| WinStruct | |
| PUP::wrap_er | "Wrapped" PUP::er: forwards requests to another PUP::er |
| MSA::Writable< ENTRY > | |
| MSA::write< T, D > | |
| MSA::write_cache_line< T > | |
| Ck::IO::impl::WriteSession | |
| Ck::IO::impl::WriteSession::buffer | |
| 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 | |
| XTTorusManager | |
| PUP::zdisk | |
| ZoltanLB | |
1.5.5