* tuples to return? */
bool boundUsed; /* true if we made use of a bounded heap */
int bound; /* if bounded, the maximum number of tuples */
- Size availMem; /* remaining memory available, in bytes */
- Size allowedMem; /* total memory allowed, in bytes */
+ int64 availMem; /* remaining memory available, in bytes */
+ int64 allowedMem; /* total memory allowed, in bytes */
int maxTapes; /* number of tapes (Knuth's T) */
int tapeRange; /* maxTapes-1 (Knuth's P) */
MemoryContext sortcontext; /* memory context holding all sort data */
int *mergenext; /* first preread tuple for each source */
int *mergelast; /* last preread tuple for each source */
int *mergeavailslots; /* slots left for prereading each tape */
- Size *mergeavailmem; /* availMem for prereading each tape */
+ int64 *mergeavailmem; /* availMem for prereading each tape */
int mergefreelist; /* head of freelist of recycled slots */
int mergefirstfree; /* first slot never used in this merge */
state->randomAccess = randomAccess;
state->bounded = false;
state->boundUsed = false;
- state->allowedMem = workMem * 1024L;
+ state->allowedMem = workMem * (int64) 1024;
state->availMem = state->allowedMem;
state->sortcontext = sortcontext;
state->tapeset = NULL;
{
int newmemtupsize;
int memtupsize = state->memtupsize;
- Size memNowUsed = state->allowedMem - state->availMem;
+ int64 memNowUsed = state->allowedMem - state->availMem;
/* Forget it if we've already maxed out memtuples, per comment above */
if (!state->growmemtuples)
{
/*
* We've used no more than half of allowedMem; double our usage,
- * clamping at INT_MAX.
+ * clamping at INT_MAX tuples.
*/
if (memtupsize < INT_MAX / 2)
newmemtupsize = memtupsize * 2;
/*
* On a 32-bit machine, allowedMem could exceed MaxAllocHugeSize. Clamp
* to ensure our request won't be rejected. Note that we can easily
- * exhaust address space before facing this outcome.
+ * exhaust address space before facing this outcome. (This is presently
+ * impossible due to guc.c's MAX_KILOBYTES limitation on work_mem, but
+ * don't rely on that at this distance.)
*/
if ((Size) newmemtupsize >= MaxAllocHugeSize / sizeof(SortTuple))
{
* palloc would be treating both old and new arrays as separate chunks.
* But we'll check LACKMEM explicitly below just in case.)
*/
- if (state->availMem < (Size) ((newmemtupsize - memtupsize) * sizeof(SortTuple)))
+ if (state->availMem < (int64) ((newmemtupsize - memtupsize) * sizeof(SortTuple)))
goto noalloc;
/* OK, do it */
* This is exported for use by the planner. allowedMem is in bytes.
*/
int
-tuplesort_merge_order(Size allowedMem)
+tuplesort_merge_order(int64 allowedMem)
{
int mOrder;
int maxTapes,
ntuples,
j;
- Size tapeSpace;
+ int64 tapeSpace;
/* Compute number of tapes to use: merge order plus 1 */
maxTapes = tuplesort_merge_order(state->allowedMem) + 1;
state->mergenext = (int *) palloc0(maxTapes * sizeof(int));
state->mergelast = (int *) palloc0(maxTapes * sizeof(int));
state->mergeavailslots = (int *) palloc0(maxTapes * sizeof(int));
- state->mergeavailmem = (Size *) palloc0(maxTapes * sizeof(Size));
+ state->mergeavailmem = (int64 *) palloc0(maxTapes * sizeof(int64));
state->tp_fib = (int *) palloc0(maxTapes * sizeof(int));
state->tp_runs = (int *) palloc0(maxTapes * sizeof(int));
state->tp_dummy = (int *) palloc0(maxTapes * sizeof(int));
int srcTape;
int tupIndex;
SortTuple *tup;
- Size priorAvail,
+ int64 priorAvail,
spaceFreed;
/*
int tapenum;
int srcTape;
int slotsPerTape;
- Size spacePerTape;
+ int64 spacePerTape;
/* Heap should be empty here */
Assert(state->memtupcount == 0);
unsigned int tuplen;
SortTuple stup;
int tupIndex;
- Size priorAvail,
+ int64 priorAvail,
spaceUsed;
if (!state->mergeactive[srcTape])
bool backward; /* store extra length words in file? */
bool interXact; /* keep open through transactions? */
bool truncated; /* tuplestore_trim has removed tuples? */
- Size availMem; /* remaining memory available, in bytes */
- Size allowedMem; /* total memory allowed, in bytes */
+ int64 availMem; /* remaining memory available, in bytes */
+ int64 allowedMem; /* total memory allowed, in bytes */
BufFile *myfile; /* underlying file, or NULL if none */
MemoryContext context; /* memory context for holding tuples */
ResourceOwner resowner; /* resowner for holding temp files */
{
int newmemtupsize;
int memtupsize = state->memtupsize;
- Size memNowUsed = state->allowedMem - state->availMem;
+ int64 memNowUsed = state->allowedMem - state->availMem;
/* Forget it if we've already maxed out memtuples, per comment above */
if (!state->growmemtuples)
{
/*
* We've used no more than half of allowedMem; double our usage,
- * clamping at INT_MAX.
+ * clamping at INT_MAX tuples.
*/
if (memtupsize < INT_MAX / 2)
newmemtupsize = memtupsize * 2;
/*
* On a 32-bit machine, allowedMem could exceed MaxAllocHugeSize. Clamp
* to ensure our request won't be rejected. Note that we can easily
- * exhaust address space before facing this outcome.
+ * exhaust address space before facing this outcome. (This is presently
+ * impossible due to guc.c's MAX_KILOBYTES limitation on work_mem, but
+ * don't rely on that at this distance.)
*/
if ((Size) newmemtupsize >= MaxAllocHugeSize / sizeof(void *))
{
* palloc would be treating both old and new arrays as separate chunks.
* But we'll check LACKMEM explicitly below just in case.)
*/
- if (state->availMem < (Size) ((newmemtupsize - memtupsize) * sizeof(void *)))
+ if (state->availMem < (int64) ((newmemtupsize - memtupsize) * sizeof(void *)))
goto noalloc;
/* OK, do it */
projects / postgresql.git / commitdiff