/*
* 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);
}
/*
* Close a spill file set. If we're planning to re-use it, insert it in the
* cache. If not, let the cleanup routine delete the files and free up memory.
*/
void
workfile_mgr_close_set(workfile_set *work_set)
{
Assert(work_set!=NULL);
elog(gp_workfile_caching_loglevel, "closing workfile set: can_be_reused=%d complete=%d location: %s, size=" INT64_FORMAT
" in_progress_size=" INT64_FORMAT,
work_set->can_be_reused, work_set->complete, work_set->path,
work_set->size, work_set->in_progress_size);
CacheEntry *cache_entry = CACHE_ENTRY_HEADER(work_set);
if (Cache_IsCached(cache_entry))
{
/* Workset came from cache. Just release it, nothing to do */
Cache_Release(workfile_mgr_cache, cache_entry);
return;
}
if (work_set->complete && work_set->can_be_reused)
{
cache_entry->size = work_set->size;
/* We want to keep this one around. Insert into cache */
Cache_Insert(workfile_mgr_cache, cache_entry);
Cache_Release(workfile_mgr_cache, cache_entry);
return;
}
/*
* Fall-through case: We need to delete this work_set, as it's not reusable.
*/
Assert(!work_set->complete || !work_set->can_be_reused);
Cache_Release(workfile_mgr_cache, cache_entry);
}
/*
* 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);
}
