Lines Matching defs:heap
2372 ** that specifies the maximum size of the created heap.
4148 ** sqlite3_create_filename(), then bad things such as heap
5488 ** undesirable behavior such as segfaults and heap corruption.
7038 ** of heap memory by deallocating non-essential memory allocations
7054 ** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap
7067 ** These interfaces impose limits on the amount of heap memory that will be
7071 ** soft limit on the amount of heap memory that may be allocated by SQLite.
7072 ** ^SQLite strives to keep heap memory utilization below the soft heap
7074 ** as heap memory usages approaches the limit.
7075 ** ^The soft heap limit is "soft" because even though SQLite strives to stay
7077 ** an [SQLITE_NOMEM] error. In other words, the soft heap limit
7084 ** when the hard heap limit is reached.
7088 ** the heap limit prior to the call, or negative in the case of an
7090 ** then no change is made to the heap limit. Hence, the current
7091 ** size of heap limits can be determined by invoking
7094 ** ^Setting the heap limits to zero disables the heap limiter mechanism.
7096 ** ^The soft heap limit may not be greater than the hard heap limit.
7097 ** ^If the hard heap limit is enabled and if sqlite3_soft_heap_limit(N)
7098 ** is invoked with a value of N that is greater than the hard heap limit,
7099 ** the soft heap limit is set to the value of the hard heap limit.
7100 ** ^The soft heap limit is automatically enabled whenever the hard heap
7102 ** the soft heap limit is outside the range of 1..N, then the soft heap
7104 ** hard heap limit is enabled makes the soft heap limit equal to the
7105 ** hard heap limit.
7110 ** ^(The heap limits are not enforced in the current implementation
7122 ** from the heap.
7125 ** The circumstances under which SQLite will enforce the heap limits may
8797 ** <dd>This parameter returns the approximate number of bytes of heap
8804 ** pager cache is shared between two or more connections the bytes of heap
8814 ** <dd>This parameter returns the approximate number of bytes of heap
8823 ** <dd>This parameter returns the approximate number of bytes of heap
8968 ** <dd>^This is the approximate number of bytes of heap memory
9021 ** In many applications, most of the heap memory allocated by
9169 ** free up as much of heap memory as possible. The page cache implementation
11461 ** CAPI3REF: Query for the amount of heap memory used by a session object.
11463 ** This API returns the total amount of heap memory in bytes currently
13647 ** SQLITE_WIN32_MALLOC // Use Win32 native heap API
13652 ** assert() macro is enabled, each call into the Win32 native heap subsystem
13653 ** will cause HeapValidate to be called. If heap validation should fail, an
14704 ** the heap. When WSD is unsupported, the variable declarations scattered
16648 /* Try to return memory used by the pcache module to the main memory heap */
19488 int mnReq, mxReq; /* Min and max heap requests sizes */
20952 #define MEMTYPE_HEAP 0x01 /* General heap allocations */
29077 ** Default value of the hard heap limit. 0 means "no limit".
29088 sqlite3_int64 alarmThreshold; /* The soft heap limit */
29092 ** True if heap is nearly "full" where "full" is defined by the
29126 ** Set the soft heap-size limit for the library. An argument of
29130 ** The return value is the value of the heap limit just before this
29133 ** If the hard heap limit is enabled, then the soft heap limit cannot
29134 ** be disabled nor raised above the hard heap limit.
29167 ** Set the hard heap-size limit for the library. An argument of zero
29168 ** disables the hard heap limit. A negative argument is a no-op used
29169 ** to obtain the return value without affecting the hard heap limit.
29171 ** The return value is the value of the hard heap limit just prior to
29174 ** Setting the hard heap limit will also activate the soft heap limit
29175 ** and constrain the soft heap limit to be no more than the hard heap
29217 ** Return true if the heap is currently under memory pressure - in other
29218 ** words if the amount of heap used is close to the limit set by
29658 ** Allocate memory, either lookaside (if possible) or heap.
41477 ** file is created. The shared memory will be simulated with heap memory.
45392 * various Win32 API heap functions instead of our own.
45397 * If this is non-zero, an isolated heap will be created by the native Win32
45398 * allocator subsystem; otherwise, the default process heap will be used. This
45400 * and an isolated heap will be created to store all allocated data.
45405 * function), all data that was allocated using the isolated heap will
45415 * This is the maximum possible initial size of the Win32-specific heap, in
45423 * This is the extra space for the initial size of the Win32-specific heap,
45432 * possible initial heap size and the default page size, setting aside the
45443 * Win32-specific heap. It cannot be negative.
45455 * initial size of the Win32-specific heap to exceed the maximum amount
45464 * The initial size of the Win32-specific heap. This value may be zero.
45473 * The maximum size of the Win32-specific heap. This value may be zero.
45480 * The extra flags to use in calls to the Win32 heap APIs. This value may be
45497 HANDLE hHeap; /* The handle to our heap. */
45498 BOOL bOwned; /* Do we own the heap (i.e. destroy it on shutdown)? */
46318 ** If a Win32 native heap has been configured, this function will attempt to
46322 ** largest committed free block in the heap, in bytes.
46340 sqlite3_log(SQLITE_NOMEM, "failed to HeapCompact (no space), heap=%p",
46344 sqlite3_log(SQLITE_ERROR, "failed to HeapCompact (%lu), heap=%p",
46350 sqlite3_log(SQLITE_NOTFOUND, "failed to HeapCompact, heap=%p",
46359 ** If a Win32 native heap has been configured, this function will attempt to
46360 ** destroy and recreate it. If the Win32 native heap is not isolated and/or
46362 ** be returned and no changes will be made to the Win32 native heap.
46376 ** the heap. Also, since both the main and memsys locks are currently
46378 ** be able to even access the heap. Attempt to destroy and recreate our
46379 ** isolated Win32 native heap now.
46394 ** The Win32 native heap cannot be modified because it may be in use.
46557 sqlite3_log(SQLITE_NOMEM, "failed to HeapAlloc %u bytes (%lu), heap=%p",
46578 sqlite3_log(SQLITE_NOMEM, "failed to HeapFree block %p (%lu), heap=%p",
46604 sqlite3_log(SQLITE_NOMEM, "failed to %s %u bytes (%lu), heap=%p",
46628 sqlite3_log(SQLITE_NOMEM, "failed to HeapSize block %p (%lu), heap=%p",
46708 sqlite3_log(SQLITE_NOMEM, "failed to HeapDestroy (%lu), heap=%p",
53599 ** The third case is a chunk of heap memory (defaulting to 100 pages worth)
54047 ** allocation onto the heap.
54049 ** Or, the heap is used for all page cache memory but the heap is
54052 ** the heap even further.
55472 ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
63114 ** lock on the database file and use heap-memory to store the wal-index
63124 ** heap-memory for the wal-index instead of the VFS shared-memory
64838 int bNoShm, /* True to run in heap-memory mode */
65865 ** constructed in pWal->apWiData[] using heap memory instead of shared
65872 ** WAL_RETRY, then the heap memory wal-index has been discarded and
65909 ** cause the heap-memory WAL-index to be discarded and the actual
65982 ** wal file since the heap-memory wal-index was created. If so, the
65983 ** heap-memory wal-index is discarded and WAL_RETRY returned to
67428 ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
68272 u32 *heap; /* Min-heap used for analyzing cell coverage */
78962 ** An implementation of a min-heap.
78964 ** aHeap[0] is the number of elements on the heap. aHeap[1] is the
78968 ** The heap property is this: Every node is less than or equal to both
78969 ** of its daughter nodes. A consequence of the heap property is that the
78970 ** root node aHeap[1] is always the minimum value currently in the heap.
78973 ** the heap, preserving the heap property. The btreeHeapPull() routine
78974 ** removes the root element from the heap (the minimum value in the heap)
78975 ** and then moves other nodes around as necessary to preserve the heap
78978 ** This heap is used for cell overlap and coverage testing. Each u32
79052 u32 *heap = 0; /* Min-heap used for checking cell coverage */
79053 u32 x, prev = 0; /* Next and previous entry on the min-heap */
79120 ** as the other cell checks, so initialize the heap. */
79121 heap = pCheck->heap;
79122 heap[0] = 0;
79188 /* Populate the coverage-checking heap for leaf pages */
79189 btreeHeapInsert(heap, (pc<<16)|(pc+info.nSize-1));
79198 /* For leaf pages, the min-heap has already been initialized and the
79202 heap = pCheck->heap;
79203 heap[0] = 0;
79208 btreeHeapInsert(heap, (pc<<16)|(pc+size-1));
79211 /* Add the freeblocks to the min-heap
79223 btreeHeapInsert(heap, (((u32)i)<<16)|(i+size-1));
79235 /* Analyze the min-heap looking for overlap between cells and/or
79238 ** Each min-heap entry is of the form: (start_address<<16)|end_address.
79243 ** The loop below pulls entries from the min-heap in order and compares
79249 prev = contentOffset - 1; /* Implied first min-heap entry */
79250 while( btreeHeapPull(heap,&x) ){
79266 if( heap[0]==0 && nFrag!=data[hdr+7] ){
79346 sCheck.heap = 0;
79358 sCheck.heap = (u32*)sqlite3PageMalloc( pBt->pageSize );
79359 if( sCheck.heap==0 ){
79439 sqlite3PageFree(sCheck.heap);
103399 ** Return true if this "journal file" is currently stored in heap memory,
115001 ** This routine allocates the StatAccum object in heap memory. The return
120218 ** illegal in a schema and will lead to errors or heap corruption
121306 ** Allocate heap space to hold an Index object with nCol columns.
136681 ** Invoke sqlite3_hard_heap_limit64() to query or set the hard heap
136682 ** limit. The hard heap limit can be activated or lowered by this
136685 ** the hard heap limit. This allows an application to set a heap limit
173808 /* The heap subsystem has now been shutdown and these values are supposed
173810 ** which would rely on that heap subsystem; therefore, make sure these
173811 ** values cannot refer to heap memory that was just invalidated when the
173812 ** heap subsystem was shutdown. This is only done if the current call to
173813 ** this function resulted in the heap subsystem actually being shutdown.
174100 ** heap. */
178637 ** allocate a larger array from the heap has failed.
213270 ** RBU_STAGE_OAL mode are actually stored in heap memory. This is to
213726 ** is supplying heap memory to the upper layer in place of *-shm
213760 ** rbu is in the RBU_STAGE_OAL state, use heap memory for *-shm space
213767 /* This is an RBU connection that uses its own heap memory for the
218285 ** Return the amount of heap memory in use.