Category

Development Platform
Home > SourceCode/Document > Database system > MySQL > View Code
SafeCounter.cpp
Package: mysql-4.1.16-win-src.zip　[view]
Upload User: romrleung
Upload Date: 2022-05-23
Package Size: 18897k
Code Size: 4k
Category:

MySQL

Development Platform:

Visual C++

SafeCounter.cpp：Code Content
  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 */
  18. #include "SimulatedBlock.hpp"
  19. #include "SafeCounter.hpp"
  20. #include <signaldata/NodeFailRep.hpp>
  22. SafeCounterManager::SafeCounterManager(class SimulatedBlock & block)
  23.   : m_block(block),
  24.     m_activeCounters(m_counterPool)
  25. {}
  26.   
  27. bool
  28. SafeCounterManager::setSize(Uint32 maxNoOfActiveMutexes) {
  29.   return m_counterPool.setSize(maxNoOfActiveMutexes);
  30. }
  32. Uint32
  33. SafeCounterManager::getSize() const {
  34.   return m_counterPool.getSize();
  35. }
  37. bool
  38. SafeCounterManager::seize(ActiveCounterPtr& ptr){
  39.   return m_activeCounters.seize(ptr);
  40. }
  42. void
  43. SafeCounterManager::release(ActiveCounterPtr& ptr){
  44.   m_activeCounters.release(ptr);
  45. }
  47. void
  48. SafeCounterManager::getPtr(ActiveCounterPtr& ptr, Uint32 ptrI){
  49.   m_activeCounters.getPtr(ptr, ptrI);
  50. }
  53. void
  54. SafeCounterManager::printNODE_FAILREP(){
  55.   ActiveCounterPtr ptr;
  57.   NodeBitmask nodes;
  58.   nodes.clear();
  59.   //  nodes.bitORC(nodes);
  61.   for(m_activeCounters.first(ptr); !ptr.isNull(); m_activeCounters.next(ptr)){
  62.     ActiveCounter::SignalDesc desc = ptr.p->m_signalDesc;
  63.     ndbout_c("theData[desc.m_senderDataOffset=%u] = %u",
  64.      desc.m_senderDataOffset, ptr.p->m_senderData);
  65.     ndbout_c("theData[desc.m_errorCodeOffset=%u] = %u",
  66.      desc.m_errorCodeOffset, desc.m_nodeFailErrorCode);
  67.     Uint32 len = MAX(MAX(desc.m_senderDataOffset, desc.m_errorCodeOffset),
  68.      desc.m_senderRefOffset);
  69.     
  70.     NodeBitmask overlapping = ptr.p->m_nodes;
  71.     Uint32 i = 0;
  72.     while((i = overlapping.find(i)) != NodeBitmask::NotFound){
  73.       ndbout_c("  theData[desc.m_senderRefOffset=%u] = %x",
  74.        desc.m_senderRefOffset, numberToRef(desc.m_block, i));
  75.       ndbout_c("  sendSignal(%x,%u,signal,%u,JBB",
  76.        m_block.reference(), desc.m_gsn, len+1);
  77.       i++;
  78.     }
  79.   }
  80. }
  82. void
  83. SafeCounterManager::execNODE_FAILREP(Signal* signal){
  84.   Uint32 * theData = signal->getDataPtrSend();
  85.   ActiveCounterPtr ptr;
  86.   NodeBitmask nodes;
  87.   nodes.assign(NodeBitmask::Size, 
  88.        ((const NodeFailRep*)signal->getDataPtr())->theNodes);
  90.   for(m_activeCounters.first(ptr); !ptr.isNull(); m_activeCounters.next(ptr)){
  91.     if(nodes.overlaps(ptr.p->m_nodes)){
  92.       ActiveCounter::SignalDesc desc = ptr.p->m_signalDesc;
  93.       theData[desc.m_senderDataOffset] = ptr.p->m_senderData;
  94.       theData[desc.m_errorCodeOffset] = desc.m_nodeFailErrorCode;
  95.       Uint32 len = MAX(MAX(desc.m_senderDataOffset, desc.m_errorCodeOffset),
  96.        desc.m_senderRefOffset);
  97.       
  98.       NodeBitmask overlapping = ptr.p->m_nodes;
  99.       overlapping.bitAND(nodes);
  100.       Uint32 i = 0;
  101.       while((i = overlapping.find(i)) != NodeBitmask::NotFound){
  102. theData[desc.m_senderRefOffset] = numberToRef(desc.m_block, i);
  103. m_block.sendSignal(m_block.reference(), desc.m_gsn, signal, len+1,JBB);
  104. i++;
  105.       }
  106.     }
  107.   }
  108. }
  110. BlockReference
  111. SafeCounterManager::reference() const {
  112.   return m_block.reference();
  113. }
  115. void
  116. SafeCounterManager::progError(int line, int err_code, const char* extra){
  117.   m_block.progError(line, err_code, extra);
  118. }
  120. bool
  121. SafeCounterHandle::clearWaitingFor(SafeCounterManager& mgr, Uint32 nodeId)
  122. {
  123.   SafeCounterManager::ActiveCounterPtr ptr;
  124.   mgr.getPtr(ptr, m_activeCounterPtrI);
  125.   ptr.p->m_nodes.clear(nodeId);
  126.   
  127.   if (ptr.p->m_nodes.isclear()){
  128.     mgr.release(ptr);
  129.     m_activeCounterPtrI = RNIL;
  130.     return true;
  131.   }
  132.   return false;
  133. }
  135. SafeCounter::~SafeCounter(){
  136.   bool clear = m_count == 0;
  137.   bool isnull = m_ptr.i == RNIL;
  139.   m_activeCounterPtrI = m_ptr.i;
  141.   if(clear && isnull)
  142.     return;
  144.   if(clear && !isnull){
  145.     m_mgr.release(m_ptr);
  146.     m_activeCounterPtrI = RNIL;
  147.     return;
  148.   }
  150.   /**
  151.    * !clear && !isnull
  152.    */
  153.   if(!isnull){
  154.     m_ptr.p->m_nodes = m_nodes;
  155.     return;
  156.   }
  158.   ErrorReporter::handleAssert("~SafeCounter:: wo/ init", __FILE__, __LINE__);
  159. }