bk commit - 5.1 tree (mikael:....) BUG#20970

[Mikael Ronström]

diff -Nur --exclude=RCS --exclude=CVS --exclude=SCCS  
--exclude=BitKeeper --exclude=ChangeSet  
clean-mysql-5.1/BUILD/Makefile.am clean-bug20970/BUILD/Makefile.am
--- clean-mysql-5.1/BUILD/Makefile.am	2005-12-18 09:06:52 -05:00
+++ clean-bug20970/BUILD/Makefile.am	2006-07-14 08:08:23 -04:00
@@ -52,6 +52,7 @@
  			compile-pentium-pgcc \
  			compile-pentium-valgrind-max \
  			compile-pentium64-debug \
+			compile-pentium64-max \
  			compile-pentium64-debug-max \
  			compile-pentium64-valgrind-max \
  			compile-ppc \
diff -Nur --exclude=RCS --exclude=CVS --exclude=SCCS  
--exclude=BitKeeper --exclude=ChangeSet  
clean-mysql-5.1/BUILD/compile-pentium64-max  
clean-bug20970/BUILD/compile-pentium64-max
--- clean-mysql-5.1/BUILD/compile-pentium64-max	1969-12-31 19:00:00  
-05:00
+++ clean-bug20970/BUILD/compile-pentium64-max	2006-07-14 08:08:23  
-04:00
@@ -0,0 +1,9 @@
+#! /bin/sh
+
+path=`dirname $0`
+. "$path/SETUP.sh"
+
+extra_flags="$pentium64_cflags $fast_cflags -g"
+extra_configs="$pentium_configs $max_configs"
+
+. "$path/FINISH.sh"
diff -Nur --exclude=RCS --exclude=CVS --exclude=SCCS  
--exclude=BitKeeper --exclude=ChangeSet  
clean-mysql-5.1/storage/ndb/include/kernel/signaldata/ 
BackupContinueB.hpp  
clean-bug20970/storage/ndb/include/kernel/signaldata/ 
BackupContinueB.hpp
---  
clean-mysql-5.1/storage/ndb/include/kernel/signaldata/ 
BackupContinueB.hpp	2006-06-27 04:15:46 -04:00
+++  
clean-bug20970/storage/ndb/include/kernel/signaldata/ 
BackupContinueB.hpp	2006-07-13 19:46:29 -04:00
@@ -32,7 +32,8 @@
      BUFFER_FULL_SCAN  = 2,
      BUFFER_FULL_FRAG_COMPLETE = 3,
      BUFFER_FULL_META  = 4,
-    BACKUP_FRAGMENT_INFO = 5
+    BACKUP_FRAGMENT_INFO = 5,
+    RESET_DISK_SPEED_COUNTER = 6
    };
  };

diff -Nur --exclude=RCS --exclude=CVS --exclude=SCCS  
--exclude=BitKeeper --exclude=ChangeSet  
clean-mysql-5.1/storage/ndb/include/kernel/signaldata/FsAppendReq.hpp  
clean-bug20970/storage/ndb/include/kernel/signaldata/FsAppendReq.hpp
---  
clean-mysql-5.1/storage/ndb/include/kernel/signaldata/FsAppendReq.hpp	 
2005-04-07 20:43:50 -04:00
+++  
clean-bug20970/storage/ndb/include/kernel/signaldata/FsAppendReq.hpp	 
2006-07-13 19:46:29 -04:00
@@ -39,7 +39,7 @@
    friend bool printFSAPPENDREQ(FILE * output, const Uint32 * theData,
  			       Uint32 len, Uint16 receiverBlockNo);
  public:
-  STATIC_CONST( SignalLength = 6 );
+  STATIC_CONST( SignalLength = 7 );

  private:

@@ -52,6 +52,7 @@
    UintR varIndex;             // DATA 3
    UintR offset;               // DATA 4
    UintR size;                 // DATA 5
+  UintR synch_flag;           // DATA 6
  };

  #endif
