Scheduler.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef SCHEDULER_H
#define SCHEDULER_H
#include "pedigree/kernel/Atomic.h"
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/CpuAffinity.h"
#include "pedigree/kernel/process/LoadAverage.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/Process.h"
#include "pedigree/kernel/process/TerminationDeferral.h"
#include "pedigree/kernel/process/WaitQueue.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/List.h"
#include "pedigree/kernel/utilities/Tree.h"
#include "pedigree/kernel/utilities/new"
 
#include <config.h>
 
class Thread;
class PerProcessorScheduler;
 
class EXPORTED_PUBLIC Scheduler {
 public:
  class EXPORTED_PUBLIC ProcessLease {
   public:
    ProcessLease();
    ProcessLease(ProcessLease&& other) noexcept;
    ~ProcessLease();
 
    ProcessLease& operator=(ProcessLease&& other) noexcept;
 
    Process* get() const {
      return m_pProcess;
    }
 
    Process* operator->() const {
      return m_pProcess;
    }
 
    explicit operator bool() const {
      return m_pProcess != nullptr;
    }
 
    void reset();
 
   private:
    friend class Scheduler;
 
    explicit ProcessLease(Process* process);
    ProcessLease(const ProcessLease&) = delete;
    ProcessLease& operator=(const ProcessLease&) = delete;
 
    Process* m_pProcess;
    TerminationDeferral m_TerminationDeferral;
  };
 
  static Scheduler& instance() {
    return m_Instance;
  }
 
  bool initialise(Process* pKernelProcess);
 
  void addThread(Thread* pThread, PerProcessorScheduler& PPSched);
  void removeThread(Thread* pThread);
 
  bool threadInSchedule(Thread* pThread);
 
  void addProcess(Process* pProcess);
  void removeProcess(Process* pProcess);
 
  void yield();
 
  static CpuAffinityMask onlineAffinity();
  static size_t affinityBytes();
  static PerProcessorScheduler* schedulerForCpu(size_t cpu);
  void rebindThread(Thread* thread, PerProcessorScheduler& scheduler);
 
  struct SystemActivity {
    uint64_t tasks = 0;
    uint64_t loads[3] = {};
    uint64_t userNanoseconds = 0;
    uint64_t kernelNanoseconds = 0;
    uint64_t idleNanoseconds = 0;
  };
  SystemActivity systemActivity();
  void recordCpuTime(const Thread& thread, CpuTimeMode mode, Time::Timestamp elapsed);
  void sampleLoadAverage();
  void requestLoadAverageSample();
 
  size_t getNumProcesses();
 
  MUST_USE_RESULT bool acquireProcess(ProcessLease& lease, size_t n);
 
  MUST_USE_RESULT bool acquireFirstProcessOfType(ProcessLease& lease, Process::ProcessType type);
 
  MUST_USE_RESULT bool acquireProcessById(ProcessLease& lease, size_t id);
  MUST_USE_RESULT bool acquireProcessByUserspaceId(ProcessLease& lease, size_t id,
                                                   const UserspacePidNamespace* space = nullptr);
  MUST_USE_RESULT bool acquireNextProcess(ProcessLease& lease, size_t afterId);
  MUST_USE_RESULT bool acquireThreadByUserspaceId(Process::ThreadLease& lease, size_t id,
                                                  const UserspacePidNamespace* space = nullptr);
 
  MUST_USE_RESULT bool acquireThreadByTaskId(Process::ThreadLease& lease, size_t id);
 
  MUST_USE_RESULT bool acquireProcess(ProcessLease& lease, Process* expected);
 
  void waitUntilProcessRemoved(Process* expected);
 
  Process* getChildProcess(Process* pParent, size_t n);
 
  void threadStatusChanged(Thread* pThread);
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  using GenericThreadStatusHook = void (*)(Thread* thread);
 
  static EXPORTED_PUBLIC void setGenericThreadStatusHook(GenericThreadStatusHook hook);
  bool runHostedLoadAverageRequestRegression();
#endif
 
  Process* getKernelProcess() const {
    return m_pKernelProcess;
  }
 
  PerProcessorScheduler* getBootstrapProcessorScheduler() const {
    return m_pBspScheduler;
  }
 
 private:
  friend class Process;
  friend class PerProcessorScheduler;
  friend class SyscallManager;
 
  bool hasActiveSyscallLocked(Service_t service) const;
 
  Scheduler();
  NOT_COPYABLE_OR_ASSIGNABLE(Scheduler);
 
  size_t reserveProcessId();
 
  void releaseProcessLease(Process* process);
 
  void drainDeferredTimeAccounting();
 
  class ActivitySample;
  static void releaseActivityEntry(Process* process, Thread* thread);
  Mutex m_ActivityLock;
  uint64_t m_NextActivityAttempt = 0;
  bool m_ActivitySamplePending = false;
  LoadAverage m_LoadAverage;
  Atomic<uint64_t> m_UserNanoseconds;
  Atomic<uint64_t> m_KernelNanoseconds;
  Atomic<uint64_t> m_IdleNanoseconds;
 
  static Scheduler m_Instance;
 
  List<Process*, 0> m_Processes;
 
  Atomic<size_t> m_NextPid;
 
  Tree<PerProcessorScheduler*, List<Thread*>*> m_PTMap;
 
  Tree<Thread*, PerProcessorScheduler*> m_TPMap;
 
  Process* m_pKernelProcess;
 
  PerProcessorScheduler* m_pBspScheduler;
 
  Spinlock m_SchedulerLock;
 
#if THREADS
  WaitQueue m_ProcessRemovalWaiters;
#endif
};
 
#endif  // SCHEDULER_H