George Giorgidze
2009-Mar-20 14:34 UTC
[LLVMdev] Possible memory leakage in the LLVM JIT Engine
Hi, In my application I am JITing thousands of functions, though I am doing it sequantially and running only one at a time. So it is crucial to be able to properly clean up the memory from an old JITed function when JITing and running the new one. I am using Haskell binding of LLVM and my application works OK. However, memory usage increases and never decreases during the run time of my application. Here is what I do: 1) I am creating a module 2) I am generating an LLVM function and putting it into the module 3) creating a module provider for the module 4) creating an execution engine for the module provider. 5) running the function (using JIT) 6) freeing machine code for the function 7) deleting the function, module, module provider, exectution engine and all other structures created before 8) going to step 1 to JIT a new function I know that the step number 7 is not really necessary. I tried to use the same execution engine, but memory still leaks. I should note that if interpreter is used instead of JIT no memmory leakage occurs. Instead of posting my Haskell code, I though it would be better if I post short C++ code that (hopefully) demonstrates the possible leakage. My suspicion is that freeMachineCodeForFunction does not do its job properly. Let us look at HowToUseJIT.cpp example that comes with LLVM source bundle and let us modify the last lines in the following way: for (;;) { gv = EE->runFunction(FooF, noargs); // Import result of execution: outs() << "Result: " << gv.IntVal << "\n"; } Everithing works fine. However if we do the following modification: for (;;) { gv = EE->runFunction(FooF, noargs); // Import result of execution: outs() << "Result: " << gv.IntVal << "\n"; EE->freeMachineCodeForFunction(FooF); EE->freeMachineCodeForFunction(Add1F); } It works but a memory usage of the application increases continuously. So my question is how can I clean up ALL of the memmory created by the JIT engine? Any pointers to a similar application that succesfully acopmlishes what I want, i.e. does lots of JITing without memory leakage, will be very much appreciated. Cheers, George -- George Giorgidze http://www.cs.nott.ac.uk/~ggg/ <http://www.cs.nott.ac.uk/%7Eggg/> -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20090320/57d88bbd/attachment.html>
Graham Wakefield
2009-Mar-22 23:30 UTC
[LLVMdev] Possible memory leakage in the LLVM JIT Engine
Hi, Was this ever resolved? I'm curious, I'm also in a situation where there may be many (very many) JITted functions over the history of an application (which may be running for many days) Thanks On Mar 20, 2009, at 7:34 AM, George Giorgidze wrote:> Hi, > > In my application I am JITing thousands of functions, though I am > doing it sequantially and running only one at a time. So it is > crucial to be able to properly clean up the memory from an old JITed > function when JITing and running the new one. > > I am using Haskell binding of LLVM and my application works OK. > However, memory usage increases and never decreases during the run > time of my application. Here is what I do: > > 1) I am creating a module > 2) I am generating an LLVM function and putting it into the module > 3) creating a module provider for the module > 4) creating an execution engine for the module provider. > 5) running the function (using JIT) > 6) freeing machine code for the function > 7) deleting the function, module, module provider, exectution engine > and all other structures created before > 8) going to step 1 to JIT a new function > > I know that the step number 7 is not really necessary. I tried to > use the same execution engine, but memory still leaks. I should note > that if interpreter is used instead of JIT no memmory leakage occurs. > > Instead of posting my Haskell code, I though it would be better if I > post short C++ code that (hopefully) demonstrates the possible > leakage. My suspicion is that freeMachineCodeForFunction does not do > its job properly. > > Let us look at HowToUseJIT.cpp example that comes with LLVM source > bundle and let us modify the last lines in the following way: > > for (;;) > { > gv = EE->runFunction(FooF, noargs); > // Import result of execution: > outs() << "Result: " << gv.IntVal << "\n"; > } > > Everithing works fine. However if we do the following modification: > > for (;;) > { > gv = EE->runFunction(FooF, noargs); > // Import result of execution: > outs() << "Result: " << gv.IntVal << "\n"; > EE->freeMachineCodeForFunction(FooF); > EE->freeMachineCodeForFunction(Add1F); > } > > It works but a memory usage of the application increases continuously. > > So my question is how can I clean up ALL of the memmory created by > the JIT engine? > > Any pointers to a similar application that succesfully acopmlishes > what I want, i.e. does lots of JITing without memory leakage, will > be very much appreciated. > > Cheers, George > > -- > George Giorgidze > http://www.cs.nott.ac.uk/~ggg/ > _______________________________________________ > LLVM Developers mailing list > LLVMdev at cs.uiuc.edu http://llvm.cs.uiuc.edu > http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev-------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20090322/cc02e567/attachment.html>
Graham, This patch maybe helpful :- http://llvm.org/bugs/show_bug.cgi?id=2608 There's a JITResolver::removeFunction() added to JITEmitter::deallocateMemoryForFunction() It looks like there is also some other work being done on this area at the moment, check SVN. Aaron ----- Original Message ----- From: Graham Wakefield To: LLVM Developers Mailing List Sent: Sunday, March 22, 2009 11:30 PM Subject: Re: [LLVMdev] Possible memory leakage in the LLVM JIT Engine Hi, Was this ever resolved? I'm curious, I'm also in a situation where there may be many (very many) JITted functions over the history of an application (which may be running for many days) Thanks On Mar 20, 2009, at 7:34 AM, George Giorgidze wrote: Hi, In my application I am JITing thousands of functions, though I am doing it sequantially and running only one at a time. So it is crucial to be able to properly clean up the memory from an old JITed function when JITing and running the new one. I am using Haskell binding of LLVM and my application works OK. However, memory usage increases and never decreases during the run time of my application. Here is what I do: 1) I am creating a module 2) I am generating an LLVM function and putting it into the module 3) creating a module provider for the module 4) creating an execution engine for the module provider. 5) running the function (using JIT) 6) freeing machine code for the function 7) deleting the function, module, module provider, exectution engine and all other structures created before 8) going to step 1 to JIT a new function I know that the step number 7 is not really necessary. I tried to use the same execution engine, but memory still leaks. I should note that if interpreter is used instead of JIT no memmory leakage occurs. Instead of posting my Haskell code, I though it would be better if I post short C++ code that (hopefully) demonstrates the possible leakage. My suspicion is that freeMachineCodeForFunction does not do its job properly. Let us look at HowToUseJIT.cpp example that comes with LLVM source bundle and let us modify the last lines in the following way: for (;;) { gv = EE->runFunction(FooF, noargs); // Import result of execution: outs() << "Result: " << gv.IntVal << "\n"; } Everithing works fine. However if we do the following modification: for (;;) { gv = EE->runFunction(FooF, noargs); // Import result of execution: outs() << "Result: " << gv.IntVal << "\n"; EE->freeMachineCodeForFunction(FooF); EE->freeMachineCodeForFunction(Add1F); } It works but a memory usage of the application increases continuously. So my question is how can I clean up ALL of the memmory created by the JIT engine? Any pointers to a similar application that succesfully acopmlishes what I want, i.e. does lots of JITing without memory leakage, will be very much appreciated. Cheers, George -- George Giorgidze http://www.cs.nott.ac.uk/~ggg/ _______________________________________________ LLVM Developers mailing list LLVMdev at cs.uiuc.edu http://llvm.cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev ------------------------------------------------------------------------------ _______________________________________________ LLVM Developers mailing list LLVMdev at cs.uiuc.edu http://llvm.cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20090323/31e218da/attachment.html>