wxOil/tunemem.cpp

   1 // $Id: tunemem.cpp 1282 2006-06-09 09:46:49Z alex $
   2 /* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE
   3 ================================XARAHEADERSTART===========================
   4
   5                Xara LX, a vector drawing and manipulation program.
   6                     Copyright (C) 1993-2006 Xara Group Ltd.
   7        Copyright on certain contributions may be held in joint with their
   8               respective authors. See AUTHORS file for details.
   9
  10 LICENSE TO USE AND MODIFY SOFTWARE
  11 ----------------------------------
  12
  13 This file is part of Xara LX.
  14
  15 Xara LX is free software; you can redistribute it and/or modify it
  16 under the terms of the GNU General Public License version 2 as published
  17 by the Free Software Foundation.
  18
  19 Xara LX and its component source files are distributed in the hope
  20 that it will be useful, but WITHOUT ANY WARRANTY; without even the
  21 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  22 See the GNU General Public License for more details.
  23
  24 You should have received a copy of the GNU General Public License along
  25 with Xara LX (see the file GPL in the root directory of the
  26 distribution); if not, write to the Free Software Foundation, Inc., 51
  27 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  28
  29
  30 ADDITIONAL RIGHTS
  31 -----------------
  32
  33 Conditional upon your continuing compliance with the GNU General Public
  34 License described above, Xara Group Ltd grants to you certain additional
  35 rights.
  36
  37 The additional rights are to use, modify, and distribute the software
  38 together with the wxWidgets library, the wxXtra library, and the "CDraw"
  39 library and any other such library that any version of Xara LX relased
  40 by Xara Group Ltd requires in order to compile and execute, including
  41 the static linking of that library to XaraLX. In the case of the
  42 "CDraw" library, you may satisfy obligation under the GNU General Public
  43 License to provide source code by providing a binary copy of the library
  44 concerned and a copy of the license accompanying it.
  45
  46 Nothing in this section restricts any of the rights you have under
  47 the GNU General Public License.
  48
  49
  50 SCOPE OF LICENSE
  51 ----------------
  52
  53 This license applies to this program (XaraLX) and its constituent source
  54 files only, and does not necessarily apply to other Xara products which may
  55 in part share the same code base, and are subject to their own licensing
  56 terms.
  57
  58 This license does not apply to files in the wxXtra directory, which
  59 are built into a separate library, and are subject to the wxWindows
  60 license contained within that directory in the file "WXXTRA-LICENSE".
  61
  62 This license does not apply to the binary libraries (if any) within
  63 the "libs" directory, which are subject to a separate license contained
  64 within that directory in the file "LIBS-LICENSE".
  65
  66
  67 ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS
  68 ----------------------------------------------
  69
  70 Subject to the terms of the GNU Public License (see above), you are
  71 free to do whatever you like with your modifications. However, you may
  72 (at your option) wish contribute them to Xara's source tree. You can
  73 find details of how to do this at:
  74   http://www.xaraxtreme.org/developers/
  75
  76 Prior to contributing your modifications, you will need to complete our
  77 contributor agreement. This can be found at:
  78   http://www.xaraxtreme.org/developers/contribute/
  79
  80 Please note that Xara will not accept modifications which modify any of
  81 the text between the start and end of this header (marked
  82 XARAHEADERSTART and XARAHEADEREND).
  83
  84
  85 MARKS
  86 -----
  87
  88 Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara
  89 designs are registered or unregistered trademarks, design-marks, and/or
  90 service marks of Xara Group Ltd. All rights in these marks are reserved.
  91
  92
  93       Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK.
  94                         http://www.xara.com/
  95
  96 =================================XARAHEADEREND============================
  97  */
  98 // Tuned Memory manager
  99
 100 /*
 101 */
 102
 103 #include "camtypes.h"
 104 #include "tunemem.h"
 105 //#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]
 106 //#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
 107
 108 // An implement to match the Declare in the .h file.
 109 CC_IMPLEMENT_MEMDUMP(TunedMemory, CC_CLASS_MEMDUMP)
 110
 111 // This will get Camelot to display the filename and linenumber of any memory allocations
 112 // that are not released at program exit
 113 // Declare smart memory handling in Debug builds
 114 #define new CAM_DEBUG_NEW
 115
 116 //static BOOL ShowBandingRAM = FALSE;
 117
 118 // Defaults for smart banding
 119 BOOL TunedMemory::RecommendInfinite = FALSE;
 120 INT32 TunedMemory::RecommendRAM = 1024*768;
 121
 122 /********************************************************************************************
 123
 124         Preference:     MaxRenderingRAM
 125         Section:
 126         Range:          >128K
 127         Purpose:        This pref is used to set the maximum amount of ram that can be used to
 128                                 render with. If there is less than the screen needs here, the rendering
 129                                 will be banded. Useful on Low memory machines.
 130
 131 ********************************************************************************************/
 132
 133 size_t TunedMemory::LimitRAM            = 1024*768;
 134 size_t TunedMemory::TotalRAM            = 1024*768;
 135 size_t TunedMemory::AvailableRAM        = 1024*768;     // Make this the same!
 136
 137
 138
 139 /********************************************************************************************
 140
 141         Preference:     IsRenderingRAMInfinte
 142         Section:
 143         Range:          TRUE, FALSE
 144         Purpose:        If this pref is TRUE then the MaxRenderingRAM preference is ignored and all
 145                                 the ram we want is used. If it is FALSE the rendering ram will be limited
 146                                 to the figure in MaxRenderingRAM
 147
 148 ********************************************************************************************/
 149
 150 BOOL TunedMemory::IsInfinite = TRUE;
 151
 152
 153 /********************************************************************************************
 154
 155         Preference:     SmartRenderingRAM
 156         Section:
 157         Range:          TRUE, FALSE
 158         Purpose:        If this pref is TRUE then the MaxRenderingRAM preference is ignored and
 159                                 the amount to use is calculated according to available memory.
 160                                 If it is FALSE the rendering ram will be limited to the figure in
 161                                 MaxRenderingRAM
 162
 163 ********************************************************************************************/
 164
 165 BOOL TunedMemory::SmartBanding = TRUE;
 166
 167
 168 /********************************************************************************************
 169
 170 >       TunedMemory::TunedMemory()
 171
 172         Author:         Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
 173         Created:        1/5/95
 174         Purpose:        Constructor - sets the memory thing up with a default value of 1Mb of
 175                                 available ram
 176
 177 ********************************************************************************************/
 178
 179 TunedMemory::TunedMemory()
 180 {
 181         // make sure that the available ram is the same as the total
 182         AvailableRAM = TotalRAM = LimitRAM;
 183 }
 184
 185
 186
 187
 188
 189 /********************************************************************************************
 190
 191 >       TunedMemory::~TunedMemory()
 192
 193         Author:         Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
 194         Created:        1/5/95
 195         Purpose:        Destructor - TRACES an error out if there is still some ram left over
 196
 197 ********************************************************************************************/
 198
 199 TunedMemory::~TunedMemory()
 200 {
 201         if (AvailableRAM!=TotalRAM)
 202         {
 203                 TRACEUSER( "Rik", wxT("At Exit the Available Ram did not equal the Total Ram in TunedMemory\n") );
 204                 TRACEUSER( "Rik", wxT("TotalRAM = %ld, Available=%ld\n"), TotalRAM, AvailableRAM );
 205         }
 206 }
 207
 208
 209
 210
 211
 212 /********************************************************************************************
 213
 214 >       LPVOID TunedMemory::LimitedCCMalloc(UINT32 Size)
 215
 216         Author:         Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
 217         Created:        1/5/95
 218         Inputs:         Size - the ammount of ram needed
 219         Returns:        A pointer to the allocated ram or NULL if there is no more ram available
 220         Purpose:        Allocates ram out of the limited pool. The Available ram is decreased.
 221         SeeAlso:        LimitedCCFree
 222
 223 ********************************************************************************************/
 224
 225 LPVOID TunedMemory::LimitedCCMalloc(size_t Size)
 226 {
 227         // Get some ram
 228         LPVOID Memory = CCMalloc(Size);
 229
 230         // if we got it, make a note of its allocation
 231         if ((Memory!=NULL) && (!IsInfinite))
 232         {
 233                 AvailableRAM -= Size;
 234         }
 235
 236         // return what we got
 237         return Memory;
 238 }
 239
 240 /********************************************************************************************
 241
 242 >       LPVOID TunedMemory::LimitedCCRealloc(LPVOID buf, UINT32 NewSize)
 243
 244         Author:         Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
 245         Created:        5/7/95
 246         Inputs:         Size - the new ammount of ram needed
 247         Returns:        A pointer to the allocated ram or NULL if there is no more ram available
 248         Purpose:        Re-Allocates ram out of the limited pool. The Available ram is decreased.
 249         SeeAlso:        LimitedCCFree
 250
 251 ********************************************************************************************/
 252
 253 LPVOID TunedMemory::LimitedCCRealloc(LPVOID buf, size_t NewSize)
 254 {
 255         // Find out how big the block is at the moment
 256         size_t OldSize = CCGetBlockSize(buf);
 257
 258         // Resize the block
 259         LPVOID Memory = CCRealloc( buf, NewSize );
 260
 261         // If it got bigger, then decrease the available RAM,
 262         // otherwise we increase it
 263         if ((Memory!=NULL) && (!IsInfinite))
 264         {
 265                 AvailableRAM -= (NewSize - OldSize);
 266         }
 267
 268         // return what we got
 269         return Memory;
 270 }
 271
 272
 273
 274
 275 /********************************************************************************************
 276
 277 >       void TunedMemory::LimitedCCFree(LPVOID buf)
 278
 279         Author:         Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
 280         Created:        1/5/95
 281         Inputs:         buf - the previously allocated buffer
 282         Purpose:        Frees the memory allocated by LimitedCCMalloc
 283
 284 ********************************************************************************************/
 285
 286 void TunedMemory::LimitedCCFree(LPVOID buf)
 287 {
 288         // Find out how big the block was
 289         size_t BlockSize = CCGetBlockSize(buf);
 290
 291         // add it back into the pool
 292         if (!IsInfinite)
 293                 AvailableRAM += BlockSize;
 294
 295         // Free the memory
 296         CCFree(buf);
 297 }
 298
 299
 300
 301
 302
 303 /********************************************************************************************
 304
 305 >       INT32 TunedMemory::GetTotalTunedMem()
 306
 307         Author:         Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
 308         Created:        1/5/95
 309         Returns:        Total ram in the limited heap
 310         Purpose:        Finds out the total ram that can be allocated in the limited memory thing.
 311                                 This is how much ram the user has deemed enough for Camelot to do its
 312                                 rendering etc with. When this ammount has been allocated rendering will
 313                                 have to wait for other regions to finish before they can start.
 314         SeeAlso:        TunedMemory::GetAvailableTunedMem
 315
 316 ********************************************************************************************/
 317
 318 size_t TunedMemory::GetTotalTunedMem()
 319 {
 320         return TotalRAM;
 321 }
 322
 323
 324
 325
 326
 327 /********************************************************************************************
 328
 329 >       INT32 TunedMemory::GetAvailableTunedMem()
 330
 331         Author:         Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
 332         Created:        1/5/95
 333         Returns:        The amount of available ram in the limited pool
 334         Purpose:        This is the amount of the ram that could be allocated (GetTotal) that is
 335                                 still left unallocated. If this amount is not enough for your job, then
 336                                 you should wait until this function returns a bigger number. It would also
 337                                 be worth checking to see if the TotalTunedRam would be enough as well.
 338
 339 ********************************************************************************************/
 340
 341 size_t TunedMemory::GetAvailableTunedMem()
 342 {
 343         return AvailableRAM;
 344 }
 345
 346
 347
 348 /********************************************************************************************
 349
 350 >       static INT32 TunedMemory::GetLimitedMemSize()
 351
 352         Author:         Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
 353         Created:        4/5/95
 354         Returns:        The current size of the limited memory thing
 355         Purpose:        To allows the Options Dialog to find out what the current setting for the
 356                                 amount of RAM that can be used for rendering is at.
 357
 358 ********************************************************************************************/
 359
 360 size_t TunedMemory::GetLimitedMemSize()
 361 {
 362         return LimitRAM;
 363 }
 364
 365
 366
 367 /********************************************************************************************
 368
 369 >       static void TunedMemory::SetLimitedMemSize(INT32 NewSize)
 370
 371         Author:         Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
 372         Created:        4/5/95
 373         Inputs:         NewSize - The new size of the limited memory heap
 374         Returns:        NewSize if ok or if the value is too low, a new minimum size.
 375         Purpose:        This function allows the options dialog to set the amount of ram to use
 376                                 for drawing to a new value that the user chose. If the value is less than
 377                                 a minimum useful value, at present 128k, then the value will be ignored and
 378                                 128k will be used.
 379
 380 ********************************************************************************************/
 381
 382 size_t TunedMemory::SetLimitedMemSize(size_t NewSize)
 383 {
 384         // make sure it is not too small for safty
 385         if (NewSize<1024*128)
 386                 NewSize = 1024*128;
 387
 388         // Find out what the difference is
 389         size_t Difference = NewSize - TotalRAM;
 390
 391         // Set the total to the new size
 392         TotalRAM = NewSize;
 393         LimitRAM = NewSize;
 394
 395         // And change the available ram as well
 396         AvailableRAM += Difference;
 397
 398         return NewSize;
 399 }
 400
 401
 402
 403 /********************************************************************************************
 404
 405 >       static BOOL TunedMemory::IsMemSizeInfinite()
 406
 407         Author:         Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
 408         Created:        4/5/95
 409         Returns:        TRUE if the Limited heap is not currently limited, FALSE if it is
 410         Purpose:        Lets the options dialog have a look at the Tuned Memorys IsInfinite state.
 411
 412 ********************************************************************************************/
 413
 414 BOOL TunedMemory::IsMemSizeInfinite()
 415 {
 416         return IsInfinite;
 417 }
 418
 419 /********************************************************************************************
 420
 421 >       static BOOL TunedMemory::IsAutomaticMemory()
 422
 423         Author:         Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
 424         Created:        16/6/95
 425         Returns:        TRUE if the memory limit will be calculated automatically.
 426                                 FALSE if the user value is being used.
 427         Purpose:        Lets the options dialog have a look at the Smart banding state.
 428
 429 ********************************************************************************************/
 430
 431 BOOL TunedMemory::IsAutomaticMemory()
 432 {
 433         // This routine has been changed to determine whether to use the
 434         // recommended memory or not.
 435         return SmartBanding;
 436 }
 437
 438
 439 /********************************************************************************************
 440
 441 >       static void TunedMemory::SetMemSizeInfinte(BOOL NewIsInfinite)
 442
 443         Author:         Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
 444         Created:        4/5/95
 445         Inputs:         NewIsInfinite - The new state of the Infinte flag
 446         Purpose:        Sets the infinte flag in the limited memory manager. TRUE means the limited
 447                                 heap should be made infinte, FALSE means use the value found by
 448                                 GetLimitedMemSize
 449                                 NOTE: This call now determines whether to use the recommended memory
 450                                       or not.
 451
 452 ********************************************************************************************/
 453
 454 void TunedMemory::SetMemSizeInfinte(BOOL NewSmartBanding)
 455 {
 456         // Set the member version
 457         SmartBanding = NewSmartBanding;
 458
 459         if (SmartBanding)
 460         {
 461                 // If 'Smart' banding enabled, then use the
 462                 // recommended memory (calculated on startup)
 463                 IsInfinite      = RecommendInfinite;
 464
 465                 if (!IsInfinite)
 466                 {
 467                         // Set the recommended memory limit
 468
 469                         // Find out what the difference is
 470                         size_t          Difference = RecommendRAM - TotalRAM;
 471
 472                         // Set the total to the new size
 473                         TotalRAM = RecommendRAM;
 474
 475                         // And change the available ram as well
 476                         AvailableRAM += Difference;
 477                 }
 478         }
 479         else
 480         {
 481                 // Use the user specified limited RAM
 482                 IsInfinite = FALSE;
 483                 TotalRAM = LimitRAM;
 484                 AvailableRAM = LimitRAM;
 485         }
 486 }
 487
 488
 489
 490
 491 /********************************************************************************************
 492
 493 >       static INT32 TunedMemory::GetScreenMemSize()
 494
 495         Author:         Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
 496         Created:        4/5/95
 497         Returns:        The mem required to do a full screen redraw with transparancy on
 498         Purpose:        This function gives a figure for the amount of ram needed to redraw
 499                                 the full screen with transparency on. for 1024 x 768 this is about 3.5Meg
 500
 501 ********************************************************************************************/
 502
 503 INT32 TunedMemory::GetScreenMemSize()
 504 {
 505         INT32                                   Width  = wxSystemSettings::GetMetric( wxSYS_SCREEN_X );
 506         INT32                                   Height = wxSystemSettings::GetMetric( wxSYS_SCREEN_Y );
 507         return Width * Height * 4;
 508 }
 509
 510
 511
 512
 513 /********************************************************************************************
 514
 515 >       static BOOL Init()
 516
 517         Author:         Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
 518         Created:        4/5/95
 519         Returns:        TRUE if it worked, FALSE if not
 520         Purpose:        Declares the preferences for this class in the ini file.
 521
 522 ********************************************************************************************/
 523
 524 BOOL TunedMemory::Init()
 525 {
 526         if( Camelot.DeclareSection( wxT("Screen"), 10 ) )
 527         {
 528                 Camelot.DeclarePref( NULL, wxT("MaxRenderingRAM"), (INT32*)&LimitRAM );
 529                 Camelot.DeclarePref( NULL, wxT("IsRenderingRAMInfinte"), &IsInfinite, FALSE, TRUE );
 530                 Camelot.DeclarePref( NULL, wxT("SmartRenderingRAM"), &SmartBanding, FALSE, TRUE );
 531
 532 //              Camelot.DeclarePref(NULL, "ShowBandingRAM", &ShowBandingRAM, FALSE, TRUE);
 533         }
 534
 535         // Find the available Physical memory,
 536         // and work out a sensible band size to use
 537         CalculateRecommendedMemory();
 538
 539         if (SmartBanding)
 540         {
 541                 // Use the recommended memory
 542                 TotalRAM        = RecommendRAM;
 543                 IsInfinite      = RecommendInfinite;
 544         }
 545         else
 546         {
 547                 // Use the user specified limited RAM
 548                 TotalRAM        = LimitRAM;
 549         }
 550
 551         // Set available ram equal to the total ram
 552         AvailableRAM = TotalRAM;
 553         return TRUE;
 554 }
 555
 556 /********************************************************************************************
 557
 558 >       void TunedMemory::CalculateRecommendedMemory()
 559
 560         Author:         Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
 561         Created:        16/6/95
 562         Purpose:        Calculates a sensible default Banding size given the Physical memory
 563                                 available.
 564
 565 ********************************************************************************************/
 566
 567 void TunedMemory::CalculateRecommendedMemory()
 568 {
 569         TRACE( _T("Warning - TunedMemory::CalculateRecommendedMemory called") );
 570
 571 #if defined(__WXMSW)
 572         MEMORYSTATUS MemStat;
 573         MemStat.dwLength = sizeof(MEMORYSTATUS);
 574         GlobalMemoryStatus(&MemStat);
 575
 576         INT32 PhysicalMemory = MemStat.dwTotalPhys;
 577         TRACEALL( wxT("Total Physical Memory is %d\n"), PhysicalMemory);
 578
 579 //      INT32 ScreenMem = GetScreenMemSize();
 580 //      TRACEALL( _T("Screen Memory is %d\n"), ScreenMem);
 581
 582         if (PhysicalMemory <= 8*1024*1024)                      // 8 Megs or less
 583         {
 584                 RecommendInfinite = FALSE;                              // Use limited memory
 585                 RecommendRAM = 512*1024;                                // Limit to max of 512 K
 586         }
 587         else if (PhysicalMemory <= 12*1024*1024)        // 8 to 12 Megs
 588         {
 589                 RecommendInfinite = FALSE;                              // Use limited memory
 590                 RecommendRAM = 1*1024*1024;                             // Limit to max of 1024 K
 591         }
 592         else if (PhysicalMemory <= 16*1024*1024)        // 12 to 16 Megs
 593         {
 594                 RecommendInfinite = FALSE;                              // Use limited memory
 595                 RecommendRAM = 2*1024*1024;                             // Limit to max of 2048 K
 596         }
 597         else                                                                            // More than 16 Megs
 598         {
 599                 RecommendInfinite = TRUE;                               // Unlimited memory
 600         }
 601
 602         if (ShowBandingRAM)
 603         {
 604                 ERROR3_PF( ("Total Physical Memory is %d", PhysicalMemory) );
 605
 606                 if (IsInfinite)
 607                 {
 608                         ERROR3("Using unlimited banding RAM");
 609                         TRACEALL( wxT("Using unlimited Rendering RAM\n") );
 610                 }
 611                 else
 612                 {
 613                         ERROR3_PF( ("Rendering RAM set to %d",TotalRAM) );
 614                         TRACEALL( wxT("Rendering RAM set to %d\n"), TotalRAM );
 615                 }
 616         }
 617 #else
 618         RecommendInfinite = TRUE;
 619 #endif
 620 }
 621