void Dbdih::initRecords()
{
// Records with dynamic sizes
for (Uint32 i = 0; i < c_diverify_queue_cnt; i++)
{
c_diverify_queue[i].apiConnectRecord = (ApiConnectRecord*)
allocRecord("ApiConnectRecord",
sizeof(ApiConnectRecord),
capiConnectFileSize);
}
connectRecord = (ConnectRecord*)allocRecord("ConnectRecord",
sizeof(ConnectRecord),
cconnectFileSize);
fileRecord = (FileRecord*)allocRecord("FileRecord",
sizeof(FileRecord),
cfileFileSize);
fragmentstore = (Fragmentstore*)allocRecord("Fragmentstore",
sizeof(Fragmentstore),
cfragstoreFileSize);
pageRecord = (PageRecord*)allocRecord("PageRecord",
sizeof(PageRecord),
cpageFileSize);
c_replicaRecordPool.setSize(creplicaFileSize);
tabRecord = (TabRecord*)allocRecord("TabRecord",
sizeof(TabRecord),
ctabFileSize);
// Initialize BAT for interface to file system
NewVARIABLE* bat = allocateBat(22);
bat[1].WA = &pageRecord->word[0];
bat[1].nrr = cpageFileSize;
bat[1].ClusterSize = sizeof(PageRecord);
bat[1].bits.q = 11;
bat[1].bits.v = 5;
bat[20].WA = &sysfileData[0];
bat[20].nrr = 1;
bat[20].ClusterSize = sizeof(sysfileData);
bat[20].bits.q = 7;
bat[20].bits.v = 5;
bat[21].WA = &sysfileDataToFile[0];
bat[21].nrr = 1;
bat[21].ClusterSize = sizeof(sysfileDataToFile);
bat[21].bits.q = 7;
bat[21].bits.v = 5;
}//Dbdih::initRecords()
void Dblqh::initRecords()
{
// Records with dynamic sizes
addFragRecord = (AddFragRecord*)allocRecord("AddFragRecord",
sizeof(AddFragRecord),
caddfragrecFileSize);
attrbuf = (Attrbuf*)allocRecord("Attrbuf",
sizeof(Attrbuf),
cattrinbufFileSize);
databuf = (Databuf*)allocRecord("Databuf",
sizeof(Databuf),
cdatabufFileSize);
gcpRecord = (GcpRecord*)allocRecord("GcpRecord",
sizeof(GcpRecord),
cgcprecFileSize);
hostRecord = (HostRecord*)allocRecord("HostRecord",
sizeof(HostRecord),
chostFileSize);
lcpRecord = (LcpRecord*)allocRecord("LcpRecord",
sizeof(LcpRecord),
clcpFileSize);
for(Uint32 i = 0; i<clcpFileSize; i++){
new (&lcpRecord[i])LcpRecord();
}
logPartRecord = (LogPartRecord*)allocRecord("LogPartRecord",
sizeof(LogPartRecord),
clogPartFileSize);
logFileRecord = (LogFileRecord*)allocRecord("LogFileRecord",
sizeof(LogFileRecord),
clogFileFileSize);
logFileOperationRecord = (LogFileOperationRecord*)
allocRecord("LogFileOperationRecord",
sizeof(LogFileOperationRecord),
clfoFileSize);
logPageRecord =
(LogPageRecord*)allocRecordAligned("LogPageRecord",
sizeof(LogPageRecord),
clogPageFileSize,
&logPageRecordUnaligned,
NDB_O_DIRECT_WRITE_ALIGNMENT,
false);
pageRefRecord = (PageRefRecord*)allocRecord("PageRefRecord",
sizeof(PageRefRecord),
cpageRefFileSize);
cscanNoFreeRec = cscanrecFileSize;
c_scanRecordPool.setSize(cscanrecFileSize);
c_scanTakeOverHash.setSize(64);
tablerec = (Tablerec*)allocRecord("Tablerec",
sizeof(Tablerec),
ctabrecFileSize);
tcConnectionrec = (TcConnectionrec*)allocRecord("TcConnectionrec",
sizeof(TcConnectionrec),
ctcConnectrecFileSize);
m_commitAckMarkerPool.setSize(ctcConnectrecFileSize);
m_commitAckMarkerHash.setSize(1024);
tcNodeFailRecord = (TcNodeFailRecord*)allocRecord("TcNodeFailRecord",
sizeof(TcNodeFailRecord),
ctcNodeFailrecFileSize);
/*
ndbout << "FRAGREC SIZE = " << sizeof(Fragrecord) << endl;
ndbout << "TAB SIZE = " << sizeof(Tablerec) << endl;
ndbout << "GCP SIZE = " << sizeof(GcpRecord) << endl;
ndbout << "LCP SIZE = " << sizeof(LcpRecord) << endl;
ndbout << "LCPLOC SIZE = " << sizeof(LcpLocRecord) << endl;
ndbout << "LOGPART SIZE = " << sizeof(LogPartRecord) << endl;
ndbout << "LOGFILE SIZE = " << sizeof(LogFileRecord) << endl;
ndbout << "TC SIZE = " << sizeof(TcConnectionrec) << endl;
ndbout << "HOST SIZE = " << sizeof(HostRecord) << endl;
ndbout << "LFO SIZE = " << sizeof(LogFileOperationRecord) << endl;
ndbout << "PR SIZE = " << sizeof(PageRefRecord) << endl;
ndbout << "SCAN SIZE = " << sizeof(ScanRecord) << endl;
*/
// Initialize BAT for interface to file system
NewVARIABLE* bat = allocateBat(2);
bat[1].WA = &logPageRecord->logPageWord[0];
bat[1].nrr = clogPageFileSize;
bat[1].ClusterSize = sizeof(LogPageRecord);
bat[1].bits.q = ZTWOLOG_PAGE_SIZE;
bat[1].bits.v = 5;
}//Dblqh::initRecords()
void
Backup::execREAD_CONFIG_REQ(Signal* signal)
{
const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr();
Uint32 ref = req->senderRef;
Uint32 senderData = req->senderData;
ndbrequire(req->noOfParameters == 0);
const ndb_mgm_configuration_iterator * p =
m_ctx.m_config.getOwnConfigIterator();
ndbrequire(p != 0);
c_defaults.m_disk_write_speed = 10 * (1024 * 1024);
c_defaults.m_disk_write_speed_sr = 100 * (1024 * 1024);
c_defaults.m_disk_synch_size = 4 * (1024 * 1024);
c_defaults.m_o_direct = true;
Uint32 noBackups = 0, noTables = 0, noAttribs = 0, noFrags = 0;
ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_DISCLESS,
&c_defaults.m_diskless));
ndb_mgm_get_int_parameter(p, CFG_DB_O_DIRECT,
&c_defaults.m_o_direct);
ndb_mgm_get_int_parameter(p, CFG_DB_CHECKPOINT_SPEED_SR,
&c_defaults.m_disk_write_speed_sr);
ndb_mgm_get_int_parameter(p, CFG_DB_CHECKPOINT_SPEED,
&c_defaults.m_disk_write_speed);
ndb_mgm_get_int_parameter(p, CFG_DB_DISK_SYNCH_SIZE,
&c_defaults.m_disk_synch_size);
ndb_mgm_get_int_parameter(p, CFG_DB_COMPRESSED_BACKUP,
&c_defaults.m_compressed_backup);
ndb_mgm_get_int_parameter(p, CFG_DB_COMPRESSED_LCP,
&c_defaults.m_compressed_lcp);
m_backup_report_frequency = 0;
ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_REPORT_FREQUENCY,
&m_backup_report_frequency);
/*
We adjust the disk speed parameters from bytes per second to rather be
words per 100 milliseconds. We convert disk synch size from bytes per
second to words per second.
*/
c_defaults.m_disk_write_speed /= (4 * 10);
c_defaults.m_disk_write_speed_sr /= (4 * 10);
/*
Temporary fix, we divide the speed by number of ldm threads since we
now can write in all ldm threads in parallel. Since previously we could
write in 2 threads we also multiply by 2 if number of ldm threads is
at least 2.
The real fix will be to make the speed of writing more adaptable and also
to use the real configured value and also add a new max disk speed value
that can be used when one needs to write faster.
*/
Uint32 num_ldm_threads = globalData.ndbMtLqhThreads;
if (num_ldm_threads == 0)
{
/* We are running with ndbd binary */
jam();
num_ldm_threads = 1;
}
c_defaults.m_disk_write_speed /= num_ldm_threads;
c_defaults.m_disk_write_speed_sr /= num_ldm_threads;
if (num_ldm_threads > 1)
{
jam();
c_defaults.m_disk_write_speed *= 2;
c_defaults.m_disk_write_speed_sr *= 2;
}
ndb_mgm_get_int_parameter(p, CFG_DB_PARALLEL_BACKUPS, &noBackups);
// ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_NO_TABLES, &noTables));
ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DICT_TABLE, &noTables));
ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_NO_ATTRIBUTES, &noAttribs));
ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DIH_FRAG_CONNECT, &noFrags));
noAttribs++; //RT 527 bug fix
c_nodePool.setSize(MAX_NDB_NODES);
c_backupPool.setSize(noBackups + 1);
c_backupFilePool.setSize(3 * noBackups + 1);
c_tablePool.setSize(noBackups * noTables + 1);
c_triggerPool.setSize(noBackups * 3 * noTables);
c_fragmentPool.setSize(noBackups * noFrags + 1);
Uint32 szDataBuf = (2 * 1024 * 1024);
Uint32 szLogBuf = (2 * 1024 * 1024);
Uint32 szWrite = 32768, maxWriteSize = (256 * 1024);
ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_DATA_BUFFER_MEM, &szDataBuf);
ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_LOG_BUFFER_MEM, &szLogBuf);
ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_WRITE_SIZE, &szWrite);
ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_MAX_WRITE_SIZE, &maxWriteSize);
if (maxWriteSize < szWrite)
{
/**
* max can't be lower than min
*/
maxWriteSize = szWrite;
}
if ((maxWriteSize % szWrite) != 0)
{
/**
* max needs to be a multiple of min
*/
maxWriteSize = (maxWriteSize + szWrite - 1) / szWrite;
maxWriteSize *= szWrite;
}
/**
* add min writesize to buffer size...and the alignment added here and there
*/
Uint32 extra = szWrite + 4 * (/* align * 512b */ 128);
szDataBuf += extra;
szLogBuf += extra;
c_defaults.m_logBufferSize = szLogBuf;
c_defaults.m_dataBufferSize = szDataBuf;
c_defaults.m_minWriteSize = szWrite;
c_defaults.m_maxWriteSize = maxWriteSize;
c_defaults.m_lcp_buffer_size = szDataBuf;
Uint32 szMem = 0;
ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_MEM, &szMem);
szMem += 3 * extra; // (data+log+lcp);
Uint32 noPages =
(szMem + sizeof(Page32) - 1) / sizeof(Page32) +
(c_defaults.m_lcp_buffer_size + sizeof(Page32) - 1) / sizeof(Page32);
// We need to allocate an additional of 2 pages. 1 page because of a bug in
// ArrayPool and another one for DICTTAINFO.
c_pagePool.setSize(noPages + NO_OF_PAGES_META_FILE + 2, true);
{ // Init all tables
SLList<Table> tables(c_tablePool);
TablePtr ptr;
while (tables.seizeFirst(ptr)) {
new (ptr.p) Table(c_fragmentPool);
}
while (tables.releaseFirst());
}
{
SLList<BackupFile> ops(c_backupFilePool);
BackupFilePtr ptr;
while (ops.seizeFirst(ptr)) {
new (ptr.p) BackupFile(* this, c_pagePool);
}
while (ops.releaseFirst());
}
{
SLList<BackupRecord> recs(c_backupPool);
BackupRecordPtr ptr;
while (recs.seizeFirst(ptr)) {
new (ptr.p) BackupRecord(* this, c_tablePool,
c_backupFilePool, c_triggerPool);
}
while (recs.releaseFirst());
}
// Initialize BAT for interface to file system
{
Page32Ptr p;
ndbrequire(c_pagePool.seizeId(p, 0));
c_startOfPages = (Uint32 *)p.p;
c_pagePool.release(p);
NewVARIABLE* bat = allocateBat(1);
bat[0].WA = c_startOfPages;
bat[0].nrr = c_pagePool.getSize()*sizeof(Page32)/sizeof(Uint32);
}
ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
conf->senderRef = reference();
conf->senderData = senderData;
sendSignal(ref, GSN_READ_CONFIG_CONF, signal,
ReadConfigConf::SignalLength, JBB);
}
void Dblqh::initRecords()
{
// Records with dynamic sizes
addFragRecord = (AddFragRecord*)allocRecord("AddFragRecord",
sizeof(AddFragRecord),
caddfragrecFileSize);
gcpRecord = (GcpRecord*)allocRecord("GcpRecord",
sizeof(GcpRecord),
cgcprecFileSize);
hostRecord = (HostRecord*)allocRecord("HostRecord",
sizeof(HostRecord),
chostFileSize);
lcpRecord = (LcpRecord*)allocRecord("LcpRecord",
sizeof(LcpRecord),
clcpFileSize);
for(Uint32 i = 0; i<clcpFileSize; i++){
new (&lcpRecord[i])LcpRecord();
}
logPartRecord = (LogPartRecord*)allocRecord("LogPartRecord",
sizeof(LogPartRecord),
NDB_MAX_LOG_PARTS);
logFileRecord = (LogFileRecord*)allocRecord("LogFileRecord",
sizeof(LogFileRecord),
clogFileFileSize);
logFileOperationRecord = (LogFileOperationRecord*)
allocRecord("LogFileOperationRecord",
sizeof(LogFileOperationRecord),
clfoFileSize);
{
AllocChunk chunks[16];
const Uint32 chunkcnt = allocChunks(chunks, 16, RG_FILE_BUFFERS,
clogPageFileSize, CFG_DB_REDO_BUFFER);
{
Ptr<GlobalPage> pagePtr;
m_shared_page_pool.getPtr(pagePtr, chunks[0].ptrI);
logPageRecord = (LogPageRecord*)pagePtr.p;
}
cfirstfreeLogPage = RNIL;
clogPageFileSize = 0;
clogPageCount = 0;
for (Int32 i = chunkcnt - 1; i >= 0; i--)
{
const Uint32 cnt = chunks[i].cnt;
ndbrequire(cnt != 0);
Ptr<GlobalPage> pagePtr;
m_shared_page_pool.getPtr(pagePtr, chunks[i].ptrI);
LogPageRecord * base = (LogPageRecord*)pagePtr.p;
ndbrequire(base >= logPageRecord);
const Uint32 ptrI = Uint32(base - logPageRecord);
for (Uint32 j = 0; j<cnt; j++)
{
refresh_watch_dog();
base[j].logPageWord[ZNEXT_PAGE] = ptrI + j + 1;
base[j].logPageWord[ZPOS_IN_FREE_LIST]= 1;
base[j].logPageWord[ZPOS_IN_WRITING]= 0;
}
base[cnt-1].logPageWord[ZNEXT_PAGE] = cfirstfreeLogPage;
cfirstfreeLogPage = ptrI;
clogPageCount += cnt;
if (ptrI + cnt > clogPageFileSize)
clogPageFileSize = ptrI + cnt;
}
cnoOfLogPages = clogPageCount;
}
#ifndef NO_REDO_PAGE_CACHE
m_redo_page_cache.m_pool.set((RedoCacheLogPageRecord*)logPageRecord,
clogPageFileSize);
m_redo_page_cache.m_hash.setSize(63);
const Uint32 * base = (Uint32*)logPageRecord;
const RedoCacheLogPageRecord* tmp1 = (RedoCacheLogPageRecord*)logPageRecord;
ndbrequire(&base[ZPOS_PAGE_NO] == &tmp1->m_page_no);
ndbrequire(&base[ZPOS_PAGE_FILE_NO] == &tmp1->m_file_no);
#endif
#ifndef NO_REDO_OPEN_FILE_CACHE
m_redo_open_file_cache.m_pool.set(logFileRecord, clogFileFileSize);
#endif
pageRefRecord = (PageRefRecord*)allocRecord("PageRefRecord",
sizeof(PageRefRecord),
cpageRefFileSize);
c_scanRecordPool.setSize(cscanrecFileSize);
c_scanTakeOverHash.setSize(64);
tablerec = (Tablerec*)allocRecord("Tablerec",
sizeof(Tablerec),
ctabrecFileSize);
tcConnectionrec = (TcConnectionrec*)allocRecord("TcConnectionrec",
sizeof(TcConnectionrec),
ctcConnectrecFileSize);
m_commitAckMarkerPool.setSize(ctcConnectrecFileSize);
m_commitAckMarkerHash.setSize(1024);
tcNodeFailRecord = (TcNodeFailRecord*)allocRecord("TcNodeFailRecord",
sizeof(TcNodeFailRecord),
ctcNodeFailrecFileSize);
/*
ndbout << "FRAGREC SIZE = " << sizeof(Fragrecord) << endl;
ndbout << "TAB SIZE = " << sizeof(Tablerec) << endl;
ndbout << "GCP SIZE = " << sizeof(GcpRecord) << endl;
ndbout << "LCP SIZE = " << sizeof(LcpRecord) << endl;
ndbout << "LCPLOC SIZE = " << sizeof(LcpLocRecord) << endl;
ndbout << "LOGPART SIZE = " << sizeof(LogPartRecord) << endl;
ndbout << "LOGFILE SIZE = " << sizeof(LogFileRecord) << endl;
ndbout << "TC SIZE = " << sizeof(TcConnectionrec) << endl;
ndbout << "HOST SIZE = " << sizeof(HostRecord) << endl;
ndbout << "LFO SIZE = " << sizeof(LogFileOperationRecord) << endl;
ndbout << "PR SIZE = " << sizeof(PageRefRecord) << endl;
ndbout << "SCAN SIZE = " << sizeof(ScanRecord) << endl;
*/
// Initialize BAT for interface to file system
NewVARIABLE* bat = allocateBat(2);
bat[1].WA = &logPageRecord->logPageWord[0];
bat[1].nrr = clogPageFileSize;
bat[1].ClusterSize = sizeof(LogPageRecord);
bat[1].bits.q = ZTWOLOG_PAGE_SIZE;
bat[1].bits.v = 5;
}//Dblqh::initRecords()
void
Restore::execREAD_CONFIG_REQ(Signal* signal)
{
jamEntry();
const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr();
Uint32 ref = req->senderRef;
Uint32 senderData = req->senderData;
ndbrequire(req->noOfParameters == 0);
const ndb_mgm_configuration_iterator * p =
m_ctx.m_config.getOwnConfigIterator();
ndbrequire(p != 0);
#if 0
Uint32 noBackups = 0, noTables = 0, noAttribs = 0;
ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_DISCLESS, &m_diskless));
ndb_mgm_get_int_parameter(p, CFG_DB_PARALLEL_BACKUPS, &noBackups);
// ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_NO_TABLES, &noTables));
ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DICT_TABLE, &noTables));
ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_NO_ATTRIBUTES, &noAttribs));
noAttribs++; //RT 527 bug fix
c_backupPool.setSize(noBackups);
c_backupFilePool.setSize(3 * noBackups);
c_tablePool.setSize(noBackups * noTables);
c_attributePool.setSize(noBackups * noAttribs);
c_triggerPool.setSize(noBackups * 3 * noTables);
// 2 = no of replicas
c_fragmentPool.setSize(noBackups * NO_OF_FRAG_PER_NODE * noTables);
Uint32 szMem = 0;
ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_MEM, &szMem);
Uint32 noPages = (szMem + sizeof(Page32) - 1) / sizeof(Page32);
// We need to allocate an additional of 2 pages. 1 page because of a bug in
// ArrayPool and another one for DICTTAINFO.
c_pagePool.setSize(noPages + NO_OF_PAGES_META_FILE + 2);
Uint32 szDataBuf = (2 * 1024 * 1024);
Uint32 szLogBuf = (2 * 1024 * 1024);
Uint32 szWrite = 32768;
ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_DATA_BUFFER_MEM, &szDataBuf);
ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_LOG_BUFFER_MEM, &szLogBuf);
ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_WRITE_SIZE, &szWrite);
c_defaults.m_logBufferSize = szLogBuf;
c_defaults.m_dataBufferSize = szDataBuf;
c_defaults.m_minWriteSize = szWrite;
c_defaults.m_maxWriteSize = szWrite;
{ // Init all tables
ArrayList<Table> tables(c_tablePool);
TablePtr ptr;
while(tables.seize(ptr)){
new (ptr.p) Table(c_attributePool, c_fragmentPool);
}
tables.release();
}
{
ArrayList<BackupFile> ops(c_backupFilePool);
BackupFilePtr ptr;
while(ops.seize(ptr)){
new (ptr.p) BackupFile(* this, c_pagePool);
}
ops.release();
}
{
ArrayList<BackupRecord> recs(c_backupPool);
BackupRecordPtr ptr;
while(recs.seize(ptr)){
new (ptr.p) BackupRecord(* this, c_pagePool, c_tablePool,
c_backupFilePool, c_triggerPool);
}
recs.release();
}
// Initialize BAT for interface to file system
{
Page32Ptr p;
ndbrequire(c_pagePool.seizeId(p, 0));
c_startOfPages = (Uint32 *)p.p;
c_pagePool.release(p);
NewVARIABLE* bat = allocateBat(1);
bat[0].WA = c_startOfPages;
bat[0].nrr = c_pagePool.getSize()*sizeof(Page32)/sizeof(Uint32);
}
#endif
m_file_pool.setSize(1);
Uint32 cnt = 2*MAX_ATTRIBUTES_IN_TABLE;
cnt += PAGES;
cnt += List::getSegmentSize()-1;
cnt /= List::getSegmentSize();
cnt += 2;
m_databuffer_pool.setSize(cnt);
ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
conf->senderRef = reference();
conf->senderData = senderData;
sendSignal(ref, GSN_READ_CONFIG_CONF, signal,
ReadConfigConf::SignalLength, JBB);
}
