netwerk/cache2/CacheIOThread.h

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #ifndef CacheIOThread__h__
   6 #define CacheIOThread__h__
   7
   8 #include "nsIThreadInternal.h"
   9 #include "nsISupportsImpl.h"
  10 #include "prthread.h"
  11 #include "nsTArray.h"
  12 #include "mozilla/Monitor.h"
  13 #include "mozilla/DebugOnly.h"
  14 #include "mozilla/Atomics.h"
  15 #include "mozilla/UniquePtr.h"
  16
  17 class nsIRunnable;
  18
  19 namespace mozilla {
  20 namespace net {
  21
  22 namespace detail {
  23 // A class keeping platform specific information needed to
  24 // cancel any long blocking synchronous IO.  Must be predeclared here
  25 // since including windows.h breaks stuff with number of macro definition
  26 // conflicts.
  27 class NativeThreadHandle;
  28 }  // namespace detail
  29
  30 class CacheIOThread final : public nsIThreadObserver {
  31   virtual ~CacheIOThread();
  32
  33  public:
  34   NS_DECL_THREADSAFE_ISUPPORTS
  35   NS_DECL_NSITHREADOBSERVER
  36
  37   CacheIOThread();
  38
  39   using EventQueue = nsTArray<nsCOMPtr<nsIRunnable>>;
  40
  41   enum ELevel : uint32_t {
  42     OPEN_PRIORITY,
  43     READ_PRIORITY,
  44     MANAGEMENT,  // Doesn't do any actual I/O
  45     OPEN,
  46     READ,
  47     WRITE_PRIORITY,
  48     WRITE,
  49     INDEX,
  50     EVICT,
  51     LAST_LEVEL,
  52
  53     // This is actually executed as the first level, but we want this enum
  54     // value merely as an indicator while other values are used as indexes
  55     // to the queue array.  Hence put at end and not as the first.
  56     XPCOM_LEVEL
  57   };
  58
  59   nsresult Init();
  60   nsresult Dispatch(nsIRunnable* aRunnable, uint32_t aLevel);
  61   nsresult Dispatch(already_AddRefed<nsIRunnable>, uint32_t aLevel);
  62   // Makes sure that any previously posted event to OPEN or OPEN_PRIORITY
  63   // levels (such as file opennings and dooms) are executed before aRunnable
  64   // that is intended to evict stuff from the cache.
  65   nsresult DispatchAfterPendingOpens(nsIRunnable* aRunnable);
  66   bool IsCurrentThread();
  67
  68   uint32_t QueueSize(bool highPriority);
  69
  70   uint32_t EventCounter() const { return mEventCounter; }
  71
  72   /**
  73    * Callable only on this thread, checks if there is an event waiting in
  74    * the event queue with a higher execution priority.  If so, the result
  75    * is true and the current event handler should break it's work and return
  76    * from Run() method immediately.  The event handler will be rerun again
  77    * when all more priority events are processed.  Events pending after this
  78    * handler (i.e. the one that called YieldAndRerun()) will not execute sooner
  79    * then this handler is executed w/o a call to YieldAndRerun().
  80    */
  81   static bool YieldAndRerun() { return sSelf ? sSelf->YieldInternal() : false; }
  82
  83   void Shutdown();
  84   // This method checks if there is a long blocking IO on the
  85   // IO thread and tries to cancel it.  It waits maximum of
  86   // two seconds.
  87   void CancelBlockingIO();
  88   already_AddRefed<nsIEventTarget> Target();
  89
  90   // A stack class used to annotate running interruptable I/O event
  91   class Cancelable {
  92     bool mCancelable;
  93
  94    public:
  95     explicit Cancelable(bool aCancelable);
  96     ~Cancelable();
  97   };
  98
  99   // Memory reporting
 100   size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
 101   size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
 102
 103  private:
 104   static void ThreadFunc(void* aClosure);
 105   void ThreadFunc();
 106   void LoopOneLevel(uint32_t aLevel) MOZ_REQUIRES(mMonitor);
 107   bool EventsPending(uint32_t aLastLevel = LAST_LEVEL);
 108   nsresult DispatchInternal(already_AddRefed<nsIRunnable> aRunnable,
 109                             uint32_t aLevel);
 110   bool YieldInternal();
 111
 112   static CacheIOThread* sSelf;
 113
 114   mozilla::Monitor mMonitor{"CacheIOThread"};
 115   PRThread* mThread{nullptr};
 116   // Only set in Init(), before the thread is started, which reads it but never
 117   // writes
 118   UniquePtr<detail::NativeThreadHandle> mNativeThreadHandle;
 119   Atomic<nsIThread*> mXPCOMThread{nullptr};
 120   Atomic<uint32_t, Relaxed> mLowestLevelWaiting{LAST_LEVEL};
 121   uint32_t mCurrentlyExecutingLevel{0};  // only accessed on CacheIO Thread
 122
 123   // Keeps the length of the each event queue, since LoopOneLevel moves all
 124   // events into a local array.
 125   Atomic<int32_t> mQueueLength[LAST_LEVEL];
 126
 127   EventQueue mEventQueue[LAST_LEVEL] MOZ_GUARDED_BY(mMonitor);
 128   // Raised when nsIEventTarget.Dispatch() is called on this thread
 129   Atomic<bool, Relaxed> mHasXPCOMEvents{false};
 130   // See YieldAndRerun() above
 131   bool mRerunCurrentEvent{false};  // Only accessed on the cache thread
 132   // Signal to process all pending events and then shutdown
 133   // Synchronized by mMonitor
 134   bool mShutdown MOZ_GUARDED_BY(mMonitor){false};
 135   // If > 0 there is currently an I/O operation on the thread that
 136   // can be canceled when after shutdown, see the Shutdown() method
 137   // for usage. Made a counter to allow nesting of the Cancelable class.
 138   Atomic<uint32_t, Relaxed> mIOCancelableEvents{0};
 139   // Event counter that increases with every event processed.
 140   Atomic<uint32_t, Relaxed> mEventCounter{0};
 141 #ifdef DEBUG
 142   bool mInsideLoop MOZ_GUARDED_BY(mMonitor){true};
 143 #endif
 144 };
 145
 146 }  // namespace net
 147 }  // namespace mozilla
 148
 149 #endif