0.3.12 test tarballs
Locked
 
|
Hi all,
I've uploaded preliminary tarballs of the 0.3.12 release to <http://quantlib.org/prerelease/>. They're not final, but please do download them and give them a try on your platform so that we can iron out most problems before creating the final ones. Thanks, Luigi ---------------------------------------- If you can't convince them, confuse them. -- Harry S. Truman |
Re: 0.3.12 test tarballs
|
|
On 2/21/06, Luigi Ballabio <[hidden email]> wrote:
> I've uploaded preliminary tarballs of the 0.3.12 release to > <http://quantlib.org/prerelease/>. They're not final, but please do > download them and give them a try on your platform so that we can iron > out most problems before creating the final ones. the Visual Studio 2005 (VC8) solution file includes the ConvertibleBonds project whose project file is actually missing. ciao -- Nando |
Re: 0.3.12 test tarballs
|
|
In reply to this post by Luigi Ballabio
Hi all,
in all Debug configurations VC8 detects a memory leak in the test suite. I am using Window XP Professional, Boost 1.33.1, Visual Studio 2005 Professional. The leak problem is present in the LiborMarketModelProcessTest suite, namely in its unit tests testMonteCarloCapletPricing and testLambdaBootstrapping. I haven't finished checking all other tests and will report if other memory leakages surface. Klaus, could you take a look at your code? Any idea about the leak? Anyone better than me at hunting memory leaks? ciao -- Nando |
|
|
Hi Nando
I checked testLambdaBootstrapping using VC 8 Express, Boost 1.33.1. My configuration does not report a memory leak;-(. Can you please send my the line number of the memory leak as reported by VC 8 Professional? cheers Klaus On Wednesday 22 February 2006 2:29 pm, you wrote: > Hi all, > > in all Debug configurations VC8 detects a memory leak in the test > suite. I am using Window XP Professional, Boost 1.33.1, Visual Studio > 2005 Professional. > > The leak problem is present in the LiborMarketModelProcessTest suite, > namely in its unit tests testMonteCarloCapletPricing and > testLambdaBootstrapping. I haven't finished checking all other tests > and will report if other memory leakages surface. > > Klaus, could you take a look at your code? Any idea about the leak? > Anyone better than me at hunting memory leaks? > > ciao -- Nando |
Re: 0.3.12 test tarballs
|
|
Hi Klaus
> I checked testLambdaBootstrapping using VC 8 Express, Boost 1.33.1. My > configuration does not report a memory leak;-(. so this memory leak checks must be a feature of VC 8 Professional > Can you please send my the > line number of the memory leak as reported by VC 8 Professional? see below. I've already checked that the memory leak detection is only triggered when LiborMarketModelProcessTest::testMonteCarloCapletPricing and/or LiborMarketModelProcessTest::testLambdaBootstrapping are included. The leak is present in all three QuantLib Debug configurations. In my MSDN Universal I also have a 180 days trial DVD of VC8 Professional. I wonder if this trial is also available for download from the microsoft web site... thank you ciao -- Nando ============================= Auto run test ======================================= Testing QuantLib-vc80-mt-sgd-0_3_12.lib ======================================= Running 236 test cases... Platform: Win32 Compiler: Microsoft Visual C++ version 8.0 STL : Dinkumware standard library version 405 Boost : 1.33.1 Testing Barone-Adesi and Whaley approximation for American options... Testing Bjerksund and Stensland approximation for American options... Testing Ju approximation for American options... Testing finite-difference engine for American options... Testing finite-differences American option greeks... Testing finite-differences shout option greeks... Testing array construction... Testing analytic continuous geometric average-price Asians... Testing analytic continuous geometric average-price Asian greeks... Testing analytic discrete geometric average-price Asians... Testing Monte Carlo discrete geometric average-price Asians... Testing Monte Carlo discrete arithmetic average-price Asians... Testing discrete-averaging geometric Asian greeks... Testing barrier options against Haug's values... Testing barrier options against Babsiri's values... Testing barrier options against Beaglehole's values... Testing two-asset European basket options.. Testing three-asset basket options against Barraquand's values... Testing three-asset American basket options against Tavella's values... Testing basket American options against 1-D case... Testing antithetic engine using odd sample number... Testing analytic Bates engine against Black formula... Testing analytic Bates engine against Merton-76 engine... Testing Bates model calibration using DAX volatility data... Testing Bermudan swaption against cached values... Testing consistency of bond price/yield calculation... Testing theoretical bond price/yield calculation... Testing bond price/yield calculation against cached values... Testing zero-coupon bond prices against cached values... Testing fixed-coupon bond prices against cached values... Testing floating-rate bond prices against cached values... Testing Brazil holiday list... Testing Italy Milan Stock Exchange holiday list... Testing UK Settlement holiday list... Testing UK London Stock Exchange holiday list... Testing UK London Metals Exchange holiday list... Testing Germany Frankfurt Stock Exchange holiday list... Testing Germany Xetra holiday list... Testing Germany Eurex holiday list... Testing TARGET holiday list... Testing US settlement holiday list... Testing US Government Bond Market holiday list... Testing US New York Stock Exchange holiday list... Testing calendar modification... Testing joint calendars... Testing cap/floor dependency on strike... Testing consistency between cap, floor and collar... Testing put/call parity for cap and floor... Testing implied term volatility for cap and floor... Testing cap/floor value against cached values... Testing Cliquet option values... Testing Cliquet option greeks... Testing performance option greeks... Testing consistency of compound-forward curve with supplied rates... Testing consistency of compound-forward curve with converted rates... Testing out-of-the-money convertible bonds against vanilla bonds... Testing zero-coupon convertible bonds against vanilla option... Testing correlation-salvaging algorithms... Testing covariance and correlation calculations... Testing dates... Testing IMM dates... Testing actual/actual day counters... Testing simple day counter... Testing 1/1 day counter... Testing European cash-or-nothing digital option... Testing European asset-or-nothing digital option... Testing European gap digital option... Testing American cash-(at-hit)-or-nothing digital option... Testing American cash-(at-hit)-or-nothing digital option greeks... Testing American asset-(at-hit)-or-nothing digital option... Testing American cash-(at-expiry)-or-nothing digital option... Testing American asset-(at-expiry)-or-nothing digital option... Testing Monte Carlo cash-(at-hit)-or-nothing American engine... Testing normal distributions... Testing bivariate cumulative normal distribution... Testing Poisson distribution... Testing cumulative Poisson distribution... Testing inverse cumulative Poisson distribution... Testing dividend European option values with no dividends... Testing dividend European option values with no dividends... Testing dividend European option greeks... Testing finite-difference dividend European option values... Testing finite-differences dividend European option greeks... Testing finite-differences dividend American option greeks... Testing degenerate finite-differences dividend European option... Testing degenerate finite-differences dividend American option... Testing European option values... Testing European option greek values... Testing European option greeks... Testing European option implied volatility... Testing self-containment of implied volatility calculation... Testing JR binomial European engines against analytic results... Testing CRR binomial European engines against analytic results... Testing EQP binomial European engines against analytic results... Testing TGEO binomial European engines against analytic results... Testing TIAN binomial European engines against analytic results... Testing LR binomial European engines against analytic results... Testing finite-difference European engines against analytic results... Testing integral engines against analytic results... Testing finite-difference European option greeks... Testing Monte Carlo European engines against analytic results... Testing Quasi Monte Carlo European engines against analytic results... Testing European price curves... Testing direct exchange rates... Testing derived exchange rates... Testing lookup of direct exchange rates... Testing lookup of triangulated exchange rates... Testing lookup of derived exchange rates... Testing factorial numbers... Testing Gamma function... Testing forward option values... Testing forward option greeks... Testing forward performance option values... Testing forward performance option greeks... Testing Gauss-Jacobi integration... Testing Gauss-Laguerre integration... Testing Gauss-Hermite integration... Testing Gauss hyperbolic integration... Testing tabulated Gauss-Laguerre integration... Testing Heston model calibration using a flat volatility surface... Testing Heston model calibration using DAX volatility data... Testing analytic Heston engine against Black formula... Testing analytic Heston engine against cached values... Testing Monte Carlo Heston engine against cached values... Testing observability of instruments... Testing segment integration... Testing trapezoid integration... Testing mid-point trapezoid integration... Testing Simpson integration... Testing Gauss-Kronrod integration... Testing interest rate conversions... Testing spline interpolation on generic values... Testing symmetry of spline interpolation end-conditions... Testing derivative end-conditions for spline interpolation... Testing non-restrictive Hyman filter... Testing spline interpolation on RPN15A data set... Testing spline interpolation on a Gaussian data set... Testing spline approximation on Gaussian data sets... Testing N-dimensional cubic spline... Testing use of interpolations as functors... Testing simple covariance models... Testing caplet pricing... Testing forward swap and swaption pricing... Testing calibration of a Libor Forward Model... Testing caplet LMM process initialisation... Testing caplet-LMM lambda bootstrapping... Testing caplet-LMM Monte-Carlo caplet pricing... Testing Merton 76 jump-diffusion model for European options... Testing jump-diffusion option greeks... Testing random seed generator... Testing 21200 primitive polynomials modulo two... Testing Sobol sequences up to dimension 21200... Testing Halton sequences... Testing Faure sequences... Testing Mersenne twister discrepancy... Testing plain Halton discrepancy... Testing random-start Halton discrepancy... Testing random-shift Halton discrepancy... Testing random-start, random-shift Halton discrepancy... Testing unit Sobol discrepancy... Testing JΣckel-Sobol discrepancy... Testing SobolLevitan-Sobol discrepancy... Testing SobolLevitanLemieux-Sobol discrepancy... Testing randomized low-discrepancy sequences up to dimension 21200... Testing eigenvalues and eigenvectors calculation... Testing matricial square root... Testing singular value decomposition... Testing Mersenne twister... Testing money arithmetic without conversions... Testing money arithmetic with conversion to base currency... Testing money arithmetic with automated conversion... Testing differential operators... Testing consistency of BSM operators... Testing 1-D path generation against cached values... Testing n-D path generation against cached values... Testing consistency of piecewise flat forward curve... Testing observability of piecewise flat forward curve... Testing consistency of piecewise-log-linear discount curve... Testing consistency of piecewise-linear discount curve... Testing consistency of piecewise-log-linear zero-yield curve... Testing consistency of piecewise-linear zero-yield curve... Testing consistency of piecewise-spline zero-yield curve... Testing consistency of piecewise-linear forward-rate curve... Testing consistency of piecewise-flat forward-rate curve... Testing observability of piecewise yield curve... Testing quanto option values... Testing quanto option greeks... Testing quanto-forward option values... Testing quanto-forward option greeks... Testing quanto-forward-performance option values... Testing observability of quotes... Testing observability of quote handles... Testing derived quotes... Testing composite quotes... Testing risk measures... Testing Gaussian pseudo-random number generation... Testing Poisson pseudo-random number generation... Testing custom Poisson pseudo-random number generation... Testing closest decimal rounding... Testing upward decimal rounding... Testing downward decimal rounding... Testing floor decimal rounding... Testing ceiling decimal rounding... Testing sampled curve construction... Testing Hull-White calibration against cached values... Testing Hull-White swap pricing against known values... Testing 1-D solvers... Testing statistics... Testing sequence statistics... Testing convergence statistics... Testing simple swap calculation of fair fixed rate... Testing simple swap calculation of fair floating spread... Testing simple swap dependency on fixed rate... Testing simple swap dependency on floating spread... Testing in-arrears swap calculation... Testing simple swap calculation against cached value... Testing swaption dependency on strike... Testing swaption dependency on spread... Testing swaption treatment of spread... Testing swaption value against cached value... Testing term structure against evaluation date change... Testing consistency of implied term structure... Testing observability of implied term structure... Testing consistency of forward-spreaded term structure... Testing observability of forward-spreaded term structure... Testing consistency of zero-spreaded term structure... Testing observability of zero-spreaded term structure... Testing TQR eigenvalue decomposition... Testing TQR zero-off-diagonal eigenvalues... Testing TQR eigenvector decomposition... Testing tracing... Testing transformed grid construction... Testing old-style Monte Carlo single-factor pricers... Testing old-style Monte Carlo multi-factor pricers... Tests completed in 2 h 38 m 37 s Test suite "QuantLib test suite" passed with: 236 assertions out of 236 passed 236 test cases out of 236 passed Detected memory leaks! Dumping objects -> {199915536} normal block at 0x00F02AD8, 16 bytes long. Data: <`{ & > 60 7B D3 00 01 00 00 00 01 00 00 00 C0 26 F0 00 {199915535} normal block at 0x00F03928, 648 bytes long. Data: < ?0 Z ? ; ?> C8 3F 30 CF 5A F1 94 3F C0 89 C1 B8 3B 0A 9C 3F {199915481} normal block at 0x00F029D0, 216 bytes long. Data: <M#z0 R ? V: ?> 4D 23 7A 30 00 52 BF 3F C2 BD 56 3A 8E 19 B1 3F {199915258} normal block at 0x00F026C0, 44 bytes long. Data: < C ) > A8 43 D7 00 0A 00 00 00 03 00 00 00 D0 29 F0 00 {199915257} normal block at 0x00F02E98, 16 bytes long. Data: < s 2 > EC 73 D3 00 01 00 00 00 01 00 00 00 C0 32 F3 00 {199915132} normal block at 0x00F02640, 80 bytes long. Data: < 8 8 ? 8 8 ?> 8E E3 38 8E E3 38 F0 3F 8E E3 38 8E E3 38 F0 3F {199915131} normal block at 0x00F025C0, 80 bytes long. Data: < 8 8 ? 8 8 @> 8E E3 38 8E E3 38 F0 3F 8E E3 38 8E E3 38 00 40 {199915130} normal block at 0x00F02E18, 80 bytes long. Data: < 8 8 ?> 00 00 00 00 00 00 00 00 8E E3 38 8E E3 38 F0 3F {199915129} normal block at 0x00F02DC0, 40 bytes long. Data: < 5 > C8 96 00 00 35 98 00 00 A2 99 00 00 0F 9B 00 00 {199915128} normal block at 0x00F02D40, 80 bytes long. Data: < 8 8 ?> 00 00 00 00 00 00 00 00 8E E3 38 8E E3 38 F0 3F {199915127} normal block at 0x00F02CC0, 80 bytes long. Data: < 4 ?m H # ?> 19 F5 EF 8B 34 C1 8F 3F 6D 83 48 C5 C8 23 9B 3F {199915126} normal block at 0x00F02C88, 12 bytes long. Data: < , , > 88 2C F0 00 88 2C F0 00 CD CD CD CD {199915125} normal block at 0x00F33428, 16 bytes long. Data: <(4 (4 > 28 34 F3 00 28 34 F3 00 CD CD CD CD CD CD CD CD {199915124} normal block at 0x00F333E8, 16 bytes long. Data: < ' 3 > D8 27 D1 00 01 00 00 00 01 00 00 00 B0 33 F3 00 {199915123} normal block at 0x00F333B0, 8 bytes long. Data: <d L > 64 E2 D0 00 4C E2 D0 00 {199915122} normal block at 0x00F332C0, 192 bytes long. Data: <l% > 6C 25 D7 00 00 00 00 00 CD CD CD CD CD CD CD CD {199915121} normal block at 0x00F03028, 12 bytes long. Data: < 3 3 / > 80 33 F0 00 80 33 F0 00 1C 2F F0 00 {199915120} normal block at 0x00F02FE8, 16 bytes long. Data: < / / t# % > A8 2F F0 00 A8 2F F0 00 74 23 F0 00 80 25 F0 00 {199915119} normal block at 0x00F02580, 16 bytes long. Data: < " > 14 D9 D1 00 02 00 00 00 01 00 00 00 E0 22 F0 00 {199915118} normal block at 0x00F02540, 16 bytes long. Data: < @$ > F4 DB D1 00 01 00 00 00 01 00 00 00 40 24 F0 00 {199915117} normal block at 0x00F02500, 16 bytes long. Data: < c u? > A8 F5 9A 63 D5 C0 75 3F 00 00 00 00 00 00 00 00 {199915116} normal block at 0x00F024C0, 16 bytes long. Data: < { G ?> 00 00 00 00 00 00 00 00 7B 14 AE 47 E1 FA E2 3F {199915115} normal block at 0x00F02440, 80 bytes long. Data: <D # $ > 44 D9 D1 00 1C 23 F0 00 00 00 00 00 00 24 F0 00 {199915114} normal block at 0x00F02400, 16 bytes long. Data: < q q\*@> 00 00 00 00 00 00 00 00 C7 71 1C C7 71 5C 2A 40 {199915113} normal block at 0x00F023C0, 16 bytes long. Data: <{ G z ?{ G z ?> 7B 14 AE 47 E1 7A 84 3F 7B 14 AE 47 E1 7A B4 3F {199915112} normal block at 0x00F033B8, 8 bytes long. Data: < S > CA 96 00 00 53 A9 00 00 {199915111} normal block at 0x00F03380, 12 bytes long. Data: <(0 (0 > 28 30 F0 00 28 30 F0 00 CD CD CD CD {199915110} normal block at 0x00F03340, 16 bytes long. Data: <@3 @3 > 40 33 F0 00 40 33 F0 00 CD CD CD CD CD CD CD CD {199915109} normal block at 0x00F022E0, 176 bytes long. Data: < > D8 D5 D1 00 FC D5 D1 00 CA 96 00 00 00 01 CD CD {199915108} normal block at 0x00F03300, 16 bytes long. Data: < 0 > EC E0 D1 00 01 00 00 00 01 00 00 00 A0 30 F0 00 {199915107} normal block at 0x00F032C8, 12 bytes long. Data: <88 0 > 38 38 F3 00 C0 C1 E8 00 BC 30 F0 00 {199915106} normal block at 0x00F03288, 16 bytes long. Data: < 2 1 x > 10 32 F0 00 D0 31 F0 00 78 C1 E8 00 F8 C1 E8 00 {199915105} normal block at 0x00F03250, 12 bytes long. Data: <p/ p/ 0 > 70 2F F0 00 70 2F F0 00 BC 30 F0 00 {199915104} normal block at 0x00F03210, 16 bytes long. Data: < 1 2 / `0 > D0 31 F0 00 88 32 F0 00 00 2F F0 00 60 30 F0 00 {199915103} normal block at 0x00F031D0, 16 bytes long. Data: < 2 2 > 88 32 F0 00 10 32 F0 00 CD CD CD CD CD CD CD CD {199915102} normal block at 0x00F03198, 12 bytes long. Data: < 1 1 > 98 31 F0 00 98 31 F0 00 CD CD CD CD {199915101} normal block at 0x00F03158, 16 bytes long. Data: < ' h > A8 27 D1 00 01 00 00 00 01 00 00 00 C0 68 E8 00 {199915100} normal block at 0x00E868C0, 4 bytes long. Data: < > 10 E2 D0 00 {199915099} normal block at 0x00F030A0, 136 bytes long. Data: <` > 60 DC D1 00 00 00 00 00 CD CD CD CD CD CD CD CD {199915098} normal block at 0x00F03060, 16 bytes long. Data: < , / > A4 2C D1 00 02 00 00 00 01 00 00 00 00 2F F0 00 {199915095} normal block at 0x00F02FA8, 16 bytes long. Data: < / / > E8 2F F0 00 E8 2F F0 00 CD CD CD CD CD CD CD CD {199915094} normal block at 0x00F02F70, 12 bytes long. Data: <P2 P2 > 50 32 F0 00 50 32 F0 00 CD CD CD CD {199915093} normal block at 0x00F02F00, 68 bytes long. Data: < $ > DC 24 D1 00 00 00 00 00 CD CD CD CD CD CD CD CD {199915077} normal block at 0x00F33280, 16 bytes long. Data: < ' I > A8 27 D1 00 01 00 00 00 01 00 00 00 90 49 E8 00 {199915076} normal block at 0x00E84990, 4 bytes long. Data: < > 10 E2 D0 00 {199915075} normal block at 0x00F02C48, 16 bytes long. Data: <`{ (2 > 60 7B D3 00 01 00 00 00 01 00 00 00 28 32 F3 00 {199915074} normal block at 0x00F02028, 648 bytes long. Data: < ?0 Z ? 6:b ?> C7 3F 30 CF 5A F1 94 3F C4 EA DD 36 3A 62 9C 3F {199915063} normal block at 0x00F02BD0, 72 bytes long. Data: < ;|S)N ?1r # ?> F8 3B 7C 53 29 4E C2 3F 31 72 C5 D8 23 CF C8 3F {199914842} normal block at 0x00F33228, 44 bytes long. Data: < C + > A8 43 D7 00 0A 00 00 00 01 00 00 00 D0 2B F0 00 {199914841} normal block at 0x00F331E8, 16 bytes long. Data: < s @< > EC 73 D3 00 01 00 00 00 01 00 00 00 40 3C F3 00 {199914716} normal block at 0x00F33168, 80 bytes long. Data: < 8 8 ? 8 8 ?> 8E E3 38 8E E3 38 F0 3F 8E E3 38 8E E3 38 F0 3F {199914715} normal block at 0x00F330E8, 80 bytes long. Data: < 8 8 ? 8 8 @> 8E E3 38 8E E3 38 F0 3F 8E E3 38 8E E3 38 00 40 {199914714} normal block at 0x00F33068, 80 bytes long. Data: < 8 8 ?> 00 00 00 00 00 00 00 00 8E E3 38 8E E3 38 F0 3F {199914713} normal block at 0x00F33F20, 40 bytes long. Data: < 5 > C8 96 00 00 35 98 00 00 A2 99 00 00 0F 9B 00 00 {199914712} normal block at 0x00F33EA0, 80 bytes long. Data: < 8 8 ?> 00 00 00 00 00 00 00 00 8E E3 38 8E E3 38 F0 3F {199914711} normal block at 0x00F33E20, 80 bytes long. Data: < 4 ?m H # ?> 19 F5 EF 8B 34 C1 8F 3F 6D 83 48 C5 C8 23 9B 3F {199914710} normal block at 0x00F33DE8, 12 bytes long. Data: < = = > E8 3D F3 00 E8 3D F3 00 CD CD CD CD {199914709} normal block at 0x00F33DA8, 16 bytes long. Data: < = = > A8 3D F3 00 A8 3D F3 00 CD CD CD CD CD CD CD CD {199914708} normal block at 0x00F33D68, 16 bytes long. Data: < ' 0= > D8 27 D1 00 01 00 00 00 01 00 00 00 30 3D F3 00 {199914707} normal block at 0x00F33D30, 8 bytes long. Data: <d L > 64 E2 D0 00 4C E2 D0 00 {199914706} normal block at 0x00F33C40, 192 bytes long. Data: <l% > 6C 25 D7 00 00 00 00 00 CD CD CD CD CD CD CD CD {199914705} normal block at 0x00F33598, 12 bytes long. Data: < 9 9 4 > D0 39 F3 00 D0 39 F3 00 8C 34 F3 00 {199914704} normal block at 0x00F33558, 16 bytes long. Data: < 5 5 D9 < > 18 35 F3 00 18 35 F3 00 44 39 F3 00 00 3C F3 00 {199914703} normal block at 0x00F33C00, 16 bytes long. Data: < 8 > 14 D9 D1 00 02 00 00 00 01 00 00 00 B0 38 F3 00 {199914702} normal block at 0x00F33BC0, 16 bytes long. Data: < : > F4 DB D1 00 01 00 00 00 01 00 00 00 C0 3A F3 00 {199914701} normal block at 0x00F33B80, 16 bytes long. Data: < c u? > A8 F5 9A 63 D5 C0 75 3F 00 00 00 00 00 00 00 00 {199914700} normal block at 0x00F33B40, 16 bytes long. Data: < { G ?> 00 00 00 00 00 00 00 00 7B 14 AE 47 E1 FA E2 3F {199914699} normal block at 0x00F33AC0, 80 bytes long. Data: <D 8 : > 44 D9 D1 00 EC 38 F3 00 00 00 00 00 80 3A F3 00 {199914698} normal block at 0x00F33A80, 16 bytes long. Data: < q q\*@> 00 00 00 00 00 00 00 00 C7 71 1C C7 71 5C 2A 40 {199914697} normal block at 0x00F33A40, 16 bytes long. Data: <{ G z ?{ G z ?> 7B 14 AE 47 E1 7A 84 3F 7B 14 AE 47 E1 7A B4 3F {199914696} normal block at 0x00F33A08, 8 bytes long. Data: < S > CA 96 00 00 53 A9 00 00 {199914695} normal block at 0x00F339D0, 12 bytes long. Data: < 5 5 > 98 35 F3 00 98 35 F3 00 CD CD CD CD {199914694} normal block at 0x00F33990, 16 bytes long. Data: < 9 9 > 90 39 F3 00 90 39 F3 00 CD CD CD CD CD CD CD CD {199914693} normal block at 0x00F338B0, 176 bytes long. Data: < > D8 D5 D1 00 FC D5 D1 00 CA 96 00 00 00 01 CD CD {199914692} normal block at 0x00F33870, 16 bytes long. Data: < 6 > EC E0 D1 00 01 00 00 00 01 00 00 00 10 36 F3 00 {199914691} normal block at 0x00F33838, 12 bytes long. Data: <P6 2 ,6 > 50 36 EF 00 C8 32 F0 00 2C 36 F3 00 {199914690} normal block at 0x00F337F8, 16 bytes long. Data: < 7 @7 x > 80 37 F3 00 40 37 F3 00 78 C1 E8 00 F8 C1 E8 00 {199914689} normal block at 0x00F337C0, 12 bytes long. Data: < 4 4 ,6 > E0 34 F3 00 E0 34 F3 00 2C 36 F3 00 {199914688} normal block at 0x00F33780, 16 bytes long. Data: <@7 7 p4 5 > 40 37 F3 00 F8 37 F3 00 70 34 F3 00 D0 35 F3 00 {199914687} normal block at 0x00F33740, 16 bytes long. Data: < 7 7 > F8 37 F3 00 80 37 F3 00 CD CD CD CD CD CD CD CD {199914686} normal block at 0x00F33708, 12 bytes long. Data: < 7 7 > 08 37 F3 00 08 37 F3 00 CD CD CD CD {199914685} normal block at 0x00F336C8, 16 bytes long. Data: < ' ? > A8 27 D1 00 01 00 00 00 01 00 00 00 F8 3F F3 00 {199914684} normal block at 0x00F33FF8, 4 bytes long. Data: < > 10 E2 D0 00 {199914683} normal block at 0x00F33610, 136 bytes long. Data: <` > 60 DC D1 00 00 00 00 00 CD CD CD CD CD CD CD CD {199914682} normal block at 0x00F335D0, 16 bytes long. Data: < , p4 > A4 2C D1 00 02 00 00 00 01 00 00 00 70 34 F3 00 {199914679} normal block at 0x00F33518, 16 bytes long. Data: <X5 X5 > 58 35 F3 00 58 35 F3 00 CD CD CD CD CD CD CD CD {199914678} normal block at 0x00F334E0, 12 bytes long. Data: < 7 7 > C0 37 F3 00 C0 37 F3 00 CD CD CD CD {199914677} normal block at 0x00F33470, 68 bytes long. Data: < $ > DC 24 D1 00 00 00 00 00 CD CD CD CD CD CD CD CD {199914661} normal block at 0x00F33028, 16 bytes long. Data: < ' pX > A8 27 D1 00 01 00 00 00 01 00 00 00 70 58 E8 00 {199914660} normal block at 0x00E85870, 4 bytes long. Data: < > 10 E2 D0 00 {196241912} normal block at 0x00EF3FE8, 16 bytes long. Data: <`{ X; > 60 7B D3 00 01 00 00 00 01 00 00 00 58 3B EF 00 {196241911} normal block at 0x00EF3D30, 648 bytes long. Data: < ?0 Z ? 6:b ?> C7 3F 30 CF 5A F1 94 3F C4 EA DD 36 3A 62 9C 3F {196241900} normal block at 0x00F33F80, 72 bytes long. Data: < ;|S)N ?1r # ?> F8 3B 7C 53 29 4E C2 3F 31 72 C5 D8 23 CF C8 3F {196241679} normal block at 0x00EF3B58, 44 bytes long. Data: < C ? > A8 43 D7 00 0A 00 00 00 01 00 00 00 80 3F F3 00 {196241678} normal block at 0x00E96E18, 16 bytes long. Data: < s (0 > EC 73 D3 00 01 00 00 00 01 00 00 00 28 30 EF 00 {196241553} normal block at 0x00EF3AD8, 80 bytes long. Data: < 8 8 ? 8 8 ?> 8E E3 38 8E E3 38 F0 3F 8E E3 38 8E E3 38 F0 3F {196241552} normal block at 0x00EF3A58, 80 bytes long. Data: < 8 8 ? 8 8 @> 8E E3 38 8E E3 38 F0 3F 8E E3 38 8E E3 38 00 40 {196241551} normal block at 0x00EF31F0, 80 bytes long. Data: < 8 8 ?> 00 00 00 00 00 00 00 00 8E E3 38 8E E3 38 F0 3F {196241550} normal block at 0x00EF3198, 40 bytes long. Data: < 5 > C8 96 00 00 35 98 00 00 A2 99 00 00 0F 9B 00 00 {196241549} normal block at 0x00EF3118, 80 bytes long. Data: < 8 8 ?> 00 00 00 00 00 00 00 00 8E E3 38 8E E3 38 F0 3F {196241548} normal block at 0x00E96D98, 80 bytes long. Data: < 4 ?m H # ?> 19 F5 EF 8B 34 C1 8F 3F 6D 83 48 C5 C8 23 9B 3F {196241547} normal block at 0x00EF33B0, 12 bytes long. Data: < 3 3 > B0 33 EF 00 B0 33 EF 00 CD CD CD CD {196241546} normal block at 0x00EF3370, 16 bytes long. Data: <p3 p3 > 70 33 EF 00 70 33 EF 00 CD CD CD CD CD CD CD CD {196241545} normal block at 0x00E8DB80, 16 bytes long. Data: < ' > D8 27 D1 00 01 00 00 00 01 00 00 00 D8 CB E8 00 {196241544} normal block at 0x00E8CBD8, 8 bytes long. Data: <d L > 64 E2 D0 00 4C E2 D0 00 {196241543} normal block at 0x00EF3028, 192 bytes long. Data: <l% > 6C 25 D7 00 00 00 00 00 CD CD CD CD CD CD CD CD {196241542} normal block at 0x00E8CAC0, 12 bytes long. Data: < 7 7 2 > E8 37 EF 00 E8 37 EF 00 A4 32 EF 00 {196241541} normal block at 0x00E96F88, 16 bytes long. Data: <03 03 \7 : > 30 33 EF 00 30 33 EF 00 5C 37 EF 00 18 3A EF 00 {196241540} normal block at 0x00EF3A18, 16 bytes long. Data: < 6 > 14 D9 D1 00 02 00 00 00 01 00 00 00 C8 36 EF 00 {196241539} normal block at 0x00EF39D8, 16 bytes long. Data: < 8 > F4 DB D1 00 01 00 00 00 01 00 00 00 D8 38 EF 00 {196241538} normal block at 0x00EF3998, 16 bytes long. Data: < c u? > A8 F5 9A 63 D5 C0 75 3F 00 00 00 00 00 00 00 00 {196241537} normal block at 0x00EF3958, 16 bytes long. Data: < { G ?> 00 00 00 00 00 00 00 00 7B 14 AE 47 E1 FA E2 3F {196241536} normal block at 0x00EF38D8, 80 bytes long. Data: <D 7 8 > 44 D9 D1 00 04 37 EF 00 00 00 00 00 98 38 EF 00 {196241535} normal block at 0x00EF3898, 16 bytes long. Data: < q q\*@> 00 00 00 00 00 00 00 00 C7 71 1C C7 71 5C 2A 40 {196241534} normal block at 0x00EF3858, 16 bytes long. Data: <{ G z ?{ G z ?> 7B 14 AE 47 E1 7A 84 3F 7B 14 AE 47 E1 7A B4 3F {196241533} normal block at 0x00EF3820, 8 bytes long. Data: < S > CA 96 00 00 53 A9 00 00 {196241532} normal block at 0x00EF37E8, 12 bytes long. Data: < > C0 CA E8 00 C0 CA E8 00 CD CD CD CD {196241531} normal block at 0x00EF37A8, 16 bytes long. Data: < 7 7 > A8 37 EF 00 A8 37 EF 00 CD CD CD CD CD CD CD CD {196241530} normal block at 0x00EF36C8, 176 bytes long. Data: < > D8 D5 D1 00 FC D5 D1 00 CA 96 00 00 00 01 CD CD {196241529} normal block at 0x00EF3688, 16 bytes long. Data: < (4 > EC E0 D1 00 01 00 00 00 01 00 00 00 28 34 EF 00 {196241528} normal block at 0x00EF3650, 12 bytes long. Data: < 88 D4 > C0 C1 E8 00 38 38 F3 00 44 34 EF 00 {196241527} normal block at 0x00EF3610, 16 bytes long. Data: < 5 X5 x > 98 35 EF 00 58 35 EF 00 78 C1 E8 00 F8 C1 E8 00 {196241526} normal block at 0x00EF35D8, 12 bytes long. Data: < 2 2 D4 > F8 32 EF 00 F8 32 EF 00 44 34 EF 00 {196241525} normal block at 0x00EF3598, 16 bytes long. Data: <X5 6 2 3 > 58 35 EF 00 10 36 EF 00 88 32 EF 00 E8 33 EF 00 {196241524} normal block at 0x00EF3558, 16 bytes long. Data: < 6 5 > 10 36 EF 00 98 35 EF 00 CD CD CD CD CD CD CD CD {196241523} normal block at 0x00EF3520, 12 bytes long. Data: < 5 5 > 20 35 EF 00 20 35 EF 00 CD CD CD CD {196241522} normal block at 0x00EF34E0, 16 bytes long. Data: < ' ` > A8 27 D1 00 01 00 00 00 01 00 00 00 60 CD E7 00 {196241521} normal block at 0x00E7CD60, 4 bytes long. Data: < > 10 E2 D0 00 {196241520} normal block at 0x00EF3428, 136 bytes long. Data: <` > 60 DC D1 00 00 00 00 00 CD CD CD CD CD CD CD CD {196241519} normal block at 0x00EF33E8, 16 bytes long. Data: < , 2 > A4 2C D1 00 02 00 00 00 01 00 00 00 88 32 EF 00 {196241516} normal block at 0x00EF3330, 16 bytes long. Data: < o o > 88 6F E9 00 88 6F E9 00 CD CD CD CD CD CD CD CD {196241515} normal block at 0x00EF32F8, 12 bytes long. Data: < 5 5 > D8 35 EF 00 D8 35 EF 00 CD CD CD CD {196241514} normal block at 0x00EF3288, 68 bytes long. Data: < $ > DC 24 D1 00 00 00 00 00 CD CD CD CD CD CD CD CD {196241498} normal block at 0x00EF1E98, 16 bytes long. Data: < ' G > A8 27 D1 00 01 00 00 00 01 00 00 00 90 47 E8 00 {196241497} normal block at 0x00E84790, 4 bytes long. Data: < > 10 E2 D0 00 {97488898} normal block at 0x00F2FF80, 16 bytes long. Data: < > BC E0 D1 00 03 00 00 00 01 00 00 00 98 FE F2 00 {97488897} normal block at 0x00F2FE98, 188 bytes long. Data: < European> 00 00 00 00 CD CD CD CD 45 75 72 6F 70 65 61 6E {97423077} normal block at 0x00F2FE18, 16 bytes long. Data: < / 0 > 10 2F D6 00 03 00 00 00 01 00 00 00 30 FD F2 00 {97423076} normal block at 0x00F2FDD8, 20 bytes long. Data: < > D8 FD F2 00 D8 FD F2 00 D8 FD F2 00 CD CD CD CD {97423075} normal block at 0x00F2FD98, 20 bytes long. Data: < > 98 FD F2 00 98 FD F2 00 98 FD F2 00 CD CD CD CD {97423074} normal block at 0x00F2FD30, 60 bytes long. Data: < . > E0 2E D6 00 00 00 00 00 CD CD CD CD CD CD CD CD {2918} normal block at 0x00E8C1F8, 16 bytes long. Data: <t, x > 74 2C D1 00 03 00 00 00 01 00 00 00 78 C1 E8 00 {2917} normal block at 0x00E8C1C0, 12 bytes long. Data: < 2 P6 > C8 32 F0 00 50 36 EF 00 CD CD CD CD {2916} normal block at 0x00E8C178, 28 bytes long. Data: <8 > 38 E1 D0 00 00 00 00 00 CD CD CD CD CD CD CD CD Object dump complete. Build log was saved at "file://c:\QL\QuantLib-0.3.12\test-suite\build\vc80\Debug\BuildLog.htm" testsuite - 0 error(s), 0 warning(s) |
|
|
Also, it would be interesting to run the LMM tests repeatedly (in the
same process, of course) and see whether we can actually observe the leak. This could be done both in release and debug mode, and for both VC7 and VC8. Anybody has a box to spare? Luigi ---------------------------------------- fix, n.,v. What one does when a problem has been reported too many times to be ignored. -- the Jargon file |
|
|
In reply to this post by Klaus Spanderen
Hi Klaus
On 2/22/06, Klaus Spanderen <[hidden email]> wrote: > Hi Nando > > I checked testLambdaBootstrapping using VC 8 Express, Boost 1.33.1. My > configuration does not report a memory leak;-(. Can you please send my the > line number of the memory leak as reported by VC 8 Professional? I don't know about VC8 Pro but valgrind detects the memory leak at line 95 of libormarketmodelprocess.cpp, the full output is below. I haven't had time to investigate further but a first guess would be that maybe the shared pointer to the LiborForwardModelProcess object is used incorrectly such that the reference counting is circumvented preventing the object from being deleted when the pointer goes out of scope. Regards, Eric ==13056== Memcheck, a memory error detector. ==13056== Copyright (C) 2002-2005, and GNU GPL'd, by Julian Seward et al. ==13056== Using LibVEX rev 1471, a library for dynamic binary translation. ==13056== Copyright (C) 2004-2005, and GNU GPL'd, by OpenWorks LLP. ==13056== Using valgrind-3.1.0, a dynamic binary instrumentation framework. ==13056== Copyright (C) 2000-2005, and GNU GPL'd, by Julian Seward et al. ==13056== For more details, rerun with: -v ==13056== ==13056== My PID = 13056, parent PID = 3158. Prog and args are: ==13056== lt-quantlib-test-suite ==13056== ==13056== ==13056== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 21 from 1) ==13056== malloc/free: in use at exit: 52,152 bytes in 84 blocks. ==13056== malloc/free: 87,206,644 allocs, 87,206,560 frees, 3,900,805,716 bytes allocated. ==13056== For counts of detected errors, rerun with: -v ==13056== searching for pointers to 84 not-freed blocks. ==13056== checked 1,230,908 bytes. ==13056== ==13056== 1,680 bytes in 1 blocks are possibly lost in loss record 15 of 28 ==13056== at 0x43CA7F8: operator new(unsigned) (vg_replace_malloc.c:164) ==13056== by 0x8A7A7A: std::__default_alloc_template<true, 0>::_S_chunk_alloc(unsigned, int&) (in /usr/lib/libstdc++.so.5.0.7) ==13056== by 0x8A798C: std::__default_alloc_template<true, 0>::_S_refill(unsigned) (in /usr/lib/libstdc++.so.5.0.7) ==13056== by 0x8A7687: std::__default_alloc_template<true, 0>::allocate(unsigned) (in /usr/lib/libstdc++.so.5.0.7) ==13056== by 0x8AD017: std::string::_Rep::_S_create(unsigned, std::allocator<char> const&) (in /usr/lib/libstdc++.so.5.0.7) ==13056== by 0x4415094: char* std::string::_S_construct<char const*>(char const*, char const*, std::allocator<char> const&, std::forward_iterator_tag) (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x44154C4: boost::unit_test_framework::retrieve_framework_parameter(char const*, int*, char**) (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x441CC26: main (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== ==13056== ==13056== 2,192 (224 direct, 1,968 indirect) bytes in 2 blocks are definitely lost in loss record 16 of 28 ==13056== at 0x43CA7F8: operator new(unsigned) (vg_replace_malloc.c:164) ==13056== by 0x821683D: (anonymous namespace)::makeProcess(QuantLib::Matrix const&) (libormarketmodelprocess.cpp:95) ==13056== by 0x8217F33: LiborMarketModelProcessTest::testMonteCarloCapletPricing() (libormarketmodelprocess.cpp:226) ==13056== by 0x80B7F35: boost::unit_test_framework::function_test_case::do_run() (unit_test_suite.hpp:138) ==13056== by 0x441748C: boost::unit_test_framework::detail::unit_test_monitor::function() (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x44115EA: (within /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x440FF30: boost::execution_monitor::execute(bool, int) (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x4417317: boost::unit_test_framework::detail::unit_test_monitor::execute_and_translate(boost::unit_test_framework::test_case*, void (boost::unit_test_framework::test_case::*)(), int) (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x441B8FB: boost::unit_test_framework::test_case::run() (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x441C0B4: boost::unit_test_framework::test_suite::do_run() (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x441BA90: boost::unit_test_framework::test_case::run() (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x441C0B4: boost::unit_test_framework::test_suite::do_run() (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== ==13056== ==13056== 1,240 (44 direct, 1,196 indirect) bytes in 1 blocks are definitely lost in loss record 18 of 28 ==13056== at 0x43CA7F8: operator new(unsigned) (vg_replace_malloc.c:164) ==13056== by 0x82121BF: boost::detail::shared_count::shared_count<QuantLib::LiborForwardModelProcess*, boost::checked_deleter<QuantLib::LiborForwardModelProcess> >(QuantLib::LiborForwardModelProcess*, boost::checked_deleter<QuantLib::LiborForwardModelProcess>) (shared_count.hpp:341) ==13056== by 0x8210C1C: boost::shared_ptr<QuantLib::LiborForwardModelProcess>::shared_ptr<QuantLib::LiborForwardModelProcess>(QuantLib::LiborForwardModelProcess*) (shared_ptr.hpp:126) ==13056== by 0x8216884: (anonymous namespace)::makeProcess(QuantLib::Matrix const&) (libormarketmodelprocess.cpp:95) ==13056== by 0x8217F80: LiborMarketModelProcessTest::testMonteCarloCapletPricing() (libormarketmodelprocess.cpp:228) ==13056== by 0x80B7F35: boost::unit_test_framework::function_test_case::do_run() (unit_test_suite.hpp:138) ==13056== by 0x441748C: boost::unit_test_framework::detail::unit_test_monitor::function() (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x44115EA: (within /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x440FF30: boost::execution_monitor::execute(bool, int) (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x4417317: boost::unit_test_framework::detail::unit_test_monitor::execute_and_translate(boost::unit_test_framework::test_case*, void (boost::unit_test_framework::test_case::*)(), int) (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x441B8FB: boost::unit_test_framework::test_case::run() (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== by 0x441C0B4: boost::unit_test_framework::test_suite::do_run() (in /usr/local/lib/libboost_unit_test_framework-gcc-1_31.so.1.31.0) ==13056== ==13056== LEAK SUMMARY: ==13056== definitely lost: 268 bytes in 3 blocks. ==13056== indirectly lost: 3,164 bytes in 24 blocks. ==13056== possibly lost: 1,680 bytes in 1 blocks. ==13056== still reachable: 47,040 bytes in 56 blocks. ==13056== suppressed: 0 bytes in 0 blocks. ==13056== Reachable blocks (those to which a pointer was found) are not shown. ==13056== To see them, rerun with: --show-reachable=yes |
|
|
On 02/23/2006 01:22:42 PM, eric ehlers wrote:
> I don't know about VC8 Pro but valgrind detects the memory leak at > line 95 of libormarketmodelprocess.cpp, the full output is below. > > I haven't had time to investigate further but a first guess would be > that maybe the shared pointer to the LiborForwardModelProcess object > is used incorrectly such that the reference counting is circumvented > preventing the object from being deleted when the pointer goes out of > scope. Ok, I see. There's a circular reference. First the shared_ptr to process is passed to fct, which stores it. Then fct is passed to process through setCovarParam and stored in turn. As process and fct hold shared_ptrs to each other, neither reference count will ever reach 0 and the allocated memory will never be freed. Klaus, is the circularity necessary in the test---or in real life? If so, we'll have to think of a way to break the cycle; a weak_ptr would be the obvious choice. Later, Luigi ---------------------------------------- A debugged program is one for which you have not yet found the conditions that make it fail. -- Jerry Ogdin |
|
|
In reply to this post by Luigi Ballabio
Hi @all,
yes, Nando, Eric & Luigi you are right! Seems that I'm using Java & C# to often and sometimes forget that shared_ptr aren't fail-safe. Lugi, I'll break this circularity in LfmHullWhiteParameterization and send you an updated version soon. thanks for the bug hunting! cheers Klaus ----- original Nachricht -------- Betreff: Re: [Quantlib-dev] 0.3.12 test tarballs Gesendet: Do 23 Feb 2006 13:47:37 CET Von: "Luigi Ballabio"<[hidden email]> > > On 02/23/2006 01:22:42 PM, eric ehlers wrote: > > I don't know about VC8 Pro but valgrind detects the memory leak at > > line 95 of libormarketmodelprocess.cpp, the full output is below. > > > > I haven't had time to investigate further but a first guess would be > > that maybe the shared pointer to the LiborForwardModelProcess object > > is used incorrectly such that the reference counting is circumvented > > preventing the object from being deleted when the pointer goes out of > > scope. > > Ok, I see. There's a circular reference. First the shared_ptr to > process is passed to fct, which stores it. Then fct is passed to > process through setCovarParam and stored in turn. As process and fct > hold shared_ptrs to each other, neither reference count will ever reach > 0 and the allocated memory will never be freed. > > Klaus, is the circularity necessary in the test---or in real life? If > so, we'll have to think of a way to break the cycle; a weak_ptr would > be the obvious choice. > > Later, > Luigi > > > ---------------------------------------- > > A debugged program is one for which you have not yet found the > conditions that make it fail. > -- Jerry Ogdin > --- original Nachricht Ende ---- |
Re: Re: 0.3.12 test tarballs
|
|
Hi Klaus
> [...] I'll break this circularity in LfmHullWhiteParameterization and > send you an updated version soon. I've checked your updated version with VC8 Professional: it solves the memory leak problem thank you ciao -- Nando |
«
Return to quantlib-dev
|
1 view|%1 views
| Free forum by Nabble | Edit this page |