diff -Nur --exclude=RCS --exclude=CVS --exclude=SCCS  
--exclude=BitKeeper --exclude=ChangeSet  
clean-mysql-5.1/storage/ndb/include/mgmapi/mgmapi_config_parameters.h  
clean-bug20970/storage/ndb/include/mgmapi/mgmapi_config_parameters.h
---  
clean-mysql-5.1/storage/ndb/include/mgmapi/mgmapi_config_parameters.h	 
2006-04-26 10:03:45 -04:00
+++  
clean-bug20970/storage/ndb/include/mgmapi/mgmapi_config_parameters.h	 
2006-07-13 19:46:29 -04:00
@@ -92,6 +92,10 @@
  #define CFG_DB_DISK_PAGE_BUFFER_MEMORY 160
  #define CFG_DB_STRING_MEMORY          161

+#define CFG_DB_DISK_SYNCH_SIZE        163
+#define CFG_DB_CHECKPOINT_SPEED       164
+#define CFG_DB_CHECKPOINT_SPEED_SR    165
+
  #define CFG_DB_SGA                    198 /* super pool mem */
  #define CFG_DB_DATA_MEM_2             199 /* used in special build in  
5.1 */

diff -Nur --exclude=RCS --exclude=CVS --exclude=SCCS  
--exclude=BitKeeper --exclude=ChangeSet  
clean-mysql-5.1/storage/ndb/src/kernel/blocks/backup/Backup.cpp  
clean-bug20970/storage/ndb/src/kernel/blocks/backup/Backup.cpp
---  
clean-mysql-5.1/storage/ndb/src/kernel/blocks/backup/Backup.cpp	2006 
-06-29 08:36:22 -04:00
+++  
clean-bug20970/storage/ndb/src/kernel/blocks/backup/Backup.cpp	2006-07 
-14 08:08:23 -04:00
@@ -84,6 +84,16 @@
    const Uint32 startphase  = signal->theData[1];
    const Uint32 typeOfStart = signal->theData[7];

+  if (startphase == 1)
+  {
+    m_curr_disk_write_speed = m_disk_write_speed_sr;
+    m_overflow_disk_write = 0;
+    m_reset_disk_speed_time = NdbTick_CurrentMillisecond();
+    m_reset_delay_used = Backup::DISK_SPEED_CHECK_DELAY;
+    signal->theData[0] = BackupContinueB::RESET_DISK_SPEED_COUNTER;
+    sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal,
+                        Backup::DISK_SPEED_CHECK_DELAY, 1);
+  }
    if (startphase == 3) {
      jam();
      g_TypeOfStart = typeOfStart;
@@ -98,7 +108,8 @@
      createSequence(signal);
      return;
    }//if
-
+  if (startphase == 254)
+    m_curr_disk_write_speed = m_disk_write_speed;
    sendSTTORRY(signal);
    return;
  }//Dbdict::execSTTOR()
@@ -144,7 +155,8 @@
    signal->theData[3] = 1;
    signal->theData[4] = 3;
    signal->theData[5] = 7;
-  signal->theData[6] = 255; // No more start phases from missra
+  signal->theData[6] = 254;
+  signal->theData[7] = 255; // No more start phases from missra
    sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 7, JBB);
  }

