Cross Reference: /external/chromium_org/third

Lines Matching defs:mem3
65 ** We often identify a chunk by its index in mem3.aPool[].  When
73 ** Pointers to the head of the list are stored in mem3.aiSmall[] 
74 ** for smaller chunks and mem3.aiHash[] for larger chunks.
88       u32 next;       /* Index in mem3.aPool[] of next free chunk */
89       u32 prev;       /* Index in mem3.aPool[] of previous free chunk */
96 ** into a single structure named "mem3".  This is to keep the
139 } mem3 = { 97535575 };
141 #define mem3 GLOBAL(struct Mem3Global, mem3)
144 ** Unlink the chunk at mem3.aPool[i] from list it is currently
148   u32 next = mem3.aPool[i].u.list.next;
149   u32 prev = mem3.aPool[i].u.list.prev;
150   assert( sqlite3_mutex_held(mem3.mutex) );
154     mem3.aPool[prev].u.list.next = next;
157     mem3.aPool[next].u.list.prev = prev;
159   mem3.aPool[i].u.list.next = 0;
160   mem3.aPool[i].u.list.prev = 0;
169   assert( sqlite3_mutex_held(mem3.mutex) );
170   assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
172   size = mem3.aPool[i-1].u.hdr.size4x/4;
173   assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
176     memsys3UnlinkFromList(i, &mem3.aiSmall[size-2]);
179     memsys3UnlinkFromList(i, &mem3.aiHash[hash]);
184 ** Link the chunk at mem3.aPool[i] so that is on the list rooted
188   assert( sqlite3_mutex_held(mem3.mutex) );
189   mem3.aPool[i].u.list.next = *pRoot;
190   mem3.aPool[i].u.list.prev = 0;
192     mem3.aPool[*pRoot].u.list.prev = i;
203   assert( sqlite3_mutex_held(mem3.mutex) );
205   assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
206   size = mem3.aPool[i-1].u.hdr.size4x/4;
207   assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
210     memsys3LinkIntoList(i, &mem3.aiSmall[size-2]);
213     memsys3LinkIntoList(i, &mem3.aiHash[hash]);
223   if( sqlite3GlobalConfig.bMemstat==0 && mem3.mutex==0 ){
224     mem3.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
226   sqlite3_mutex_enter(mem3.mutex);
229   sqlite3_mutex_leave(mem3.mutex);
236   if( !mem3.alarmBusy ){
237     mem3.alarmBusy = 1;
238     assert( sqlite3_mutex_held(mem3.mutex) );
239     sqlite3_mutex_leave(mem3.mutex);
241     sqlite3_mutex_enter(mem3.mutex);
242     mem3.alarmBusy = 0;
254   assert( sqlite3_mutex_held(mem3.mutex) );
256   assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock );
257   assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock );
258   x = mem3.aPool[i-1].u.hdr.size4x;
259   mem3.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2);
260   mem3.aPool[i+nBlock-1].u.hdr.prevSize = nBlock;
261   mem3.aPool[i+nBlock-1].u.hdr.size4x |= 2;
262   return &mem3.aPool[i];
266 ** Carve a piece off of the end of the mem3.iMaster free chunk.
271   assert( sqlite3_mutex_held(mem3.mutex) );
272   assert( mem3.szMaster>=nBlock );
273   if( nBlock>=mem3.szMaster-1 ){
275     void *p = memsys3Checkout(mem3.iMaster, mem3.szMaster);
276     mem3.iMaster = 0;
277     mem3.szMaster = 0;
278     mem3.mnMaster = 0;
283     newi = mem3.iMaster + mem3.szMaster - nBlock;
284     assert( newi > mem3.iMaster+1 );
285     mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = nBlock;
286     mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x |= 2;
287     mem3.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1;
288     mem3.szMaster -= nBlock;
289     mem3.aPool[newi-1].u.hdr.prevSize = mem3.szMaster;
290     x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
291     mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
292     if( mem3.szMaster < mem3.mnMaster ){
293       mem3.mnMaster = mem3.szMaster;
295     return (void*)&mem3.aPool[newi];
302 ** mem3.aiSmall[] or mem3.aiHash[].  
307 ** If it sees a chunk that is larger than mem3.iMaster, it replaces 
308 ** the current mem3.iMaster with the new larger chunk.  In order for
309 ** this mem3.iMaster replacement to work, the master chunk must be
318   assert( sqlite3_mutex_held(mem3.mutex) );
320     iNext = mem3.aPool[i].u.list.next;
321     size = mem3.aPool[i-1].u.hdr.size4x;
325       assert( i > mem3.aPool[i-1].u.hdr.prevSize );
326       prev = i - mem3.aPool[i-1].u.hdr.prevSize;
328         iNext = mem3.aPool[prev].u.list.next;
332       x = mem3.aPool[prev-1].u.hdr.size4x & 2;
333       mem3.aPool[prev-1].u.hdr.size4x = size*4 | x;
334       mem3.aPool[prev+size-1].u.hdr.prevSize = size;
340     if( size>mem3.szMaster ){
341       mem3.iMaster = i;
342       mem3.szMaster = size;
359   assert( sqlite3_mutex_held(mem3.mutex) );
374     i = mem3.aiSmall[nBlock-2];
376       memsys3UnlinkFromList(i, &mem3.aiSmall[nBlock-2]);
381     for(i=mem3.aiHash[hash]; i>0; i=mem3.aPool[i].u.list.next){
382       if( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ){
383         memsys3UnlinkFromList(i, &mem3.aiHash[hash]);
393   if( mem3.szMaster>=nBlock ){
405   for(toFree=nBlock*16; toFree<(mem3.nPool*16); toFree *= 2){
407     if( mem3.iMaster ){
408       memsys3Link(mem3.iMaster);
409       mem3.iMaster = 0;
410       mem3.szMaster = 0;
413       memsys3Merge(&mem3.aiHash[i]);
416       memsys3Merge(&mem3.aiSmall[i]);
418     if( mem3.szMaster ){
419       memsys3Unlink(mem3.iMaster);
420       if( mem3.szMaster>=nBlock ){
440   assert( sqlite3_mutex_held(mem3.mutex) );
441   assert( p>mem3.aPool && p<&mem3.aPool[mem3.nPool] );
442   i = p - mem3.aPool;
443   assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 );
444   size = mem3.aPool[i-1].u.hdr.size4x/4;
445   assert( i+size<=mem3.nPool+1 );
446   mem3.aPool[i-1].u.hdr.size4x &= ~1;
447   mem3.aPool[i+size-1].u.hdr.prevSize = size;
448   mem3.aPool[i+size-1].u.hdr.size4x &= ~2;
452   if( mem3.iMaster ){
453     while( (mem3.aPool[mem3.iMaster-1].u.hdr.size4x&2)==0 ){
454       size = mem3.aPool[mem3.iMaster-1].u.hdr.prevSize;
455       mem3.iMaster -= size;
456       mem3.szMaster += size;
457       memsys3Unlink(mem3.iMaster);
458       x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
459       mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
460       mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
462     x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
463     while( (mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x&1)==0 ){
464       memsys3Unlink(mem3.iMaster+mem3.szMaster);
465       mem3.szMaster += mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x/4;
466       mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
467       mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
558   /* Store a pointer to the memory block in global structure mem3. */
560   mem3.aPool = (Mem3Block *)sqlite3GlobalConfig.pHeap;
561   mem3.nPool = (sqlite3GlobalConfig.nHeap / sizeof(Mem3Block)) - 2;
564   mem3.szMaster = mem3.nPool;
565   mem3.mnMaster = mem3.szMaster;
566   mem3.iMaster = 1;
567   mem3.aPool[0].u.hdr.size4x = (mem3.szMaster<<2) + 2;
568   mem3.aPool[mem3.nPool].u.hdr.prevSize = mem3.nPool;
569   mem3.aPool[mem3.nPool].u.hdr.size4x = 1;
579   mem3.mutex = 0;
606   for(i=1; i<=mem3.nPool; i+=size/4){
607     size = mem3.aPool[i-1].u.hdr.size4x;
609       fprintf(out, "%p size error\n", &mem3.aPool[i]);
613     if( (size&1)==0 && mem3.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){
614       fprintf(out, "%p tail size does not match\n", &mem3.aPool[i]);
618     if( ((mem3.aPool[i+size/4-1].u.hdr.size4x&2)>>1)!=(size&1) ){
619       fprintf(out, "%p tail checkout bit is incorrect\n", &mem3.aPool[i]);
624       fprintf(out, "%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8);
626       fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8,
627                   i==mem3.iMaster ? " **master**" : "");
631     if( mem3.aiSmall[i]==0 ) continue;
633     for(j = mem3.aiSmall[i]; j>0; j=mem3.aPool[j].u.list.next){
634       fprintf(out, " %p(%d)", &mem3.aPool[j],
635               (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
640     if( mem3.aiHash[i]==0 ) continue;
642     for(j = mem3.aiHash[i]; j>0; j=mem3.aPool[j].u.list.next){
643       fprintf(out, " %p(%d)", &mem3.aPool[j],
644               (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
648   fprintf(out, "master=%d\n", mem3.iMaster);
649   fprintf(out, "nowUsed=%d\n", mem3.nPool*8 - mem3.szMaster*8);
650   fprintf(out, "mxUsed=%d\n", mem3.nPool*8 - mem3.mnMaster*8);
651   sqlite3_mutex_leave(mem3.mutex);