/*
* Create a new file set
* type is the WorkFileType for the files: BUFFILE or BFZ
* can_be_reused: if set to false, then we don't insert this set into the cache,
* since the caller is telling us there is no point. This can happen for
* example when spilling during index creation.
* ps is the PlanState for the subtree rooted at the operator
* snapshot contains snapshot information for the current transaction
*
*/
workfile_set *
workfile_mgr_create_set(enum ExecWorkFileType type, bool can_be_reused, PlanState *ps)
{
Assert(NULL != workfile_mgr_cache);
Plan *plan = NULL;
if (ps != NULL)
{
plan = ps->plan;
}
AssertImply(can_be_reused, plan != NULL);
NodeTag node_type = T_Invalid;
if (ps != NULL)
{
node_type = ps->type;
}
char *dir_path = create_workset_directory(node_type, currentSliceId);
if (!workfile_sets_resowner_callback_registered)
{
RegisterResourceReleaseCallback(workfile_set_free_callback, NULL);
workfile_sets_resowner_callback_registered = true;
}
/* Create parameter info for the populate function */
workset_info set_info;
set_info.file_type = type;
set_info.nodeType = node_type;
set_info.dir_path = dir_path;
set_info.session_start_time = GetCurrentTimestamp();
set_info.operator_work_mem = get_operator_work_mem(ps);
CacheEntry *newEntry = Cache_AcquireEntry(workfile_mgr_cache, &set_info);
if (NULL == newEntry)
{
/* Clean up the directory we created. */
workfile_mgr_delete_set_directory(dir_path);
/* Could not acquire another entry from the cache - we filled it up */
ereport(ERROR,
(errmsg("could not create workfile manager entry: exceeded number of concurrent spilling queries")));
}
/* Path has now been copied to the workfile_set. We can free it */
pfree(dir_path);
/* Complete initialization of the entry with post-acquire actions */
Assert(NULL != newEntry);
workfile_set *work_set = CACHE_ENTRY_PAYLOAD(newEntry);
Assert(work_set != NULL);
elog(gp_workfile_caching_loglevel, "new spill file set. key=0x%x prefix=%s opMemKB=" INT64_FORMAT,
work_set->key, work_set->path, work_set->metadata.operator_work_mem);
return work_set;
}
/*
* Thoroughly checks if an existing workfile_set can be used for the current
* subplan.
*/
bool
workfile_mgr_can_reuse(workfile_set *work_set, PlanState *ps)
{
Assert(NULL != work_set);
Assert(NULL != ps);
uint64 operatorMemKB = get_operator_work_mem(ps);
Assert(operatorMemKB > 0);
if (operatorMemKB < work_set->metadata.operator_work_mem)
{
return false;
}
return true;
}
/*
* Look up file set the cache given a certain PlanState.
* Return NULL if not found.
*/
static workfile_set *
workfile_mgr_lookup_set(PlanState *ps)
{
Assert(NULL != ps);
Assert(NULL != workfile_mgr_cache);
Assert(NULL != ps->plan);
Assert(nodeTag(ps->plan) >= T_Plan && nodeTag(ps->plan) < T_PlanInvalItem);
/* Create parameter info for the populate function */
workset_info set_info;
set_info.dir_path = NULL;
set_info.operator_work_mem = get_operator_work_mem(ps);
set_info.on_disk = false;
CacheEntry *localEntry = acquire_entry_retry(workfile_mgr_cache, &set_info);
Assert(localEntry != NULL);
workfile_set *local_work_set = (workfile_set *) CACHE_ENTRY_PAYLOAD(localEntry);
/* Populate the rest of the entries needed for look-up
* Allocate the serialized plan in the TopMemoryContext since this memory
* context is still available when calling the transaction callback at the
* time when the transaction aborts.
*/
MemoryContext oldcxt = MemoryContextSwitchTo(TopMemoryContext);
workfile_set_plan *s_plan = workfile_mgr_serialize_plan(ps);
MemoryContextSwitchTo(oldcxt);
Assert(s_plan != NULL);
local_work_set->set_plan = s_plan;
local_work_set->key = workfile_mgr_hash_key(s_plan);
CacheEntry *cachedEntry = Cache_Lookup(workfile_mgr_cache, localEntry);
/* Release local entry and free up plan memory. We don't need it anymore */
Cache_Release(workfile_mgr_cache, localEntry);
workfile_set *work_set = NULL;
if (NULL != cachedEntry)
{
work_set = (workfile_set *) CACHE_ENTRY_PAYLOAD(cachedEntry);
}
return work_set;
}
/*
* Create a new file set
* type is the WorkFileType for the files: BUFFILE or BFZ
* can_be_reused: if set to false, then we don't insert this set into the cache,
* since the caller is telling us there is no point. This can happen for
* example when spilling during index creation.
* ps is the PlanState for the subtree rooted at the operator
* snapshot contains snapshot information for the current transaction
*
*/
workfile_set *
workfile_mgr_create_set(enum ExecWorkFileType type, bool can_be_reused, PlanState *ps, workfile_set_snapshot snapshot)
{
Assert(NULL != workfile_mgr_cache);
Plan *plan = NULL;
if (ps != NULL)
{
plan = ps->plan;
}
AssertImply(can_be_reused, plan != NULL);
NodeTag node_type = T_Invalid;
if (ps != NULL)
{
node_type = ps->type;
}
char *dir_path = create_workset_directory(node_type, currentSliceId);
/* Create parameter info for the populate function */
workset_info set_info;
set_info.file_type = type;
set_info.snapshot = snapshot;
set_info.nodeType = node_type;
set_info.can_be_reused = can_be_reused && workfile_mgr_is_reusable(ps);
set_info.dir_path = dir_path;
set_info.session_start_time = GetCurrentTimestamp();
set_info.operator_work_mem = get_operator_work_mem(ps);
set_info.on_disk = true;
CacheEntry *newEntry = NULL;
PG_TRY();
{
newEntry = acquire_entry_retry(workfile_mgr_cache, &set_info);
}
PG_CATCH();
{
/* Failed to acquire new entry, cache full. Clean up the directory we created. */
workfile_mgr_delete_set_directory(dir_path);
PG_RE_THROW();
}
PG_END_TRY();
/* Path has now been copied to the workfile_set. We can free it */
pfree(dir_path);
/* Complete initialization of the entry with post-acquire actions */
Assert(NULL != newEntry);
workfile_set *work_set = CACHE_ENTRY_PAYLOAD(newEntry);
Assert(work_set != NULL);
if (work_set->can_be_reused)
{
Assert(plan != NULL);
Assert(nodeTag(plan) >= T_Plan && nodeTag(plan) < T_PlanInvalItem);
workfile_set_plan *s_plan = workfile_mgr_serialize_plan(ps);
work_set->key = workfile_mgr_hash_key(s_plan);
workfile_mgr_save_plan(work_set, s_plan);
workfile_mgr_free_plan(s_plan);
}
elog(gp_workfile_caching_loglevel, "new spill file set. key=0x%x can_be_reused=%d prefix=%s opMemKB=" INT64_FORMAT,
work_set->key, work_set->can_be_reused, work_set->path, work_set->metadata.operator_work_mem);
return work_set;
}