@@ -170,6 +182,42 @@
    const Uint32 Tdata2 = signal->theData[2];

    switch(Tdata0) {
+  case BackupContinueB::RESET_DISK_SPEED_COUNTER:
+  {
+    /*
+      Adjust for upto 10 millisecond delay of this signal. Longer
+      delays will not be handled, in this case the system is most
+      likely under too high load and it won't matter very much that
+      we decrease the speed of checkpoints.
+
+      We use a technique where we allow an overflow write in one
+      period. This overflow will be removed from the next period
+      such that the load will at average be as specified.
+    */
+    int delay_time = m_reset_delay_used;
+    NDB_TICKS curr_time = NdbTick_CurrentMillisecond();
+    int sig_delay = curr_time - m_reset_disk_speed_time;
+
+    m_words_written_this_period = m_overflow_disk_write;
+    m_overflow_disk_write = 0;
+    m_reset_disk_speed_time = curr_time;
+
+    if (sig_delay > delay_time + 10)
+      delay_time = Backup::DISK_SPEED_CHECK_DELAY - 10;
+    else if (sig_delay < delay_time - 10)
+      delay_time = Backup::DISK_SPEED_CHECK_DELAY + 10;
+    else
+      delay_time = Backup::DISK_SPEED_CHECK_DELAY - (sig_delay -  
delay_time);
+    m_reset_delay_used= delay_time;
+    signal->theData[0] = BackupContinueB::RESET_DISK_SPEED_COUNTER;
+    sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, delay_time,  
1);
+#if 0
+    ndbout << "Signal delay was = " << sig_delay;
+    ndbout << " Current time = " << curr_time << endl;
+    ndbout << " Delay time will be = " << delay_time << endl <<
endl;
+#endif
+    break;
+  }
    case BackupContinueB::BACKUP_FRAGMENT_INFO:
    {
      const Uint32 ptr_I = Tdata1;
@@ -202,8 +250,8 @@
      fragInfo->FragmentNo = htonl(fragPtr_I);
      fragInfo->NoOfRecordsLow = htonl(fragPtr.p->noOfRecords &  
0xFFFFFFFF);
      fragInfo->NoOfRecordsHigh = htonl(fragPtr.p->noOfRecords >> 32);
-    fragInfo->FilePosLow = htonl(0 & 0xFFFFFFFF);
-    fragInfo->FilePosHigh = htonl(0 >> 32);
+    fragInfo->FilePosLow = htonl(0);
+    fragInfo->FilePosHigh = htonl(0);

      filePtr.p->operation.dataBuffer.updateWritePtr(sz);

@@ -2619,6 +2667,7 @@
    c_backupFilePool.getPtr(filePtr, ptr.p->ctlFilePtr);
    ndbrequire(filePtr.p->fileRunning == 0);
    filePtr.p->fileRunning = 1;
+  filePtr.p->words_written_since_last_synch = 0;

    req->userPointer = filePtr.i;
    FsOpenReq::setVersion(req->fileNumber, 2);
@@ -2633,6 +2682,7 @@
    c_backupFilePool.getPtr(filePtr, ptr.p->logFilePtr);
    ndbrequire(filePtr.p->fileRunning == 0);
    filePtr.p->fileRunning = 1;
+  filePtr.p->words_written_since_last_synch = 0;

    req->userPointer = filePtr.i;
    FsOpenReq::setVersion(req->fileNumber, 2);
@@ -2647,6 +2697,7 @@
    c_backupFilePool.getPtr(filePtr, ptr.p->dataFilePtr);
    ndbrequire(filePtr.p->fileRunning == 0);
    filePtr.p->fileRunning = 1;
+  filePtr.p->words_written_since_last_synch = 0;

    req->userPointer = filePtr.i;
    FsOpenReq::setVersion(req->fileNumber, 2);
@@ -3881,44 +3932,103 @@
    checkFile(signal, filePtr);
  }

