开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
TransporterFacade.hpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：9k
源码类别：

MySQL数据库

开发平台：

Visual C++

TransporterFacade.hpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #ifndef TransporterFacade_H
  18. #define TransporterFacade_H
  20. #include <kernel_types.h>
  21. #include <ndb_limits.h>
  22. #include <NdbThread.h>
  23. #include <TransporterRegistry.hpp>
  24. #include <NdbMutex.h>
  25. #include "DictCache.hpp"
  26. #include <BlockNumbers.h>
  28. class ClusterMgr;
  29. class ArbitMgr;
  30. class IPCConfig;
  31. struct ndb_mgm_configuration;
  32. class ConfigRetriever;
  34. class Ndb;
  35. class NdbApiSignal;
  37. typedef void (* ExecuteFunction)(void *, NdbApiSignal *, LinearSectionPtr ptr[3]);
  38. typedef void (* NodeStatusFunction)(void *, Uint32, bool nodeAlive, bool nfComplete);
  40. extern "C" {
  41.   void* runSendRequest_C(void*);
  42.   void* runReceiveResponse_C(void*);
  43.   void atexit_stop_instance();
  44. }
  46. /**
  47.  * Max number of Ndb objects in different threads.  
  48.  * (Ndb objects should not be shared by different threads.)
  49.  */
  50. class TransporterFacade
  51. {
  52. public:
  53.   TransporterFacade();
  54.   virtual ~TransporterFacade();
  55.   bool init(Uint32, const ndb_mgm_configuration *);
  57.   static TransporterFacade* instance();
  58.   int start_instance(int, const ndb_mgm_configuration*);
  59.   static void stop_instance();
  60.   
  61.   /**
  62.    * Register this block for sending/receiving signals
  63.    * @return BlockNumber or -1 for failure
  64.    */
  65.   int open(void* objRef, ExecuteFunction, NodeStatusFunction);
  66.   
  67.   // Close this block number
  68.   int close(BlockNumber blockNumber, Uint64 trans_id);
  70.   // Only sends to nodes which are alive
  71.   int sendSignal(NdbApiSignal * signal, NodeId nodeId);
  72.   int sendSignal(NdbApiSignal*, NodeId, 
  73.  LinearSectionPtr ptr[3], Uint32 secs);
  74.   int sendFragmentedSignal(NdbApiSignal*, NodeId, 
  75.    LinearSectionPtr ptr[3], Uint32 secs);
  77.   // Is node available for running transactions
  78.   bool   get_node_alive(NodeId nodeId) const;
  79.   bool   get_node_stopping(NodeId nodeId) const;
  80.   bool   getIsDbNode(NodeId nodeId) const;
  81.   bool   getIsNodeSendable(NodeId nodeId) const;
  82.   Uint32 getNodeGrp(NodeId nodeId) const;
  83.   Uint32 getNodeSequence(NodeId nodeId) const;
  85.   // Is there space in sendBuffer to send messages
  86.   bool   check_send_size(Uint32 node_id, Uint32 send_size);
  88.   // My own processor id
  89.   NodeId ownId() const;
  91.   void connected();
  93.   void doConnect(int NodeId);
  94.   void reportConnected(int NodeId);
  95.   void doDisconnect(int NodeId);
  96.   void reportDisconnected(int NodeId);
  98.   NodeId get_an_alive_node();
  99.   void ReportNodeAlive(NodeId nodeId);
  100.   void ReportNodeDead(NodeId nodeId);
  101.   void ReportNodeFailureComplete(NodeId nodeId);
  102.   
  103.   void lock_mutex();
  104.   void unlock_mutex();
  106.   // Improving the API performance
  107.   void forceSend(Uint32 block_number);
  108.   void checkForceSend(Uint32 block_number);
  110.   // Close this block number
  111.   int close_local(BlockNumber blockNumber);
  113.   // Scan batch configuration parameters
  114.   Uint32 get_scan_batch_size();
  115.   Uint32 get_batch_byte_size();
  116.   Uint32 get_batch_size();
  118. private:
  119.   /**
  120.    * Send a signal unconditional of node status (used by ClusterMgr)
  121.    */
  122.   friend class ClusterMgr;
  123.   friend class ArbitMgr;
  124.   friend class MgmtSrvr;
  125.   friend class SignalSender;
  126.   friend class GrepPS;
  127.   friend class ExtSender; ///< @todo Hack to be able to sendSignalUnCond
  128.   friend class GrepSS;
  129.   friend class Ndb;
  130.   friend class Ndb_cluster_connection_impl;
  132.   int sendSignalUnCond(NdbApiSignal *, NodeId nodeId);
  134.   bool isConnected(NodeId aNodeId);
  135.   void doStop();
  136.   
  137.   TransporterRegistry* theTransporterRegistry;
  138.   SocketServer m_socket_server;
  139.   int sendPerformedLastInterval;
  140.   int theOwnId;
  142.   NodeId theStartNodeId;
  144.   ClusterMgr* theClusterMgr;
  145.   ArbitMgr* theArbitMgr;
  146.   
  147.   // Improving the API response time
  148.   int checkCounter;
  149.   Uint32 currentSendLimit;
  150.   
  151.   void calculateSendLimit();
  153.   // Scan batch configuration parameters
  154.   Uint32 m_scan_batch_size;
  155.   Uint32 m_batch_byte_size;
  156.   Uint32 m_batch_size;
  158.   // Declarations for the receive and send thread
  159.   int  theStopReceive;
  161.   void threadMainSend(void);
  162.   NdbThread* theSendThread;
  163.   void threadMainReceive(void);
  164.   NdbThread* theReceiveThread;
  166.   friend void* runSendRequest_C(void*);
  167.   friend void* runReceiveResponse_C(void*);
  168.   friend void atexit_stop_instance();
  170.   /**
  171.    * Block number handling
  172.    */
  173. public:
  174.   STATIC_CONST( MAX_NO_THREADS = 4711 );
  175. private:
  177.   struct ThreadData {
  178.     STATIC_CONST( ACTIVE = (1 << 16) | 1 );
  179.     STATIC_CONST( INACTIVE = (1 << 16) );
  180.     STATIC_CONST( END_OF_LIST = MAX_NO_THREADS + 1 );
  181.     
  182.     ThreadData(Uint32 initialSize = 32);
  183.     
  184.     /**
  185.      * Split "object" into 3 list
  186.      *   This to improve locality
  187.      *   when iterating over lists
  188.      */
  189.     struct Object_Execute {
  190.       void * m_object;
  191.       ExecuteFunction m_executeFunction;
  192.     };
  193.     struct NodeStatus_NextFree {
  194.       NodeStatusFunction m_statusFunction;
  195.     };
  197.     Uint32 m_firstFree;
  198.     Vector<Uint32> m_statusNext;
  199.     Vector<Object_Execute> m_objectExecute;
  200.     Vector<NodeStatusFunction> m_statusFunction;
  201.     
  202.     int open(void* objRef, ExecuteFunction, NodeStatusFunction);
  203.     int close(int number);
  204.     void expand(Uint32 size);
  206.     inline Object_Execute get(Uint16 blockNo) const {
  207.       blockNo -= MIN_API_BLOCK_NO;
  208.       if(blockNo < m_objectExecute.size()){
  209. return m_objectExecute[blockNo];
  210.       }
  211.       Object_Execute oe = { 0, 0 };
  212.       return oe;
  213.     }
  215.     /**
  216.      * Is the block number used currently
  217.      */
  218.     inline bool getInUse(Uint16 index) const {
  219.       return (m_statusNext[index] & (1 << 16)) != 0;
  220.     }
  221.   } m_threads;
  222.   
  223.   Uint32 m_max_trans_id;
  224.   Uint32 m_fragmented_signal_id;
  226.   /**
  227.    * execute function
  228.    */
  229.   friend void execute(void * callbackObj, SignalHeader * const header, 
  230.                       Uint8 prio, 
  231.                       Uint32 * const theData, LinearSectionPtr ptr[3]);
  232.   
  233. public:
  234.   NdbMutex* theMutexPtr;
  235. private:
  236.   static TransporterFacade* theFacadeInstance;
  238. public:
  239.   GlobalDictCache m_globalDictCache;
  240. };
  242. inline
  243. TransporterFacade*
  244. TransporterFacade::instance()
  245. {
  246.   return theFacadeInstance;
  247. }
  249. inline
  250. void 
  251. TransporterFacade::lock_mutex()
  252. {
  253.   NdbMutex_Lock(theMutexPtr);
  254. }
  256. inline
  257. void 
  258. TransporterFacade::unlock_mutex()
  259. {
  260.   NdbMutex_Unlock(theMutexPtr);
  261. }
  263. #include "ClusterMgr.hpp"
  265. inline
  266. bool
  267. TransporterFacade::check_send_size(Uint32 node_id, Uint32 send_size)
  268. {
  269.   return true;
  270. }
  272. inline
  273. bool
  274. TransporterFacade::getIsDbNode(NodeId n) const {
  275.   return 
  276.     theClusterMgr->getNodeInfo(n).defined && 
  277.     theClusterMgr->getNodeInfo(n).m_info.m_type == NodeInfo::DB;
  278. }
  280. inline
  281. Uint32
  282. TransporterFacade::getNodeGrp(NodeId n) const {
  283.   return theClusterMgr->getNodeInfo(n).m_state.nodeGroup;
  284. }
  287. inline
  288. bool
  289. TransporterFacade::get_node_alive(NodeId n) const {
  291.   const ClusterMgr::Node & node = theClusterMgr->getNodeInfo(n);
  292.   return node.m_alive;
  293. }
  295. inline
  296. bool
  297. TransporterFacade::get_node_stopping(NodeId n) const {
  298.   const ClusterMgr::Node & node = theClusterMgr->getNodeInfo(n);
  299.   return ((node.m_state.startLevel == NodeState::SL_STOPPING_1) ||
  300.           (node.m_state.startLevel == NodeState::SL_STOPPING_2));
  301. }
  303. inline
  304. bool
  305. TransporterFacade::getIsNodeSendable(NodeId n) const {
  306.   const ClusterMgr::Node & node = theClusterMgr->getNodeInfo(n);
  307.   const Uint32 startLevel = node.m_state.startLevel;
  309.   if (node.m_info.m_type == NodeInfo::DB) {
  310.     if(node.m_state.singleUserMode && 
  311.        ownId() == node.m_state.singleUserApi) {
  312.       return (node.compatible && 
  313.               (node.m_state.startLevel == NodeState::SL_STOPPING_1 ||
  314.                node.m_state.startLevel == NodeState::SL_STARTED ||
  315.                node.m_state.startLevel == NodeState::SL_SINGLEUSER));
  316.       }
  317.       else
  318.         return node.compatible && (startLevel == NodeState::SL_STARTED ||
  319.                                  startLevel == NodeState::SL_STOPPING_1);
  320.   } else if (node.m_info.m_type == NodeInfo::REP) {
  321.     /**
  322.      * @todo Check that REP node actually has received API_REG_REQ
  323.      */
  324.     return node.compatible;
  325.   } else {
  326.     ndbout_c("TransporterFacade::getIsNodeSendable: Illegal node type: "
  327.              "%d of node: %d", 
  328.              node.m_info.m_type, n);
  329.     abort();
  330.     return false; // to remove compiler warning
  331.   }
  332. }
  334. inline
  335. Uint32
  336. TransporterFacade::getNodeSequence(NodeId n) const {
  337.   return theClusterMgr->getNodeInfo(n).m_info.m_connectCount;
  338. }
  340. inline
  341. Uint32
  342. TransporterFacade::get_scan_batch_size() {
  343.   return m_scan_batch_size;
  344. }
  346. inline
  347. Uint32
  348. TransporterFacade::get_batch_byte_size() {
  349.   return m_batch_byte_size;
  350. }
  352. inline
  353. Uint32
  354. TransporterFacade::get_batch_size() {
  355.   return m_batch_size;
  356. }
  360. #endif // TransporterFacade_H