C++ ProcessId::getState方法代码示例

int32_t OSSim::eventSuspend(Pid_t cpid, Pid_t pid)
{
    LOG("OSSim::suspend(%d) Received from pid %d",pid,cpid);
    ProcessId *proc = ProcessId::getProcessId(pid);
    if( proc == 0 ) {
        LOG("OSSim::suspend(%d) non existing process???", pid);
        return 0;
    }
    // Increment the suspend counter
    proc->incSuspendedCounter();
    // Check if process already suspended
    if(proc->getState()==SuspendedState) {
        I(0);
        LOG("OSSim::suspend(%d) already suspended (recursive=%d)"
            , pid, proc->getSuspendedCounter());
        return 0;
    }
    // The process should be ready or running
    I((proc->getState()==ReadyState)||(proc->getState()==RunningState));
    // Need to suspend only if suspended counter is positive
    if(proc->getSuspendedCounter()>0) {
        // The process is no longer runnable
        cpus.makeNonRunnable(proc);
        // Set the state to SuspendedState
        proc->setState(SuspendedState);
    } else {
        I(0);
        LOG("OSSim::suspend(%d,%d) OOO suspend/resume (%d)", cpid, pid, proc->getSuspendedCounter());
    }
    return 1;
}

void OSSim::stop(Pid_t pid)
{
    // Get the procss descriptor
    ProcessId *proc = ProcessId::getProcessId(pid);
    // The descriptor should exist, and the process should be runnable
    I(proc&&((proc->getState()==ReadyState)||(proc->getState()==RunningState)));
    // Make the process non-runnable
    cpus.makeNonRunnable(proc);
}

Pid_t OSSim::contextSwitch(CPU_t cpu, Pid_t nPid)
{
    // This is the process we displaced to run the target process
    Pid_t oldPid=-1;
    ProcessId *newProc = ProcessId::getProcessId(nPid);
    I(newProc);
    GProcessor *newCore=cpus.getProcessor(cpu);
    I(newCore);
    // Get the cpu where the target process is already running
    CPU_t runCpu=(newProc->getState()==RunningState)?newProc->getCPU():-1;
    // If already running on the target processor, do nothing
    if(runCpu==cpu)
        return -1;
    // If target core has no available flows, make one
    if(!newCore->availableFlows()) {
        oldPid=newCore->findVictimPid();
        ProcessId *oldProc=ProcessId::getProcessId(oldPid);
        cpus.switchOut(cpu, oldProc);
    }
    // Is the target process already running on another cpu?
    if(runCpu!=-1) {
        // Get another process to run on original cpu
        ProcessId *repProc=ProcessId::queueGet(runCpu);
        // Get the target process out of old core
        cpus.switchOut(runCpu, newProc);
        // Get the replacement process (if any) into the old core
        if(repProc)
            cpus.switchIn(runCpu,repProc);
        // Get the target process in the target cpu
        cpus.switchIn(cpu, newProc);
    } else {
        // If new process not ready, make it ready
        if(newProc->getState()!=ReadyState) {
            // Make it prefer the target cpu
            newProc->setCPU(cpu);
            // Make it ready
            newProc->setState(InvalidState);
            cpus.makeRunnable(newProc);
            // The target cpu is prefered by the target process, and
            // the target cpu has available flows. Thus, the target
            // process should be now running on the target cpu
            I(newProc->getCPU()==cpu);
            I(newProc->getState()==RunningState);
        } else {
            // The new process is already ready, just switch it in
            cpus.switchIn(cpu,newProc);
        }
    }
    return oldPid;
}

int32_t OSSim::eventResume(Pid_t cpid, Pid_t pid)
{
    LOG("OSSim::resume(%d,%d)", cpid, pid);
    ProcessId *proc = ProcessId::getProcessId(pid);
    if( proc == 0 ) {
        LOG("OSSim::resume(%d,%d) non existing process???", cpid, pid);
        return 0;
    }
    // Decrement the suspend counter
    proc->decSuspendedCounter();
    // If process is in SuspendedState
    if(proc->getState()==SuspendedState) {
        // If the suspend count is not positive
        if(proc->getSuspendedCounter()<=0) {
            // Make the process runnable
            proc->setState(InvalidState);
            cpus.makeRunnable(proc);
        }
        return 1;
    } else {
        I(0);
        LOG("OSSim::resume(%d,%d) OOO suspend/resume (%d)", cpid, pid, proc->getSuspendedCounter());
    }
    return 0;
}

