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

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

MySQL数据库

开发平台：

Visual C++

SimulatedBlock.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 SIMULATEDBLOCK_H
  18. #define SIMULATEDBLOCK_H
  20. #include <NdbTick.h>
  21. #include <kernel_types.h>
  22. #include <ndb_version.h>
  24. #include "VMSignal.hpp"
  25. #include <RefConvert.hpp>
  26. #include <BlockNumbers.h>
  27. #include <GlobalSignalNumbers.h>
  28. #include "pc.hpp"
  29. #include <NodeInfo.hpp>
  30. #include <NodeState.hpp>
  31. #include "GlobalData.hpp"
  32. #include "LongSignal.hpp"
  33. #include <SignalLoggerManager.hpp>
  35. #include <Error.hpp>
  36. #include <ErrorReporter.hpp>
  37. #include <ErrorHandlingMacros.hpp>
  39. #include "DLList.hpp"
  40. #include "ArrayPool.hpp"
  41. #include "DLHashTable.hpp"
  42. #include "Callback.hpp"
  43. #include "SafeCounter.hpp"
  44. #include "MetaData.hpp"
  46. #include <mgmapi.h>
  47. #include <mgmapi_config_parameters.h>
  48. #include <mgmapi_config_parameters_debug.h>
  49. #include <kernel_config_parameters.h>
  50. #include <Configuration.hpp>
  52. #include <signaldata/ReadConfig.hpp>
  53. #include <signaldata/UpgradeStartup.hpp>
  56. /**
  57.  * Something for filesystem access
  58.  */
  59. struct  NewBaseAddrBits              /* 32 bits */
  60. {
  61.   unsigned int     q               : 4;    /* Highest index - 2log */
  62.   /* Strings are treated as 16 bit indexed        */
  63.   /* variables with the number of characters in   */
  64.   /* index 0, byte 0                              */
  65.   unsigned int     v               : 3;    /* Size in bits - 2log */
  66.   unsigned int     unused : 25 ;
  67. };
  69. typedef struct NewVar
  70. {
  71.   Uint32 *              WA;
  72.   Uint32                nrr;
  73.   Uint32                ClusterSize;    /* Real Cluster size    */
  74.   NewBaseAddrBits       bits;
  75. } NewVARIABLE;  /* 128 bits */
  77. class SimulatedBlock {
  78.   friend class SafeCounter;
  79.   friend class SafeCounterManager;
  80.   friend struct UpgradeStartup;
  81. public:
  82.   friend class BlockComponent;
  83.   virtual ~SimulatedBlock();
  84.   
  85. protected:
  86.   /**
  87.    * Constructor
  88.    */
  89.   SimulatedBlock(BlockNumber blockNumber,
  90.                  const class Configuration & theConfiguration); 
  92.   /**********************************************************
  93.    * Handling of execFunctions
  94.    */
  95.   typedef void (SimulatedBlock::* ExecFunction)(Signal* signal);
  96.   void addRecSignalImpl(GlobalSignalNumber g, ExecFunction fun, bool f =false);
  97.   void installSimulatedBlockFunctions();
  98.   ExecFunction theExecArray[MAX_GSN+1];
  99. public:
  100.   /**
  101.    * 
  102.    */
  103.   inline void executeFunction(GlobalSignalNumber gsn, Signal* signal);
  104. public:
  105.   typedef void (SimulatedBlock::* CallbackFunction)(class Signal*, 
  106.     Uint32 callbackData,
  107.     Uint32 returnCode);
  108.   struct Callback {
  109.     CallbackFunction m_callbackFunction;
  110.     Uint32 m_callbackData;
  111.   };
  112. protected:
  113.   static Callback TheEmptyCallback;
  114.   void execute(Signal* signal, Callback & c, Uint32 returnCode);
  115.   
  116.   
  117.   /**********************************************************
  118.    * Send signal - dialects
  119.    */
  121.   void sendSignal(BlockReference ref, 
  122.   GlobalSignalNumber gsn, 
  123.                   Signal* signal, 
  124.   Uint32 length, 
  125.   JobBufferLevel jbuf ) const ;
  127.   void sendSignal(NodeReceiverGroup rg,
  128.   GlobalSignalNumber gsn, 
  129.                   Signal* signal, 
  130.   Uint32 length, 
  131.   JobBufferLevel jbuf ) const ;
  133.   void sendSignal(BlockReference ref, 
  134.   GlobalSignalNumber gsn, 
  135.                   Signal* signal, 
  136.   Uint32 length, 
  137.   JobBufferLevel jbuf,
  138.   LinearSectionPtr ptr[3],
  139.   Uint32 noOfSections) const ;
  140.   
  141.   void sendSignal(NodeReceiverGroup rg, 
  142.   GlobalSignalNumber gsn, 
  143.                   Signal* signal, 
  144.   Uint32 length, 
  145.   JobBufferLevel jbuf,
  146.   LinearSectionPtr ptr[3],
  147.   Uint32 noOfSections) const ;
  149.   // Send multiple signal with delay. In this VM the jobbufffer level has 
  150.   // no effect on on delayed signals
  151.   //
  152.   void sendSignalWithDelay(BlockReference ref, 
  153.    GlobalSignalNumber gsn, 
  154.                            Signal* signal,
  155.                            Uint32 delayInMilliSeconds, 
  156.    Uint32 length) const ;
  158.   void EXECUTE_DIRECT(Uint32 block, 
  159.       Uint32 gsn, 
  160.       Signal* signal, 
  161.       Uint32 len);
  162.   
  163.   class SectionSegmentPool& getSectionSegmentPool();
  164.   void releaseSections(Signal* signal);
  166.   /**********************************************************
  167.    * Fragmented signals
  168.    */
  169.   
  170.   /**
  171.    * Assemble fragments
  172.    *
  173.    * @return true if all fragments has arrived
  174.    *         false otherwise
  175.    */
  176.   bool assembleFragments(Signal * signal);
  177.   
  178.   void sendFragmentedSignal(BlockReference ref, 
  179.     GlobalSignalNumber gsn, 
  180.     Signal* signal, 
  181.     Uint32 length, 
  182.     JobBufferLevel jbuf,
  183.     Callback & = TheEmptyCallback,
  184.     Uint32 messageSize = 240);
  186.   void sendFragmentedSignal(NodeReceiverGroup rg, 
  187.     GlobalSignalNumber gsn, 
  188.     Signal* signal, 
  189.     Uint32 length, 
  190.     JobBufferLevel jbuf,
  191.     Callback & = TheEmptyCallback,
  192.     Uint32 messageSize = 240);
  194.   void sendFragmentedSignal(BlockReference ref, 
  195.     GlobalSignalNumber gsn, 
  196.     Signal* signal, 
  197.     Uint32 length, 
  198.     JobBufferLevel jbuf,
  199.     LinearSectionPtr ptr[3],
  200.     Uint32 noOfSections,
  201.     Callback &,
  202.     Uint32 messageSize = 240);
  204.   void sendFragmentedSignal(NodeReceiverGroup rg, 
  205.     GlobalSignalNumber gsn, 
  206.     Signal* signal, 
  207.     Uint32 length, 
  208.     JobBufferLevel jbuf,
  209.     LinearSectionPtr ptr[3],
  210.     Uint32 noOfSections,
  211.     Callback &,
  212.     Uint32 messageSize = 240);
  214.   /**********************************************************
  215.    * Fragmented signals structures
  216.    */
  218.   /**
  219.    * Struct used when assembling fragmented long signals at receiver side
  220.    */
  221.   struct FragmentInfo {
  222.     FragmentInfo(Uint32 fragId, Uint32 sender);
  223.     
  224.     Uint32 m_senderRef;
  225.     Uint32 m_fragmentId;
  226.     Uint32 m_sectionPtrI[3];
  227.     union {
  228.       Uint32 nextPool;
  229.       Uint32 nextHash;
  230.     };
  231.     Uint32 prevHash;
  232.     
  233.     inline bool equal(FragmentInfo & p) const {
  234.       return m_senderRef == p.m_senderRef && m_fragmentId == p.m_fragmentId;
  235.     }
  236.     
  237.     inline Uint32 hashValue() const {
  238.       return m_senderRef + m_fragmentId ;
  239.     }
  240.   }; // sizeof() = 32 bytes
  241.   
  242.   /**
  243.    * Struct used when sending fragmented signals
  244.    */
  245.   struct FragmentSendInfo {
  246.     FragmentSendInfo();
  247.     
  248.     enum Status {
  249.       SendNotComplete = 0,
  250.       SendComplete    = 1
  251.     };
  252.     Uint8  m_status;
  253.     Uint8  m_prio;
  254.     Uint16  m_fragInfo;
  255.     Uint16 m_gsn;
  256.     Uint16 m_messageSize; // Size of each fragment
  257.     Uint32 m_fragmentId;
  258.     union {
  259.       Ptr<struct SectionSegment> m_segmented;
  260.       LinearSectionPtr m_linear;
  261.     } m_sectionPtr[3];
  262.     LinearSectionPtr m_theDataSection;
  263.     NodeReceiverGroup m_nodeReceiverGroup; // 3
  264.     Callback m_callback;
  265.     union  {
  266.       Uint32 nextPool;
  267.       Uint32 nextList;
  268.     };
  269.     Uint32 prevList;
  270.   };
  271.   
  272.   /**
  273.    * setupFragmentSendInfo
  274.    *   Setup a struct to be used with sendSignalFragment
  275.    *   Used by sendFragmentedSignal
  276.    */
  277.   bool sendFirstFragment(FragmentSendInfo & info,
  278.  NodeReceiverGroup rg, 
  279.  GlobalSignalNumber gsn, 
  280.  Signal* signal, 
  281.  Uint32 length, 
  282.  JobBufferLevel jbuf,
  283.  LinearSectionPtr ptr[3],
  284.  Uint32 noOfSections,
  285.  Uint32 messageSize = 240);
  286.   
  287.   bool sendFirstFragment(FragmentSendInfo & info,
  288.  NodeReceiverGroup rg, 
  289.  GlobalSignalNumber gsn, 
  290.  Signal* signal, 
  291.  Uint32 length, 
  292.  JobBufferLevel jbuf,
  293.  Uint32 messageSize = 240);
  294.   
  295.   /**
  296.    * Send signal fragment
  297.    *
  298.    * @see sendFragmentedSignal
  299.    */
  300.   void sendNextSegmentedFragment(Signal* signal, FragmentSendInfo & info);
  302.   /**
  303.    * Send signal fragment
  304.    *
  305.    * @see sendFragmentedSignal
  306.    */
  307.   void sendNextLinearFragment(Signal* signal, FragmentSendInfo & info);
  308.   
  309.   BlockNumber    number() const;
  310.   BlockReference reference() const;
  311.   NodeId         getOwnNodeId() const;
  313.   /**
  314.    * Refresh Watch Dog in initialising code
  315.    *
  316.    */
  317.   void refresh_watch_dog();
  319.   /**
  320.    * Prog error
  321.    * This function should be called when this node should be shutdown
  322.    * If the cause of the shutdown is known use extradata to add an 
  323.    * errormessage describing the problem
  324.    */
  325.   void progError(int line, int err_code, const char* extradata=NULL) const ;
  326. private:
  327.   void  signal_error(Uint32, Uint32, Uint32, const char*, int) const ;
  328.   const NodeId         theNodeId;
  329.   const BlockNumber    theNumber;
  330.   const BlockReference theReference;
  331.   
  332. protected:
  333.   NewVARIABLE* allocateBat(int batSize);
  334.   void freeBat();
  335.   static const NewVARIABLE* getBat    (BlockNumber blockNo);
  336.   static Uint16             getBatSize(BlockNumber blockNo);
  337.   
  338.   static BlockReference calcTcBlockRef   (NodeId aNode);
  339.   static BlockReference calcLqhBlockRef  (NodeId aNode);
  340.   static BlockReference calcAccBlockRef  (NodeId aNode);
  341.   static BlockReference calcTupBlockRef  (NodeId aNode);
  342.   static BlockReference calcTuxBlockRef  (NodeId aNode);
  343.   static BlockReference calcDihBlockRef  (NodeId aNode);
  344.   static BlockReference calcQmgrBlockRef (NodeId aNode);
  345.   static BlockReference calcDictBlockRef (NodeId aNode);
  346.   static BlockReference calcNdbCntrBlockRef (NodeId aNode);
  347.   static BlockReference calcTrixBlockRef (NodeId aNode);
  348.   static BlockReference calcBackupBlockRef (NodeId aNode);
  349.   static BlockReference calcSumaBlockRef (NodeId aNode);
  351.   static BlockReference calcApiClusterMgrBlockRef (NodeId aNode);
  353.   /** 
  354.    * allocRecord
  355.    * Allocates memory for the datastructures where ndb keeps the data
  356.    *
  357.    */
  358.   void* allocRecord(const char * type, size_t s, size_t n, bool clear = true);
  359.   
  360.   /**
  361.    * Deallocate record
  362.    *
  363.    * NOTE: Also resets pointer
  364.    */
  365.   void deallocRecord(void **, const char * type, size_t s, size_t n);
  366.   
  367.   /**
  368.    * General info event (sent to cluster log)
  369.    */
  370.   void infoEvent(const char * msg, ...) const ;
  371.   void warningEvent(const char * msg, ...) const ;
  372.   
  373.   /**
  374.    * The configuration object
  375.    */
  376.   const class Configuration & theConfiguration;
  378.   /**
  379.    * Get node state
  380.    */
  381.   const NodeState & getNodeState() const;
  383.   /**
  384.    * Get node info
  385.    */
  386.   const NodeInfo & getNodeInfo(NodeId nodeId) const;
  387.   NodeInfo & setNodeInfo(NodeId);
  388.   
  389. private:
  390.   NewVARIABLE* NewVarRef;      /* New Base Address Table for block  */
  391.   Uint16       theBATSize;     /* # entries in BAT */
  393.   /**
  394.    * Node state
  395.    */
  396.   NodeState theNodeState;
  397.   void execNDB_TAMPER(Signal * signal);
  398.   void execNODE_STATE_REP(Signal* signal);
  399.   void execCHANGE_NODE_STATE_REQ(Signal* signal);
  401.   void execSIGNAL_DROPPED_REP(Signal* signal);
  402.   void execCONTINUE_FRAGMENTED(Signal* signal);
  404.   Uint32 c_fragmentIdCounter;
  405.   ArrayPool<FragmentInfo> c_fragmentInfoPool;
  406.   DLHashTable<FragmentInfo> c_fragmentInfoHash;
  407.   
  408.   bool c_fragSenderRunning;
  409.   ArrayPool<FragmentSendInfo> c_fragmentSendPool;
  410.   DLList<FragmentSendInfo> c_linearFragmentSendList;
  411.   DLList<FragmentSendInfo> c_segmentedFragmentSendList;
  412.   
  413. public: 
  414.   class MutexManager {
  415.     friend class Mutex;
  416.     friend class SimulatedBlock;
  417.     friend class DbUtil;
  418.   public:
  419.     MutexManager(class SimulatedBlock &);
  420.     
  421.     bool setSize(Uint32 maxNoOfActiveMutexes);
  422.     Uint32 getSize() const ; // Get maxNoOfActiveMutexes
  423.     
  424.   private:
  425.     /**
  426.      * core interface
  427.      */
  428.     struct ActiveMutex {
  429.       Uint32 m_gsn; // state
  430.       Uint32 m_mutexId;
  431.       Uint32 m_mutexKey;
  432.       Callback m_callback;
  433.       union {
  434. Uint32 nextPool;
  435. Uint32 nextList;
  436.       };
  437.       Uint32 prevList;
  438.     };
  439.     typedef Ptr<ActiveMutex> ActiveMutexPtr;
  440.     
  441.     bool seize(ActiveMutexPtr& ptr);
  442.     void release(Uint32 activeMutexPtrI);
  443.     
  444.     void getPtr(ActiveMutexPtr& ptr);
  445.     
  446.     void create(Signal*, ActiveMutexPtr&);
  447.     void destroy(Signal*, ActiveMutexPtr&);
  448.     void lock(Signal*, ActiveMutexPtr&);
  449.     void trylock(Signal*, ActiveMutexPtr&);
  450.     void unlock(Signal*, ActiveMutexPtr&);
  451.     
  452.   private:
  453.     void execUTIL_CREATE_LOCK_REF(Signal* signal);
  454.     void execUTIL_CREATE_LOCK_CONF(Signal* signal);
  455.     void execUTIL_DESTORY_LOCK_REF(Signal* signal);
  456.     void execUTIL_DESTORY_LOCK_CONF(Signal* signal);
  457.     void execUTIL_LOCK_REF(Signal* signal);
  458.     void execUTIL_LOCK_CONF(Signal* signal);
  459.     void execUTIL_UNLOCK_REF(Signal* signal);
  460.     void execUTIL_UNLOCK_CONF(Signal* signal);
  461.     
  462.     SimulatedBlock & m_block;
  463.     ArrayPool<ActiveMutex> m_mutexPool;
  464.     DLList<ActiveMutex> m_activeMutexes;
  465.     
  466.     BlockReference reference() const;
  467.     void progError(int line, int err_code, const char* extra = 0);
  468.   };
  469.   
  470.   friend class MutexManager;
  471.   MutexManager c_mutexMgr;
  473.   void ignoreMutexUnlockCallback(Signal* signal, Uint32 ptrI, Uint32 retVal);
  475.   SafeCounterManager c_counterMgr;
  476. private:
  477.   void execUTIL_CREATE_LOCK_REF(Signal* signal);
  478.   void execUTIL_CREATE_LOCK_CONF(Signal* signal);
  479.   void execUTIL_DESTORY_LOCK_REF(Signal* signal);
  480.   void execUTIL_DESTORY_LOCK_CONF(Signal* signal);
  481.   void execUTIL_LOCK_REF(Signal* signal);
  482.   void execUTIL_LOCK_CONF(Signal* signal);
  483.   void execUTIL_UNLOCK_REF(Signal* signal);
  484.   void execUTIL_UNLOCK_CONF(Signal* signal);
  486.   void execREAD_CONFIG_REQ(Signal* signal);
  487. protected:
  488.   void execUPGRADE(Signal* signal);
  490.   void fsRefError(Signal* signal, Uint32 line, const char *msg);
  491.   void execFSWRITEREF(Signal* signal);
  492.   void execFSREADREF(Signal* signal);
  493.   void execFSOPENREF(Signal* signal);
  494.   void execFSCLOSEREF(Signal* signal);
  495.   void execFSREMOVEREF(Signal* signal);
  496.   void execFSSYNCREF(Signal* signal);
  497.   void execFSAPPENDREF(Signal* signal);
  499.   // Variable for storing inserted errors, see pc.H
  500.   ERROR_INSERT_VARIABLE;
  502. private:
  503.   // Metadata common part shared by block instances
  504.   MetaData::Common* c_ptrMetaDataCommon;
  505. public:
  506.   void setMetaDataCommon(MetaData::Common* ptr) { c_ptrMetaDataCommon = ptr; }
  507.   MetaData::Common* getMetaDataCommon() { return c_ptrMetaDataCommon; }
  509. #ifdef VM_TRACE_TIME
  510. public:
  511.   void clearTimes();
  512.   void printTimes(FILE * output);
  513.   void addTime(Uint32 gsn, Uint64 time);
  514.   void subTime(Uint32 gsn, Uint64 time);
  515.   struct TimeTrace {
  516.     Uint32 cnt;
  517.     Uint64 sum, sub;
  518.   } m_timeTrace[MAX_GSN+1];
  519.   Uint32 m_currentGsn;
  520. #endif
  522. #ifdef VM_TRACE
  523.   Ptr<void> **m_global_variables;
  524.   void clear_global_variables();
  525.   void init_globals_list(void ** tmp, size_t cnt);
  526. #endif
  527. };
  529. inline 
  530. void 
  531. SimulatedBlock::executeFunction(GlobalSignalNumber gsn, Signal* signal){
  532.   ExecFunction f = theExecArray[gsn];
  533.   if(gsn <= MAX_GSN && f != 0){
  534. #ifdef VM_TRACE
  535.     clear_global_variables();
  536. #endif
  537.     (this->*f)(signal);
  538.     return;
  539.   }
  541.   /**
  542.    * This point only passed if an error has occurred
  543.    */
  544.   char errorMsg[255];
  545.   if (!(gsn <= MAX_GSN)) {
  546.     BaseString::snprintf(errorMsg, 255, "Illegal signal received (GSN %d too high)", gsn);
  547.     ERROR_SET(fatal, ERR_ERROR_PRGERR, errorMsg, errorMsg);
  548.   }
  549.   if (!(theExecArray[gsn] != 0)) {
  550.     BaseString::snprintf(errorMsg, 255, "Illegal signal received (GSN %d not added)", gsn);
  551.     ERROR_SET(fatal, ERR_ERROR_PRGERR, errorMsg, errorMsg);
  552.   }
  553.   ndbrequire(false);
  554. }
  556. inline
  557. void
  558. SimulatedBlock::execute(Signal* signal, Callback & c, Uint32 returnCode){
  559.   CallbackFunction fun = c.m_callbackFunction; 
  560.   ndbrequire(fun != 0);
  561.   c.m_callbackFunction = NULL;
  562.   (this->*fun)(signal, c.m_callbackData, returnCode);
  563. }
  565. inline 
  566. BlockNumber
  567. SimulatedBlock::number() const {
  568.    return theNumber;
  569. }
  571. inline
  572. BlockReference
  573. SimulatedBlock::reference() const {
  574.    return theReference;
  575. }
  577. inline
  578. NodeId
  579. SimulatedBlock::getOwnNodeId() const {
  580.   return theNodeId;
  581. }
  583. inline
  584. BlockReference
  585. SimulatedBlock::calcTcBlockRef   (NodeId aNodeId){
  586.   return numberToRef(DBTC, aNodeId);
  587. }
  589. inline
  590. BlockReference
  591. SimulatedBlock::calcLqhBlockRef  (NodeId aNodeId){
  592. return numberToRef(DBLQH, aNodeId);
  593. }
  595. inline
  596. BlockReference
  597. SimulatedBlock::calcAccBlockRef  (NodeId aNodeId){
  598.   return numberToRef(DBACC, aNodeId);
  599. }
  601. inline
  602. BlockReference
  603. SimulatedBlock::calcTupBlockRef  (NodeId aNodeId){
  604.   return numberToRef(DBTUP, aNodeId);
  605. }
  607. inline
  608. BlockReference
  609. SimulatedBlock::calcTuxBlockRef  (NodeId aNodeId){
  610.   return numberToRef(DBTUX, aNodeId);
  611. }
  613. inline
  614. BlockReference
  615. SimulatedBlock::calcDihBlockRef  (NodeId aNodeId){
  616.   return numberToRef(DBDIH, aNodeId);
  617. }
  619. inline
  620. BlockReference
  621. SimulatedBlock::calcDictBlockRef (NodeId aNodeId){
  622.   return numberToRef(DBDICT, aNodeId);
  623. }
  625. inline
  626. BlockReference
  627. SimulatedBlock::calcQmgrBlockRef (NodeId aNodeId){
  628.   return numberToRef(QMGR, aNodeId);
  629. }
  631. inline
  632. BlockReference
  633. SimulatedBlock::calcNdbCntrBlockRef (NodeId aNodeId){
  634.   return numberToRef(NDBCNTR, aNodeId);
  635. }
  637. inline
  638. BlockReference
  639. SimulatedBlock::calcTrixBlockRef (NodeId aNodeId){
  640.   return numberToRef(TRIX, aNodeId);
  641. }
  643. inline
  644. BlockReference
  645. SimulatedBlock::calcBackupBlockRef (NodeId aNodeId){
  646.   return numberToRef(BACKUP, aNodeId);
  647. }
  649. inline
  650. BlockReference
  651. SimulatedBlock::calcSumaBlockRef (NodeId aNodeId){
  652.   return numberToRef(SUMA, aNodeId);
  653. }
  655. inline
  656. BlockReference
  657. SimulatedBlock::calcApiClusterMgrBlockRef (NodeId aNodeId){
  658.   return numberToRef(API_CLUSTERMGR, aNodeId);
  659. }
  661. inline
  662. const NodeState &
  663. SimulatedBlock::getNodeState() const {
  664.   return theNodeState;
  665. }
  667. inline
  668. const NodeInfo &
  669. SimulatedBlock::getNodeInfo(NodeId nodeId) const {
  670.   ndbrequire(nodeId > 0 && nodeId < MAX_NODES);
  671.   return globalData.m_nodeInfo[nodeId];
  672. }
  674. inline
  675. void
  676. SimulatedBlock::EXECUTE_DIRECT(Uint32 block, 
  677.        Uint32 gsn, 
  678.        Signal* signal, 
  679.        Uint32 len){
  680.   signal->setLength(len);
  681. #ifdef VM_TRACE
  682.   if(globalData.testOn){
  683.     signal->header.theVerId_signalNumber = gsn;
  684.     signal->header.theReceiversBlockNumber = block;
  685.     signal->header.theSendersBlockRef = reference();
  686.     globalSignalLoggers.executeDirect(signal->header,
  687.       0,        // in
  688.       &signal->theData[0],
  689.                                       globalData.ownId);
  690.   }
  691. #endif
  692.   SimulatedBlock* b = globalData.getBlock(block);
  693. #ifdef VM_TRACE_TIME
  694.   Uint32 us1, us2;
  695.   Uint64 ms1, ms2;
  696.   NdbTick_CurrentMicrosecond(&ms1, &us1);
  697.   Uint32 tGsn = m_currentGsn;
  698.   b->m_currentGsn = gsn;
  699. #endif
  700.   b->executeFunction(gsn, signal);
  701. #ifdef VM_TRACE_TIME
  702.   NdbTick_CurrentMicrosecond(&ms2, &us2);
  703.   Uint64 diff = ms2;
  704.   diff -= ms1;
  705.   diff *= 1000000;
  706.   diff += us2;
  707.   diff -= us1;
  708.   b->addTime(gsn, diff);
  709.   m_currentGsn = tGsn;
  710.   subTime(tGsn, diff);
  711. #endif
  712. #ifdef VM_TRACE
  713.   if(globalData.testOn){
  714.     signal->header.theVerId_signalNumber = gsn;
  715.     signal->header.theReceiversBlockNumber = block;
  716.     signal->header.theSendersBlockRef = reference();
  717.     globalSignalLoggers.executeDirect(signal->header,
  718.       1,        // out
  719.       &signal->theData[0],
  720.                                       globalData.ownId);
  721.   }
  722. #endif
  723. }
  725. #ifdef VM_TRACE_TIME
  726. inline
  727. void
  728. SimulatedBlock::addTime(Uint32 gsn, Uint64 time){
  729.   m_timeTrace[gsn].cnt ++;
  730.   m_timeTrace[gsn].sum += time;
  731. }
  733. inline
  734. void
  735. SimulatedBlock::subTime(Uint32 gsn, Uint64 time){
  736.   m_timeTrace[gsn].sub += time;
  737. }
  738. #endif
  740. /**
  741.  * Defines for backward compatiblility
  742.  */
  744. #define BLOCK_DEFINES(BLOCK) 
  745.   typedef void (BLOCK::* ExecSignalLocal) (Signal* signal); 
  746.   typedef void (BLOCK::* BlockCallback)(Signal*, Uint32 callb, Uint32 retCode); 
  747.   inline CallbackFunction safe_cast(BlockCallback f){ 
  748.     return static_cast<CallbackFunction>(f); 
  749.   } 
  750. public:
  751. private: 
  752.   void addRecSignal(GlobalSignalNumber gsn, ExecSignalLocal f, bool force = false)
  754. #define BLOCK_CONSTRUCTOR(BLOCK)
  756. #define BLOCK_FUNCTIONS(BLOCK) 
  757. void 
  758. BLOCK::addRecSignal(GlobalSignalNumber gsn, ExecSignalLocal f, bool force){ 
  759.   addRecSignalImpl(gsn, (ExecFunction)f, force);
  760. }
  762. #include "Mutex.hpp"
  764. #endif