marray | Fast Runtime-Flexible Multi | Performance Testing library

Does the activity register any broadcast receiver? The leaktrace shows LoadedApk.mReceivers which is an ArrayMap of receivers to receiver dispatcher and the activity is the receiver dispatcher.

TopicFragment is in a created state, Fragment.mAnimationInfo retains a Fragment$AnimationInfo and Fragment$AnimationInfo.mFocusedView retains the fragments detached view which should have been GCed.

This value is set by calls to Fragment.setFocusView(), and a quick search shows that's never ever cleared: https://cs.android.com/search?q=setFocusedView&sq=&ss=androidx%2Fplatform%2Fframeworks%2Fsupport

Looks like this change was introduced in 2020: https://cs.android.com/androidx/platform/frameworks/support/+/1052c3662c40176f7f02da9e06b989dcab21d500

The best would be to file an issue against the androidx fragments library.

Actually this was already filed, fixed in the next release: https://issuetracker.google.com/issues/179925887

const ATypedefdArray arr = marray; will call copy constructor, and destructor will be called at end of scope.

if both are trivial, then clang/gcc succeed to detect unused variable Demo.

If any are non trivial, they might have side effects, and so are used. they might have expected side effect have some intentional RAII usage as std::lock_guard, or unintentional as std::string. so no warning Demo

You forgot to dereferce (*sizes):

thinking it was probably wrapping memmove for efficiency

First I decided to check for you whether this is actually true, and it is.

• unsafeMove eventually boils down to the basicUnsafeCopy operation defined for MVector, which delegates to copyMutableArray.
• copyMutableArray's implementation varies by GHC version. For old versions, it was just an IO loop in ordinary Haskell, but since 7.8 it has delegated to a primop copyMutableArray#.
• copyMutableArray# is a wrapper around memmove and memcopy, depending whether the arrays overlap.

I grepped through the source of Data.Array, and found no references to copyMutableArray. Another possibility would be that Data.Array exposes some way for you to view your STUArray as a MutableArray, and thereby call copyMutableArray yourself. But I also find no mention of MutableArray in Data.Array.

My tentative conclusion is that there is no memmove/memcopy wrapper in Data.Array.

Have a look at read very carefully https://docs.julialang.org/en/v1/manual/performance-tips/

Basic cleanups start with:

1. Your SpotPrices struct does not need to me mutable. Anyway since there is only one field you could just define it as SpotPrices=Vector{Float64}
2. You do not want untyped containers - instead of prices = [] do prices = Float64[]
3. Using DataFrames.groupby will be much faster than finding unique elements and filtering by them
4. If yo do not need initialze than do not do it Vector{Float64}(undef, sample_size) is much faster than zeros(sample_size, 24)
5. You do not need to synchronize @sync before a multi-threaded loop
6. Create a random states - one separate one for each thread and use them whenever calling the rand function

If an array is int * then an array of arrays is int ** and if you want to return an array of arrays as an out parameter, then you need a pointer to that -- int ***. So you need to change the type of mArray as well as the ptrArray parameter:

I formatted your code so it's readable. And by indenting it, you can see where the problem is. It's in line 6/7 in the "FROM" part. Oracle can't really figure out what you're trying to do with that statement and when the parser reaches the end of the query at "(+)", he tells you that there is something missing/awkward. That's why he tells you it's the "(+)". But the problem is earlier. It's the way your build your "FROM" part. It's a bit confusing, so here is just a pointers:

when using "union", you don't give an alias to each of the two queries. The result set of both queries is "unioned", so you can't reference either of them in the "WHERE" part.

You should rewrite your query and instead of joining Client with a Union, you should Union two separate queries: one joining Client with casual_jobs, one joining Client with contrac_job. Following example is done without testing it in an SQL tool:

I think j+columns should be j+=columns. The equal sign is missing.