void CollisionWorld::removeManifoldLookup(CollisionObject* a, CollisionObject* b)
{
int ia = a->mID;
int ib = b->mID;
if (ib<ia)
{
int iat = ia;
ia = ib;
ib = iat;
}
int hval = hash(ia, ib);
if (!mManifoldLookup[hval%mManifoldBuckets].first())
return;
LinkedListNode<ContactManifold*>* node = mManifoldLookup[hval%mManifoldBuckets].first();
ContactManifold* m = 0;
while (node)
{
m = node->item();
if ((m->getA() == a && m->getB() == b) || (m->getA() == b && m->getB() == a))
{
mManifoldLookup[hval%mManifoldBuckets].remove(node);
return;
}
node = node->next();
}
}
bool VirtualMemoryTracker::add_reserved_region(address base_addr, size_t size,
const NativeCallStack& stack, MEMFLAGS flag, bool all_committed) {
assert(base_addr != NULL, "Invalid address");
assert(size > 0, "Invalid size");
assert(_reserved_regions != NULL, "Sanity check");
ReservedMemoryRegion rgn(base_addr, size, stack, flag);
ReservedMemoryRegion* reserved_rgn = _reserved_regions->find(rgn);
LinkedListNode<ReservedMemoryRegion>* node;
if (reserved_rgn == NULL) {
VirtualMemorySummary::record_reserved_memory(size, flag);
node = _reserved_regions->add(rgn);
if (node != NULL) {
node->data()->set_all_committed(all_committed);
return true;
} else {
return false;
}
} else {
if (reserved_rgn->same_region(base_addr, size)) {
reserved_rgn->set_call_stack(stack);
reserved_rgn->set_flag(flag);
return true;
} else if (reserved_rgn->adjacent_to(base_addr, size)) {
VirtualMemorySummary::record_reserved_memory(size, flag);
reserved_rgn->expand_region(base_addr, size);
reserved_rgn->set_call_stack(stack);
return true;
} else {
// Overlapped reservation.
// It can happen when the regions are thread stacks, as JNI
// thread does not detach from VM before exits, and leads to
// leak JavaThread object
if (reserved_rgn->flag() == mtThreadStack) {
guarantee(!CheckJNICalls, "Attached JNI thread exited without being detached");
// Overwrite with new region
// Release old region
VirtualMemorySummary::record_uncommitted_memory(reserved_rgn->committed_size(), reserved_rgn->flag());
VirtualMemorySummary::record_released_memory(reserved_rgn->size(), reserved_rgn->flag());
// Add new region
VirtualMemorySummary::record_reserved_memory(rgn.size(), flag);
*reserved_rgn = rgn;
return true;
}
// CDS mapping region.
// CDS reserves the whole region for mapping CDS archive, then maps each section into the region.
// NMT reports CDS as a whole.
if (reserved_rgn->flag() == mtClassShared) {
assert(reserved_rgn->contain_region(base_addr, size), "Reserved CDS region should contain this mapping region");
return true;
}
ShouldNotReachHere();
return false;
}
}
}
ContactManifold *CollisionWorld::findManifold(CollisionObject *a, CollisionObject *b)
{
GIMBLE_HANDLE ia = a->mID;
GIMBLE_HANDLE ib = b->mID;
if (ib<ia)
{
GIMBLE_HANDLE iat = ia;
ia = ib;
ib = iat;
}
int hval = hash(ia, ib);
if (!mManifoldLookup[hval%mManifoldBuckets].first())
return 0;
LinkedListNode<ContactManifold*> *node = mManifoldLookup[hval%mManifoldBuckets].first();
ContactManifold *m = 0;
while (node)
{
m = node->item();
if ((m->getA() == a && m->getB() == b) || (m->getA() == b && m->getB() == a))
return m;
node = node->next();
}
return 0;
}
bool SinglyLinkedList<Type>::remove(int key) {
if (size <= 0) {
return false;
}
LinkedListNode<Type>* pLoc = head;
LinkedListNode<Type>* pPre = nullptr;
while (pLoc->next != nullptr && pLoc->getKey() != key) {
Efficiency::totalDataStructureOperations++;
pPre = pLoc;
pLoc = pLoc->next;
}
if (pLoc->getKey() != key) return false;
if (pLoc == head) {
Efficiency::totalDataStructureOperations++;
head = pLoc->next;
size--;
return true;
}
pPre->next = pLoc->next;
if (pPre->next == nullptr) rear = pPre;
delete pLoc;
size--;
Efficiency::totalDataStructureOperations++;
return true;
}
void LinkedList<T>::add(T *data)
{
if(this->list == NULL)
this->list = new LinkedListNode<T>(data);
else
{
LinkedListNode<T> *carriage = this->list;
for(; carriage != NULL; carriage = carriage->next());
}
}
Type SinglyLinkedList<Type>::get(int key) {
LinkedListNode<Type>* pLoc = head;
while (pLoc != nullptr) {
if (pLoc->getKey() == key) {
Efficiency::totalDataStructureOperations++;
return pLoc->getData();
}
Efficiency::totalDataStructureOperations++;
pLoc = pLoc->next;
}
throw "not found";
}
vector<Type> SinglyLinkedList<Type>::convertToVector() {
vector<Type> v;
if (size == 0) return v;
LinkedListNode<Type>* pLoc = head;
while (pLoc->next != nullptr) {
Efficiency::totalDataStructureOperations++;
v.push_back(pLoc->getData());
pLoc = pLoc->next;
}
Efficiency::totalDataStructureOperations++;
v.push_back(pLoc->getData());
return v;
}
size_t ReservedMemoryRegion::committed_size() const {
if (all_committed()) {
return size();
} else {
size_t committed = 0;
LinkedListNode<CommittedMemoryRegion>* head =
_committed_regions.head();
while (head != NULL) {
committed += head->data()->size();
head = head->next();
}
return committed;
}
}
bool VirtualMemoryTracker::walk_virtual_memory(VirtualMemoryWalker* walker) {
assert(_reserved_regions != NULL, "Sanity check");
ThreadCritical tc;
// Check that the _reserved_regions haven't been deleted.
if (_reserved_regions != NULL) {
LinkedListNode<ReservedMemoryRegion>* head = _reserved_regions->head();
while (head != NULL) {
const ReservedMemoryRegion* rgn = head->peek();
if (!walker->do_allocation_site(rgn)) {
return false;
}
head = head->next();
}
}
return true;
}
void print()
{
std::cout << data;
if (next != nullptr)
{
next->print();
}
}
bool ReservedMemoryRegion::add_committed_region(address addr, size_t size, const NativeCallStack& stack) {
assert(addr != NULL, "Invalid address");
assert(size > 0, "Invalid size");
assert(contain_region(addr, size), "Not contain this region");
if (all_committed()) return true;
CommittedMemoryRegion committed_rgn(addr, size, stack);
LinkedListNode<CommittedMemoryRegion>* node = _committed_regions.head();
while (node != NULL) {
CommittedMemoryRegion* rgn = node->data();
if (rgn->same_region(addr, size)) {
return true;
}
if (rgn->adjacent_to(addr, size)) {
// special case to expand prior region if there is no next region
LinkedListNode<CommittedMemoryRegion>* next = node->next();
if (next == NULL && rgn->call_stack()->equals(stack)) {
VirtualMemorySummary::record_uncommitted_memory(rgn->size(), flag());
// the two adjacent regions have the same call stack, merge them
rgn->expand_region(addr, size);
VirtualMemorySummary::record_committed_memory(rgn->size(), flag());
return true;
}
}
if (rgn->overlap_region(addr, size)) {
// Clear a space for this region in the case it overlaps with any regions.
remove_uncommitted_region(addr, size);
break; // commit below
}
if (rgn->end() >= addr + size){
break;
}
node = node->next();
}
// New committed region
VirtualMemorySummary::record_committed_memory(size, flag());
return add_committed_region(committed_rgn);
}
void ReservedMemoryRegion::move_committed_regions(address addr, ReservedMemoryRegion& rgn) {
assert(addr != NULL, "Invalid address");
// split committed regions
LinkedListNode<CommittedMemoryRegion>* head =
_committed_regions.head();
LinkedListNode<CommittedMemoryRegion>* prev = NULL;
while (head != NULL) {
if (head->data()->base() >= addr) {
break;
}
prev = head;
head = head->next();
}
if (head != NULL) {
if (prev != NULL) {
prev->set_next(head->next());
} else {
_committed_regions.set_head(NULL);
}
}
rgn._committed_regions.set_head(head);
}
bool ReservedMemoryRegion::add_committed_region(address addr, size_t size, const NativeCallStack& stack) {
assert(addr != NULL, "Invalid address");
assert(size > 0, "Invalid size");
assert(contain_region(addr, size), "Not contain this region");
if (all_committed()) return true;
CommittedMemoryRegion committed_rgn(addr, size, stack);
LinkedListNode<CommittedMemoryRegion>* node = _committed_regions.find_node(committed_rgn);
if (node != NULL) {
CommittedMemoryRegion* rgn = node->data();
if (rgn->same_region(addr, size)) {
return true;
}
if (rgn->adjacent_to(addr, size)) {
// check if the next region covers this committed region,
// the regions may not be merged due to different call stacks
LinkedListNode<CommittedMemoryRegion>* next =
node->next();
if (next != NULL && next->data()->contain_region(addr, size)) {
if (next->data()->same_region(addr, size)) {
next->data()->set_call_stack(stack);
}
return true;
}
if (rgn->call_stack()->equals(stack)) {
VirtualMemorySummary::record_uncommitted_memory(rgn->size(), flag());
// the two adjacent regions have the same call stack, merge them
rgn->expand_region(addr, size);
VirtualMemorySummary::record_committed_memory(rgn->size(), flag());
return true;
}
VirtualMemorySummary::record_committed_memory(size, flag());
if (rgn->base() > addr) {
return _committed_regions.insert_before(committed_rgn, node) != NULL;
} else {
return _committed_regions.insert_after(committed_rgn, node) != NULL;
}
}
assert(rgn->contain_region(addr, size), "Must cover this region");
return true;
} else {
// New committed region
VirtualMemorySummary::record_committed_memory(size, flag());
return add_committed_region(committed_rgn);
}
}
bool ReservedMemoryRegion::remove_uncommitted_region(address addr, size_t sz) {
// uncommit stack guard pages
if (flag() == mtThreadStack && !same_region(addr, sz)) {
return true;
}
assert(addr != NULL, "Invalid address");
assert(sz > 0, "Invalid size");
if (all_committed()) {
assert(_committed_regions.is_empty(), "Sanity check");
assert(contain_region(addr, sz), "Reserved region does not contain this region");
set_all_committed(false);
VirtualMemorySummary::record_uncommitted_memory(sz, flag());
if (same_region(addr, sz)) {
return true;
} else {
CommittedMemoryRegion rgn(base(), size(), *call_stack());
if (rgn.base() == addr || rgn.end() == (addr + sz)) {
rgn.exclude_region(addr, sz);
return add_committed_region(rgn);
} else {
// split this region
// top of the whole region
address top =rgn.end();
// use this region for lower part
size_t exclude_size = rgn.end() - addr;
rgn.exclude_region(addr, exclude_size);
if (add_committed_region(rgn)) {
// higher part
address high_base = addr + sz;
size_t high_size = top - high_base;
CommittedMemoryRegion high_rgn(high_base, high_size, NativeCallStack::EMPTY_STACK);
return add_committed_region(high_rgn);
} else {
return false;
}
}
}
} else {
// we have to walk whole list to remove the committed regions in
// specified range
LinkedListNode<CommittedMemoryRegion>* head =
_committed_regions.head();
LinkedListNode<CommittedMemoryRegion>* prev = NULL;
VirtualMemoryRegion uncommitted_rgn(addr, sz);
while (head != NULL && !uncommitted_rgn.is_empty()) {
CommittedMemoryRegion* crgn = head->data();
// this committed region overlaps to region to uncommit
if (crgn->overlap_region(uncommitted_rgn.base(), uncommitted_rgn.size())) {
if (crgn->same_region(uncommitted_rgn.base(), uncommitted_rgn.size())) {
// find matched region, remove the node will do
VirtualMemorySummary::record_uncommitted_memory(uncommitted_rgn.size(), flag());
_committed_regions.remove_after(prev);
return true;
} else if (crgn->contain_region(uncommitted_rgn.base(), uncommitted_rgn.size())) {
// this committed region contains whole uncommitted region
VirtualMemorySummary::record_uncommitted_memory(uncommitted_rgn.size(), flag());
return remove_uncommitted_region(head, uncommitted_rgn.base(), uncommitted_rgn.size());
} else if (uncommitted_rgn.contain_region(crgn->base(), crgn->size())) {
// this committed region has been uncommitted
size_t exclude_size = crgn->end() - uncommitted_rgn.base();
uncommitted_rgn.exclude_region(uncommitted_rgn.base(), exclude_size);
VirtualMemorySummary::record_uncommitted_memory(crgn->size(), flag());
LinkedListNode<CommittedMemoryRegion>* tmp = head;
head = head->next();
_committed_regions.remove_after(prev);
continue;
} else if (crgn->contain_address(uncommitted_rgn.base())) {
size_t toUncommitted = crgn->end() - uncommitted_rgn.base();
crgn->exclude_region(uncommitted_rgn.base(), toUncommitted);
uncommitted_rgn.exclude_region(uncommitted_rgn.base(), toUncommitted);
VirtualMemorySummary::record_uncommitted_memory(toUncommitted, flag());
} else if (uncommitted_rgn.contain_address(crgn->base())) {
size_t toUncommitted = uncommitted_rgn.end() - crgn->base();
crgn->exclude_region(crgn->base(), toUncommitted);
uncommitted_rgn.exclude_region(uncommitted_rgn.end() - toUncommitted,
toUncommitted);
VirtualMemorySummary::record_uncommitted_memory(toUncommitted, flag());
}
}
prev = head;
head = head->next();
}
}
return true;
}
bool ReservedMemoryRegion::remove_uncommitted_region(address addr, size_t sz) {
// uncommit stack guard pages
if (flag() == mtThreadStack && !same_region(addr, sz)) {
return true;
}
assert(addr != NULL, "Invalid address");
assert(sz > 0, "Invalid size");
if (all_committed()) {
assert(_committed_regions.is_empty(), "Sanity check");
assert(contain_region(addr, sz), "Reserved region does not contain this region");
set_all_committed(false);
VirtualMemorySummary::record_uncommitted_memory(sz, flag());
if (same_region(addr, sz)) {
return true;
} else {
CommittedMemoryRegion rgn(base(), size(), *call_stack());
if (rgn.base() == addr || rgn.end() == (addr + sz)) {
rgn.exclude_region(addr, sz);
return add_committed_region(rgn);
} else {
// split this region
// top of the whole region
address top =rgn.end();
// use this region for lower part
size_t exclude_size = rgn.end() - addr;
rgn.exclude_region(addr, exclude_size);
if (add_committed_region(rgn)) {
// higher part
address high_base = addr + sz;
size_t high_size = top - high_base;
CommittedMemoryRegion high_rgn(high_base, high_size, NativeCallStack::EMPTY_STACK);
return add_committed_region(high_rgn);
} else {
return false;
}
}
}
} else {
CommittedMemoryRegion del_rgn(addr, sz, *call_stack());
address end = addr + sz;
LinkedListNode<CommittedMemoryRegion>* head = _committed_regions.head();
LinkedListNode<CommittedMemoryRegion>* prev = NULL;
CommittedMemoryRegion* crgn;
while (head != NULL) {
crgn = head->data();
if (crgn->same_region(addr, sz)) {
VirtualMemorySummary::record_uncommitted_memory(crgn->size(), flag());
_committed_regions.remove_after(prev);
return true;
}
// del_rgn contains crgn
if (del_rgn.contain_region(crgn->base(), crgn->size())) {
VirtualMemorySummary::record_uncommitted_memory(crgn->size(), flag());
head = head->next();
_committed_regions.remove_after(prev);
continue; // don't update head or prev
}
// Found addr in the current crgn. There are 2 subcases:
if (crgn->contain_address(addr)) {
// (1) Found addr+size in current crgn as well. (del_rgn is contained in crgn)
if (crgn->contain_address(end - 1)) {
VirtualMemorySummary::record_uncommitted_memory(sz, flag());
return remove_uncommitted_region(head, addr, sz); // done!
} else {
// (2) Did not find del_rgn's end in crgn.
size_t size = crgn->end() - del_rgn.base();
crgn->exclude_region(addr, size);
VirtualMemorySummary::record_uncommitted_memory(size, flag());
}
} else if (crgn->contain_address(end - 1)) {
// Found del_rgn's end, but not its base addr.
size_t size = del_rgn.end() - crgn->base();
crgn->exclude_region(crgn->base(), size);
VirtualMemorySummary::record_uncommitted_memory(size, flag());
return true; // should be done if the list is sorted properly!
}
prev = head;
head = head->next();
}
}
return true;
}
bool stageInGame::update() {
if (keyboard::isKeyPressed(KEY_ESC)) {
BITMAP *preview = create_bitmap(SCREEN_W, SCREEN_H);
draw(preview);
globalData::gameCurrentStage = new stageInGameMenu(this, preview);
return STAGE_RUNNING;
}
if (keyboard::isKeyPressed(KEY_P)) {
BITMAP *preview = create_bitmap(SCREEN_W, SCREEN_H);
draw(preview);
globalData::gameCurrentStage = new stagePauseMenu(this, preview);
return STAGE_RUNNING;
}
if (clock() > inputSpawnNext) {
bool success = loadObjects();
if (!success) return STAGE_OVER;
}
if (myBullet != NULL) {
bool K = myBullet->update(&objListAsteroid, &objListParticle);
if (!K) {
delete myBullet;
myBullet = NULL;
}
}
if (gameLevelScoreUpdate < time(NULL)) {
gameScore ++;
gameLevelScoreUpdate = time(NULL);
}
updateObjectList(objListAsteroid.getFirst());
updateObjectList(objListParticle.getFirst());
updateHud();
///This here should be put somewhere, integrate into asteroid update or somthing,
///looping through the asteroids again is quite ineffecient.
LinkedListNode<ObjectInterface*>* Node = objListAsteroid.getFirst();
while(Node != NULL) {
objAsteroid* obj = (objAsteroid*)Node->getValue();
if (obj->Y > BASE_Y_COORDINATE) {
gameLife -= obj->Life/2;
obj->Life = -1;
drawDamage = 5;
}
Node = Node->getNext();
}
///---
if (!hudTargetLocked) {
currentUserInput = "";
}
else
{
currentUserInput = updateUserInput(currentUserInput);
}
if ((keyboard::isKeyPressed(KEY_ENTER) || keyboard::isKeyPressed(KEY_ENTER_PAD)) && hudTargetLocked && myBullet == NULL) {
int numericUserInput = 0;
istringstream stringConvertion (currentUserInput, istringstream::in);
stringConvertion >> numericUserInput;
if (numericUserInput == currentAnswer) {
myBullet = new objBullet(TURRET_X, TURRET_Y, hudTargetX, hudTargetY, hudTurretDirection, 50);
hudTargetLocked = false;
}
else
{
generateQuestion();
}
currentUserInput = "";
}
