reclaim | Abstract interface for concurrent memory reclamation | Reactive Programming library

After testing, seems like the underlying reason is exactly what @juanpa suspected.

Basic indexing in numpy returns a view and not a copy of the array, so the underlying buffer is still held. You can access the original array using a[0].base.

If however you'd create a copy of the array like so: a = [i.copy() for i in a], you'd suddenly see a drop in the allocated memory, as the original objects would all be lost and cleared.

Do note however, that if you allocate other objects between the slicing and the copying, you might not release that memory back due to fragmentation.

Run this code and you'll see the difference:

The allocated size listed in that table includes Metaspace. Metaspace is memory pool separate from the java object heap. Therefore the sum of heap and metaspace can exceed the maximum heap size.

1 pod has unbound immediate PersistentVolumeClaims. - this error means the pod cannot bound to the PVC on the node where it has been scheduled to run on. This can happen when the PVC bounded to a PV that refers to a location that is not valid on the node that the pod is scheduled to run on. It will be helpful if you can post the complete output of kubectl get nodes -o wide, kubectl describe pvc triplestore-data-storage, kubectl describe pv triplestore-data-storage-dir to the question.

The mean time, PVC/PV is optional when using hostPath, can you try the following spec and see if the pod can come online:

First thing that you need to remember in Cassandra is that deletes really increase disk consumption, not decreasing it, until the compaction happens and old data is deleted. The Last Pickle has a great blog post on that topic.

Regarding your questions:

1. Batches on different partition keys are heavily increasing a pressure onto coordinator node, so they aren't recommended, especially such big. Prefer to delete one by one
2. cqlsh always sends commands to the same host (this is enforced by WhiteListPolicy) that acts as coordinator that then forwards traffic to node owning that data.
3. I would recommend to use external tool, either Spark + Spark Cassandra Connector, or you can use DSBulk to perform deletes as well, by using a custom query, something like this (assuming that you have CSV file with all values for partition column(s) that you want to delete - :pk the name of the column in the header of CSV file, and pk - name of partition column in your schema):

I really hope nobody else runs across this, but finally I found the problem and for once it was not only between the chair and the monitor, but also RTFM was involved.

As mentioned I am using minikube to run my k8s cluster which provides PVs stored on the host disk. Where it is stored you may ask? Exaclty, here: /tmp/hostpath-provisioner/default/data-sessiondb-0/data/. You find the problem? No, I also took some time to figure it out. WHY ON EARTH does minikube use the tmp folder to store persistant volume claims?

This folder gets autom. cleared every now and so on.

SOLUTION: Change the path and DO NOT STORE PVs IN tmp FOLDERS.

They mention this here: https://minikube.sigs.k8s.io/docs/handbook/persistent_volumes/#a-note-on-mounts-persistence-and-minikube-hosts and give an example.

But why use the "dangerous" tmp path per default and not, let's say, data without putting a Warning banner there?

Sigh. Closing this question ^^

--> Workaround: https://github.com/kubernetes/minikube/issues/7511#issuecomment-612099413

Github issues to this topic:

• https://github.com/kubernetes/minikube/issues/7511
• https://github.com/kubernetes/minikube/issues/13038
• https://github.com/kubernetes/minikube/issues/3318
• https://github.com/kubernetes/minikube/issues/5144

My Github issue for clarification in the docs: https://github.com/kubernetes/minikube/issues/13038#issuecomment-981821696

Is there a way for me to reclaim ownership?

Simple answer: No.

Unless... there's a function to specifically reclaim ownership from the zero address. Which would not make much sense to implement.

Is my understanding of dangling pointers here wrong?

Yes.

The memory should now be invalid, correct?

Depends on how you define "invalid". It is still accessible, and may contain the original, or any other value (the value it contains is undefined).

why hasn't the OS reclaimed that memory and made it invalid

You mean "inaccessible", not "invalid".

Doing so for stack operations would be exceedingly inefficient, and no OS in existence does this. This isn't done for heap either (outside of heap debug allocators), for the same reason.

In addition, OSes are limited by the capabilities of the processors they are running on, and no mainstream processor has ability to make inaccessible anything less than a full page (usually 4096 bytes or more). So even if the OS wanted to make the dangling stack inaccessible, it wouldn't be able to -- the area it would need to make inaccessible is too small.

Update:

So then would this not be a dangling pointer?

Yes, this is a dangling stack pointer.

My understanding is that the function dangling_ptr() allocates memory for x on the stack and returns the address of that memory.

Correct.

Once dangling_ptr() terminates, all the memory reserved via that stack frame is freed and now no longer reliable to refer to.

Correct in that you should no longer read or write that memory.

Incorrect in that nothing is freed here -- the memory is still on the stack, it's just in the unallocated part of the stack.

Where am I going wrong in my understanding there?

You believe that once the memory is unallocated, something definitive should happen when you access it.

But what actually happens is undefined -- anything can happen. Among the things which could happen: you could read the original value, you could read some other value, your program may crash (this outcome is unlikely on most OSes for reasons stated above).

The issue comes from the line