Leaks with very first example using MLX42

[MiguelViHe]

Hi everybody!

I'm starting using Mlx42 for so_long project. I have controlled every possible error with the map and now i'm trying to learn how to use mlx42. Till now, executing valgrind in my program i don't have leaks but after ejecuting this very simple code opening a window:

int	initialize_game()
{
	mlx_t		*mlx;

	if (!(mlx = mlx_init(512, 512, "my_game", true)))
	{
		ft_fdprintf(2, mlx_strerror(mlx_errno));
		return (EXIT_FAILURE);
	}
	mlx_loop(mlx);
	mlx_terminate(mlx);
	return (EXIT_SUCCESS);
}

I have these leaks when i close the window with the x:

==19229== LEAK SUMMARY:
==19229==    definitely lost: 0 bytes in 0 blocks
==19229==    indirectly lost: 0 bytes in 0 blocks
==19229==      possibly lost: 0 bytes in 0 blocks
==19229==    still reachable: 326,176 bytes in 3,088 blocks
==19229==         suppressed: 32 bytes in 1 blocks
==19229== 
==19229== For lists of detected and suppressed errors, rerun with: -s
==19229== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

I'm working in garuda linux and it looks work fine, because it opens the window without problem.
I'm not sure where the leaks are, but i think is from the init function despite of I do the terminate. Somebody can help me to discover where my problem is. Thank you very much!!

[W2Wizard]

definitely lost: 0 bytes in 0 blocks
==19229== indirectly lost: 0 bytes in 0 blocks
==19229== possibly lost: 0 bytes in 0 blocks

I fail to see the leaks here ? If you're referring to the still reachable those are fine to be ignored.

[MiguelViHe]

Exactly, I refered to the reachable and the suppresed. And also the HEAP SUMMARY that i forgot to copy in the first post and show different number of allocs than frees:

==7576== HEAP SUMMARY:
==7576==     in use at exit: 326,208 bytes in 3,089 blocks
==7576==   total heap usage: 119,032 allocs, 115,943 frees, 22,870,791 bytes allocated
==7576== 
==7576== LEAK SUMMARY:
==7576==    definitely lost: 0 bytes in 0 blocks
==7576==    indirectly lost: 0 bytes in 0 blocks
==7576==      possibly lost: 0 bytes in 0 blocks
==7576==    still reachable: 326,176 bytes in 3,088 blocks
==7576==         suppressed: 32 bytes in 1 blocks
==7576== Rerun with --leak-check=full to see details of leaked memory
==7576== 
==7576== For lists of detected and suppressed errors, rerun with: -s
==7576== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) 

Thank you very much for your help I'm newbie with the use of valgrind.

[W2Wizard]

People like to argue if these things still count as leaks or not but I follow what Valgrind says.

5.2. | With Memcheck's memory leak detector, what's the difference between "definitely lost", "indirectly lost", "possibly lost", "still reachable", and "suppressed"?

---

The details are in the Memcheck section of the user manual. In short: "definitely lost" means your program is leaking memory -- fix those leaks!"indirectly lost" means your program is leaking memory in a pointer-based structure. (E.g. if the root node of a binary tree is "definitely lost", all the children will be "indirectly lost".)

If you fix the "definitely lost" leaks, the "indirectly lost" leaks should go away.

"possibly lost" means your program is leaking memory, unless you're doing unusual things with pointers that could cause them to point into the middle of an allocated block; see the user manual for some possible causes. Use --show-possibly-lost=no if you don't want to see these reports.

"still reachable" means your program is probably ok -- it didn't free some memory it could have. This is quite common and often reasonable. Don't use --show-reachable=yes if you don't want to see these reports.

"suppressed" means that a leak error has been suppressed. There are some suppressions in the default suppression files. You can ignore suppressed errors.

[MiguelViHe]

Okey so I would have these in mind to argue if necessary.
Thank you very much for your help!