+/*
+  This routine handles two problems with writing to disk during local
+  checkpoints and backups. The first problem is that we need to limit
+  the writing to ensure that we don't use too much CPU and disk  
resources
+  for backups and checkpoints. The perfect solution to this is to use
+  a dynamic algorithm that adapts to the environment. Until we have
+  implemented this we can satisfy ourselves with an algorithm that
+  uses a configurable limit.
+
+  The second problem is that in Linux we can get severe problems if we
+  write very much to the disk without synching. In the worst case we
+  can have Gigabytes of data in the Linux page cache before we reach
+  the limit of how much we can write. If this happens the performance
+  will drop significantly when we reach this limit since the Linux  
flush
+  daemon will spend a few minutes on writing out the page cache to  
disk.
+  To avoid this we ensure that a file never have more than a certain
+  amount of data outstanding before synch. This variable is also
+  configurable.
+*/
+bool
+Backup::ready_to_write(bool ready, Uint32 sz, bool eof, Uint32  
*synch_flag,
+                       BackupFile *fileP)
+{
+#if 0
+  ndbout << "ready_to_write: ready = " << ready << " eof = " <<
eof;
+  ndbout << " sz = " << sz << endl;
+  ndbout << "words this period = " << m_words_written_this_period;
+  ndbout << " words since last synch = " <<  
fileP->words_written_since_last_synch;
+  ndbout << endl << "overflow disk write = " << m_overflow_disk_write;
+  ndbout << endl << "Current Millisecond is = ";
+  ndbout << NdbTick_CurrentMillisecond() << endl;
+#endif
+  if ((ready || eof) &&
+      m_words_written_this_period <= m_curr_disk_write_speed)
+  {
+    /*
+      We have a buffer ready to write or we have reached end of
+      file and thus we must write the last before closing the
+      file.
+      We have already check that we are allowed to write at this
+      moment. We only worry about history of last 100 milliseconds.
+      What happened before that is of no interest since a disk
+      write that was issued more than 100 milliseconds should be
+      completed by now.
+    */
+    int overflow;
+    m_words_written_this_period += sz;
+    overflow = m_words_written_this_period - m_curr_disk_write_speed;
+    if (overflow > 0)
+      m_overflow_disk_write = overflow;
+    fileP->words_written_since_last_synch += sz;
+    if (fileP->words_written_since_last_synch >= m_disk_synch_size)
+    {
+      fileP->words_written_since_last_synch = 0;
+      *synch_flag= 1;
+    }
+#if 0
+    ndbout << "Will write with synch_flag = " << *synch_flag << endl;
+    ndbout << endl;
+#endif
+    return true;
+  }
+  else
+  {
+#if 0
+    ndbout << "Will not write now" << endl << endl;
+#endif
+    return false;
+  }
+}
+
  void
  Backup::checkFile(Signal* signal, BackupFilePtr filePtr)
  {
-
  #ifdef DEBUG_ABORT
    //  ndbout_c("---- check file filePtr.i = %u", filePtr.i);
  #endif

    OperationRecord & op = filePtr.p->operation;
-
-  Uint32 * tmp, sz; bool eof;
-  if(op.dataBuffer.getReadPtr(&tmp, &sz, &eof))
+  Uint32 *tmp = NULL;
+  Uint32 sz = 0;
+  Uint32 synch_flag = 0;
+  bool eof = FALSE;
+  bool ready = op.dataBuffer.getReadPtr(&tmp, &sz, &eof);
+#if 0
+  ndbout << "Ptr to data = " << hex << tmp << endl;
+#endif
+  if (!ready_to_write(ready, sz, eof, &synch_flag, filePtr.p))
    {
      jam();
-
-    jam();
-    FsAppendReq * req = (FsAppendReq *)signal->getDataPtrSend();
-    req->filePointer   = filePtr.p->filePointer;
-    req->userPointer   = filePtr.i;
-    req->userReference = reference();
-    req->varIndex      = 0;
-    req->offset        = tmp - c_startOfPages;
-    req->size          = sz;
-
-    sendSignal(NDBFS_REF, GSN_FSAPPENDREQ, signal,
-	       FsAppendReq::SignalLength, JBA);
-    return;
-  }
-
-  if(!eof) {
-    jam();
      signal->theData[0] = BackupContinueB::BUFFER_UNDERFLOW;
      signal->theData[1] = filePtr.i;
-    sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 50, 2);
+    sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 20, 2);
      return;
