/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "nsMemoryImpl.h" #include "nsThreadUtils.h" #include "nsIObserver.h" #include "nsIObserverService.h" #include "nsISimpleEnumerator.h" #include "nsCOMPtr.h" #include "mozilla/Services.h" static nsMemoryImpl sGlobalMemory; NS_IMPL_QUERY_INTERFACE(nsMemoryImpl, nsIMemory) NS_IMETHODIMP nsMemoryImpl::HeapMinimize(bool aImmediate) { return FlushMemory(u"heap-minimize", aImmediate); } NS_IMETHODIMP nsMemoryImpl::IsLowMemoryPlatform(bool* aResult) { *aResult = false; return NS_OK; } /*static*/ nsresult nsMemoryImpl::Create(nsISupports* aOuter, const nsIID& aIID, void** aResult) { if (NS_WARN_IF(aOuter)) { return NS_ERROR_NO_AGGREGATION; } return sGlobalMemory.QueryInterface(aIID, aResult); } nsresult nsMemoryImpl::FlushMemory(const char16_t* aReason, bool aImmediate) { nsresult rv = NS_OK; if (aImmediate) { // They've asked us to run the flusher *immediately*. We've // got to be on the UI main thread for us to be able to do // that...are we? if (!NS_IsMainThread()) { NS_ERROR("can't synchronously flush memory: not on UI thread"); return NS_ERROR_FAILURE; } } bool lastVal = sIsFlushing.exchange(true); if (lastVal) { return NS_OK; } PRIntervalTime now = PR_IntervalNow(); // Run the flushers immediately if we can; otherwise, proxy to the // UI thread an run 'em asynchronously. if (aImmediate) { rv = RunFlushers(aReason); } else { // Don't broadcast more than once every 1000ms to avoid being noisy if (PR_IntervalToMicroseconds(now - sLastFlushTime) > 1000) { sFlushEvent.mReason = aReason; rv = NS_DispatchToMainThread(&sFlushEvent); } } sLastFlushTime = now; return rv; } nsresult nsMemoryImpl::RunFlushers(const char16_t* aReason) { nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService(); if (os) { // Instead of: // os->NotifyObservers(this, "memory-pressure", aReason); // we are going to do this manually to see who/what is // deallocating. nsCOMPtr<nsISimpleEnumerator> e; os->EnumerateObservers("memory-pressure", getter_AddRefs(e)); if (e) { nsCOMPtr<nsIObserver> observer; bool loop = true; while (NS_SUCCEEDED(e->HasMoreElements(&loop)) && loop) { nsCOMPtr<nsISupports> supports; e->GetNext(getter_AddRefs(supports)); if (!supports) { continue; } observer = do_QueryInterface(supports); observer->Observe(observer, "memory-pressure", aReason); } } } sIsFlushing = false; return NS_OK; } // XXX need NS_IMPL_STATIC_ADDREF/RELEASE NS_IMETHODIMP_(MozExternalRefCountType) nsMemoryImpl::FlushEvent::AddRef() { return 2; } NS_IMETHODIMP_(MozExternalRefCountType) nsMemoryImpl::FlushEvent::Release() { return 1; } NS_IMPL_QUERY_INTERFACE(nsMemoryImpl::FlushEvent, nsIRunnable) NS_IMETHODIMP nsMemoryImpl::FlushEvent::Run() { sGlobalMemory.RunFlushers(mReason); return NS_OK; } mozilla::Atomic<bool> nsMemoryImpl::sIsFlushing; PRIntervalTime nsMemoryImpl::sLastFlushTime = 0; nsMemoryImpl::FlushEvent nsMemoryImpl::sFlushEvent; nsresult NS_GetMemoryManager(nsIMemory** aResult) { return sGlobalMemory.QueryInterface(NS_GET_IID(nsIMemory), (void**)aResult); }