From 97557fcddf31f037f04141320ac0d29289480cca Mon Sep 17 00:00:00 2001 From: Gerald Squelart Date: Wed, 17 May 2017 16:36:26 +1200 Subject: [PATCH] Bug 1365538 - Use Mutex instead of Monitor in FileBlockCache - r=cpearce Since both FileBlockCache Monitor's are only used as locks, we should just use simple Mutex'es (smaller, faster, and tighter API). MozReview-Commit-ID: DdNNPN1kFrs --HG-- extra : rebase_source : 5216929b182d08544b3077374955dfb4ac5b7b16 --- dom/media/FileBlockCache.cpp | 46 ++++++++++++++++++------------------ dom/media/FileBlockCache.h | 22 ++++++++--------- 2 files changed, 34 insertions(+), 34 deletions(-) diff --git a/dom/media/FileBlockCache.cpp b/dom/media/FileBlockCache.cpp index bd7656c89132..ee7ce461bb75 100644 --- a/dom/media/FileBlockCache.cpp +++ b/dom/media/FileBlockCache.cpp @@ -31,11 +31,11 @@ FileBlockCache::SetCacheFile(PRFileDesc* aFD) return; } { - MonitorAutoLock lock(mFileMonitor); + MutexAutoLock lock(mFileMutex); mFD = aFD; } { - MonitorAutoLock lock(mDataMonitor); + MutexAutoLock lock(mDataMutex); if (!mIsOpen) { // We've been closed while waiting for the file descriptor. Bail out. // Rely on the destructor to close the file descriptor. @@ -55,7 +55,7 @@ FileBlockCache::Init() { LOG("Init()"); - MonitorAutoLock mon(mDataMonitor); + MutexAutoLock mon(mDataMutex); nsresult rv = NS_NewNamedThread("FileBlockCache", getter_AddRefs(mThread), nullptr, @@ -91,10 +91,10 @@ FileBlockCache::Init() } FileBlockCache::FileBlockCache() - : mFileMonitor("MediaCache.Writer.IO.Monitor"), + : mFileMutex("MediaCache.Writer.IO.Mutex"), mFD(nullptr), mFDCurrentPos(0), - mDataMonitor("MediaCache.Writer.Data.Monitor"), + mDataMutex("MediaCache.Writer.Data.Mutex"), mIsWriteScheduled(false), mIsOpen(false) { @@ -111,7 +111,7 @@ void FileBlockCache::Close() nsCOMPtr thread; { - MonitorAutoLock mon(mDataMonitor); + MutexAutoLock mon(mDataMutex); if (!mIsOpen) { return; } @@ -124,7 +124,7 @@ void FileBlockCache::Close() PRFileDesc* fd; { - MonitorAutoLock lock(mFileMonitor); + MutexAutoLock lock(mFileMutex); fd = mFD; mFD = nullptr; } @@ -164,7 +164,7 @@ nsresult FileBlockCache::WriteBlock(uint32_t aBlockIndex, Span aData1, Span aData2) { - MonitorAutoLock mon(mDataMonitor); + MutexAutoLock mon(mDataMutex); if (!mIsOpen) return NS_ERROR_FAILURE; @@ -192,7 +192,7 @@ FileBlockCache::WriteBlock(uint32_t aBlockIndex, void FileBlockCache::EnsureWriteScheduled() { - mDataMonitor.AssertCurrentThreadOwns(); + mDataMutex.AssertCurrentThreadOwns(); MOZ_ASSERT(mIsOpen); if (mIsWriteScheduled) { @@ -209,7 +209,7 @@ void FileBlockCache::EnsureWriteScheduled() nsresult FileBlockCache::Seek(int64_t aOffset) { - mFileMonitor.AssertCurrentThreadOwns(); + mFileMutex.AssertCurrentThreadOwns(); if (mFDCurrentPos != aOffset) { MOZ_ASSERT(mFD); @@ -229,7 +229,7 @@ nsresult FileBlockCache::ReadFromFile(int64_t aOffset, int32_t& aBytesRead) { LOG("ReadFromFile(offset=%" PRIu64 ", len=%u)", aOffset, aBytesToRead); - mFileMonitor.AssertCurrentThreadOwns(); + mFileMutex.AssertCurrentThreadOwns(); MOZ_ASSERT(mFD); nsresult res = Seek(aOffset); @@ -248,7 +248,7 @@ nsresult FileBlockCache::WriteBlockToFile(int32_t aBlockIndex, { LOG("WriteBlockToFile(index=%u)", aBlockIndex); - mFileMonitor.AssertCurrentThreadOwns(); + mFileMutex.AssertCurrentThreadOwns(); MOZ_ASSERT(mFD); nsresult rv = Seek(BlockIndexToOffset(aBlockIndex)); @@ -269,7 +269,7 @@ nsresult FileBlockCache::MoveBlockInFile(int32_t aSourceBlockIndex, { LOG("MoveBlockInFile(src=%u, dest=%u)", aSourceBlockIndex, aDestBlockIndex); - mFileMonitor.AssertCurrentThreadOwns(); + mFileMutex.AssertCurrentThreadOwns(); uint8_t buf[BLOCK_SIZE]; int32_t bytesRead = 0; @@ -285,7 +285,7 @@ nsresult FileBlockCache::MoveBlockInFile(int32_t aSourceBlockIndex, nsresult FileBlockCache::Run() { NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread"); - MonitorAutoLock mon(mDataMonitor); + MutexAutoLock mon(mDataMutex); NS_ASSERTION(!mChangeIndexList.empty(), "Only dispatch when there's work to do"); NS_ASSERTION(mIsWriteScheduled, "Should report write running or scheduled."); MOZ_ASSERT(mFD); @@ -302,14 +302,14 @@ nsresult FileBlockCache::Run() // Process each pending change. We pop the index out of the change // list, but leave the BlockChange in mBlockChanges until the change // is written to file. This is so that any read which happens while - // we drop mDataMonitor to write will refer to the data's source in + // we drop mDataMutex to write will refer to the data's source in // memory, rather than the not-yet up to date data written to file. // This also ensures we will insert a new index into mChangeIndexList // when this happens. // Hold a reference to the change, in case another change // overwrites the mBlockChanges entry for this block while we drop - // mDataMonitor to take mFileMonitor. + // mDataMutex to take mFileMutex. int32_t blockIndex = mChangeIndexList.front(); mChangeIndexList.pop_front(); RefPtr change = mBlockChanges[blockIndex]; @@ -317,8 +317,8 @@ nsresult FileBlockCache::Run() "Change index list should only contain entries for blocks " "with changes"); { - MonitorAutoUnlock unlock(mDataMonitor); - MonitorAutoLock lock(mFileMonitor); + MutexAutoUnlock unlock(mDataMutex); + MutexAutoLock lock(mFileMutex); if (change->IsWrite()) { WriteBlockToFile(blockIndex, change->mData.get()); } else if (change->IsMove()) { @@ -326,7 +326,7 @@ nsresult FileBlockCache::Run() } } // If a new change has not been made to the block while we dropped - // mDataMonitor, clear reference to the old change. Otherwise, the old + // mDataMutex, clear reference to the old change. Otherwise, the old // reference has been cleared already. if (mBlockChanges[blockIndex] == change) { mBlockChanges[blockIndex] = nullptr; @@ -343,7 +343,7 @@ nsresult FileBlockCache::Read(int64_t aOffset, int32_t aLength, int32_t* aBytes) { - MonitorAutoLock mon(mDataMonitor); + MutexAutoLock mon(mDataMutex); if (!mIsOpen || (aOffset / BLOCK_SIZE) > INT32_MAX) return NS_ERROR_FAILURE; @@ -380,8 +380,8 @@ nsresult FileBlockCache::Read(int64_t aOffset, // from file. nsresult res; { - MonitorAutoUnlock unlock(mDataMonitor); - MonitorAutoLock lock(mFileMonitor); + MutexAutoUnlock unlock(mDataMutex); + MutexAutoLock lock(mFileMutex); res = ReadFromFile(BlockIndexToOffset(blockIndex) + start, dst, amount, @@ -399,7 +399,7 @@ nsresult FileBlockCache::Read(int64_t aOffset, nsresult FileBlockCache::MoveBlock(int32_t aSourceBlockIndex, int32_t aDestBlockIndex) { - MonitorAutoLock mon(mDataMonitor); + MutexAutoLock mon(mDataMutex); if (!mIsOpen) return NS_ERROR_FAILURE; diff --git a/dom/media/FileBlockCache.h b/dom/media/FileBlockCache.h index 7e00809dae57..80bfa6251c19 100644 --- a/dom/media/FileBlockCache.h +++ b/dom/media/FileBlockCache.h @@ -8,8 +8,8 @@ #define FILE_BLOCK_CACHE_H_ #include "mozilla/Attributes.h" -#include "mozilla/Monitor.h" #include "mozilla/MozPromise.h" +#include "mozilla/Mutex.h" #include "mozilla/UniquePtr.h" #include "mozilla/AbstractThread.h" #include "nsTArray.h" @@ -143,10 +143,10 @@ private: void SetCacheFile(PRFileDesc* aFD); - // Monitor which controls access to mFD and mFDCurrentPos. Don't hold - // mDataMonitor while holding mFileMonitor! mFileMonitor must be owned + // Mutex which controls access to mFD and mFDCurrentPos. Don't hold + // mDataMutex while holding mFileMutex! mFileMutex must be owned // while accessing any of the following data fields or methods. - Monitor mFileMonitor; + Mutex mFileMutex; // Moves a block already committed to file. nsresult MoveBlockInFile(int32_t aSourceBlockIndex, int32_t aDestBlockIndex); @@ -164,14 +164,14 @@ private: // The current file offset in the file. int64_t mFDCurrentPos; - // Monitor which controls access to all data in this class, except mFD - // and mFDCurrentPos. Don't hold mDataMonitor while holding mFileMonitor! - // mDataMonitor must be owned while accessing any of the following data + // Mutex which controls access to all data in this class, except mFD + // and mFDCurrentPos. Don't hold mDataMutex while holding mFileMutex! + // mDataMutex must be owned while accessing any of the following data // fields or methods. - Monitor mDataMonitor; + Mutex mDataMutex; // Ensures we either are running the event to preform IO, or an event // has been dispatched to preform the IO. - // mDataMonitor must be owned while calling this. + // mDataMutex must be owned while calling this. void EnsureWriteScheduled(); // Array of block changes to made. If mBlockChanges[offset/BLOCK_SIZE] == nullptr, @@ -192,8 +192,8 @@ private: // True if the writer is ready to enqueue writes. bool mIsOpen; // True if we've got a temporary file descriptor. Note: we don't use mFD - // directly as that's synchronized via mFileMonitor and we need to make - // decisions about whether we can write while holding mDataMonitor. + // directly as that's synchronized via mFileMutex and we need to make + // decisions about whether we can write while holding mDataMutex. bool mInitialized = false; };