-  }//if
-
-  if(sz > 0) {
+  }
+  else if (sz > 0)
+  {
      jam();
      FsAppendReq * req = (FsAppendReq *)signal->getDataPtrSend();
      req->filePointer   = filePtr.p->filePointer;
@@ -3926,13 +4036,14 @@
      req->userReference = reference();
      req->varIndex      = 0;
      req->offset        = tmp - c_startOfPages;
-    req->size          = sz; // Round up
+    req->size          = sz;
+    req->synch_flag = synch_flag;

      sendSignal(NDBFS_REF, GSN_FSAPPENDREQ, signal,
  	       FsAppendReq::SignalLength, JBA);
      return;
-  }//if
-
+  }
+
  #ifdef DEBUG_ABORT
    Uint32 running= filePtr.p->fileRunning;
    Uint32 closing= filePtr.p->fileClosing;
@@ -3961,7 +4072,6 @@
               filePtr.i,
               running, closing);
  #endif
-
    }
  }

@@ -4214,16 +4324,15 @@
        continue;
      }//if

+    filePtr.p->operation.dataBuffer.eof();
      if(filePtr.p->fileRunning == 1){
        jam();
  #ifdef DEBUG_ABORT
        ndbout_c("Close files fileRunning == 1, filePtr.i=%u",  
filePtr.i);
  #endif
-      filePtr.p->operation.dataBuffer.eof();
      } else {
        jam();
        filePtr.p->fileClosing = 1;
-      filePtr.p->operation.dataBuffer.eof();
        checkFile(sig, filePtr); // make sure we write everything before  
closing

        FsCloseReq * req = (FsCloseReq *)sig->getDataPtrSend();
@@ -4287,6 +4396,7 @@
    ndbrequire(filePtr.p->scanRunning == 0);	

    filePtr.p->fileOpened = 0;
+  filePtr.p->words_written_since_last_synch = 0;
    filePtr.p->operation.dataBuffer.reset();

    BackupRecordPtr ptr;
@@ -4729,6 +4839,7 @@
    ndbrequire(filePtr.p->fileRunning == 0);
    filePtr.p->fileClosing = 0;
    filePtr.p->fileRunning = 1;
+  filePtr.p->words_written_since_last_synch = 0;

    req->userPointer = filePtr.i;
    FsOpenReq::setVersion(req->fileNumber, 5);
diff -Nur --exclude=RCS --exclude=CVS --exclude=SCCS  
--exclude=BitKeeper --exclude=ChangeSet  
clean-mysql-5.1/storage/ndb/src/kernel/blocks/backup/Backup.hpp  
clean-bug20970/storage/ndb/src/kernel/blocks/backup/Backup.hpp
---  
clean-mysql-5.1/storage/ndb/src/kernel/blocks/backup/Backup.hpp	2006 
-06-27 05:22:35 -04:00
+++  
clean-bug20970/storage/ndb/src/kernel/blocks/backup/Backup.hpp	2006-07 
-14 08:08:23 -04:00
@@ -33,6 +33,7 @@
  #include <blocks/mutexes.hpp>

  #include <NdbTCP.h>
+#include <NdbTick.h>
  #include <Array.hpp>

  /**
@@ -337,6 +338,7 @@
      Uint32 fragmentNo;
      Uint32 filePointer;
      Uint32 errorCode;
+    Uint32 words_written_since_last_synch;
      BackupFormat::FileType fileType;
      OperationRecord operation;

@@ -534,6 +536,18 @@
    DLList<BackupRecord> c_backups;
    Config c_defaults;
    Uint32 m_diskless;
+  /*
+    Variables that control checkpoint to disk speed
+  */
+  Uint32 m_disk_write_speed_sr;
+  Uint32 m_disk_write_speed;
+  Uint32 m_curr_disk_write_speed;
+  Uint32 m_disk_synch_size;
+  Uint32 m_words_written_this_period;
+  Uint32 m_overflow_disk_write;
+  Uint32 m_reset_delay_used;
+  NDB_TICKS m_reset_disk_speed_time;
+  static const int  DISK_SPEED_CHECK_DELAY = 100;

    STATIC_CONST(NO_OF_PAGES_META_FILE =  
MAX_WORDS_META_FILE/BACKUP_WORDS_PER_PAGE);

@@ -631,6 +645,9 @@
    void lcp_open_file_done(Signal*, BackupRecordPtr);
    void lcp_close_file_conf(Signal* signal, BackupRecordPtr);
    void lcp_send_end_lcp_conf(Signal* signal, BackupRecordPtr);
+
+  bool ready_to_write(bool ready, Uint32 sz, bool eof, Uint32  
*synch_flag,
+                      BackupFile *fileP);
  };

  inline
