sanitizer | Utility to find and fix problems within vaults | Identity Management library

Using watch-point: Unfortunately the value can change many many times in a valid way until the change is invalid. Even the final value might an will appear many times (which is valid). So it's not possible to check for a specific value.

A GDB watchpoint does not only support breaks if the value at a particular memory address changes to a particular value. It also supports more complex conditional expressions, such as:

The issue here is the definition of "memory leak". I would have liked to have quoted a section in LeakSanitizer's documentation where it offers a clear and precise definition of the concept, which seems fundamental to its operation, but I couldn't find one, so you'll have to bear with a bit of projection on my part.

A region of dynamically allocated (i.e. with malloc or friends) memory has leaked when there is no possible way for it to be freed. In other words, if your program allocates memory and throws away the address before the allocation has been free'd, the memory has leaked.

That's subtly different from what you might think the definition is. You might think that memory has leaked if your program terminates without freeing every block of memory it allocated. That's certainly a possible definition, and I'm not going to criticise it (much), but it's actually not very precise.

At what point has the program terminated? It hasn't really terminated when main() returns, because you might still have clean-up functions registered with atexit(), and those functions don't execute until after main() returns. (Or when exit() is called, which is effectively the same thing.) It's actually pretty common (though, to my mind, pointless) to use atexit() functions precisely in order to free() objects which might not have been deallocated before exit().

OK, you can't check whether a memory allocation has been freed by checking whether it has been freed when main returns. If you want to do it that way, you need to defer the test until really the last possible moment. But at what's really the last possible moment, the process is about to cease to exist and the operating system is going to reclaim all the memory used by the process, including whatever resources were acquired by the memory allocation library. So at the last possible moment, there is no memory leak, because there is no memory.

(There are embedded systems which have no concept of separate processes memory, etc., and so what I wrote up there might not apply to every possible computation system. But it applies to everything on which AddressSanitizer is implemented.)

A key point is that the atexit() handler needs to be able to find the objects it is cleaning up, and since it executes after main() has terminated, it cannot use any automatic (i.e. stack-allocated) object. Only objects with static lifetime are available to it. So for it to be able to do its task, the address of the object to be cleaned up on termination must be stored in global memory. If the region's memory is not stored somewhere persistent, the memory has leaked (as per my definition above) and we don't actually have to wait to see whether an atexit manages to free the memory.

Which brings us back to what I claim is a workable definition of a memory leak: dynamically allocated memory whose address is no longer present in the executable. That memory region can no longer be used, so it's garbage, but it cannot be freed because there the program doesn't know what its address is.

Your lines array is a global variable. Indeed, you point that out in your question:

I guess lines does not throw a memory leak because it was declared in the global space?

That's correct. lines is a global variable, so its contents are still accessible even after main() returns. Not only are its contents accessible, so is any memory pointed to by some object in the array it points to. You could, if you wanted to, free the saved lines in an atexit handler:

The main issue here is that Sanitize() gets called once per decorated class property declaration, and so for any given class property there will be only one currentValue. Meaning that two instances of the class will share the same currentValue. If you want to store one value per decorated class property per class instance, then you need access to class instances, and you will have to store the value either in those instances (via a property key that isn't going to interfere with any other properties), or in some map whose key is those instances. In the following I will show how to store the value in the class instances, and to avoid worrying about property name collision I will use the symbol output of the Symbol function, which is guaranteed to be unique.

Also note that Sanitize() is passed the class prototype as the target argument, so any manipulation you perform on target will affect the prototype and not any instance of the class. When you write target[propertyKey], you are looking up the property in the class prototype, and string-valued properties will almost certainly not be set in the prototype. So this is probably not necessary or useful, and we should get rid of it.

So if you only have direct access to the class prototype, how do you do anything with class instances? Well, to do this, you should use the this context of the get method and set method of the accessor property descriptor you pass to defineProperty(). And that means get and set need to be methods or at least function expressions, and not arrow function expressions which have no distinct this context.

Okay, enough explanation, here's the code:

What you are guaranteed is, upon moving a std::vector, no iterator, pointer or reference will be invalidated. This would apply to the vectors inside thing. See notes in https://en.cppreference.com/w/cpp/container/vector/vector

When a std::vector grows, all iterators, pointers and references to it become invalid. So if you had a reference to a thing, those would be blown away, but you do not have that, so we are good.

While a std::vector grows, it will move the previous elements to the new allocation if the contained type has a noexcept move constructor. For std::vectors, this is the case after C++17. The automatically generated move constructor of thing therefore should also qualify.

Considering these, the code you have posted is correct. As we do not see all the code, there must be an issue somewhere else that interacts with the code you have. Perhaps you have a user defined move constructor in the real code that you did not mark as noexcept, or you push_back to one of the foo vectors.

Also, the reserve call is a no-op: foos.reserve(bars.size());. bars.size() here is 0. Did you mean bars.reserve(foos.size());?

I hope I understand what you mean. Yo should check the option homepage_text and to add the filter.

You cannot use semaphores in conjunction with async-await. See Swift concurrency: Behind the scenes:

[Primitives] like semaphores ... are unsafe to use with Swift concurrency. This is because they hide dependency information from the Swift runtime, but introduce a dependency in execution in your code. Since the runtime is unaware of this dependency, it cannot make the right scheduling decisions and resolve them. In particular, do not use primitives that create unstructured tasks and then retroactively introduce a dependency across task boundaries by using a semaphore or an unsafe primitive. Such a code pattern means that a thread can block indefinitely against the semaphore until another thread is able to unblock it. This violates the runtime contract of forward progress for threads.

You might consider testing with the LIBDISPATCH_COOPERATIVE_POOL_STRICT environment variable as discussed here, in the same video.

You ask:

I'm trying to bridge the divide between synchronous and asynchronous code (perhaps the wrong way).

You should refactor the code that calls this synchronous method to adopt asynchronous pattern, and then excise all blocking API (e.g., semaphore wait, dispatch group wait, etc.). Those were anti-patterns in the GCD world and are to be avoided within Swift concurrency. I understand why developers who are unfamiliar with asynchronous programming are so attracted to those synchronous anti-patterns, but it has always been a mistake, and should be excised from one’s code.

Bottom line, in Swift concurrency one must “maintain a runtime contract that threads are always able to make forward progress.” Just embrace asynchronous patterns (i.e., stay within async-await without any old-school thread-blocking techniques) and you should be good.

FWIW, the Swift concurrency: Update a sample app shows interesting techniques for incrementally updating an old app. E.g., mark this blocking method as deprecated, and then the compiler will warn you where it is called and you can direct your refactoring efforts to those offending routines.

This seems like everything is working correctly rails just likes to output what its doing to the console but it should have added those to your file.

lldb has target module lookup -a flag that shows the name of the module and it's load address.

e.g.,

You could simplify your search this way: