Lines Matching defs:heap
3031 ** that specifies the maximum size of the created heap.
4775 ** sqlite3_create_filename(), then bad things such as heap
6075 ** undesirable behavior such as segfaults and heap corruption.
7483 ** of heap memory by deallocating non-essential memory allocations
7499 ** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap
7512 ** These interfaces impose limits on the amount of heap memory that will be
7516 ** soft limit on the amount of heap memory that may be allocated by SQLite.
7517 ** ^SQLite strives to keep heap memory utilization below the soft heap
7519 ** as heap memory usages approaches the limit.
7520 ** ^The soft heap limit is "soft" because even though SQLite strives to stay
7522 ** an [SQLITE_NOMEM] error. In other words, the soft heap limit
7529 ** when the hard heap limit is reached.
7533 ** the heap limit prior to the call, or negative in the case of an
7535 ** then no change is made to the heap limit. Hence, the current
7536 ** size of heap limits can be determined by invoking
7539 ** ^Setting the heap limits to zero disables the heap limiter mechanism.
7541 ** ^The soft heap limit may not be greater than the hard heap limit.
7542 ** ^If the hard heap limit is enabled and if sqlite3_soft_heap_limit(N)
7543 ** is invoked with a value of N that is greater than the hard heap limit,
7544 ** the the soft heap limit is set to the value of the hard heap limit.
7545 ** ^The soft heap limit is automatically enabled whenever the hard heap
7547 ** the soft heap limit is outside the range of 1..N, then the soft heap
7549 ** hard heap limit is enabled makes the soft heap limit equal to the
7550 ** hard heap limit.
7555 ** ^(The heap limits are not enforced in the current implementation
7567 ** from the heap.
7570 ** The circumstances under which SQLite will enforce the heap limits may
9208 ** <dd>This parameter returns the approximate number of bytes of heap
9215 ** pager cache is shared between two or more connections the bytes of heap
9225 ** <dd>This parameter returns the approximate number of bytes of heap
9234 ** <dd>This parameter returns the approximate number of bytes of heap
9369 ** <dd>^This is the approximate number of bytes of heap memory
9420 ** In many applications, most of the heap memory allocated by
9568 ** free up as much of heap memory as possible. The page cache implementation
11519 ** CAPI3REF: Query for the amount of heap memory used by a session object.
11521 ** This API returns the total amount of heap memory in bytes currently
13699 ** SQLITE_WIN32_MALLOC // Use Win32 native heap API
13704 ** assert() macro is enabled, each call into the Win32 native heap subsystem
13705 ** will cause HeapValidate to be called. If heap validation should fail, an
14731 ** the heap. When WSD is unsupported, the variable declarations scattered
16330 /* Try to return memory used by the pcache module to the main memory heap */
19241 int mnReq, mxReq; /* Min and max heap requests sizes */
20612 #define MEMTYPE_HEAP 0x01 /* General heap allocations */
27639 ** Default value of the hard heap limit. 0 means "no limit".
27650 sqlite3_int64 alarmThreshold; /* The soft heap limit */
27654 ** True if heap is nearly "full" where "full" is defined by the
27688 ** Set the soft heap-size limit for the library. An argument of
27692 ** The return value is the value of the heap limit just before this
27695 ** If the hard heap limit is enabled, then the soft heap limit cannot
27696 ** be disabled nor raised above the hard heap limit.
27729 ** Set the hard heap-size limit for the library. An argument of zero
27730 ** disables the hard heap limit. A negative argument is a no-op used
27731 ** to obtain the return value without affecting the hard heap limit.
27733 ** The return value is the value of the hard heap limit just prior to
27736 ** Setting the hard heap limit will also activate the soft heap limit
27737 ** and constrain the soft heap limit to be no more than the hard heap
27780 ** Return true if the heap is currently under memory pressure - in other
27781 ** words if the amount of heap used is close to the limit set by
28168 ** Allocate memory, either lookaside (if possible) or heap.
38402 ** file is created. The shared memory will be simulated with heap memory.
42427 * various Win32 API heap functions instead of our own.
42432 * If this is non-zero, an isolated heap will be created by the native Win32
42433 * allocator subsystem; otherwise, the default process heap will be used. This
42435 * and an isolated heap will be created to store all allocated data.
42440 * function), all data that was allocated using the isolated heap will
42450 * This is the maximum possible initial size of the Win32-specific heap, in
42458 * This is the extra space for the initial size of the Win32-specific heap,
42467 * possible initial heap size and the default page size, setting aside the
42478 * Win32-specific heap. It cannot be negative.
42490 * initial size of the Win32-specific heap to exceed the maximum amount
42499 * The initial size of the Win32-specific heap. This value may be zero.
42508 * The maximum size of the Win32-specific heap. This value may be zero.
42515 * The extra flags to use in calls to the Win32 heap APIs. This value may be
42532 HANDLE hHeap; /* The handle to our heap. */
42533 BOOL bOwned; /* Do we own the heap (i.e. destroy it on shutdown)? */
43353 ** If a Win32 native heap has been configured, this function will attempt to
43357 ** largest committed free block in the heap, in bytes.
43375 sqlite3_log(SQLITE_NOMEM, "failed to HeapCompact (no space), heap=%p",
43379 sqlite3_log(SQLITE_ERROR, "failed to HeapCompact (%lu), heap=%p",
43385 sqlite3_log(SQLITE_NOTFOUND, "failed to HeapCompact, heap=%p",
43394 ** If a Win32 native heap has been configured, this function will attempt to
43395 ** destroy and recreate it. If the Win32 native heap is not isolated and/or
43397 ** be returned and no changes will be made to the Win32 native heap.
43411 ** the heap. Also, since both the main and memsys locks are currently
43413 ** be able to even access the heap. Attempt to destroy and recreate our
43414 ** isolated Win32 native heap now.
43429 ** The Win32 native heap cannot be modified because it may be in use.
43592 sqlite3_log(SQLITE_NOMEM, "failed to HeapAlloc %u bytes (%lu), heap=%p",
43613 sqlite3_log(SQLITE_NOMEM, "failed to HeapFree block %p (%lu), heap=%p",
43639 sqlite3_log(SQLITE_NOMEM, "failed to %s %u bytes (%lu), heap=%p",
43663 sqlite3_log(SQLITE_NOMEM, "failed to HeapSize block %p (%lu), heap=%p",
43743 sqlite3_log(SQLITE_NOMEM, "failed to HeapDestroy (%lu), heap=%p",
50266 ** The third case is a chunk of heap memory (defaulting to 100 pages worth)
50719 ** allocation onto the heap.
50721 ** Or, the heap is used for all page cache memory but the heap is
50724 ** the heap even further.
52138 ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
59611 ** lock on the database file and use heap-memory to store the wal-index
59621 ** heap-memory for the wal-index instead of the VFS shared-memory
61261 int bNoShm, /* True to run in heap-memory mode */
62256 ** constructed in pWal->apWiData[] using heap memory instead of shared
62263 ** WAL_RETRY, then the heap memory wal-index has been discarded and
62300 ** cause the heap-memory WAL-index to be discarded and the actual
62371 ** wal file since the heap-memory wal-index was created. If so, the
62372 ** heap-memory wal-index is discarded and WAL_RETRY returned to
63792 ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
64635 u32 *heap; /* Min-heap used for analyzing cell coverage */
74922 ** An implementation of a min-heap.
74924 ** aHeap[0] is the number of elements on the heap. aHeap[1] is the
74928 ** The heap property is this: Every node is less than or equal to both
74929 ** of its daughter nodes. A consequence of the heap property is that the
74930 ** root node aHeap[1] is always the minimum value currently in the heap.
74933 ** the heap, preserving the heap property. The btreeHeapPull() routine
74934 ** removes the root element from the heap (the minimum value in the heap)
74935 ** and then moves other nodes around as necessary to preserve the heap
74938 ** This heap is used for cell overlap and coverage testing. Each u32
75012 u32 *heap = 0; /* Min-heap used for checking cell coverage */
75013 u32 x, prev = 0; /* Next and previous entry on the min-heap */
75080 ** as the other cell checks, so initialize the heap. */
75081 heap = pCheck->heap;
75082 heap[0] = 0;
75148 /* Populate the coverage-checking heap for leaf pages */
75149 btreeHeapInsert(heap, (pc<<16)|(pc+info.nSize-1));
75158 /* For leaf pages, the min-heap has already been initialized and the
75162 heap = pCheck->heap;
75163 heap[0] = 0;
75168 btreeHeapInsert(heap, (pc<<16)|(pc+size-1));
75171 /* Add the freeblocks to the min-heap
75183 btreeHeapInsert(heap, (((u32)i)<<16)|(i+size-1));
75195 /* Analyze the min-heap looking for overlap between cells and/or
75198 ** Each min-heap entry is of the form: (start_address<<16)|end_address.
75203 ** The loop below pulls entries from the min-heap in order and compares
75209 prev = contentOffset - 1; /* Implied first min-heap entry */
75210 while( btreeHeapPull(heap,&x) ){
75226 if( heap[0]==0 && nFrag!=data[hdr+7] ){
75306 sCheck.heap = 0;
75318 sCheck.heap = (u32*)sqlite3PageMalloc( pBt->pageSize );
75319 if( sCheck.heap==0 ){
75399 sqlite3PageFree(sCheck.heap);
98361 ** Return true if this "journal file" is currently stored in heap memory,
109162 ** This routine allocates the StatAccum object in heap memory. The return
114063 ** illegal in a schema and will lead to errors or heap corruption
115110 ** Allocate heap space to hold an Index object with nCol columns.
129721 ** Invoke sqlite3_hard_heap_limit64() to query or set the hard heap
129722 ** limit. The hard heap limit can be activated or lowered by this
129725 ** the hard heap limit. This allows an application to set a heap limit
164457 /* The heap subsystem has now been shutdown and these values are supposed
164459 ** which would rely on that heap subsystem; therefore, make sure these
164460 ** values cannot refer to heap memory that was just invalidated when the
164461 ** heap subsystem was shutdown. This is only done if the current call to
164462 ** this function resulted in the heap subsystem actually being shutdown.
164749 ** heap. */
169002 ** allocate a larger array from the heap has failed.
203370 ** RBU_STAGE_OAL mode are actually stored in heap memory. This is to
203826 ** is supplying heap memory to the upper layer in place of *-shm
203860 ** rbu is in the RBU_STAGE_OAL state, use heap memory for *-shm space
203867 /* This is an RBU connection that uses its own heap memory for the
208182 ** Return the amount of heap memory in use.