diff -Nur --exclude=RCS --exclude=CVS --exclude=SCCS  
--exclude=BitKeeper --exclude=ChangeSet  
clean-mysql-5.1/storage/ndb/src/kernel/blocks/backup/BackupInit.cpp  
clean-bug20970/storage/ndb/src/kernel/blocks/backup/BackupInit.cpp
---  
clean-mysql-5.1/storage/ndb/src/kernel/blocks/backup/BackupInit.cpp	 
2006-06-27 04:15:46 -04:00
+++  
clean-bug20970/storage/ndb/src/kernel/blocks/backup/BackupInit.cpp	 
2006-07-14 08:08:23 -04:00
@@ -148,6 +148,21 @@

    Uint32 noBackups = 0, noTables = 0, noAttribs = 0, noFrags = 0;
    ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_DISCLESS,  
&m_diskless));
+  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_CHECKPOINT_SPEED_SR,
+                                        &m_disk_write_speed_sr));
+  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_CHECKPOINT_SPEED,
+                                        &m_disk_write_speed));
+  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_DISK_SYNCH_SIZE,
+                                        &m_disk_synch_size));
+  /*
+    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.
+  */
+  m_disk_write_speed /= (4 * 10);
+  m_disk_write_speed_sr /= (4 * 10);
+  m_disk_synch_size >>= 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));
diff -Nur --exclude=RCS --exclude=CVS --exclude=SCCS  
--exclude=BitKeeper --exclude=ChangeSet  
clean-mysql-5.1/storage/ndb/src/kernel/blocks/ndbfs/AsyncFile.cpp  
clean-bug20970/storage/ndb/src/kernel/blocks/ndbfs/AsyncFile.cpp
---  
clean-mysql-5.1/storage/ndb/src/kernel/blocks/ndbfs/AsyncFile.cpp	2006 
-06-13 10:21:39 -04:00
+++  
clean-bug20970/storage/ndb/src/kernel/blocks/ndbfs/AsyncFile.cpp	2006 
-07-13 19:46:29 -04:00
@@ -219,6 +219,10 @@
      case Request:: append:
        appendReq(request);
        break;
+    case Request:: append_synch:
+      appendReq(request);
+      syncReq(request);
+      break;
      case Request::rmrf:
        rmrfReq(request, (char*)theFileName.c_str(),  
request->par.rmrf.own_directory);
        break;
diff -Nur --exclude=RCS --exclude=CVS --exclude=SCCS  
--exclude=BitKeeper --exclude=ChangeSet  
clean-mysql-5.1/storage/ndb/src/kernel/blocks/ndbfs/AsyncFile.hpp  
clean-bug20970/storage/ndb/src/kernel/blocks/ndbfs/AsyncFile.hpp
---  
clean-mysql-5.1/storage/ndb/src/kernel/blocks/ndbfs/AsyncFile.hpp	2005 
-11-07 06:19:08 -05:00
+++  
clean-bug20970/storage/ndb/src/kernel/blocks/ndbfs/AsyncFile.hpp	2006 
-07-13 19:46:29 -04:00
@@ -123,6 +123,7 @@
      sync,
      end,
      append,
+    append_synch,
      rmrf,
      readPartial
    };
