I'm in a team developing a video based application that extensively uses Intel's IPP library (IPP v6.1).
Lately we started testing the application on the pre-released OS X 10.9.4 version, and encountered several crashes at different locations, when the application runs for a long time (several hours). In most of the cases the crashes were in Apple's threads and code.
I started analysing the issues using the Xcode leak instrument and found out that the memory consumption of the application is significantly higher when running on OS X 10.9.4 than on OS X 10.9.2. For example, after an hour of running on 10.9.4 the application memory consumption reaches about 800 MB, and after 90 minutes it reaches 1.8 GB, whereas the same application on 10.9.2 is constantly using about 120 MB.
Most of the additional memory consumption, on 10.9.4, seems to be due to Intel's IPP allocations. However, the Xcode leak instrument did not identify any leaks in the code.
Does anyone know of a similar issue with OS X 10.9.4?
What main IPP functions are you using? IPP 6.1 is beyond of our support (and not validated with latest OS X. ) Have you get chance to try latest IPP version?
and one more benefit of latest IPP is we have removed internal memory allocation, developers can control all memories.
Thanks for you answer Ying,
Moving to version 8.1 might not be so simple and will probably require a lot of changes and time. I would have done it, if I was certain it will solve my issue.
Do you aware of any other similar issues?
Any idea what could have caused this memory issue with 10.9.4? After all, everything is working well with 10.9.2...
As for IPP functions, almost none of them allocate dynamic memory inside (though, this is for latest versions of IPP). We are deprecating these functions and provide equivalent functions without internal allocations, i.e. GetSize and Init interfaces.
You can locate all IPP memory allocating functions - most of them are called like "ipp*InitAlloc*" - and investigate how the memory, allocated by them, is released. In case of *InitAlloc* functions there are always ipp*Free pair functions to release dynamic memory. These functions must be called as soon as corresponding IPP structure or buffer is not needed. The general codepath of working with these group of functions is:
- status = ipp<func>InitAlloc(args, &ptr_to_IPP_struct_ptr);
- call ipp<func><Some Processing Function>(args, IPP_struct_ptr)
- call ipp<func>Free(IPP_struct_ptr)
All of "free" functions do nothing but call ippFree. At time of IPP 6.1 they were thoroughly tested on OS X too.
So, the problem likely is outside of IPP functions.