void ObjectMemory::inflate_for_handle(STATE, ObjectHeader* obj, capi::Handle* handle) {
utilities::thread::SpinLock::LockGuard guard(inflation_lock_);
HeaderWord orig = obj->header;
if(orig.f.meaning == eAuxWordInflated) {
obj->inflated_header(state)->set_handle(state, handle);
return;
}
uint32_t ih_index = 0;
InflatedHeader* ih = inflated_headers_->allocate(state, obj, &ih_index);
ih->update(state, orig);
ih->set_handle(state, handle);
ih->mark(this, mark_);
while(!obj->set_inflated_header(state, ih_index, orig)) {
orig = obj->header;
if(orig.f.meaning == eAuxWordInflated) {
obj->inflated_header(state)->set_handle(state, handle);
ih->clear();
return;
}
ih->update(state, orig);
ih->set_handle(state, handle);
}
}
bool ObjectMemory::inflate_lock_count_overflow(STATE, ObjectHeader* obj,
int count)
{
utilities::thread::SpinLock::LockGuard guard(inflation_lock_);
HeaderWord orig = obj->header;
if(orig.f.meaning == eAuxWordInflated) {
return false;
}
uint32_t ih_header = 0;
InflatedHeader* ih = inflated_headers_->allocate(state, obj, &ih_header);
ih->update(state, orig);
ih->initialize_mutex(state->vm()->thread_id(), count);
ih->mark(this, mark_);
while(!obj->set_inflated_header(state, ih_header, orig)) {
orig = obj->header;
if(orig.f.meaning == eAuxWordInflated) {
return false;
}
ih->update(state, orig);
ih->initialize_mutex(state->vm()->thread_id(), count);
}
return true;
}
bool ObjectMemory::inflate_for_contention(STATE, ObjectHeader* obj) {
utilities::thread::SpinLock::LockGuard guard(inflation_lock_);
for(;;) {
HeaderWord orig = obj->header;
InflatedHeader* ih = 0;
uint32_t ih_header = 0;
switch(orig.f.meaning) {
case eAuxWordEmpty:
ih = inflated_headers_->allocate(state, obj, &ih_header);
break;
case eAuxWordObjID:
// We could be have made a header before trying again, so
// keep using the original one.
ih = inflated_headers_->allocate(state, obj, &ih_header);
ih->set_object_id(orig.f.aux_word);
break;
case eAuxWordHandle:
ih = inflated_headers_->allocate(state, obj, &ih_header);
ih->set_handle(state, obj->handle(state));
break;
case eAuxWordLock:
// We have to be locking the object to inflate it, thats the law.
if(orig.f.aux_word >> cAuxLockTIDShift != state->vm()->thread_id()) {
if(cDebugThreading) {
std::cerr << "[LOCK " << state->vm()->thread_id() << " object locked by another thread while inflating for contention]" << std::endl;
}
return false;
}
if(cDebugThreading) {
std::cerr << "[LOCK " << state->vm()->thread_id() << " being unlocked and inflated atomicly]" << std::endl;
}
ih = inflated_headers_->allocate(state, obj, &ih_header);
break;
case eAuxWordInflated:
if(cDebugThreading) {
std::cerr << "[LOCK " << state->vm()->thread_id() << " asked to inflated already inflated lock]" << std::endl;
}
return false;
}
ih->mark(this, mark_);
// Try it all over again if it fails.
if(!obj->set_inflated_header(state, ih_header, orig)) {
ih->clear();
continue;
}
obj->clear_lock_contended();
if(cDebugThreading) {
std::cerr << "[LOCK " << state->vm()->thread_id() << " inflated lock for contention.]" << std::endl;
}
// Now inflated but not locked, which is what we want.
return true;
}
}
bool ObjectMemory::inflate_and_lock(STATE, ObjectHeader* obj) {
utilities::thread::SpinLock::LockGuard guard(inflation_lock_);
InflatedHeader* ih = 0;
uint32_t ih_index = 0;
int initial_count = 0;
HeaderWord orig = obj->header;
switch(orig.f.meaning) {
case eAuxWordEmpty:
// ERROR, we can not be here because it's empty. This is only to
// be called when the header is already in use.
return false;
case eAuxWordObjID:
// We could be have made a header before trying again, so
// keep using the original one.
ih = inflated_headers_->allocate(state, obj, &ih_index);
ih->set_object_id(orig.f.aux_word);
break;
case eAuxWordLock:
// We have to locking the object to inflate it, thats the law.
if(orig.f.aux_word >> cAuxLockTIDShift != state->vm()->thread_id()) {
return false;
}
ih = inflated_headers_->allocate(state, obj, &ih_index);
initial_count = orig.f.aux_word & cAuxLockRecCountMask;
break;
case eAuxWordHandle:
// Handle in use so inflate and update handle
ih = inflated_headers_->allocate(state, obj, &ih_index);
ih->set_handle(state, obj->handle(state));
break;
case eAuxWordInflated:
// Already inflated. ERROR, let the caller sort it out.
if(cDebugThreading) {
std::cerr << "[LOCK " << state->vm()->thread_id() << " asked to inflated already inflated lock]" << std::endl;
}
return false;
}
ih->initialize_mutex(state->vm()->thread_id(), initial_count);
ih->mark(this, mark_);
while(!obj->set_inflated_header(state, ih_index, orig)) {
// The header can't have been inflated by another thread, the
// inflation process holds the OM lock.
//
// So some other bits must have changed, so lets just spin and
// keep trying to update it.
// Sanity check that the meaning is still the same, if not, then
// something is really wrong.
if(orig.f.meaning != obj->header.f.meaning) {
if(cDebugThreading) {
std::cerr << "[LOCK object header consistence error detected.]" << std::endl;
}
return false;
}
orig = obj->header;
if(orig.f.meaning == eAuxWordInflated) {
return false;
}
}
return true;
}