diff -Nur --exclude=RCS --exclude=CVS --exclude=SCCS  
--exclude=BitKeeper --exclude=ChangeSet  
clean-mysql-5.1/storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp  
clean-bug20970/storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp
---  
clean-mysql-5.1/storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp	2006-03 
-22 04:54:47 -05:00
+++  
clean-bug20970/storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp	2006-07-13  
19:46:29 -04:00
@@ -567,6 +567,7 @@
    const Uint32  tSz   = myBaseAddrRef->nrr;
    const Uint32 offset = fsReq->offset;
    const Uint32 size   = fsReq->size;
+  const Uint32 synch_flag = fsReq->synch_flag;
    Request *request = theRequestPool->get();

    if (openFile == NULL) {
@@ -596,12 +597,15 @@
    request->error = 0;
    request->set(userRef, userPointer, filePointer);
    request->file = openFile;
-  request->action = Request::append;
    request->theTrace = signal->getTrace();

    request->par.append.buf = (const char *)(tWA + offset);
    request->par.append.size = size << 2;
-
+
+  if (!synch_flag)
+    request->action = Request::append;
+  else
+    request->action = Request::append_synch;
    ndbrequire(forward(openFile, request));
    return;

@@ -744,7 +748,9 @@
        sendSignal(ref, GSN_FSSYNCREF, signal, FsRef::SignalLength, JBB);
        break;
      }
-    case Request::append: {
+    case Request::append:
+    case Request::append_synch:
+    {
        jam();
        sendSignal(ref, GSN_FSAPPENDREF, signal, FsRef::SignalLength,  
JBB);
        break;
@@ -814,7 +820,9 @@
        sendSignal(ref, GSN_FSSYNCCONF, signal, 1, JBB);
        break;
      }//case
-    case Request::append: {
+    case Request::append:
+    case Request::append_synch:
+    {
        jam();
        signal->theData[1] = request->par.append.size;
        sendSignal(ref, GSN_FSAPPENDCONF, signal, 2, JBB);
diff -Nur --exclude=RCS --exclude=CVS --exclude=SCCS  
--exclude=BitKeeper --exclude=ChangeSet  
clean-mysql-5.1/storage/ndb/src/mgmsrv/ConfigInfo.cpp  
clean-bug20970/storage/ndb/src/mgmsrv/ConfigInfo.cpp
--- clean-mysql-5.1/storage/ndb/src/mgmsrv/ConfigInfo.cpp	2006-07-13  
19:49:21 -04:00
+++ clean-bug20970/storage/ndb/src/mgmsrv/ConfigInfo.cpp	2006-07-13  
19:52:23 -04:00
@@ -1192,6 +1192,42 @@
      0, 0 },

    {
+    CFG_DB_DISK_SYNCH_SIZE,
+    "DiskSyncSize",
+    DB_TOKEN,
+    "Data written to a file before a synch is forced",
+    ConfigInfo::CI_USED,
+    false,
+    ConfigInfo::CI_INT,
+    "4M",
+    "32k",
+    STR_VALUE(MAX_INT_RNIL) },
+
+  {
+    CFG_DB_CHECKPOINT_SPEED,
+    "DiskCheckpointSpeed",
+    DB_TOKEN,
+    "Bytes per second allowed to be written by checkpoint",
+    ConfigInfo::CI_USED,
+    false,
+    ConfigInfo::CI_INT,
+    "4M",
+    "1M",
+    STR_VALUE(MAX_INT_RNIL) },
+
+  {
+    CFG_DB_CHECKPOINT_SPEED_SR,
+    "DiskCheckpointSpeedInRestart",
+    DB_TOKEN,
+    "Bytes per second allowed to be written by checkpoint during  
restart",
+    ConfigInfo::CI_USED,
+    false,
+    ConfigInfo::CI_INT,
+    "10M",
+    "1M",
+    STR_VALUE(MAX_INT_RNIL) },
+
+  {
      CFG_DB_BACKUP_MEM,
      "BackupMemory",
      DB_TOKEN,

Mikael Ronstrom, Senior Software Architect
MySQL AB, www.mysql.com

Jumpstart your cluster:
http://www.mysql.com/consulting/packaged/cluster.html
My blog:
http://mikaelronstrom.blogspot.com