| List: | Internals | « Previous MessageNext Message » | |
| From: | jonas.oreland | Date: | March 22 2005 3:53pm |
| Subject: | bk commit into 5.1-ndb tree (joreland:1.1795) | ||
| View as plain text | |||
Below is the list of changes that have just been committed into a local 5.1-ndb repository of jonas. When jonas does a push these changes will be propagated to the main repository and, within 24 hours after the push, to the public repository. For information on how to access the public repository see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html ChangeSet 1.1795 05/03/22 15:53:42 joreland@stripped +13 -0 wl1870 - ndb diskdata log buffer handling - possible extra timeslice on tup commit log space handling - possible abort on prepare ndb/src/kernel/vm/SimulatedBlock.hpp 1.14 05/03/22 15:53:38 joreland@stripped +1 -0 Make Lgman able to use Callback ndb/src/kernel/blocks/tsman.cpp 1.28 05/03/22 15:53:38 joreland@stripped +4 -4 Change pgman interface ndb/src/kernel/blocks/pgman.hpp 1.16 05/03/22 15:53:38 joreland@stripped +6 -4 Change interface + always timeslice (for testing purposes) ndb/src/kernel/blocks/pgman.cpp 1.14 05/03/22 15:53:38 joreland@stripped +18 -3 Inc. size + impl. of delay(for testing) ndb/src/kernel/blocks/lgman.hpp 1.18 05/03/22 15:53:38 joreland@stripped +39 -5 Log buffer waiter ndb/src/kernel/blocks/lgman.cpp 1.21 05/03/22 15:53:38 joreland@stripped +112 -7 Log buffer waiter ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp 1.52 05/03/22 15:53:38 joreland@stripped +97 -21 Impl. allocation of log space handle misc flags wrt to multi operations ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp 1.13 05/03/22 15:53:38 joreland@stripped +7 -59 Change disk_page_free to always have page loaded before started ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp 1.19 05/03/22 15:53:38 joreland@stripped +0 -1 remove ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp 1.38 05/03/22 15:53:38 joreland@stripped +186 -56 Move dealloc_tuple into commit of last operation (instead of TUP_DEALLOC_REQ) as the operation record is need as we can be timesliced while waiting for log buffer space ndb/src/kernel/blocks/dbtup/Dbtup.hpp 1.48 05/03/22 15:53:38 joreland@stripped +24 -19 Impl. log buffer wait queue(commit) + allocation of log space during prepare ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp 1.23 05/03/22 15:53:38 joreland@stripped +1 -1 Bigger global pool ndb/include/kernel/signaldata/LgmanContinueB.hpp 1.2 05/03/22 15:53:38 joreland@stripped +1 -0 Impl. log buffer wait queue # This is a BitKeeper patch. What follows are the unified diffs for the # set of deltas contained in the patch. The rest of the patch, the part # that BitKeeper cares about, is below these diffs. # User: joreland # Host: eel.hemma.oreland.se.ndb.mysql.com # Root: /home/jonas/src/mysql-5.1-ndb-dd --- 1.1/ndb/include/kernel/signaldata/LgmanContinueB.hpp Thu Mar 17 09:34:14 2005 +++ 1.2/ndb/include/kernel/signaldata/LgmanContinueB.hpp Tue Mar 22 15:53:38 2005 @@ -29,6 +29,7 @@ CUT_LOG_TAIL = 0 ,FILTER_LOG = 1 ,FLUSH_LOG = 2 + ,PROCESS_LOG_BUFFER_WAITERS = 3 }; }; --- 1.12/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp Fri Mar 11 14:20:29 2005 +++ 1.13/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp Tue Mar 22 15:53:38 2005 @@ -613,68 +613,16 @@ void Dbtup::disk_page_free(Signal *signal, Tablerec *tabPtrP, - Local_key* key, Uint32 gci) + Local_key* key, PagePtr pagePtr, Uint32 gci) { - Page_cache_client::Request req; - req.m_callback.m_callbackData= key->m_page_idx; - req.m_callback.m_callbackFunction = - safe_cast(&Dbtup::disk_page_free_callback); - - int flags= 0; //Page_cache_client::DEALLOC_REQ; - memcpy(&req.m_page, key, sizeof(Local_key)); - - int res= m_pgman.get_page(signal, req, flags); - switch(res) - { - case 0: - case -1: - break; - default: - Ptr<GlobalPage> page; - m_global_page_pool.getPtr(page, (Uint32)res); - disk_page_free_callback_1(signal, tabPtrP, *(PagePtr*)&page, - key->m_page_idx); - } -} - -void -Dbtup::disk_page_free_callback(Signal* signal, - Uint32 page_idx, Uint32 page_id) -{ - //ndbout_c("disk_alloc_page_callback id: %d", page_id); - - Ptr<GlobalPage> gpage; - m_global_page_pool.getPtr(gpage, page_id); - - PagePtr pagePtr= *(PagePtr*)&gpage; - - Ptr<Tablerec> tabPtr; - tabPtr.i= pagePtr.p->m_table_id; - ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec); - - // It can't be in a free list when just - // picked up from disk - pagePtr.p->list_index |= 0x8000; - disk_page_free_callback_1(signal, tabPtr.p, pagePtr, page_idx); -} - -void -Dbtup::disk_page_free_callback_1(Signal* signal, - Tablerec* tabPtrP, - PagePtr pagePtr, - Uint32 page_idx) -{ - Local_key key; - key.m_file_no= pagePtr.p->m_file_no; - key.m_page_no= pagePtr.p->m_page_no; - key.m_page_idx= page_idx; + Uint32 page_idx= key->m_page_idx; Uint32 logfile_group_id= tabPtrP->m_logfile_group_id; if(tabPtrP->m_attributes[DD].m_no_of_varsize == 0) { const Uint32 *src= ((Fix_page*)pagePtr.p)->get_ptr(page_idx, 0); - disk_page_undo_free(pagePtr.p, &key, - src, 4*tabPtrP->m_offsets[DD].m_fix_header_size, - 0, logfile_group_id); + disk_page_undo_free(pagePtr.p, key, + src, tabPtrP->m_offsets[DD].m_fix_header_size, + gci, logfile_group_id); ((Fix_page*)pagePtr.p)->free_record(page_idx); } @@ -682,9 +630,9 @@ { const Uint32 *src= ((Var_page*)pagePtr.p)->get_ptr(page_idx); Uint32 sz= ((Var_page*)pagePtr.p)->get_entry_len(page_idx); - disk_page_undo_free(pagePtr.p, &key, + disk_page_undo_free(pagePtr.p, key, src, sz, - 0, logfile_group_id); + gci, logfile_group_id); ((Var_page*)pagePtr.p)->free_record(page_idx); } --- 1.20/ndb/src/kernel/blocks/lgman.cpp Mon Mar 21 12:20:55 2005 +++ 1.21/ndb/src/kernel/blocks/lgman.cpp Tue Mar 22 15:53:38 2005 @@ -73,6 +73,7 @@ m_file_pool.setSize(10); m_file_hash.setSize(10); m_data_buffer_pool.setSize(10); + m_log_buffer_waiter_pool.setSize(10); } Lgman::~Lgman() @@ -118,7 +119,15 @@ Ptr<Logfile_group> ptr; m_logfile_group_pool.getPtr(ptr, ptrI); flush_log(signal, ptr); - break; + return; + } + case LgmanContinueB::PROCESS_LOG_BUFFER_WAITERS: + { + Uint32 ptrI = signal->theData[1]; + Ptr<Logfile_group> ptr; + m_logfile_group_pool.getPtr(ptr, ptrI); + process_log_buffer_waiters(signal, ptr); + return; } } } @@ -391,10 +400,10 @@ CreateFileImplConf::SignalLength, JBB); } - if(lg_ptr.p->m_current_file.m_ptr_i == RNIL) + if(lg_ptr.p->m_current_file_ptr_i == RNIL) { jam(); - lg_ptr.p->m_current_file.m_ptr_i= ptr.i; + lg_ptr.p->m_current_file_ptr_i= ptr.i; } } @@ -417,7 +426,7 @@ m_last_written_lsn = 0; m_current_sync_lsn = 0; - m_current_file.m_ptr_i = RNIL; + m_current_file_ptr_i = RNIL; m_free_buffer_words = 0; m_pos[READER].m_current_page.m_ptr_i = RNIL; // { m_buffer_pages, idx } m_pos[READER].m_current_pos.m_ptr_i = RNIL; // { page ptr.i, m_words_used} @@ -714,6 +723,47 @@ return 0; } +int +Logfile_client::get_log_buffer(Signal* signal, Uint32 sz, + SimulatedBlock::Callback* callback) +{ + Lgman::Logfile_group key; + key.m_logfile_group_id= m_logfile_group_id; + Ptr<Lgman::Logfile_group> ptr; + if(m_lgman->m_logfile_group_hash.find(ptr, key)) + { + if(ptr.p->m_free_buffer_words >= sz) + { + return 1; + } + + bool empty= false; + { + Ptr<Lgman::Log_buffer_waiter> wait; + LocalDLFifoList<Lgman::Log_buffer_waiter> + list(m_lgman->m_log_buffer_waiter_pool, ptr.p->m_log_buffer_waiters); + + empty= list.isEmpty(); + if(!list.seize(wait)) + return -1; + + wait.p->m_size= sz; + wait.p->m_block= m_block; + memcpy(&wait.p->m_callback, callback,sizeof(SimulatedBlock::Callback)); + } + + if(empty) + { // Start ContinueB + m_lgman->process_log_buffer_waiters(signal, ptr); + } + + ndbout_c("in log buffer wait queue"); + + return 0; + } + return -1; +} + NdbOut& operator<<(NdbOut& out, const Lgman::Logfile_group::Position& pos) { @@ -733,7 +783,7 @@ jamEntry(); - if(ptr.p->m_current_file.m_ptr_i == RNIL || + if(ptr.p->m_current_file_ptr_i == RNIL || reader.m_current_page == writer.m_current_page) { signal->theData[0] = LgmanContinueB::FLUSH_LOG; @@ -830,6 +880,50 @@ signal->theData[0] = LgmanContinueB::FLUSH_LOG; signal->theData[1] = ptr.i; sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, tot*100, 2); + + if(tot > 0 && !ptr.p->m_log_buffer_waiters.isEmpty()) + { + jam(); + process_log_buffer_waiters(signal, ptr); + } +} + +void +Lgman::process_log_buffer_waiters(Signal* signal, Ptr<Logfile_group> ptr) +{ + printf("process_log_buffer_waiters -"); + Uint32 free_buffer= ptr.p->m_free_buffer_words; + LocalDLFifoList<Log_buffer_waiter> + list(m_log_buffer_waiter_pool, ptr.p->m_log_buffer_waiters); + + if(list.isEmpty()) + { + return; + } + + bool removed= false; + Ptr<Log_buffer_waiter> waiter; + list.first(waiter); + if(waiter.p->m_size < free_buffer) + { + removed= true; + Uint32 block = waiter.p->m_block; + SimulatedBlock* b = globalData.getBlock(block); + b->execute(signal, waiter.p->m_callback, 0); + + printf("removing from list - "); + list.release(waiter); + } + + if(removed && !list.isEmpty()) + { + ndbout_c(" - continueb "); + signal->theData[0] = LgmanContinueB::PROCESS_LOG_BUFFER_WAITERS; + signal->theData[1] = ptr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + } + + ndbout_c(""); } Uint32 @@ -838,7 +932,7 @@ { assert(pages); Ptr<Undofile> filePtr; - m_file_pool.getPtr(filePtr, ptr.p->m_current_file.m_ptr_i); + m_file_pool.getPtr(filePtr, ptr.p->m_current_file_ptr_i); if(filePtr.p->m_online.m_outstanding > 0 || filePtr.p->m_state & Undofile::FS_FULL) @@ -906,7 +1000,7 @@ jam(); files.first(next); } - ptr.p->m_current_file.m_ptr_i = next.i; + ptr.p->m_current_file_ptr_i = next.i; if(cnt != pages) { @@ -980,3 +1074,14 @@ } } +int +Lgman::alloc_log_space(Uint32 logfile_group_ref, Uint32 words) +{ + return 0; +} + +int +Lgman::free_log_space(Uint32 logfile_group_ref, Uint32 words) +{ + return 0; +} --- 1.17/ndb/src/kernel/blocks/lgman.hpp Mon Mar 21 12:20:55 2005 +++ 1.18/ndb/src/kernel/blocks/lgman.hpp Tue Mar 22 15:53:38 2005 @@ -64,6 +64,18 @@ Uint64 m_lsn; }; + struct Log_buffer_waiter + { + Uint32 m_size; + Uint32 m_block; + Callback m_callback; + union { + Uint32 nextPool; + Uint32 nextList; + }; + Uint32 prevList; + }; + struct Undofile { Undofile(){} @@ -114,7 +126,7 @@ m_logfile_group_ptr_i == rec.m_logfile_group_ptr_i; } }; - + typedef LocalDataBuffer<15> Page_map; struct Buffer_idx @@ -144,11 +156,13 @@ Lcp_record m_lcp[2]; - Buffer_idx m_current_file; // { file_ptr.i, page no } - DLFifoList<Undofile>::Head m_files; // Files w/ free space - DLList<Undofile>::Head m_meta_files; // Files being created or dropped + Uint32 m_current_file_ptr_i; // Current file + Uint64 m_free_file_words; // Free words in logfile group + DLFifoList<Undofile>::Head m_files; // Files in log + DLList<Undofile>::Head m_meta_files;// Files being created or dropped Uint32 m_free_buffer_words; // Free buffer page words + DLFifoList<Log_buffer_waiter>::Head m_log_buffer_waiters; Page_map::Head m_buffer_pages; // Pairs of { ptr.i, count } struct Position { Buffer_idx m_current_page; // { m_buffer_pages, idx } @@ -169,11 +183,21 @@ return key == rec.key; } }; + + /** + * Alloc/free space in log + * Alloction will be removed at either/or + * 1) Logfile_client::add_entry + * 2) free_log_space + */ + int alloc_log_space(Uint32 logfile_ref, Uint32 words); + int free_log_space(Uint32 logfile_ref, Uint32 words); private: friend class Logfile_client; ArrayPool<Undofile> m_file_pool; ArrayPool<Logfile_group> m_logfile_group_pool; + ArrayPool<Log_buffer_waiter> m_log_buffer_waiter_pool; Page_map::DataBufferPool m_data_buffer_pool; @@ -184,7 +208,9 @@ bool alloc_logbuffer_memory(Ptr<Logfile_group>, Uint32 pages); void free_logbuffer_memory(Ptr<Logfile_group>); Uint32* get_log_buffer(Ptr<Logfile_group>, Uint32 sz); + void process_log_buffer_waiters(Signal* signal, Ptr<Logfile_group>); Uint32 next_page(Logfile_group* ptrP, Uint32 i); + void cut_log_tail(Signal*, Ptr<Logfile_group> ptr, Uint32 lcp_id); void open_file(Signal*, Ptr<Undofile>, Uint32 requestInfo); @@ -205,7 +231,6 @@ struct Request { - Uint64 m_lsn; SimulatedBlock::Callback m_callback; }; @@ -239,6 +264,15 @@ Uint64 add_entry(Local_key, void * base, Change*); Uint64 add_entry(Local_key, Uint32 off, Uint32 change); + /** + * Check for space in log buffer + * + * return >0 if available + * 0 on time slice + * -1 on error + */ + int get_log_buffer(Signal*, Uint32 sz, SimulatedBlock::Callback* m_callback); + private: Uint64 m_latest_lsn; Uint32* get_log_buffer(Uint32 sz); --- 1.13/ndb/src/kernel/blocks/pgman.cpp Mon Mar 7 14:39:34 2005 +++ 1.14/ndb/src/kernel/blocks/pgman.cpp Tue Mar 22 15:53:38 2005 @@ -34,9 +34,9 @@ addRecSignal(GSN_FSREADREF, &Pgman::execFSREADREF); addRecSignal(GSN_FSREADCONF, &Pgman::execFSREADCONF); - m_page_entry_pool.setSize(100); - m_page_entry_hash.setSize(32); - m_page_request_pool.setSize(100); + m_page_entry_pool.setSize(256); + m_page_entry_hash.setSize(64); + m_page_request_pool.setSize(10000); m_data_buffer_pool.setSize(1); { @@ -135,6 +135,15 @@ } void +Pgman::delay(Signal* signal, Ptr<Page_entry> ptr) +{ + jam(); + signal->theData[0] = PgmanContinueB::PROCESS_CALLBACKS; + signal->theData[1] = ptr.i; + sendSignal(PGMAN_REF, GSN_CONTINUEB, signal, 2, JBB); +} + +void Pgman::execFSREADREF(Signal* signal) { jamEntry(); @@ -206,6 +215,7 @@ if(!m_pgman->m_page_entry_hash.seize(m_current_entry)) { // ERROR CODE + ndbout_c("Out of page entries"); return -1; } m_current_entry.p->m_file_no = m_page_entry_key.m_file_no; @@ -217,6 +227,7 @@ LocalDLFifoList<Pgman::Page_request> list(m_pgman->m_page_request_pool, m_current_entry.p->m_requests); + bool empty= list.isEmpty(); if(list.seize(ptr)) { ptr.p->m_flags = flags; @@ -224,8 +235,12 @@ ptr.p->m_callback = req.m_callback; if(!found) m_pgman->fetch(signal, m_current_entry); + else if(empty) + m_pgman->delay(signal, m_current_entry); return 0; } + + ndbout_c("Out of page request"); return -1; } --- 1.15/ndb/src/kernel/blocks/pgman.hpp Mon Mar 7 14:39:34 2005 +++ 1.16/ndb/src/kernel/blocks/pgman.hpp Tue Mar 22 15:53:38 2005 @@ -98,6 +98,7 @@ Uint32 alloc_data_file(Uint32 file_no); void fetch(Signal*, Ptr<Page_entry>); + void delay(Signal*, Ptr<Page_entry>); void flush(Signal*, Ptr<Page_entry>); void unmap(Signal*, Ptr<Page_entry>); void update_lsn(Ptr<Page_entry>, Uint64 lsn); @@ -124,7 +125,7 @@ SimulatedBlock::Callback m_callback; }; - GlobalPage* m_ptr_p; + Ptr<GlobalPage> m_ptr; /** * Request flags @@ -243,10 +244,11 @@ if(m_pgman->m_page_entry_hash.find(m_current_entry, m_page_entry_key)) { m_pgman->m_statistics.m_page_hits++; - if((! (flags & STRICT_ORDER)) || m_current_entry.p->m_requests.isEmpty()) + //if((! (flags & STRICT_ORDER)) || m_current_entry.p->m_requests.isEmpty()) + if((! (flags & STRICT_ORDER))) { - m_ptr_p = m_current_entry.p->m_real_page_ptr.p; - return m_current_entry.p->m_real_page_ptr.i; + m_ptr = m_current_entry.p->m_real_page_ptr; + return m_ptr.i; } } return queue_request(signal, req, flags); --- 1.27/ndb/src/kernel/blocks/tsman.cpp Fri Mar 11 08:30:27 2005 +++ 1.28/ndb/src/kernel/blocks/tsman.cpp Tue Mar 22 15:53:38 2005 @@ -844,7 +844,7 @@ int real_page_id; if ((real_page_id = m_page_cache_client.get_page(signal, preq, flags)) > 0) { - GlobalPage* ptr_p = m_page_cache_client.m_ptr_p; + GlobalPage* ptr_p = m_page_cache_client.m_ptr.p; File_formats::Datafile::Extent_page* page = (File_formats::Datafile::Extent_page*)ptr_p; @@ -954,7 +954,7 @@ int real_page_id; if ((real_page_id = m_page_cache_client.get_page(signal, preq, flags)) > 0) { - GlobalPage* ptr_p = m_page_cache_client.m_ptr_p; + GlobalPage* ptr_p = m_page_cache_client.m_ptr.p; File_formats::Datafile::Extent_page* page = (File_formats::Datafile::Extent_page*)ptr_p; @@ -1028,7 +1028,7 @@ int real_page_id; if ((real_page_id = m_page_cache_client.get_page(signal, preq, flags)) > 0) { - GlobalPage* ptr_p = m_page_cache_client.m_ptr_p; + GlobalPage* ptr_p = m_page_cache_client.m_ptr.p; File_formats::Datafile::Extent_page* page = (File_formats::Datafile::Extent_page*)ptr_p; @@ -1115,7 +1115,7 @@ File_formats::Datafile::Extent_header* header; if ((real_page_id = m_page_cache_client.get_page(signal, preq, flags)) > 0) { - GlobalPage* ptr_p = m_page_cache_client.m_ptr_p; + GlobalPage* ptr_p = m_page_cache_client.m_ptr.p; File_formats::Datafile::Extent_page* page = (File_formats::Datafile::Extent_page*)ptr_p; --- 1.22/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp Fri Mar 4 07:45:43 2005 +++ 1.23/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp Tue Mar 22 15:53:38 2005 @@ -92,7 +92,7 @@ addRecSignal(GSN_TESTSIG, &Cmvmi::execTESTSIG); subscriberPool.setSize(5); - m_global_page_pool.setSize(100); + m_global_page_pool.setSize(256); const ndb_mgm_configuration_iterator * db = theConfig.getOwnConfigIterator(); for(unsigned j = 0; j<LogLevel::LOGLEVEL_CATEGORIES; j++){ --- 1.47/ndb/src/kernel/blocks/dbtup/Dbtup.hpp Wed Mar 16 23:42:35 2005 +++ 1.48/ndb/src/kernel/blocks/dbtup/Dbtup.hpp Tue Mar 22 15:53:38 2005 @@ -387,7 +387,10 @@ bool is_first_operation() const { return prevActiveOp == RNIL;} bool is_last_operation() const { return nextActiveOp == RNIL;} - Uint32 firstAttrinbufrec; //Used until copyAttrinfo + Uint32 m_undo_buffer_space; // In words + union { + Uint32 firstAttrinbufrec; //Used until copyAttrinfo + }; union { Uint32 lastAttrinbufrec; //Used until copyAttrinfo Uint32 nextPool; @@ -422,7 +425,10 @@ * functionality for multi-updates of the same record in one * transaction. */ - Uint32 savepointId; + union { + Uint32 savepointId; + Uint32 m_commit_disk_callback_page; + }; /* * We use 32 bits to save change mask for the most common cases. @@ -442,7 +448,6 @@ struct OpBitFields { unsigned int trans_state : 3; unsigned int tuple_state : 2; - unsigned int undo_logged : 1; unsigned int in_active_list : 1; unsigned int op_type : 3; @@ -451,6 +456,7 @@ unsigned int change_mask_state : 2; unsigned int m_disk_preallocated : 1; unsigned int m_load_diskpage_on_commit : 1; + unsigned int m_wait_log_buffer : 1; }; union { OpBitFields op_struct; @@ -999,11 +1005,12 @@ /** * header bits */ - STATIC_CONST ( TUP_VERSION_MASK = 0xFFFF ); - STATIC_CONST ( CHAINED_ROW = 0x10000 ); // Is var part on different page - STATIC_CONST ( DISK_PART = 0x20000 ); // Is there a disk part - STATIC_CONST ( DISK_ALLOC = 0x40000 ); // Is disk part allocated - STATIC_CONST ( DISK_INLINE = 0x80000 ); // Is disk inline + STATIC_CONST( TUP_VERSION_MASK = 0xFFFF ); + STATIC_CONST( CHAINED_ROW = 0x010000 ); // Is var part on different page + STATIC_CONST( DISK_PART = 0x020000 ); // Is there a disk part + STATIC_CONST( DISK_ALLOC = 0x040000 ); // Is disk part allocated + STATIC_CONST( DISK_INLINE = 0x080000 ); // Is disk inline + STATIC_CONST( DEALLOC = 0x100000 ); // Is record to be deleted Uint32 get_tuple_version() const { return m_header_bits & TUP_VERSION_MASK; @@ -2359,10 +2366,7 @@ Ptr<Tablerec>, Ptr<GlobalPage>); - void disk_page_free(Signal*, Tablerec*, Local_key*, Uint32 gci); - void disk_page_free_callback(Signal* signal, Uint32 page_idx, Uint32 pageid); - void disk_page_free_callback_1(Signal* signal, Tablerec* tabPtrP, - PagePtr pageP, Uint32 page_idx); + void disk_page_free(Signal*, Tablerec*, Local_key*, PagePtr, Uint32); void disk_page_update_free_space(Tablerec*, Ptr<Page_request>, DLList<Page_request>::Head list[], @@ -2372,6 +2376,8 @@ void disk_page_unmap_callback(Signal*, Uint32 tableId, Uint32 page_id); void disk_page_commit_callback(Signal*, Uint32 opPtrI, Uint32 page_id); + void disk_page_log_buffer_callback(Signal*, Uint32 opPtrI, Uint32); + void disk_page_undo_alloc(Page*, const Local_key*, Uint32 sz, Uint32 gci, Uint32 logfile_group_id); @@ -2381,13 +2387,12 @@ void disk_page_undo_free(Page*, const Local_key*, const Uint32*, Uint32 sz, Uint32 gci, Uint32 logfile_group_id); - void commit_operation(Signal*, - Uint32 gci, - Tuple_header* tuple_ptr, - Operationrec*, - Fragrecord*, - Tablerec*); - + void commit_operation(Signal*, Uint32, Tuple_header*, + Operationrec*, Fragrecord*, Tablerec*); + + void dealloc_tuple(Signal* signal, Uint32, Page*, Tuple_header*, + Operationrec*, Fragrecord*, Tablerec*); + int handle_size_change_after_update(KeyReqStruct* req_struct, Fragrecord* const regFragPtr, Tablerec* const regTabPtr, --- 1.37/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp Fri Mar 11 14:20:29 2005 +++ 1.38/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp Tue Mar 22 15:53:38 2005 @@ -33,6 +33,7 @@ ljamEntry(); +#if 0 //ndbout_c("execTUP_DEALLOCREQ"); frag_id= signal->theData[0]; @@ -72,6 +73,7 @@ } else { free_fix_rec(regFragPtr.p, regTabPtr.p, &tmp, (Fix_page*)pagePtr.p); } +#endif } void Dbtup::execTUP_WRITELOG_REQ(Signal* signal) @@ -148,6 +150,42 @@ regOperPtr->op_struct.op_type= ZREAD; regOperPtr->op_struct.m_disk_preallocated= 0; regOperPtr->op_struct.m_load_diskpage_on_commit= 0; + regOperPtr->op_struct.m_wait_log_buffer= 0; +} + +void +Dbtup::dealloc_tuple(Signal* signal, + Uint32 gci, + Page* page, + Tuple_header* ptr, + Operationrec* regOperPtr, + Fragrecord* regFragPtr, + Tablerec* regTabPtr) +{ + if (ptr->m_header_bits & Tuple_header::DISK_PART) + { + Local_key disk; + memcpy(&disk, ptr->get_disk_ref_ptr(regTabPtr), sizeof(disk)); + Ptr<GlobalPage> disk_page; + m_global_page_pool.getPtr(disk_page, + regOperPtr->m_commit_disk_callback_page); + disk_page_free(signal, regTabPtr, &disk, *(PagePtr*)&disk_page, gci); + } + + if (regTabPtr->var_sized_record) { + ljam(); + + if(ptr->m_header_bits & Tuple_header::CHAINED_ROW) + { + free_var_part(regFragPtr, regTabPtr, + *(Var_part_ref*)ptr->get_var_part_ptr(regTabPtr)); + } + free_var_part(regFragPtr, regTabPtr, + ®OperPtr->m_tuple_location, (Var_page*)page); + } else { + free_fix_rec(regFragPtr, regTabPtr, + ®OperPtr->m_tuple_location, (Fix_page*)page); + } } void @@ -158,12 +196,8 @@ Fragrecord* regFragPtr, Tablerec* regTabPtr) { - /** - * Commit of delete is handled in TUP_DEALLOCREQ - */ - if(regOperPtr->op_struct.op_type == ZDELETE) - return; - + ndbassert(regOperPtr->op_struct.op_type != ZDELETE); + Uint32 save= tuple_ptr->m_operation_ptr_i; Uint32 bits= tuple_ptr->m_header_bits; @@ -203,11 +237,19 @@ memcpy(&key, copy->get_disk_ref_ptr(regTabPtr), sizeof(Local_key)); Uint32 logfile_group_id= regTabPtr->m_logfile_group_id; - /** - * Page has already been requested...-> use m_pgman.m_ptr_p - */ + Page* page= (Page*)m_pgman.m_ptr.p; + if(regOperPtr->op_struct.m_load_diskpage_on_commit != 0) + { + /** + * Page has already been requested...-> use m_pgman.m_ptr_p + */ + } + else + { + page= (Page*) + m_global_page_pool.getPtr(regOperPtr->m_commit_disk_callback_page); + } Uint32 sz, *dst; - Page* page= (Page*)m_pgman.m_ptr_p; if(copy_bits & Tuple_header::DISK_ALLOC) { if(regTabPtr->m_attributes[DD].m_no_of_varsize == 0) @@ -215,7 +257,6 @@ ndbassert(page->uncommitted_used_space > 0); page->uncommitted_used_space--; key.m_page_idx= ((Fix_page*)page)->alloc_record(); - disk_page_undo_alloc(page, &key, 1, gci, logfile_group_id); } else @@ -229,7 +270,7 @@ disk_page_undo_alloc(page, &key, sz, gci, logfile_group_id); } } - + if(regTabPtr->m_attributes[DD].m_no_of_varsize == 0) { sz= 4*regTabPtr->m_offsets[DD].m_fix_header_size; @@ -283,11 +324,36 @@ tupCommitReq->gci= gci; regOperPtr.p->op_struct.m_load_diskpage_on_commit= 0; + regOperPtr.p->m_commit_disk_callback_page= page_id; - Ptr<GlobalPage> page; - m_global_page_pool.getPtr(page, page_id); - m_pgman.m_ptr_p= page.p; + execTUP_COMMITREQ(signal); + if(signal->theData[0] == 0) + c_lqh->tupcommit_conf_callback(signal, regOperPtr.p->userpointer); +} +void +Dbtup::disk_page_log_buffer_callback(Signal* signal, + Uint32 opPtrI, + Uint32 unused) +{ + Uint32 hash_value; + Uint32 gci; + OperationrecPtr regOperPtr; + + ljamEntry(); + + c_operation_pool.getPtr(regOperPtr, opPtrI); + c_lqh->get_op_info(regOperPtr.p->userpointer, &hash_value, &gci); + + TupCommitReq * const tupCommitReq= (TupCommitReq *)signal->getDataPtr(); + + tupCommitReq->opPtr= opPtrI; + tupCommitReq->hashValue= hash_value; + tupCommitReq->gci= gci; + + ndbassert(regOperPtr.p->op_struct.m_load_diskpage_on_commit == 0); + regOperPtr.p->op_struct.m_wait_log_buffer= 0; + execTUP_COMMITREQ(signal); ndbassert(signal->theData[0] == 0); @@ -331,48 +397,85 @@ ptrCheckGuard(regTabPtr, no_of_tablerec, tablerec); + PagePtr page; Tuple_header* tuple_ptr= 0; - if (get_tuple_state(regOperPtr.p) == TUPLE_PREPARED) + if(regOperPtr.p->op_struct.m_load_diskpage_on_commit) { - PagePtr page; - Uint32* ptr= get_ptr(&page, ®OperPtr.p->m_tuple_location, regTabPtr.p); - tuple_ptr= (Tuple_header*)ptr; - req_struct.m_tuple_ptr= tuple_ptr; - + ndbassert(regOperPtr.p->is_last_operation()); + Page_cache_client::Request req; - if(regOperPtr.p->op_struct.m_load_diskpage_on_commit) + /** + * Check for page + */ + if(!regOperPtr.p->m_copy_tuple_location.isNull()) { - /** - * Check for page - */ Tuple_header* tmp= (Tuple_header*) c_undo_buffer.get_ptr(®OperPtr.p->m_copy_tuple_location); memcpy(&req.m_page, tmp->get_disk_ref_ptr(regTabPtr.p), sizeof(Local_key)); - req.m_callback.m_callbackData= regOperPtr.i; - req.m_callback.m_callbackFunction = - safe_cast(&Dbtup::disk_page_commit_callback); - - int flags= - Page_cache_client::COMMIT_REQ | Page_cache_client::STRICT_ORDER; - int res= m_pgman.get_page(signal, req, flags); - switch(res){ - case 0: - /** - * Timeslice - */ - signal->theData[0] = 1; - return; - case -1: - ndbrequire("NOT YET IMPLEMENTED" == 0); - break; - } + } + else + { + tuple_ptr= (Tuple_header*) + get_ptr(&page, ®OperPtr.p->m_tuple_location, regTabPtr.p); + memcpy(&req.m_page, + tuple_ptr->get_disk_ref_ptr(regTabPtr.p), sizeof(Local_key)); + } + req.m_callback.m_callbackData= regOperPtr.i; + req.m_callback.m_callbackFunction = + safe_cast(&Dbtup::disk_page_commit_callback); + + int flags= + Page_cache_client::COMMIT_REQ | Page_cache_client::STRICT_ORDER; + int res= m_pgman.get_page(signal, req, flags); + switch(res){ + case 0: + /** + * Timeslice + */ + signal->theData[0] = 1; + return; + case -1: + ndbrequire("NOT YET IMPLEMENTED" == 0); + break; } + regOperPtr.p->m_commit_disk_callback_page= res; + } + + if(regOperPtr.p->op_struct.m_wait_log_buffer) + { + ndbassert(regOperPtr.p->is_last_operation()); + + Callback cb; + cb.m_callbackData= regOperPtr.i; + cb.m_callbackFunction = + safe_cast(&Dbtup::disk_page_log_buffer_callback); + Uint32 sz= regOperPtr.p->m_undo_buffer_space; + Logfile_client lgman(this, c_lgman, regTabPtr.p->m_logfile_group_id); + int res= lgman.get_log_buffer(signal, sz, &cb); + switch(res){ + case 0: + signal->theData[0] = 1; + return; + case -1: + ndbrequire("NOT YET IMPLEMENTED" == 0); + break; + } + } + + if (get_tuple_state(regOperPtr.p) == TUPLE_PREPARED) + { if (regOperPtr.p->is_first_operation() && regOperPtr.p->is_last_operation()) { + if(!tuple_ptr) + { + req_struct.m_tuple_ptr= tuple_ptr = (Tuple_header*) + get_ptr(&page, ®OperPtr.p->m_tuple_location,regTabPtr.p); + } + if (!regTabPtr.p->tuxCustomTriggers.isEmpty()) { ljam(); executeTuxCommitTriggers(signal, @@ -380,11 +483,21 @@ regFragPtr.p, regTabPtr.p); } - + set_change_mask_info(&req_struct, regOperPtr.p); checkDetachedTriggers(&req_struct, regOperPtr.p, regTabPtr.p); - commit_operation(signal, gci, tuple_ptr, - regOperPtr.p, regFragPtr.p, regTabPtr.p); + if(regOperPtr.p->op_struct.op_type != ZDELETE) + { + commit_operation(signal, gci, tuple_ptr, + regOperPtr.p, regFragPtr.p, regTabPtr.p); + removeActiveOpList(regOperPtr.p, tuple_ptr); + } + else + { + removeActiveOpList(regOperPtr.p, tuple_ptr); + dealloc_tuple(signal, gci, page.p, tuple_ptr, + regOperPtr.p, regFragPtr.p, regTabPtr.p); + } } else { /* -------------------------------------------------------------- */ // This transaction wrote the same record multiple times. We only @@ -392,16 +505,20 @@ /* -------------------------------------------------------------- */ ljam(); complexTrigger(signal, - &req_struct, - regOperPtr.p, - regFragPtr.p, - regTabPtr.p); + &req_struct, + regOperPtr.p, + regFragPtr.p, + regTabPtr.p); OperationrecPtr lastOperPtr; lastOperPtr.i= tuple_ptr->m_operation_ptr_i; c_operation_pool.getPtr(lastOperPtr); - commit_operation(signal, gci, tuple_ptr, - lastOperPtr.p, regFragPtr.p, regTabPtr.p); + + if(lastOperPtr.p->op_struct.op_type != ZDELETE) + commit_operation(signal, gci, tuple_ptr, + lastOperPtr.p, regFragPtr.p, regTabPtr.p); + else + tuple_ptr->m_header_bits |= Tuple_header::DEALLOC; } } else @@ -410,13 +527,26 @@ ndbrequire(get_tuple_state(regOperPtr.p) == TUPLE_TO_BE_COMMITTED); if(regOperPtr.p->is_last_operation()) { - PagePtr page; - Uint32* ptr= get_ptr(&page, ®OperPtr.p->m_tuple_location,regTabPtr.p); - tuple_ptr= (Tuple_header*)ptr; + if(!tuple_ptr) + { + tuple_ptr= (Tuple_header*) + get_ptr(&page, ®OperPtr.p->m_tuple_location,regTabPtr.p); + } + + removeActiveOpList(regOperPtr.p, tuple_ptr); + if(regOperPtr.p->is_first_operation() && + tuple_ptr->m_header_bits & Tuple_header::DEALLOC) + { + /** + * Dealloc tuple on commit of last operation + * (last <==> is_last_operation && is_first_operation + */ + dealloc_tuple(signal, gci, page.p, tuple_ptr, + regOperPtr.p, regFragPtr.p, regTabPtr.p); + } } } - removeActiveOpList(regOperPtr.p, tuple_ptr); initOpConnection(regOperPtr.p); signal->theData[0] = 0; } --- 1.18/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp Fri Feb 18 15:04:58 2005 +++ 1.19/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp Tue Mar 22 15:53:38 2005 @@ -302,7 +302,6 @@ out << " [tuple_state " << dec << op.op_struct.tuple_state << "]"; out << " [trans_state " << dec << op.op_struct.trans_state << "]"; out << " [in_active_list " << dec << op.op_struct.in_active_list << "]"; - out << " [undo_logged " << dec << op.op_struct.undo_logged << "]"; // links out << " [prevActiveOp " << hex << op.prevActiveOp << "]"; out << " [nextActiveOp " << hex << op.nextActiveOp << "]"; --- 1.51/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp Fri Mar 11 17:11:02 2005 +++ 1.52/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp Tue Mar 22 15:53:38 2005 @@ -290,12 +290,21 @@ prevOpPtr.i= req_struct->m_tuple_ptr->m_operation_ptr_i; regOperPtr.p->prevActiveOp= prevOpPtr.i; regOperPtr.p->nextActiveOp= RNIL; + regOperPtr.p->m_undo_buffer_space= 0; req_struct->m_tuple_ptr->m_operation_ptr_i= regOperPtr.i; if (prevOpPtr.i == RNIL) { return true; } else { req_struct->prevOpPtr.p= prevOpPtr.p= c_operation_pool.getPtr(prevOpPtr.i); prevOpPtr.p->nextActiveOp= regOperPtr.i; + + regOperPtr.p->op_struct.m_wait_log_buffer= 1; + regOperPtr.p->op_struct.m_load_diskpage_on_commit= 1; + regOperPtr.p->m_undo_buffer_space= prevOpPtr.p->m_undo_buffer_space; + + prevOpPtr.p->op_struct.m_wait_log_buffer= 0; + prevOpPtr.p->op_struct.m_load_diskpage_on_commit= 0; + if(prevOpPtr.p->op_struct.tuple_state == TUPLE_PREPARED) { Uint32 op= regOperPtr.p->op_struct.op_type; @@ -601,6 +610,7 @@ if(regOperPtr->op_struct.tuple_state == TUPLE_INITIAL_INSERT) { jam(); + regOperPtr->op_struct.m_wait_log_buffer= 1; regOperPtr->op_struct.m_load_diskpage_on_commit= 1; return 1; } @@ -647,12 +657,13 @@ switch(flags & 7) { case ZREAD: - case ZDELETE: case ZREAD_EX: break; + case ZDELETE: case ZUPDATE: case ZINSERT: case ZWRITE: + regOperPtr->op_struct.m_wait_log_buffer= 1; regOperPtr->op_struct.m_load_diskpage_on_commit= 1; } return res; @@ -1089,13 +1100,12 @@ Tablerec* const regTabPtr, KeyReqStruct* req_struct) { - Uint32 *dst; if ((dst= c_undo_buffer.alloc_copy_tuple(&operPtrP->m_copy_tuple_location, regTabPtr->total_rec_size)) == 0) { - TUPKEY_abort(signal, 1); - return -1; + terrorCode= ZMEM_NOMEM_ERROR; + goto error; } Tuple_header* org; @@ -1119,11 +1129,8 @@ if (regTabPtr->checksumIndicator && (calculateChecksum(req_struct->m_tuple_ptr, regTabPtr) != 0)) { - jam(); - ndbout_c("here 3"); terrorCode= ZTUPLE_CORRUPTED_ERROR; - tupkeyErrorLab(signal); - return -1; + goto error; } req_struct->m_tuple_ptr= (Tuple_header*)dst; @@ -1132,10 +1139,27 @@ Uint32 sizes[4]; Uint64 cmp[2]; }; + if (regTabPtr->need_expand()) + { expand_tuple(req_struct, sizes, org, regTabPtr); + if(operPtrP->is_first_operation() && regTabPtr->m_no_of_disk_attributes) + { + Uint32 sz= operPtrP->m_undo_buffer_space= + (sizeof(Dbtup::Disk_undo::Update) >> 2) + sizes[DD]; + + terrorCode= c_lgman->alloc_log_space(regTabPtr->m_logfile_group_id, + sz); + if(terrorCode) + { + goto error; + } + } + } else + { memcpy(dst, org, 4*regTabPtr->m_offsets[MM].m_fix_header_size); + } tup_version= (tup_version + 1) & ZTUP_VERSION_MASK; operPtrP->tupVersion= tup_version; @@ -1152,8 +1176,7 @@ } if (retValue == -1) { - tupkeyErrorLab(signal); - return -1; + goto error; } if (regTabPtr->need_shrink()) @@ -1163,7 +1186,7 @@ regFragPtr, regTabPtr, sizes)) { - return -1; + goto error; } } @@ -1173,6 +1196,10 @@ setChecksum(req_struct->m_tuple_ptr, regTabPtr); } return retValue; + +error: + tupkeyErrorLab(signal); + return -1; } /* ---------------------------------------------------------------- */ @@ -1186,6 +1213,7 @@ regOperPtr->nextActiveOp= RNIL; regOperPtr->prevActiveOp= RNIL; regOperPtr->op_struct.in_active_list= true; + regOperPtr->m_undo_buffer_space= sizeof(Dbtup::Disk_undo::Alloc) >> 2; req_struct->check_offset[MM]= regTabPtr->get_check_offset(MM); req_struct->check_offset[DD]= regTabPtr->get_check_offset(DD); @@ -1252,20 +1280,21 @@ Tablerec* const regTabPtr, KeyReqStruct *req_struct) { - Uint32 *dst; - if ((dst= c_undo_buffer.alloc_copy_tuple(®OperPtr.p->m_copy_tuple_location, - regTabPtr->total_rec_size)) == 0) + Uint32 *dst, *ptr= 0; + Tuple_header *org= req_struct->m_tuple_ptr; + Tuple_header *tuple_ptr; + if ((dst= + c_undo_buffer.alloc_copy_tuple(®OperPtr.p->m_copy_tuple_location, + regTabPtr->total_rec_size)) == 0) { - TUPKEY_abort(signal, 1); - return -1; + goto mem_error; } + tuple_ptr= req_struct->m_tuple_ptr= (Tuple_header*)dst; if(0) ndbout << "dst: " << hex << UintPtr(dst) << " - " << regOperPtr.p->m_copy_tuple_location << endl; - Tuple_header *org= req_struct->m_tuple_ptr; - Tuple_header *tuple_ptr= req_struct->m_tuple_ptr= (Tuple_header*)dst; Uint32 tup_version; union { @@ -1276,6 +1305,16 @@ { tup_version= 1; prepare_initial_insert(req_struct, regOperPtr.p, regTabPtr); + if(regTabPtr->m_no_of_disk_attributes) + { + int res; + if((res= c_lgman->alloc_log_space(regTabPtr->m_logfile_group_id, + regOperPtr.p->m_undo_buffer_space))) + { + terrorCode= res; + goto error; + } + } } else { @@ -1310,7 +1349,6 @@ /** * Alloc memory */ - Uint32* ptr= 0; if(regOperPtr.p->is_first_operation()) { Uint32 frag_page_id; @@ -1376,7 +1414,7 @@ jam(); setChecksum(req_struct->m_tuple_ptr, regTabPtr); } - + if (!regTabPtr->var_sized_record || cmp[0] == cmp[1]) return 0; @@ -1385,9 +1423,16 @@ regTabPtr, sizes); } + + mem_error: - abort(); + terrorCode= ZMEM_NOMEM_ERROR; + goto error; + +error: + tupkeyErrorLab(signal); + return -1; } /* ---------------------------------------------------------------- */ @@ -1409,6 +1454,32 @@ else { regOperPtr->tupVersion= req_struct->m_tuple_ptr->get_tuple_version(); + if(regTabPtr->m_no_of_disk_attributes) + { + Uint32 sz; + if(regTabPtr->m_attributes[DD].m_no_of_varsize) + { + /** + * Need to have page in memory to read size + * to alloc undo space + */ + abort(); + } + else + sz= (sizeof(Dbtup::Disk_undo::Free) >> 2) + + regTabPtr->m_offsets[DD].m_fix_header_size; + + regOperPtr->m_undo_buffer_space= sz; + + int res; + if((res= c_lgman->alloc_log_space(regTabPtr->m_logfile_group_id, + sz))) + { + terrorCode= res; + goto error; + } + + } } if (req_struct->attrinfo_len == 0) { @@ -1416,6 +1487,10 @@ } return handleReadReq(signal, regOperPtr, regTabPtr, req_struct); + +error: + tupkeyErrorLab(signal); + return -1; } bool @@ -2428,6 +2503,7 @@ // Fix diskpart req_struct->m_disk_ptr= (Tuple_header*)dst_ptr; memcpy(dst_ptr, src_ptr, 4*tabPtrP->m_offsets[DD].m_fix_header_size); + sizes[DD] = tabPtrP->m_offsets[DD].m_fix_header_size; if(dd_vars) { --- 1.13/ndb/src/kernel/vm/SimulatedBlock.hpp Wed Mar 16 16:02:14 2005 +++ 1.14/ndb/src/kernel/vm/SimulatedBlock.hpp Tue Mar 22 15:53:38 2005 @@ -80,6 +80,7 @@ friend class AsyncFile; friend class Pgman; friend class Page_cache_client; + friend class Lgman; friend class Logfile_client; public: friend class BlockComponent;
| Thread | ||
|---|---|---|
| • bk commit into 5.1-ndb tree (joreland:1.1795) | jonas.oreland | 22 Mar |
© 1995-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
Page generated in 0.862 sec. using MySQL 5.1.14-beta-log