/*
* Add or update an entry in the Global MDVSN cache for a versioning event
* found in the event list. Reconcile with current contents of the cache
* if needed.
* event: The event containing the versioning information for an update
*/
static void
mdver_globalhandler_add_version(mdver_event *event)
{
Assert(NULL != event);
Cache *glob_mdvsn = mdver_get_glob_mdvsn();
if (mdver_is_nuke_event(event))
{
mdver_glob_mdvsn_nuke();
return;
}
mdver_entry mdver = { InvalidOid, INVALID_MD_VERSION, INVALID_MD_VERSION };
mdver.key = event->key;
mdver.ddl_version = INVALID_MD_VERSION;
mdver.dml_version = INVALID_MD_VERSION;
/* FIXME gcaragea 04/14/2014: Trigger evictions if cache is full (MPP-22923) */
CacheEntry *acquired_entry = Cache_AcquireEntry(glob_mdvsn, &mdver);
Assert(NULL != acquired_entry);
/*
* We're about to look-up and insert/update a shared cache entry.
* Grab writer lock in exclusive mode, so that no other backend
* tries to insert or update the same entry at the same time.
*/
LWLockAcquire(MDVerWriteLock, LW_EXCLUSIVE);
CacheEntry *cached_entry = Cache_Lookup(glob_mdvsn, acquired_entry);
if (NULL != cached_entry)
{
mdver_globalhandler_reconcile(event, cached_entry);
/* Done with the looked-up entry. Release it */
Cache_Release(glob_mdvsn, cached_entry);
}
else
{
/* Entry not found, insert new entry */
mdver_entry *new_mdver_entry = CACHE_ENTRY_PAYLOAD(acquired_entry);
#ifdef MD_VERSIONING_INSTRUMENTATION
elog(gp_mdversioning_loglevel, "Inserting into GlobalMDVSN entry %d: (%d,%d)",
event->key,
(int) event->new_ddl_version, (int) event->new_dml_version);
#endif
new_mdver_entry->ddl_version = event->new_ddl_version;
new_mdver_entry->dml_version = event->new_dml_version;
Cache_Insert(glob_mdvsn, acquired_entry);
}
Cache_Release(glob_mdvsn, acquired_entry);
LWLockRelease(MDVerWriteLock);
}
/*
* 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;
}
/*
* Look up an entry in the Global MDVSN component.
* To avoid any concurrency issues, this returns a copy of the entry,
* palloc'ed in the current memory context. The caller is responsible
* for freeing this copy.
*
* Returns a copy of the entry if found, NULL otherwise.
*
*/
mdver_entry *
mdver_glob_mdvsn_find(Oid oid)
{
Assert(NULL != mdver_glob_mdvsn);
mdver_entry mdver_info;
mdver_info.key = oid;
/* FIXME gcaragea 03/18/2014: Trigger evictions if cache is full (MPP-22923) */
CacheEntry *localEntry = Cache_AcquireEntry(mdver_glob_mdvsn, &mdver_info);
Assert(NULL != localEntry);
CacheEntry *cachedEntry = Cache_Lookup(mdver_glob_mdvsn, localEntry);
/* Release local entry. We don't need it anymore */
Cache_Release(mdver_glob_mdvsn, localEntry);
mdver_entry *mdver_copy = NULL;
if (NULL != cachedEntry)
{
/* Found a match. Make a local copy */
mdver_entry *shared_mdver = (mdver_entry *) CACHE_ENTRY_PAYLOAD(cachedEntry);
mdver_copy = (mdver_entry *) palloc0(sizeof(mdver_entry));
/* Lock entry to ensure atomicity of copy */
Cache_LockEntry(mdver_glob_mdvsn, cachedEntry);
memcpy(mdver_copy, shared_mdver, sizeof(mdver_entry));
/* Got the copy, unlock entry */
Cache_UnlockEntry(mdver_glob_mdvsn, cachedEntry);
/*
* We're also done with the entry, release our pincount on it
*
* TODO gcaragea 05/02/2014: Are there cases where we need to hold the
* entry past this point? (MPP-22923)
*/
Cache_Release(mdver_glob_mdvsn, cachedEntry);
}
return mdver_copy;
}
/*
* When a backend is requesting the more recent version of an object,
* if the Local MDVSN cache doesn't have the version, and if a NUKE event
* hasn't been encountered in the current transaction, it is looked up
* in the Global MDVSN shared cache.
*
* If the object is found in Global MDVSN, return the global version.
* If the object is not found, generate a new version, record it in Global MDVSN
* and then return it.
*
* key: The key of the looked-up object
* ddl_version: used to return the ddl version for the object
* dml_version: used to return the dml version for the object
*
*/
static void
mdver_request_from_global(Oid key, uint64 *ddl_version, uint64 *dml_version)
{
Assert(NULL != ddl_version);
Assert(NULL != dml_version);
Cache *mdver_glob_mdvsn = mdver_get_glob_mdvsn();
Assert(NULL != mdver_glob_mdvsn);
mdver_entry entry = {key, INVALID_MD_VERSION, INVALID_MD_VERSION};
/* FIXME gcaragea 06/03/2014: Trigger evictions if cache is full (MPP-22923) */
CacheEntry *localEntry = Cache_AcquireEntry(mdver_glob_mdvsn, &entry);
Assert(NULL != localEntry);
/*
* We're about to look-up and insert a shared cache entry.
* Grab writer lock in exclusive mode, so that no other backend
* can insert or update the same entry at the same time.
*/
LWLockAcquire(MDVerWriteLock, LW_EXCLUSIVE);
CacheEntry *cachedEntry = Cache_Lookup(mdver_glob_mdvsn, localEntry);
if (NULL != cachedEntry)
{
/* Not found in LVSN, not nuke happened, eventually found in GVSN */
mdver_entry *crt_entry = CACHE_ENTRY_PAYLOAD(cachedEntry);
*ddl_version = crt_entry->ddl_version;
*dml_version = crt_entry->dml_version;
#ifdef MD_VERSIONING_INSTRUMENTATION
elog(gp_mdversioning_loglevel, "Found version in Global MDVSN: (%d, " UINT64_FORMAT ", " UINT64_FORMAT "). Adding it to Local MDVSN",
key, crt_entry->ddl_version, crt_entry->dml_version);
#endif
/*
* We're also done with the entry, release our pincount on it
*
* TODO gcaragea 05/02/2014: Are there cases where we need to hold the
* entry past this point? (MPP-22923)
*/
Cache_Release(mdver_glob_mdvsn, cachedEntry);
}
else
{
/* Not found in LVSN, not nuke happened, not found in GVSN either */
/* Generate new version */
*ddl_version = mdver_next_global_version();
*dml_version = mdver_next_global_version();
/* Add to GVSN */
mdver_entry *new_entry = CACHE_ENTRY_PAYLOAD(localEntry);
new_entry->ddl_version = *ddl_version;
new_entry->dml_version = *dml_version;
#ifdef MD_VERSIONING_INSTRUMENTATION
elog(gp_mdversioning_loglevel, "Inserting new version in Global MDVSN: (%d, " UINT64_FORMAT ", " UINT64_FORMAT "). Adding it to Local MDVSN",
key, new_entry->ddl_version, new_entry->dml_version);
#endif
Cache_Insert(mdver_glob_mdvsn, localEntry);
}
LWLockRelease(MDVerWriteLock);
/* Release local entry. We don't need it anymore */
Cache_Release(mdver_glob_mdvsn, localEntry);
}
