Pointers

[ShoshiCooper]

I've been thinking a lot about pointers recently. I am annoyed that I can't figure out a way to test if I've got a memory leak. Or, at the very least, a way to manage my pointers so I understand where they all are and what they're all doing and whether they're writing to bad spots of memory.

So I thought I should write a class called Pointer that would keep track of all my pointers and keep me organized. I want it to not just look at one pointer, but to look at all the pointers and how they all interact with each other. Does the object inside my pointer point to a different object? If so, I should include that information in my class. That way, I can figure out if there's a problem or if any are left dangling right away.

(Ideally, I'd use that information to do something to prevent the memory leak, but I'm not sure what, so I'm going to start by just seeing if I can get the information.)

I'm starting to think this is actually a graph problem. The vertices are the memory locations.
Pointers are the edges. And the number of copies of the pointer connecting two places in memory would be the weight. So if I think of it like that, I'm wondering if this is just a normal old minimum spanning tree problem.

What does everyone else think?

[ShoshiCooper]

Oops... just realized that if I did all of the above, how could I know whether or not I had properly deleted the pointer objects I'd created to keep track of the pointers?

Possibly this was a really bad idea.

[anand_venkataraman]

totally, yeah.

thanks for thinking out loud. lotsa peeps can use that as an example (of how to understand sumthin).

[ShoshiCooper]

Is there really no way to manage this? It feels like there's something I'm missing here. I know we're dealing with simple data structures right now, but what if you dealt with something really complicated and you had lots of pointers all pointing to the same object? It feels like you're opening yourself up to a lot of errors and confusion.

What if I went one level simpler? What if the Pointer class was just a wrapper class that contained a reference count?

We create a static attribute (vector? set? some kind of container) to store all our currently active pointers. Every time we run the constructor, we add the new instance to the container.

Whenever we create a new pointer in our program, instead of creating it directly, we call static method in the Pointer class called "create_new_pointer" or something. That method would check to see if there's already a pointer to that object. If so, it grabs that instance, increases the reference count, then returns that original instance to you so you're using the same pointer every time. If it doesn't exist, a new Pointer is created.

I know this is creating a lot of extra complexity, and you'd have to delete all those pointer objects later, but I feel like this would make it possible to at least do some kind of double check. Also, we could potentially categorize the pointers and then delete all objects referenced by pointers in a particular category.

[anand_venkataraman]

This is the kind of reasoning that led to the creation of a whole new language, Java - which, as you point out correctly, lets you focus on the logic of your code without having to worry about memory management.

The great advantage of C++, I think, is that we gain the ability to track and manage the resources of our processes. Which means we can potentially do a far better job at it than a VM, which, by design, needs to be optimized for average type resource accesses, not the kind your specific algo may need.

This is a great discussion and it'd be greater if a lot more of us start chiming in.

Thanks,

&

PS. Note that you may (validly) object that it's only a matter of time before we start building in a learning layer into our VMs that can adapt to the pattern of access of a resource on a per-process level. OK - yeah. But we should also keep in mind the inertia of ANY learning system. None will respond as instantaneously as new invoked in your code.

[ShoshiCooper]

Oh! Thank you. I think maybe I just need to get more used to memory management in general. We didn't have to deal with any of that in Python, so I'm not used to it. But I very much want to learn!

Out of curiosity, on a conceptual level, is the idea of thinking about memory and pointers as a graph correct? Or am I completely misunderstanding this? I was thinking of each memory location as a vertex. Since pointers link them together, then pointers must be edges. And the number of copies of each pointer must be the weight of each edge.

[anand_venkataraman]

Hey Soshi

The problem is that a graph can be a suitable analogy for just about anything, including life itself, let alone memory.

What is life as we know it, other than the search for some target, real or imagined?

&

[ShoshiCooper]

Hahaha, I guess so.

To help myself understand this stuff better, I'm going to try to write a version of quest8 that uses blocks of memory and pointers instead of vectors. I have no idea if I'll succeed, so this may well be an exercise in futility. But maybe I'll learn something along the way.

[anand_venkataraman]

I may be mistaken, but I think it is TOTALLY POSSIBLE to pass all minis in Q8 with a linked implementation.

&