| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| // This file contains a class, NAClusterInfo, which provides information about |
| // the cluster in which SQL/MX is running. It assumes that all nodes in |
| // it are identical (in terms of parameters like the number of CPUs and the |
| // kind of CPU they are, as well as on the memory available and the page size |
| // etc.) It also tells which DP2 processs are running in which SMP. It assumes |
| // that SMPs are numbered 0, 1, 2, ... etc |
| |
| #ifndef __NA_CLUSTER_INFO_H |
| #define __NA_CLUSTER_INFO_H |
| |
| #include "Platform.h" |
| #include "CmpCommon.h" |
| #include "ObjectNames.h" |
| |
| #include "seabed/ms.h" |
| |
| void SetStaticCompiler(NABoolean isStaticCompiler); |
| NABoolean IsStaticCompiler(); |
| |
| //----------------------------- |
| // Classes defined in this file |
| //----------------------------- |
| |
| class NodeMapEntry; |
| class NodeMap; |
| class NAClusterInfo; |
| |
| //---------------------- |
| // Known processor types |
| //---------------------- |
| enum ProcesorTypes { |
| CPU_ARCH_INTEL_80386, |
| CPU_ARCH_INTEL_80486, |
| CPU_ARCH_PENTIUM, |
| CPU_ARCH_PENTIUM_PRO, |
| CPU_ARCH_MIPS, |
| CPU_ARCH_ALPHA, |
| CPU_ARCH_PPC, |
| CPU_ARCH_UNKNOWN |
| }; |
| //<pb> |
| //------------------------------------------------------------------------------ |
| // Cluster information is truly global. If ARKCMP ever becomes multi-threaded, |
| // this cluster information should be accessible to all threads. |
| // |
| // Cluster information is set up once and then used until ARKCMP terminates. |
| // The only way to refresh the cluster information is to stop and restart |
| // ARKCMP. |
| //------------------------------------------------------------------------------ |
| extern THREAD_P NAClusterInfo* gpClusterInfo; |
| extern void setUpClusterInfo(CollHeap* heap); |
| |
| class NAClusterInfo : public NABasicObject |
| { |
| public: |
| friend class NADefaults; |
| |
| |
| NAClusterInfo(CollHeap * heap); |
| ~NAClusterInfo(); |
| |
| virtual Int32 processorFrequency() const = 0; |
| virtual float ioTransferRate() const = 0; |
| virtual float seekTime() const = 0; |
| virtual Int32 cpuArchitecture() const = 0; |
| |
| virtual size_t numberOfCpusPerSMP() const = 0; |
| |
| virtual size_t pageSize() const = 0; |
| virtual size_t physicalMemoryAvailable() const = 0; |
| virtual size_t totalMemoryAvailable() const = 0; |
| virtual size_t virtualMemoryAvailable() = 0; |
| |
| // number of physical nodes (from Trafodion monitor or OSIM) |
| Int32 numOfPhysicalSMPs(); |
| // this is an adjusted number, based on CQDs |
| Int32 numOfSMPs(); |
| |
| // This is called by captureNAClusterInfo() to capture the OSIM |
| // information that is specific to the operating system. Each new |
| // platform must define this. |
| virtual void captureOSInfo(ofstream & f) const = 0; |
| |
| Int32 getNumActiveCluster() const { return 1; } |
| NABoolean smpActive(Int32 smp) const; |
| |
| // return total number of CPUs (includes all, that is, even down CPUs) |
| Lng32 getTotalNumberOfCPUs(); |
| const NAArray<CollIndex> &getCPUArray() { return cpuArray_; } |
| |
| Lng32 mapNodeNameToNodeNum(const NAString &node) const; |
| void cleanupPerStatement(); |
| |
| // The OSIM uses these following methods to capture and simulate |
| // cluster information respectively. |
| void initializeForOSIMCapture(); |
| void captureNAClusterInfo(ofstream & naclfile); |
| void simulateNAClusterInfo(); |
| NABoolean NODE_ID_TO_NAME(Int32 nodeId, char *nodeName, short maxLen, short *actualLen); |
| // three methods to enter, leave and test the test mode. The test |
| // mode is for testing POS. |
| |
| NABoolean inTestMode() const { return inTestMode_; }; |
| void setTestMode() { inTestMode_ = TRUE; }; |
| void resetTestMode() { inTestMode_ = FALSE; }; |
| |
| protected : |
| |
| //------------------------------------------------------------------------ |
| // localSMP_ is the current node ID. |
| //------------------------------------------------------------------------ |
| short localSMP_; |
| |
| //------------------------------------------------------------------------ |
| // heap_ is where this NAClusterInfo was allocated. This should be the |
| // context heap. |
| //------------------------------------------------------------------------ |
| CollHeap * heap_; |
| |
| // ------------------------------------------------------------------------ |
| // A list of node ids of available nodes. Typically, this will be |
| // a list of the numbers 0 ... n-1 but in some cases a node in |
| // the middle may be removed, so we end up with "holes" in the |
| // node ids. |
| // ------------------------------------------------------------------------ |
| NAArray<CollIndex> cpuArray_; |
| |
| //------------------------------------------------------------------------ |
| // hashdictionary used to store the mapping of cluster name to cluster id |
| // This structure is stored on the context heap |
| // because we don't expect this mapping to change during a session.. |
| //------------------------------------------------------------------------ |
| NAHashDictionary<Int32, NAString>* nodeIdToNodeNameMap_; |
| |
| // hashdictionary that maps nodeName to nodeId. |
| NAHashDictionary<NAString, Int32> *nodeNameToNodeIdMap_; |
| |
| NABoolean inTestMode_; // test mode indicator |
| }; |
| |
| class NAClusterInfoLinux : public NAClusterInfo |
| { |
| public: |
| NAClusterInfoLinux(CollHeap * heap); |
| ~NAClusterInfoLinux(); |
| Int32 processorFrequency() const; |
| float ioTransferRate() const; |
| float seekTime() const; |
| Int32 cpuArchitecture() const; |
| |
| //------------------------------------------------------------------------- |
| // On Linux, numberOfCpusPerSMP() returns the number of Linux nodes in the |
| // cluster. |
| //------------------------------------------------------------------------- |
| size_t numberOfCpusPerSMP() const; |
| |
| size_t pageSize() const; |
| size_t physicalMemoryAvailable() const; |
| size_t totalMemoryAvailable() const; |
| size_t virtualMemoryAvailable(); |
| |
| void captureOSInfo(ofstream &) const; |
| |
| Int32 get_pid() { return pid_; }; |
| Int32 get_nid() { return nid_; }; |
| |
| private: |
| void determineLinuxSysInfo(); |
| |
| void simulateNAClusterInfoLinux(); |
| |
| int pid_; // the pid of the current process |
| int nid_; // the nid of the current process |
| |
| private: |
| |
| //------------------------------------------------------------------------- |
| // Stores the frequency of the SMP, in Megahertz |
| //------------------------------------------------------------------------- |
| Int32 frequency_; |
| |
| //------------------------------------------------------------------------- |
| // Stores the IO transfer rate of the disk, in MB/sec |
| //------------------------------------------------------------------------- |
| float iorate_; |
| |
| //------------------------------------------------------------------------- |
| // Stores the average seek time of the disk, in ms |
| //------------------------------------------------------------------------- |
| float seekTime_; |
| |
| //------------------------------------------------------------------------- |
| // Stores the memory page size, in kilobytes. |
| //------------------------------------------------------------------------- |
| size_t pageSize_; |
| |
| //------------------------------------------------------------------------- |
| // Stores the total memory available, in bytes. |
| //------------------------------------------------------------------------- |
| size_t totalMemoryAvailable_; |
| |
| //------------------------------------------------------------------------- |
| // Number of CPU cores per Linux node. |
| //------------------------------------------------------------------------- |
| size_t numCPUcoresPerNode_; |
| |
| }; |
| |
| #endif // __NA_CLUSTER_INFO_H |