The world's most popular open source database

MySQL 5.1: mysql/src/5.1-dbg/storage/ndb/src/kernel/vm/SimulatedBlock.cpp File Reference

mysql/src/5.1-dbg/storage/ndb/src/kernel/vm/SimulatedBlock.cpp File Reference

#include <ndb_global.h>
#include "SimulatedBlock.hpp"
#include <NdbOut.hpp>
#include <GlobalData.hpp>
#include <Emulator.hpp>
#include <ErrorHandlingMacros.hpp>
#include <TimeQueue.hpp>
#include <TransporterRegistry.hpp>
#include <SignalLoggerManager.hpp>
#include <FastScheduler.hpp>
#include "ndbd_malloc.hpp"
#include <signaldata/EventReport.hpp>
#include <signaldata/ContinueFragmented.hpp>
#include <signaldata/NodeStateSignalData.hpp>
#include <signaldata/FsRef.hpp>
#include <signaldata/SignalDroppedRep.hpp>
#include <DebuggerNames.hpp>
#include "LongSignal.hpp"
#include <Properties.hpp>
#include "Configuration.hpp"
#include <AttributeDescriptor.hpp>
#include <NdbSqlUtil.hpp>
#include "KeyDescriptor.hpp"

Include dependency graph for SimulatedBlock.cpp:

Go to the source code of this file.


Defines
#define	ljamEntry() jamEntryLine(30000 + __LINE__)
#define	ljam() jamLine(30000 + __LINE__)
#define	lsout(x)
Functions
bool	import (Ptr< SectionSegment > &first, const Uint32 *src, Uint32 len)
void	release (SegmentedSectionPtr &ptr)
Variables
SectionSegmentPool	g_sectionSegmentPool
CArray< KeyDescriptor >	g_key_descriptor_pool

Define Documentation

#define ljam ( ) jamLine(30000 + __LINE__)

Definition at line 43 of file SimulatedBlock.cpp.

#define ljamEntry ( ) jamEntryLine(30000 + __LINE__)

Definition at line 42 of file SimulatedBlock.cpp.

#define lsout ( x )

Definition at line 1173 of file SimulatedBlock.cpp.

Referenced by SimulatedBlock::sendNextLinearFragment(), and SimulatedBlock::sendNextSegmentedFragment().

Function Documentation

bool import	(	Ptr< SectionSegment > &	first,
		const Uint32 *	src,
		Uint32	len
	)

Definition at line 65 of file TransporterCallback.cpp.

References g_sectionSegmentPool, Ptr< T >::i, SectionSegment::m_lastSegment, SectionSegment::m_nextSegment, SectionSegment::m_ownerRef, SectionSegment::m_sz, memcpy, Ptr< T >::p, RNIL, ArrayPool< T >::seize(), and SectionSegment::theData.

00065                                                                    {
00070   Uint32 dummyPrev[4]; 
00071 
00072   first.p = 0;
00073   if(g_sectionSegmentPool.seize(first)){
00074     ;
00075   } else {
00076     return false;
00077   }
00078 
00079   first.p->m_sz = len;
00080   first.p->m_ownerRef = 0;
00081   
00082   Ptr<SectionSegment> prevPtr = { (SectionSegment *)&dummyPrev[0], 0 };
00083   Ptr<SectionSegment> currPtr = first;
00084   
00085   while(len > SectionSegment::DataLength){
00086     prevPtr.p->m_nextSegment = currPtr.i;
00087     memcpy(&currPtr.p->theData[0], src, 4 * SectionSegment::DataLength);
00088     src += SectionSegment::DataLength;
00089     len -= SectionSegment::DataLength;
00090     prevPtr = currPtr;
00091     if(g_sectionSegmentPool.seize(currPtr)){
00092       ;
00093     } else {
00094       first.p->m_lastSegment = prevPtr.i;
00095       return false;
00096     }
00097   }
00098 
00099   first.p->m_lastSegment = currPtr.i;
00100   currPtr.p->m_nextSegment = RNIL;
00101   memcpy(&currPtr.p->theData[0], src, 4 * len);
00102   return true;
00103 }

Here is the call graph for this function:

void release ( SegmentedSectionPtr & ptr )

Definition at line 183 of file TransporterCallback.cpp.

References g_sectionSegmentPool, SegmentedSectionPtr::i, SectionSegment::m_lastSegment, SegmentedSectionPtr::p, ArrayPool< T >::releaseList(), relSz, and SegmentedSectionPtr::sz.

Referenced by rl_do_undo(), rl_free_undo_list(), SimulatedBlock::sendSignal(), and test().

00183                                   {
00184   g_sectionSegmentPool.releaseList(relSz(ptr.sz),
00185                                    ptr.i, 
00186                                    ptr.p->m_lastSegment);
00187 }

Here is the call graph for this function: