From 9e3c08db40b8916968b9f30096c7be3f00ce9647 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 21 Apr 2024 13:44:51 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- .../docs/profilerthreadregistration.umlet.uxf | 710 +++++++++++++++++++++ 1 file changed, 710 insertions(+) create mode 100644 tools/profiler/docs/profilerthreadregistration.umlet.uxf (limited to 'tools/profiler/docs/profilerthreadregistration.umlet.uxf') diff --git a/tools/profiler/docs/profilerthreadregistration.umlet.uxf b/tools/profiler/docs/profilerthreadregistration.umlet.uxf new file mode 100644 index 0000000000..3e07215db4 --- /dev/null +++ b/tools/profiler/docs/profilerthreadregistration.umlet.uxf @@ -0,0 +1,710 @@ + + + 10 + + UMLClass + + 200 + 330 + 370 + 250 + + ThreadRegistry::OffThreadRef +-- ++UnlockedConstReaderCRef() const ++WithUnlockedConstReader(F&& aF) const ++UnlockedConstReaderAndAtomicRWCRef() const ++WithUnlockedConstReaderAndAtomicRW(F&& aF) const ++UnlockedConstReaderAndAtomicRWRef() ++WithUnlockedConstReaderAndAtomicRW(F&& aF) ++UnlockedRWForLockedProfilerCRef() ++WithUnlockedRWForLockedProfiler(F&& aF) ++UnlockedRWForLockedProfilerRef() ++WithUnlockedRWForLockedProfiler(F&& aF) ++ConstLockedRWFromAnyThread() ++WithConstLockedRWFromAnyThread(F&& aF) ++LockedRWFromAnyThread() ++WithLockedRWFromAnyThread(F&& aF) + + + + UMLClass + + 310 + 80 + 560 + 160 + + ThreadRegistry +-- +-sRegistryMutex: RegistryMutex (aka BaseProfilerSharedMutex) +/exclusive lock used during un/registration, shared lock for other accesses/ +-- +friend class ThreadRegistration +-Register(ThreadRegistration::OnThreadRef) +-Unregister(ThreadRegistration::OnThreadRef) +-- ++WithOffThreadRef(ProfilerThreadId, auto&& aF) static ++WithOffThreadRefOr(ProfilerThreadId, auto&& aF, auto&& aFallbackReturn) static: auto + + + + UMLClass + + 310 + 630 + 530 + 260 + + ThreadRegistration +-- +-mDataMutex: DataMutex (aka BaseProfilerMutex) +-mIsOnHeap: bool +-mIsRegistryLockedSharedOnThisThread: bool +-tlsThreadRegistration: MOZ_THREAD_LOCAL(ThreadRegistration*) +-GetTLS() static: tlsThreadRegistration* +-GetFromTLS() static: ThreadRegistration* +-- ++ThreadRegistration(const char* aName, const void* aStackTop) ++~ThreadRegistration() ++RegisterThread(const char* aName, const void* aStackTop) static: ProfilingStack* ++UnregisterThread() static ++IsRegistered() static: bool ++GetOnThreadPtr() static OnThreadPtr ++WithOnThreadRefOr(auto&& aF, auto&& aFallbackReturn) static: auto ++IsDataMutexLockedOnCurrentThread() static: bool + + + + UMLClass + + 880 + 620 + 450 + 290 + + ThreadRegistration::OnThreadRef +-- ++UnlockedConstReaderCRef() const ++WithUnlockedConstReader(auto&& aF) const: auto ++UnlockedConstReaderAndAtomicRWCRef() const ++WithUnlockedConstReaderAndAtomicRW(auto&& aF) const: auto ++UnlockedConstReaderAndAtomicRWRef() ++WithUnlockedConstReaderAndAtomicRW(auto&& aF): auto ++UnlockedRWForLockedProfilerCRef() const ++WithUnlockedRWForLockedProfiler(auto&& aF) const: auto ++UnlockedRWForLockedProfilerRef() ++WithUnlockedRWForLockedProfiler(auto&& aF): auto ++UnlockedReaderAndAtomicRWOnThreadCRef() const ++WithUnlockedReaderAndAtomicRWOnThread(auto&& aF) const: auto ++UnlockedReaderAndAtomicRWOnThreadRef() ++WithUnlockedReaderAndAtomicRWOnThread(auto&& aF): auto ++RWOnThreadWithLock LockedRWOnThread() ++WithLockedRWOnThread(auto&& aF): auto + + + + UMLClass + + 1040 + 440 + 230 + 70 + + ThreadRegistration::OnThreadPtr +-- ++operator*(): OnThreadRef ++operator->(): OnThreadRef + + + + UMLClass + + 450 + 940 + 350 + 240 + + ThreadRegistrationData +-- +-mProfilingStack: ProfilingStack +-mStackTop: const void* const +-mThread: nsCOMPtr<nsIThread> +-mJSContext: JSContext* +-mJsFrameBuffer: JsFrame* +-mJSFlags: uint32_t +-Sleep: Atomic<int> +-mThreadCpuTimeInNsAtLastSleep: Atomic<uint64_t> +-mWakeCount: Atomic<uint64_t, Relaxed> +-mRecordWakeCountMutex: BaseProfilerMutex +-mAlreadyRecordedWakeCount: uint64_t +-mAlreadyRecordedCpuTimeInMs: uin64_t +-mThreadProfilingFeatures: ThreadProfilingFeatures + + + + UMLClass + + 460 + 1220 + 330 + 80 + + ThreadRegistrationUnlockedConstReader +-- ++Info() const: const ThreadRegistrationInfo& ++PlatformDataCRef() const: const PlatformData& ++StackTop() const: const void* + + + + UMLClass + + 440 + 1340 + 370 + 190 + + ThreadRegistrationUnlockedConstReaderAndAtomicRW +-- ++ProfilingStackCRef() const: const ProfilingStack& ++ProfilingStackRef(): ProfilingStack& ++ProfilingFeatures() const: ThreadProfilingFeatures ++SetSleeping() ++SetAwake() ++GetNewCpuTimeInNs(): uint64_t ++RecordWakeCount() const ++ReinitializeOnResume() ++CanDuplicateLastSampleDueToSleep(): bool ++IsSleeping(): bool + + + + UMLClass + + 460 + 1570 + 330 + 60 + + ThreadRegistrationUnlockedRWForLockedProfiler +-- ++GetProfiledThreadData(): const ProfiledThreadData* ++GetProfiliedThreadData(): ProfiledThreadData* + + + + UMLClass + + 430 + 1670 + 390 + 50 + + ThreadRegistrationUnlockedReaderAndAtomicRWOnThread +-- ++GetJSContext(): JSContext* + + + + UMLClass + + 380 + 1840 + 490 + 190 + + ThreadRegistrationLockedRWFromAnyThread +-- ++SetProfilingFeaturesAndData( + ThreadProfilingFeatures, ProfiledThreadData*, const PSAutoLock&) ++ClearProfilingFeaturesAndData(const PSAutoLock&) ++GetJsFrameBuffer() const JsFrame* ++GetEventTarget() const: const nsCOMPtr<nsIEventTarget> ++ResetMainThread() ++GetRunningEventDelay(const TimeStamp&, TimeDuration&, TimeDuration&) ++StartJSSampling(uint32_t) ++StopJSSampling() + + + + UMLClass + + 490 + 2070 + 260 + 80 + + ThreadRegistrationLockedRWOnThread +-- ++SetJSContext(JSContext*) ++ClearJSContext() ++PollJSSampling() + + + + Relation + + 610 + 1170 + 30 + 70 + + lt=<<- + 10.0;10.0;10.0;50.0 + + + UMLClass + + 500 + 2190 + 240 + 60 + + ThreadRegistration::EmbeddedData +-- + + + + Relation + + 610 + 1290 + 30 + 70 + + lt=<<- + 10.0;10.0;10.0;50.0 + + + Relation + + 610 + 1520 + 30 + 70 + + lt=<<- + 10.0;10.0;10.0;50.0 + + + Relation + + 610 + 1620 + 30 + 70 + + lt=<<- + 10.0;10.0;10.0;50.0 + + + Relation + + 650 + 1710 + 30 + 150 + + lt=<<- + 10.0;10.0;10.0;130.0 + + + Relation + + 610 + 2020 + 30 + 70 + + lt=<<- + 10.0;10.0;10.0;50.0 + + + Relation + + 610 + 2140 + 30 + 70 + + lt=<<- + 10.0;10.0;10.0;50.0 + + + Relation + + 340 + 880 + 180 + 1370 + + lt=->>>>> +mData + 160.0;1350.0;10.0;1350.0;10.0;10.0 + + + UMLClass + + 990 + 930 + 210 + 100 + + ThreadRegistrationInfo +-- ++Name(): const char* ++RegisterTime(): const TimeStamp& ++ThreadId(): ProfilerThreadId ++IsMainThread(): bool + + + + Relation + + 790 + 980 + 220 + 40 + + lt=->>>>> +mInfo + 200.0;20.0;10.0;20.0 + + + UMLClass + + 990 + 1040 + 210 + 50 + + PlatformData +-- + + + + + Relation + + 790 + 1040 + 220 + 40 + + lt=->>>>> +mPlatformData + 200.0;20.0;10.0;20.0 + + + UMLClass + + 990 + 1100 + 210 + 60 + + ProfiledThreadData +-- + + + + Relation + + 790 + 1100 + 220 + 40 + + lt=->>>> +mProfiledThreadData: * + 200.0;20.0;10.0;20.0 + + + Relation + + 710 + 480 + 350 + 170 + + lt=->>>> +m1=0..1 +mThreadRegistration: * + 10.0;150.0;330.0;10.0 + + + Relation + + 830 + 580 + 260 + 130 + + lt=->>>> +m1=1 +mThreadRegistration: * + 10.0;110.0;40.0;20.0;220.0;20.0;240.0;40.0 + + + Relation + + 1140 + 500 + 90 + 140 + + lt=<. +<creates> + 10.0;120.0;10.0;10.0 + + + Relation + + 780 + 900 + 450 + 380 + + lt=<. +<accesses> + 10.0;360.0;430.0;360.0;430.0;10.0 + + + Relation + + 800 + 900 + 510 + 560 + + lt=<. +<accesses> + 10.0;540.0;420.0;540.0;420.0;10.0 + + + Relation + + 780 + 900 + 540 + 720 + + lt=<. +<accesses> + 10.0;700.0;450.0;700.0;450.0;10.0 + + + Relation + + 810 + 900 + 520 + 820 + + lt=<. +<accesses> + 10.0;800.0;430.0;800.0;430.0;10.0 + + + UMLClass + + 900 + 2070 + 410 + 80 + + ThreadRegistration::OnThreadRef::ConstRWOnThreadWithLock +-- +-mDataLock: BaseProfilerAutoLock +-- ++DataCRef() const: ThreadRegistrationLockedRWOnThread& ++operator->() const: ThreadRegistrationLockedRWOnThread& + + + + Relation + + 740 + 2100 + 180 + 40 + + lt=->>>> +mLockedRWOnThread + 10.0;20.0;160.0;20.0 + + + Relation + + 1250 + 900 + 90 + 1190 + + lt=<. +<creates> + 10.0;1170.0;10.0;10.0 + + + Relation + + 660 + 440 + 400 + 210 + + lt=<. +<creates> + 380.0;10.0;10.0;190.0 + + + Relation + + 740 + 880 + 160 + 50 + + lt=<. +<creates> + 140.0;30.0;50.0;30.0;10.0;10.0 + + + Relation + + 460 + 230 + 150 + 120 + + lt=->>>> +m1=0..N +sRegistryContainer: +static Vector<> + 10.0;100.0;10.0;10.0 + + + UMLClass + + 800 + 250 + 470 + 150 + + ThreadRegistry::LockedRegistry +-- +-mRegistryLock: RegistryLockShared (aka BaseProfilerAutoLockShared) +-- ++LockedRegistry() ++~LockedRegistry() ++begin() const: const OffThreadRef* ++end() const: const OffThreadRef* ++begin(): OffThreadRef* ++end(): OffThreadRef* + + + + Relation + + 560 + 350 + 260 + 50 + + lt=<. +<accesses with +shared lock> + 10.0;20.0;240.0;20.0 + + + Relation + + 550 + 390 + 330 + 260 + + lt=<. +<updates +mIsRegistryLockedSharedOnThisThread> + 10.0;240.0;310.0;10.0 + + + Relation + + 330 + 570 + 170 + 80 + + lt=->>>> +m1=1 +mThreadRegistration: * + 120.0;60.0;40.0;10.0 + + + Relation + + 280 + 570 + 200 + 710 + + lt=<. +<accesses> + 180.0;690.0;10.0;690.0;10.0;10.0 + + + Relation + + 270 + 570 + 190 + 890 + + lt=<. +<accesses> + 170.0;870.0;10.0;870.0;10.0;10.0 + + + UMLClass + + 200 + 1740 + 440 + 80 + + ThreadRegistry::OffThreadRef::{,Const}RWFromAnyThreadWithLock +-- +-mDataLock: BaseProfilerAutoLock +-- ++DataCRef() {,const}: ThreadRegistrationLockedRWOnThread& ++operator->() {,const}: ThreadRegistrationLockedRWOnThread& + + + + Relation + + 250 + 570 + 90 + 1190 + + lt=<. +<creates> + 10.0;1170.0;10.0;10.0 + + + Relation + + 180 + 1810 + 220 + 120 + + lt=->>>> +mLockedRWFromAnyThread + 200.0;100.0;80.0;100.0;80.0;10.0 + + -- cgit v1.2.3