void OSSim::eventExit(Pid_t cpid, int32_t err)
{
    LOG("OSSim::exit err[%d] (cpid %d)", err, cpid);
    ProcessId *proc = ProcessId::getProcessId(cpid);
    I(proc);
    // If not in InvalidState, removefrom the running queue
    if(proc->getState()==RunningState || proc->getState()==ReadyState )
        cpus.makeNonRunnable(proc);
    // Try to wakeup parent
    tryWakeupParent(cpid);
    // Destroy the process
    proc->destroy();

#ifdef SESC_THERM
    ReportTherm::stopCB();
#endif
}

void OSSim::unstop(Pid_t pid)
{
    // Get the procss descriptor
    ProcessId *proc = ProcessId::getProcessId(pid);
    // The descriptor should exist, and the process should be in the InvalidState
    I(proc&&(proc->getState()==InvalidState));
    // Make the process runnable
    cpus.makeRunnable(proc);
}

int32_t OSSim::eventYield(Pid_t curPid, Pid_t yieldPid)
{
    //  LOG("OSSim::yield(%d,%d)", curPid, yieldPid);
    ProcessId  *curProc=ProcessId::getProcessId(curPid);
    // The current process should be running
    I(curProc->getState()==RunningState);
    // get the CPU where the current process is running
    CPU_t cpu=curProc->getCPU();
    // Get the ProcessId of the new process
    ProcessId *yieldProc;
    if(yieldPid<0) {
        // No specific new process, get next ready process
        yieldProc=ProcessId::queueGet(cpu);
    } else {
        // Specific ready process, get its ProcessId
        yieldProc=ProcessId::getProcessId(yieldPid);
        // there should be such a process
        if(!yieldProc) {
            LOG("OSSim::yield(%d) to non existing process???", yieldPid);
            return 0;
        }
    }
    // Do nothing if no process to yield to
    if(!yieldProc)
        return 1;
    // Do nothing if the new process already running
    if(yieldProc->getState()==RunningState)
        return 1;
    // The new process should not be suspended
    if(yieldProc->getState()==SuspendedState) {
        LOG("OSSim::yield(%d) to a suspended process???", yieldPid);
        return 0;
    }
    // The new process should not be pinned to a other processor
    if(yieldProc->isPinned()&&(yieldProc->getCPU()!=cpu)) {
        LOG("OSSim::yield(%d) to a NOMIGRABLE process in another CPU", yieldPid);
        return 0;
    }
    // Remove current process from the processor
    cpus.switchOut(cpu,curProc);
    // Put the new process on that processor
    cpus.switchIn(cpu,yieldProc);
    return 1;
}

void OSSim::setPriority(Pid_t pid, int32_t newPrio)
{
    ProcessId *proc = ProcessId::getProcessId(pid);
    I(proc);

    int32_t oldPrio=proc->getPriority();

    if(newPrio==oldPrio)
        return;

    // Set the new priority of the process
    ProcessId *otherProc=proc->setPriority(newPrio);
    if(newPrio>oldPrio) {
        // Priority is better now, check if still running
        if(proc->getState()==RunningState) {
            // Is there a process we need to swap with
            if(otherProc) {
                // Get the cpu where the demoted process is running
                CPU_t cpu=proc->getCPU();
                // Switch the demoted process out
                cpus.switchOut(cpu,proc);
                // Switch the new process in
                cpus.switchIn(cpu,otherProc);
            }
        }
    } else {
        // Priority is worse now, check if ready but not already running
        if(proc->getState()==ReadyState) {
            // Is there a process we need to swap with
            if(otherProc) {
                // Get the cpu where the other process is running
                CPU_t cpu=otherProc->getCPU();
                // Switch the victim process out
                cpus.switchOut(cpu,otherProc);
                // Switch the promoted process in
                cpus.switchIn(cpu,proc);
            }
        }
    }
}

void OSSim::eventWait(Pid_t cpid)
{
    // All the threads have already finished
    if(cpid<0)
        return;
    LOG("OSSim::wait (cpid %d)", cpid);
    ProcessId *proc = ProcessId::getProcessId(cpid);
    if(proc->getNChilds()==0) {
        // No child pending
        return;
    }
    // Should be still running
    I(proc->getState()==RunningState);
    // Make it non-runnable
    cpus.makeNonRunnable(proc);
    // Set state to WaitingState
    proc->setState(WaitingState);
}

void OSSim::tryWakeupParent(Pid_t cpid)
{
    ProcessId *proc = ProcessId::getProcessId(cpid);
    I(proc);
    Pid_t ppid = proc->getPPid();
    if (ppid < 0)
        return;

    ProcessId *pproc = ProcessId::getProcessId(ppid);
    // Does the parent process still exist?
    if(pproc == 0)
        return;

    if(pproc->getState()==WaitingState) {
        LOG("Waiting pid(%d) is awaked (child %d call)",ppid,cpid);
        pproc->setState(InvalidState);
        cpus.makeRunnable(pproc);
    }
}