void Thread::Dealloc() {
AssertNoncritical();
// destroy all the ports on this thread
for (int i = 0; i < portList.GetMap().GetBucketCount(); ++i) {
auto & bucket = portList.GetMap().GetBucket(i);
for (auto j = bucket.GetStart(); j != bucket.GetEnd(); ++j) {
ThreadPort & p = *j;
p.Sever();
p.Dealloc(false);
}
}
if (inScheduler) {
GetTask().GetScheduler().Remove(*this);
}
if (killed) {
if (inTask) {
GetTask().GetThreadList().Remove(*this);
}
GetTask().Release();
}
delete this;
}
void * operator new(size_t s) {
AssertNoncritical();
void * result;
if (!anarch::Domain::GetCurrent().Alloc(result, s)) {
return NULL;
}
return result;
}
void GarbageCollector::Main() {
AssertNoncritical();
while (1) {
anarch::SetCritical(true);
objectsLock.Seize();
GarbageObject * obj = objects.Shift();
if (!obj) {
scheduler.SetInfiniteTimeout(objectsLock);
anarch::SetCritical(false);
} else {
objectsLock.Release();
anarch::SetCritical(false);
obj->Dealloc();
}
}
}
void NoncriticalLock::SeizeYielding() {
AssertNoncritical();
super::SeizeYielding();
}
void NoncriticalLock::Release() {
AssertNoncritical();
super::Release();
}
void NoncriticalLock::Seize() {
AssertNoncritical();
super::Seize();
}
Terminal & Terminal::New(Port * p, GarbageCollector & c) {
AssertNoncritical();
Terminal * t = new Terminal(p, c);
assert(t != NULL);
return *t;
}
void Terminal::Hangup() {
AssertNoncritical();
if (connection) {
connection->Close(*this);
}
}
void Terminal::Dealloc() {
AssertNoncritical();
Hangup();
delete this;
}
KernelTask & KernelTask::New(Scheduler & s) {
AssertNoncritical();
KernelTask * t = new KernelTask(s);
assert(t != NULL);
return *t;
}
Thread & Thread::New(Task & t, anarch::State & s) {
AssertNoncritical();
Thread * result = new Thread(t, s);
assert(result != NULL);
return *result;
}
void operator delete[](void * p) {
AssertNoncritical();
anarch::Domain::GetCurrent().Free(p);
}
void Hpet::Stop() {
AssertNoncritical();
ScopedCritical critical;
volatile uint64_t * regs = (volatile uint64_t *)map.GetStart();
regs[2] &= ~(uint64_t)1;
}
