106628   SortSubtask *pTask;        /* Used by this thread only */  member
106771   SortSubtask *pTask;             /* Task that owns this merger */  member
106989 static int vdbeSorterMapFile(SortSubtask *pTask, SorterFile *pFile, u8 **pp){  argument
106991   if( pFile->iEof<=(i64)(pTask->pSorter->db->nMaxSorterMmap) ){
107007   SortSubtask *pTask,             /* Task context */  argument
107025   rc = vdbeSorterMapFile(pTask, pFile, &pReadr->aMap);
107027     int pgsz = pTask->pSorter->pgsz;
107065             pIncr->pTask, pReadr, &pIncr->aFile[0], pIncr->iStartOff
107101   SortSubtask *pTask,             /* Task context */  argument
107114   rc = vdbePmaReaderSeek(pTask, pReadr, pFile, iStart);
107134   SortSubtask *pTask,             /* Subtask context (for pKeyInfo) */  argument
107139   UnpackedRecord *r2 = pTask->pUnpacked;
107161   SortSubtask *pTask,             /* Subtask context (for pKeyInfo) */  argument
107166   UnpackedRecord *r2 = pTask->pUnpacked;
107180   SortSubtask *pTask,             /* Subtask context (for pKeyInfo) */  argument
107202     if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
107204           pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2
107208     assert( pTask->pSorter->pKeyInfo->aSortFlags!=0 );
107209     assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) );
107210     if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){
107223   SortSubtask *pTask,             /* Subtask context (for pKeyInfo) */  argument
107272   assert( pTask->pSorter->pKeyInfo->aSortFlags!=0 );
107274     if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
107276           pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2
107279   }else if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){
107280     assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) );
107375       SortSubtask *pTask = &pSorter->aTask[i];  local
107376       pTask->pSorter = pSorter;
107433 static void vdbeSortSubtaskCleanup(sqlite3 *db, SortSubtask *pTask){  argument
107434   sqlite3DbFree(db, pTask->pUnpacked);
107438   if( pTask->list.aMemory ){
107439     sqlite3_free(pTask->list.aMemory);
107443     assert( pTask->list.aMemory==0 );
107444     vdbeSorterRecordFree(0, pTask->list.pList);
107446   if( pTask->file.pFd ){
107447     sqlite3OsCloseFree(pTask->file.pFd);
107449   if( pTask->file2.pFd ){
107450     sqlite3OsCloseFree(pTask->file2.pFd);
107452   memset(pTask, 0, sizeof(SortSubtask));
107456 static void vdbeSorterWorkDebug(SortSubtask *pTask, const char *zEvent){  argument
107458   int iTask = (pTask - pTask->pSorter->aTask);
107459   sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
107469   SortSubtask *pTask,  argument
107473   int iTask = (pTask - pTask->pSorter->aTask);
107474   sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
107478   SortSubtask *pTask,  argument
107484     sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
107499 static int vdbeSorterJoinThread(SortSubtask *pTask){  argument
107501   if( pTask->pThread ){
107503     int bDone = pTask->bDone;
107506     vdbeSorterBlockDebug(pTask, !bDone, "enter");
107507     (void)sqlite3ThreadJoin(pTask->pThread, &pRet);
107508     vdbeSorterBlockDebug(pTask, !bDone, "exit");
107510     assert( pTask->bDone==1 );
107511     pTask->bDone = 0;
107512     pTask->pThread = 0;
107521   SortSubtask *pTask,             /* Thread will use this task object */  argument
107525   assert( pTask->pThread==0 && pTask->bDone==0 );
107526   return sqlite3ThreadCreate(&pTask->pThread, xTask, pIn);
107545     SortSubtask *pTask = &pSorter->aTask[i];  local
107546     int rc2 = vdbeSorterJoinThread(pTask);
107553 # define vdbeSorterJoinThread(pTask) SQLITE_OK  argument
107576     pNew->pTask = 0;
107604       vdbeSorterJoinThread(pIncr->pTask);
107631     SortSubtask *pTask = &pSorter->aTask[i];  local
107632     vdbeSortSubtaskCleanup(db, pTask);
107633     pTask->pSorter = pSorter;
107724 static int vdbeSortAllocUnpacked(SortSubtask *pTask){  argument
107725   if( pTask->pUnpacked==0 ){
107726     pTask->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pTask->pSorter->pKeyInfo);
107727     if( pTask->pUnpacked==0 ) return SQLITE_NOMEM_BKPT;
107728     pTask->pUnpacked->nField = pTask->pSorter->pKeyInfo->nKeyField;
107729     pTask->pUnpacked->errCode = 0;
107739   SortSubtask *pTask,             /* Calling thread context */  argument
107750     res = pTask->xCompare(
107751         pTask, &bCached, SRVAL(p1), p1->nVal, SRVAL(p2), p2->nVal
107794 static int vdbeSorterSort(SortSubtask *pTask, SorterList *pList){  argument
107800   rc = vdbeSortAllocUnpacked(pTask);
107804   pTask->xCompare = vdbeSorterGetCompare(pTask->pSorter);
107822       p = vdbeSorterMerge(pTask, p, aSlot[i]);
107836     p = p ? vdbeSorterMerge(pTask, p, aSlot[i]) : aSlot[i];
107840   assert( pTask->pUnpacked->errCode==SQLITE_OK
107841        || pTask->pUnpacked->errCode==SQLITE_NOMEM
107843   return pTask->pUnpacked->errCode;
107948 static int vdbeSorterListToPMA(SortSubtask *pTask, SorterList *pList){  argument
107949   sqlite3 *db = pTask->pSorter->db;
107956   i64 iSz = pList->szPMA + sqlite3VarintLen(pList->szPMA) + pTask->file.iEof;
107959   vdbeSorterWorkDebug(pTask, "enter");
107964   if( pTask->file.pFd==0 ){
107965     rc = vdbeSorterOpenTempFile(db, 0, &pTask->file.pFd);
107966     assert( rc!=SQLITE_OK || pTask->file.pFd );
107967     assert( pTask->file.iEof==0 );
107968     assert( pTask->nPMA==0 );
107973     vdbeSorterExtendFile(db, pTask->file.pFd, pTask->file.iEof+pList->szPMA+9);
107978     rc = vdbeSorterSort(pTask, pList);
107985     vdbePmaWriterInit(pTask->file.pFd, &writer, pTask->pSorter->pgsz,
107986                       pTask->file.iEof);
107987     pTask->nPMA++;
107996     rc = vdbePmaWriterFinish(&writer, &pTask->file.iEof, &pTask->nSpill);
107999   vdbeSorterWorkDebug(pTask, "exit");
108001   assert( rc!=SQLITE_OK || pTask->file.iEof==iSz );
108018   SortSubtask *pTask = pMerger->pTask;  local
108043         iRes = pTask->xCompare(pTask, &bCached,
108076   return (rc==SQLITE_OK ? pTask->pUnpacked->errCode : rc);
108084   SortSubtask *pTask = (SortSubtask*)pCtx;  local
108086   assert( pTask->bDone==0 );
108087   rc = vdbeSorterListToPMA(pTask, &pTask->list);
108088   pTask->bDone = 1;
108104   SortSubtask *pTask = 0;    /* Thread context used to create new PMA */
108121     pTask = &pSorter->aTask[iTest];
108122     if( pTask->bDone ){
108123       rc = vdbeSorterJoinThread(pTask);
108125     if( rc!=SQLITE_OK || pTask->pThread==0 ) break;
108137       assert( pTask!=0 );
108138       assert( pTask->pThread==0 && pTask->bDone==0 );
108139       assert( pTask->list.pList==0 );
108140       assert( pTask->list.aMemory==0 || pSorter->list.aMemory!=0 );
108142       aMem = pTask->list.aMemory;
108143       pCtx = (void*)pTask;
108144       pSorter->iPrev = (u8)(pTask - pSorter->aTask);
108145       pTask->list = pSorter->list;
108156       rc = vdbeSorterCreateThread(pTask, vdbeSorterFlushThread, pCtx);
108284   SortSubtask *pTask = pIncr->pTask;  local
108289   vdbeSorterPopulateDebug(pTask, "enter");
108291   vdbePmaWriterInit(pOut->pFd, &writer, pTask->pSorter->pgsz, iStart);
108306     assert( pIncr->pMerger->pTask==pTask );
108310   rc2 = vdbePmaWriterFinish(&writer, &pOut->iEof, &pTask->nSpill);
108312   vdbeSorterPopulateDebug(pTask, "exit");
108324   pIncr->pTask->bDone = 1;
108334   return vdbeSorterCreateThread(pIncr->pTask, vdbeIncrPopulateThread, p);
108360     rc = vdbeSorterJoinThread(pIncr->pTask);
108395   SortSubtask *pTask,     /* The thread that will be using the new IncrMerger */  argument
108404     pIncr->pTask = pTask;
108405     pIncr->mxSz = MAX(pTask->pSorter->mxKeysize+9,pTask->pSorter->mxPmaSize/2);
108406     pTask->file2.iEof += pIncr->mxSz;
108421   pIncr->pTask->file2.iEof -= pIncr->mxSz;
108460     SortSubtask *pTask = pMerger->pTask;  local
108463     assert( pTask->pUnpacked!=0 );  /* from vdbeSortSubtaskMain() */
108464     res = pTask->xCompare(
108465         pTask, &bCached, p1->aKey, p1->nKey, p2->aKey, p2->nKey
108515   SortSubtask *pTask,             /* Thread that will run pMerger */  argument
108531   assert( pMerger->pTask==0 );
108532   pMerger->pTask = pTask;
108554   return pTask->pUnpacked->errCode;
108593   SortSubtask *pTask = pIncr->pTask;  local
108594   sqlite3 *db = pTask->pSorter->db;
108599   rc = vdbeMergeEngineInit(pTask, pIncr->pMerger, eMode);
108615       if( pTask->file2.pFd==0 ){
108616         assert( pTask->file2.iEof>0 );
108617         rc = vdbeSorterOpenTempFile(db, pTask->file2.iEof, &pTask->file2.pFd);
108618         pTask->file2.iEof = 0;
108621         pIncr->aFile[1].pFd = pTask->file2.pFd;
108622         pIncr->iStartOff = pTask->file2.iEof;
108623         pTask->file2.iEof += mxSz;
108662   pReader->pIncr->pTask->bDone = 1;
108686       rc = vdbeSorterCreateThread(pIncr->pTask, vdbePmaReaderBgIncrInit, pCtx);
108709   SortSubtask *pTask,             /* Sorter task to read from */  argument
108725     rc = vdbePmaReaderInit(pTask, &pTask->file, iOff, pReadr, &nDummy);
108766   SortSubtask *pTask,             /* Task context */  argument
108778   rc = vdbeIncrMergerNew(pTask, pLeaf, &pIncr);
108793         rc = vdbeIncrMergerNew(pTask, pNew, &pReadr->pIncr);
108841     SortSubtask *pTask = &pSorter->aTask[iTask];  local
108842     assert( pTask->nPMA>0 || SQLITE_MAX_WORKER_THREADS>0 );
108843     if( SQLITE_MAX_WORKER_THREADS==0 || pTask->nPMA ){
108845       int nDepth = vdbeSorterTreeDepth(pTask->nPMA);
108848       if( pTask->nPMA<=SORTER_MAX_MERGE_COUNT ){
108849         rc = vdbeMergeEngineLevel0(pTask, pTask->nPMA, &iReadOff, &pRoot);
108855         for(i=0; i<pTask->nPMA && rc==SQLITE_OK; i += SORTER_MAX_MERGE_COUNT){
108859           nReader = MIN(pTask->nPMA - i, SORTER_MAX_MERGE_COUNT);
108860           rc = vdbeMergeEngineLevel0(pTask, nReader, &iReadOff, &pMerger);
108862             rc = vdbeSorterAddToTree(pTask, nDepth, iSeq++, pRoot, pMerger);
108870           rc = vdbeIncrMergerNew(pTask, pRoot, &pMain->aReadr[iTask].pIncr);
108935               assert( pIncr->pTask!=pLast );
108950                 (p->pIncr->pTask==&pSorter->aTask[iTask])             /* a */
109054       assert( pSorter->pMerger->pTask==(&pSorter->aTask[0]) );