Code/CryEngine/CrySystem/MemReplay.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include <CryCore/BitFiddling.h>
   5
   6 #include <stdio.h>
   7 #include <algorithm>  // std::min()
   8 #include <CrySystem/ISystem.h>
   9 #include <CryCore/Platform/platform.h>
  10
  11 #include "MemoryManager.h"
  12
  13 #include "MemReplay.h"
  14
  15 #include "System.h"
  16 #include <CryNetwork/CrySocks.h>
  17
  18 extern SSystemCVars g_cvars;
  19
  20 // FIXME DbgHelp broken on Durango currently
  21 #if CRY_PLATFORM_WINDOWS //|| CRY_PLATFORM_DURANGO
  22         #include "DebugCallStack.h"
  23         #include <Psapi.h>
  24         #include "DbgHelp.h"
  25
  26 namespace
  27 {
  28 struct CVDebugInfo
  29 {
  30         DWORD cvSig;
  31         GUID  pdbSig;
  32         DWORD age;
  33         char  pdbName[256];
  34 };
  35 }
  36 #endif
  37
  38 #if CRY_PLATFORM_DURANGO
  39         #include <processthreadsapi.h>
  40 #endif
  41
  42 #if CRY_PLATFORM_LINUX || CRY_PLATFORM_ANDROID
  43         #include <sys/mman.h>
  44         #if !defined(_GNU_SOURCE)
  45                 #define _GNU_SOURCE
  46         #endif
  47         #include <link.h>
  48 #endif
  49
  50 #if CRY_PLATFORM_LINUX || CRY_PLATFORM_ANDROID || CRY_PLATFORM_APPLE
  51         #include <sys/mman.h>
  52 #endif
  53
  54 #if CRY_PLATFORM_ORBIS
  55         #include <net.h>
  56         #include <CryNetwork/CrySocks.h>
  57 #endif
  58
  59 #if CAPTURE_REPLAY_LOG || ENABLE_STATOSCOPE
  60
  61 #pragma pack(push)
  62 #pragma pack(1)
  63
  64 struct MemReplayFrameStartEvent
  65 {
  66         static const int EventId = MemReplayEventIds::RE_FrameStart;
  67
  68         uint32           frameId;
  69
  70         MemReplayFrameStartEvent(uint32 frameId)
  71                 : frameId(frameId)
  72         {}
  73 } __PACKED;
  74
  75 struct MemReplayLabelEvent
  76 {
  77         static const int EventId = MemReplayEventIds::RE_Label;
  78
  79         char             label[1];
  80
  81         MemReplayLabelEvent(const char* label)
  82         {
  83                 // Assume there is room beyond this instance.
  84                 strcpy(this->label, label); // we're intentionally writing beyond the end of this array, so don't use cry_strcpy()
  85         }
  86 } __PACKED;
  87
  88 struct MemReplayAddFixedContextEvent
  89 {
  90         static const int EventId = MemReplayEventIds::RE_AddFixedContext;
  91
  92         uint64 threadId;
  93         uint32 contextType;
  94         uint32 fixedContextId;
  95         char   name[1];
  96
  97         MemReplayAddFixedContextEvent(uint64 threadId, const char* name, EMemStatContextType type, IMemReplay::FixedContextID ctxId)
  98         {
  99                 this->threadId = threadId;
 100                 this->contextType = static_cast<uint32>(type);
 101                 this->fixedContextId = ctxId;
 102                 // We're going to assume that there actually is enough space to store the name directly in the struct.
 103                 strcpy(this->name, name); // we're intentionally writing beyond the end of this array, so don't use cry_strcpy()
 104         }
 105 } __PACKED;
 106
 107 struct MemReplayPushFixedContextEvent
 108 {
 109         static const int EventId = MemReplayEventIds::RE_PushFixedContext;
 110
 111         uint64 threadId;
 112         IMemReplay::FixedContextID contextId;
 113
 114         MemReplayPushFixedContextEvent(uint64 threadId, IMemReplay::FixedContextID contextId)
 115         {
 116                 this->threadId = threadId;
 117                 this->contextId = contextId;
 118         }
 119 } __PACKED;
 120
 121 struct MemReplayPushContextEvent
 122 {
 123         static const int EventId = MemReplayEventIds::RE_PushContext3;
 124
 125         uint64           threadId;
 126         uint32           contextType;
 127
 128         // This field must be the last in the structure, and enough memory should be allocated
 129         // for the structure to hold the required name.
 130         char name[1];
 131
 132         MemReplayPushContextEvent(uint64 threadId, const char* name, EMemStatContextType type)
 133         {
 134                 // We're going to assume that there actually is enough space to store the name directly in the struct.
 135
 136                 this->threadId = threadId;
 137                 this->contextType = static_cast<uint32>(type);
 138                 strcpy(this->name, name); // we're intentionally writing beyond the end of this array, so don't use cry_strcpy()
 139         }
 140 } __PACKED;
 141
 142 struct MemReplayPopContextEvent
 143 {
 144         static const int EventId = MemReplayEventIds::RE_PopContext;
 145
 146         uint64 threadId;
 147
 148         explicit MemReplayPopContextEvent(uint64 threadId)
 149         {
 150                 this->threadId = threadId;
 151         }
 152 } __PACKED;
 153
 154 struct MemReplayModuleRefEvent
 155 {
 156         static const int EventId = MemReplayEventIds::RE_ModuleRef;
 157
 158         char             name[256];
 159         char             path[256];
 160         char             sig[512];
 161         UINT_PTR         address;
 162         UINT_PTR         size;
 163
 164         MemReplayModuleRefEvent(const char* name, const char* path, const UINT_PTR address, UINT_PTR size, const char* sig)
 165         {
 166                 cry_strcpy(this->name, name);
 167                 cry_strcpy(this->path, path);
 168                 cry_strcpy(this->sig, sig);
 169                 this->address = address;
 170                 this->size = size;
 171         }
 172 } __PACKED;
 173
 174 struct MemReplayModuleUnRefEvent
 175 {
 176         static const int EventId = MemReplayEventIds::RE_ModuleUnRef;
 177
 178         UINT_PTR         address;
 179
 180         MemReplayModuleUnRefEvent(UINT_PTR address)
 181                 : address(address) {}
 182 } __PACKED;
 183
 184 struct MemReplayModuleRefShortEvent
 185 {
 186         static const int EventId = MemReplayEventIds::RE_ModuleShortRef;
 187
 188         char             name[256];
 189
 190         MemReplayModuleRefShortEvent(const char* name)
 191         {
 192                 cry_strcpy(this->name, name);
 193         }
 194 } __PACKED;
 195
 196 struct MemReplayAllocEvent
 197 {
 198         static const int EventId = MemReplayEventIds::RE_Alloc6;
 199
 200         uint64           threadId;
 201         UINT_PTR         id;
 202         uint32           alignment;
 203         uint32           sizeRequested;
 204         uint32           sizeConsumed;
 205         int32            sizeGlobal; //  Inferred from changes in global memory status
 206
 207         uint16           moduleId;
 208         uint16           allocClass;
 209         uint16           allocSubClass;
 210         uint16           callstackLength;
 211         UINT_PTR         callstack[1]; // Must be last.
 212
 213         MemReplayAllocEvent(uint64 threadId, uint16 moduleId, uint16 allocClass, uint16 allocSubClass, UINT_PTR id, uint32 alignment, uint32 sizeReq, uint32 sizeCon, int32 sizeGlobal)
 214                 : threadId(threadId)
 215                 , id(id)
 216                 , alignment(alignment)
 217                 , sizeRequested(sizeReq)
 218                 , sizeConsumed(sizeCon)
 219                 , sizeGlobal(sizeGlobal)
 220                 , moduleId(moduleId)
 221                 , allocClass(allocClass)
 222                 , allocSubClass(allocSubClass)
 223                 , callstackLength(0)
 224         {
 225         }
 226 } __PACKED;
 227
 228 struct MemReplayFreeEvent
 229 {
 230         static const int EventId = MemReplayEventIds::RE_Free6;
 231
 232         uint64           threadId;
 233         UINT_PTR         id;
 234         int32            sizeGlobal; //  Inferred from changes in global memory status
 235
 236         uint16           moduleId;
 237         uint16           allocClass;
 238         uint16           allocSubClass;
 239
 240         uint16           callstackLength;
 241         UINT_PTR         callstack[1]; // Must be last.
 242
 243         MemReplayFreeEvent(uint64 threadId, uint16 moduleId, uint16 allocClass, uint16 allocSubClass, UINT_PTR id, int32 sizeGlobal)
 244                 : threadId(threadId)
 245                 , id(id)
 246                 , sizeGlobal(sizeGlobal)
 247                 , moduleId(moduleId)
 248                 , allocClass(allocClass)
 249                 , allocSubClass(allocSubClass)
 250                 , callstackLength(0)
 251         {
 252         }
 253 } __PACKED;
 254
 255 struct MemReplayInfoEvent
 256 {
 257         static const int EventId = MemReplayEventIds::RE_Info3;
 258
 259         uint32           executableSize;
 260         uint32           initialGlobalSize;
 261         uint32           bucketsFree;
 262
 263         MemReplayInfoEvent(uint32 executableSize, uint32 initialGlobalSize, uint32 bucketsFree)
 264                 : executableSize(executableSize)
 265                 , initialGlobalSize(initialGlobalSize)
 266                 , bucketsFree(bucketsFree)
 267         {
 268         }
 269 } __PACKED;
 270
 271 struct MemReplayAddressProfileEvent
 272 {
 273         static const int EventId = MemReplayEventIds::RE_AddressProfile2;
 274
 275         UINT_PTR         rsxStart;
 276         uint32           rsxLength;
 277
 278         MemReplayAddressProfileEvent(UINT_PTR rsxStart, uint32 rsxLength)
 279                 : rsxStart(rsxStart)
 280                 , rsxLength(rsxLength)
 281         {
 282         }
 283 } __PACKED;
 284
 285 struct MemReplayAllocUsageEvent
 286 {
 287         static const int EventId = MemReplayEventIds::RE_AllocUsage2;
 288
 289         uint32           allocClass;
 290         UINT_PTR         id;
 291         uint32           used;
 292
 293         MemReplayAllocUsageEvent(uint16 allocClass, UINT_PTR id, uint32 used)
 294                 : allocClass(allocClass)
 295                 , id(id)
 296                 , used(used)
 297         {
 298         }
 299 } __PACKED;
 300
 301 struct MemReplayScreenshotEvent
 302 {
 303         static const int EventId = MemReplayEventIds::RE_Screenshot;
 304
 305         uint8            bmp[1];
 306
 307         MemReplayScreenshotEvent()
 308         {
 309         }
 310 } __PACKED;
 311
 312 struct MemReplaySizerPushEvent
 313 {
 314         static const int EventId = MemReplayEventIds::RE_SizerPush;
 315
 316         char             name[1];
 317
 318         MemReplaySizerPushEvent(const char* name)
 319         {
 320                 strcpy(this->name, name);
 321         }
 322 } __PACKED;
 323
 324 struct MemReplaySizerPopEvent
 325 {
 326         static const int EventId = MemReplayEventIds::RE_SizerPop;
 327 } __PACKED;
 328
 329 struct MemReplaySizerAddRangeEvent
 330 {
 331         static const int EventId = MemReplayEventIds::RE_SizerAddRange;
 332
 333         UINT_PTR         address;
 334         uint32           size;
 335         int32            count;
 336
 337         MemReplaySizerAddRangeEvent(const UINT_PTR address, uint32 size, int32 count)
 338                 : address(address)
 339                 , size(size)
 340                 , count(count)
 341         {}
 342
 343 } __PACKED;
 344
 345 struct MemReplayBucketMarkEvent
 346 {
 347         static const int EventId = MemReplayEventIds::RE_BucketMark2;
 348
 349         UINT_PTR         address;
 350         uint32           length;
 351         int32            index;
 352         uint32           alignment;
 353
 354         MemReplayBucketMarkEvent(UINT_PTR address, uint32 length, int32 index, uint32 alignment)
 355                 : address(address)
 356                 , length(length)
 357                 , index(index)
 358                 , alignment(alignment)
 359         {}
 360
 361 } __PACKED;
 362
 363 struct MemReplayBucketUnMarkEvent
 364 {
 365         static const int EventId = MemReplayEventIds::RE_BucketUnMark2;
 366
 367         UINT_PTR         address;
 368         int32            index;
 369
 370         MemReplayBucketUnMarkEvent(UINT_PTR address, int32 index)
 371                 : address(address)
 372                 , index(index)
 373         {}
 374 } __PACKED;
 375
 376 struct MemReplayAddAllocReferenceEvent
 377 {
 378         static const int EventId = MemReplayEventIds::RE_AddAllocReference;
 379
 380         UINT_PTR         address;
 381         UINT_PTR         referenceId;
 382         uint32           callstackLength;
 383         UINT_PTR         callstack[1];
 384
 385         MemReplayAddAllocReferenceEvent(UINT_PTR address, UINT_PTR referenceId)
 386                 : address(address)
 387                 , referenceId(referenceId)
 388                 , callstackLength(0)
 389         {
 390         }
 391 } __PACKED;
 392
 393 struct MemReplayRemoveAllocReferenceEvent
 394 {
 395         static const int EventId = MemReplayEventIds::RE_RemoveAllocReference;
 396
 397         UINT_PTR         referenceId;
 398
 399         MemReplayRemoveAllocReferenceEvent(UINT_PTR referenceId)
 400                 : referenceId(referenceId)
 401         {
 402         }
 403 } __PACKED;
 404
 405 struct MemReplayPoolMarkEvent
 406 {
 407         static const int EventId = MemReplayEventIds::RE_PoolMark2;
 408
 409         UINT_PTR         address;
 410         uint32           length;
 411         int32            index;
 412         uint32           alignment;
 413         char             name[1];
 414
 415         MemReplayPoolMarkEvent(UINT_PTR address, uint32 length, int32 index, uint32 alignment, const char* name)
 416                 : address(address)
 417                 , length(length)
 418                 , index(index)
 419                 , alignment(alignment)
 420         {
 421                 strcpy(this->name, name);
 422         }
 423
 424 } __PACKED;
 425
 426 struct MemReplayPoolUnMarkEvent
 427 {
 428         static const int EventId = MemReplayEventIds::RE_PoolUnMark;
 429
 430         UINT_PTR         address;
 431         int32            index;
 432
 433         MemReplayPoolUnMarkEvent(UINT_PTR address, int32 index)
 434                 : address(address)
 435                 , index(index)
 436         {}
 437 } __PACKED;
 438
 439 struct MemReplayTextureAllocContextEvent
 440 {
 441         static const int EventId = MemReplayEventIds::RE_TextureAllocContext2;
 442
 443         UINT_PTR         address;
 444         uint32           mip;
 445         uint32           width;
 446         uint32           height;
 447         uint32           flags;
 448         char             name[1];
 449
 450         MemReplayTextureAllocContextEvent(UINT_PTR ptr, uint32 mip, uint32 width, uint32 height, uint32 flags, const char* name)
 451                 : address(ptr)
 452                 , mip(mip)
 453                 , width(width)
 454                 , height(height)
 455                 , flags(flags)
 456         {
 457                 strcpy(this->name, name);
 458         }
 459 } __PACKED;
 460
 461 struct MemReplayBucketCleanupEnabledEvent
 462 {
 463         static const int EventId = MemReplayEventIds::RE_BucketCleanupEnabled;
 464
 465         UINT_PTR         allocatorBaseAddress;
 466         uint32           cleanupsEnabled;
 467
 468         MemReplayBucketCleanupEnabledEvent(UINT_PTR allocatorBaseAddress, bool cleanupsEnabled)
 469                 : allocatorBaseAddress(allocatorBaseAddress)
 470                 , cleanupsEnabled(cleanupsEnabled ? 1 : 0)
 471         {
 472         }
 473 } __PACKED;
 474
 475 struct MemReplayReallocEvent
 476 {
 477         static const int EventId = MemReplayEventIds::RE_Realloc3;
 478
 479         uint64           threadId;
 480         UINT_PTR         oldId;
 481         UINT_PTR         newId;
 482         uint32           alignment;
 483         uint32           newSizeRequested;
 484         uint32           newSizeConsumed;
 485         int32            sizeGlobal; //  Inferred from changes in global memory status
 486
 487         uint16           moduleId;
 488         uint16           allocClass;
 489         uint16           allocSubClass;
 490
 491         uint16           callstackLength;
 492         UINT_PTR         callstack[1]; // Must be last.
 493
 494         MemReplayReallocEvent(uint64 threadId, uint16 moduleId, uint16 allocClass, uint16 allocSubClass, UINT_PTR oldId, UINT_PTR newId, uint32 alignment, uint32 newSizeReq, uint32 newSizeCon, int32 sizeGlobal)
 495                 : threadId(threadId)
 496                 , oldId(oldId)
 497                 , newId(newId)
 498                 , alignment(alignment)
 499                 , newSizeRequested(newSizeReq)
 500                 , newSizeConsumed(newSizeCon)
 501                 , sizeGlobal(sizeGlobal)
 502                 , moduleId(moduleId)
 503                 , allocClass(allocClass)
 504                 , allocSubClass(allocSubClass)
 505                 , callstackLength(0)
 506         {
 507         }
 508 } __PACKED;
 509
 510 struct MemReplayRegisterContainerEvent
 511 {
 512         static const int EventId = MemReplayEventIds::RE_RegisterContainer;
 513
 514         UINT_PTR         key;
 515         uint32           type;
 516
 517         uint32           callstackLength;
 518         UINT_PTR         callstack[1]; // Must be last
 519
 520         MemReplayRegisterContainerEvent(UINT_PTR key, uint32 type)
 521                 : key(key)
 522                 , type(type)
 523                 , callstackLength(0)
 524         {
 525         }
 526
 527 } __PACKED;
 528
 529 struct MemReplayUnregisterContainerEvent
 530 {
 531         static const int EventId = MemReplayEventIds::RE_UnregisterContainer;
 532
 533         UINT_PTR         key;
 534
 535         explicit MemReplayUnregisterContainerEvent(UINT_PTR key)
 536                 : key(key)
 537         {
 538         }
 539
 540 } __PACKED;
 541
 542 struct MemReplayBindToContainerEvent
 543 {
 544         static const int EventId = MemReplayEventIds::RE_BindToContainer;
 545
 546         UINT_PTR         key;
 547         UINT_PTR         ptr;
 548
 549         MemReplayBindToContainerEvent(UINT_PTR key, UINT_PTR ptr)
 550                 : key(key)
 551                 , ptr(ptr)
 552         {
 553         }
 554
 555 } __PACKED;
 556
 557 struct MemReplayUnbindFromContainerEvent
 558 {
 559         static const int EventId = MemReplayEventIds::RE_UnbindFromContainer;
 560
 561         UINT_PTR         key;
 562         UINT_PTR         ptr;
 563
 564         MemReplayUnbindFromContainerEvent(UINT_PTR key, UINT_PTR ptr)
 565                 : key(key)
 566                 , ptr(ptr)
 567         {
 568         }
 569
 570 } __PACKED;
 571
 572 struct MemReplayRegisterFixedAddressRangeEvent
 573 {
 574         static const int EventId = MemReplayEventIds::RE_RegisterFixedAddressRange;
 575
 576         UINT_PTR         address;
 577         uint32           length;
 578
 579         char             name[1];
 580
 581         MemReplayRegisterFixedAddressRangeEvent(UINT_PTR address, uint32 length, const char* name)
 582                 : address(address)
 583                 , length(length)
 584         {
 585                 strcpy(this->name, name);
 586         }
 587 } __PACKED;
 588
 589 struct MemReplaySwapContainersEvent
 590 {
 591         static const int EventId = MemReplayEventIds::RE_SwapContainers;
 592
 593         UINT_PTR         keyA;
 594         UINT_PTR         keyB;
 595
 596         MemReplaySwapContainersEvent(UINT_PTR keyA, UINT_PTR keyB)
 597                 : keyA(keyA)
 598                 , keyB(keyB)
 599         {
 600         }
 601 } __PACKED;
 602
 603 struct MemReplayMapPageEvent
 604 {
 605         static const int EventId = MemReplayEventIds::RE_MapPage2;
 606
 607         UINT_PTR         address;
 608         uint32           length;
 609         uint32           callstackLength;
 610         UINT_PTR         callstack[1];
 611
 612         MemReplayMapPageEvent(UINT_PTR address, uint32 length)
 613                 : address(address)
 614                 , length(length)
 615                 , callstackLength(0)
 616         {
 617         }
 618 } __PACKED;
 619
 620 struct MemReplayUnMapPageEvent
 621 {
 622         static const int EventId = MemReplayEventIds::RE_UnMapPage;
 623
 624         UINT_PTR         address;
 625         uint32           length;
 626
 627         MemReplayUnMapPageEvent(UINT_PTR address, uint32 length)
 628                 : address(address)
 629                 , length(length)
 630         {
 631         }
 632 } __PACKED;
 633
 634 #pragma pack(pop)
 635
 636 ReplayDiskWriter::ReplayDiskWriter(const char* pSuffix)
 637         : m_fp(NULL)
 638         , m_written(0)
 639 {
 640         if (pSuffix == NULL || strcmp(pSuffix, "") == 0)
 641         {
 642                 time_t curTime;
 643                 time(&curTime);
 644                 struct tm* lt = localtime(&curTime);
 645
 646                 strftime(m_filename, CRY_ARRAY_COUNT(m_filename), "memlog-%Y%m%d-%H%M%S.zmrl", lt);
 647         }
 648         else
 649         {
 650                 cry_sprintf(m_filename, "memlog-%s.zmrl", pSuffix);
 651         }
 652 }
 653
 654 bool ReplayDiskWriter::Open()
 655 {
 656         #ifdef USE_FILE_HANDLE_CACHE
 657                 #undef fopen
 658         #endif
 659         char fn[MAX_PATH] = "";
 660         #if CRY_PLATFORM_ORBIS
 661         cry_strcpy(fn, "/data/");
 662         #endif
 663         cry_strcat(fn, m_filename);
 664         m_fp = ::fopen(fn, "wb");
 665         return m_fp != NULL;
 666
 667         #if defined(USE_FILE_HANDLE_CACHE)
 668                 #define fopen WrappedFopen
 669         #endif
 670 }
 671
 672 void ReplayDiskWriter::Close()
 673 {
 674         #ifdef USE_FILE_HANDLE_CACHE
 675                 #undef fclose
 676         #endif
 677
 678         if (m_fp)
 679         {
 680                 ::fclose(m_fp);
 681
 682                 m_fp = NULL;
 683         }
 684
 685         #if defined(USE_FILE_HANDLE_CACHE)
 686                 #define fclose WrappedFclose
 687         #endif
 688 }
 689
 690 int ReplayDiskWriter::Write(const void* data, size_t sz, size_t n)
 691 {
 692         #ifdef USE_FILE_HANDLE_CACHE
 693                 #undef fwrite
 694         #endif
 695         int res = ::fwrite(data, sz, n, m_fp);
 696         #if defined(USE_FILE_HANDLE_CACHE)
 697                 #define fwrite WrappedFWrite
 698         #endif
 699
 700         m_written += res * sz;
 701
 702         return res;
 703 }
 704
 705 void ReplayDiskWriter::Flush()
 706 {
 707         #ifdef USE_FILE_HANDLE_CACHE
 708                 #undef fflush
 709         #endif
 710
 711         ::fflush(m_fp);
 712
 713         #if defined(USE_FILE_HANDLE_CACHE)
 714                 #define fflush WrappedFflush
 715         #endif
 716 }
 717
 718 ReplaySocketWriter::ReplaySocketWriter(const char* address)
 719         : m_port(29494)
 720         , m_sock(CRY_INVALID_SOCKET)
 721         , m_written(0)
 722 {
 723         #if defined(REPLAY_SOCKET_WRITER)
 724         const char* portStart = strchr(address, ':');
 725         if (portStart)
 726                 m_port = atoi(portStart + 1);
 727         else
 728                 portStart = address + strlen(address);
 729
 730         cry_strcpy(m_address, address, (size_t)(portStart - address));
 731         #else
 732         ZeroArray(m_address);
 733         #endif //#if defined(REPLAY_SOCKET_WRITER)
 734 }
 735
 736 bool ReplaySocketWriter::Open()
 737 {
 738         #if defined(REPLAY_SOCKET_WRITER)
 739         CRYINADDR_T addr32 = 0;
 740
 741                 #if CRY_PLATFORM_WINAPI
 742         WSADATA wsaData;
 743         PREFAST_SUPPRESS_WARNING(6031);       // we don't need wsaData
 744         WSAStartup(MAKEWORD(2, 2), &wsaData); // ensure CrySock::socket has been initialized
 745                 #endif
 746
 747         addr32 = CrySock::GetAddrForHostOrIP(m_address, 0);
 748
 749         if (!addr32)
 750                 return false;
 751
 752         m_sock = CrySock::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 753         if (m_sock == CRY_INVALID_SOCKET)
 754                 return false;
 755
 756         CRYSOCKADDR_IN addr = { 0 };
 757         addr.sin_family = AF_INET;
 758         addr.sin_addr.s_addr = addr32;
 759
 760         int connectErr = CRY_SOCKET_ERROR;
 761         for (uint16 port = m_port; (connectErr == CRY_SOCKET_ERROR) && port < (29494 + 32); ++port)
 762         {
 763                 addr.sin_port = htons(port);
 764                 connectErr = CrySock::connect(m_sock, (CRYSOCKADDR*) &addr, sizeof(addr));
 765         }
 766
 767         if (connectErr == CRY_SOCKET_ERROR)
 768         {
 769                 CrySock::shutdown(m_sock, SD_BOTH);
 770                 CrySock::closesocket(m_sock);
 771
 772                 m_sock = CRY_INVALID_SOCKET;
 773                 return false;
 774         }
 775         #endif //#if defined(REPLAY_SOCKET_WRITER)
 776         return true;
 777 }
 778
 779 void ReplaySocketWriter::Close()
 780 {
 781         #if defined(REPLAY_SOCKET_WRITER)
 782         if (m_sock != CRY_INVALID_SOCKET)
 783         {
 784                 CrySock::shutdown(m_sock, SD_BOTH);
 785                 CrySock::closesocket(m_sock);
 786                 m_sock = CRY_INVALID_SOCKET;
 787         }
 788
 789                 #if !CRY_PLATFORM_LINUX && !CRY_PLATFORM_ANDROID && !CRY_PLATFORM_APPLE && !CRY_PLATFORM_ORBIS
 790         WSACleanup();
 791                 #endif
 792
 793         #endif //#if defined(REPLAY_SOCKET_WRITER)
 794 }
 795
 796 int ReplaySocketWriter::Write(const void* data, size_t sz, size_t n)
 797 {
 798         #if defined(REPLAY_SOCKET_WRITER)
 799         if (m_sock != CRY_INVALID_SOCKET)
 800         {
 801                 const char* bdata = reinterpret_cast<const char*>(data);
 802                 size_t toSend = sz * n;
 803                 while (toSend > 0)
 804                 {
 805                         int sent = send(m_sock, bdata, toSend, 0);
 806
 807                         if (sent == CRY_SOCKET_ERROR)
 808                         {
 809                                 __debugbreak();
 810                                 break;
 811                         }
 812
 813                         toSend -= sent;
 814                         bdata += sent;
 815                 }
 816
 817                 m_written += sz * n;
 818         }
 819
 820         #endif //#if defined(REPLAY_SOCKET_WRITER)
 821
 822         return n;
 823 }
 824
 825 void ReplaySocketWriter::Flush()
 826 {
 827 }
 828
 829 #endif
 830
 831 #if CAPTURE_REPLAY_LOG
 832
 833 typedef CryLockT<CRYLOCK_RECURSIVE> MemFastMutex;
 834 static MemFastMutex& GetLogMutex()
 835 {
 836         static MemFastMutex logmutex;
 837         return logmutex;
 838 }
 839 static uint32 g_memReplayFrameCount;
 840 const int k_maxCallStackDepth = 256;
 841
 842 static volatile UINT_PTR s_replayLastGlobal = 0;
 843 static volatile int s_replayStartingFree = 0;
 844
 845 static volatile threadID s_recordThreadId = threadID(-1);
 846
 847 inline bool ThreadIsNotFlushing()
 848 {
 849         return s_recordThreadId != CryGetCurrentThreadId();
 850 }
 851
 852 // No write thread: While writing out data we need to avoid recording new entries, as we are under lock
 853 // With write Thread: Just ignore allocations from the recording thread
 854 struct RecordingThreadScope
 855 {
 856         RecordingThreadScope() { assert(s_recordThreadId == threadID(-1)); s_recordThreadId = CryGetCurrentThreadId(); }
 857         ~RecordingThreadScope() { assert(s_recordThreadId != threadID(-1)); s_recordThreadId = threadID(-1); }
 858 };
 859
 860 #if CRY_PLATFORM_WINDOWS || CRY_PLATFORM_DURANGO
 861
 862         void* ReplayAllocatorBase::ReserveAddressSpace(size_t sz)
 863         {
 864                 return VirtualAlloc(NULL, sz, MEM_RESERVE, PAGE_READWRITE);
 865         }
 866
 867         void ReplayAllocatorBase::UnreserveAddressSpace(void* base, void* committedEnd)
 868         {
 869                 VirtualFree(base, 0, MEM_RELEASE);
 870         }
 871
 872         void* ReplayAllocatorBase::MapAddressSpace(void* addr, size_t sz)
 873         {
 874                 return VirtualAlloc(addr, sz, MEM_COMMIT, PAGE_READWRITE);
 875         }
 876
 877 #elif CRY_PLATFORM_ORBIS
 878
 879 void* ReplayAllocatorBase::ReserveAddressSpace(size_t sz)
 880 {
 881         return VirtualAllocator::AllocateVirtualAddressSpace(sz);
 882 }
 883
 884 void ReplayAllocatorBase::UnreserveAddressSpace(void* base, void* committedEnd)
 885 {
 886         VirtualAllocator::FreeVirtualAddressSpace(base);
 887 }
 888
 889 void* ReplayAllocatorBase::MapAddressSpace(void* addr, size_t sz)
 890 {
 891         for (size_t i = 0; i < sz; i += PAGE_SIZE)
 892         {
 893                 if (!VirtualAllocator::MapPage((char*)addr + i))
 894                 {
 895                         for (size_t k = 0; k < i; k += PAGE_SIZE)
 896                         {
 897                                 VirtualAllocator::UnmapPage((char*)addr + k);
 898                         }
 899                         return NULL;
 900                 }
 901         }
 902         return addr;
 903 }
 904
 905 #elif CRY_PLATFORM_LINUX || CRY_PLATFORM_ANDROID || CRY_PLATFORM_APPLE
 906         void* ReplayAllocatorBase::ReserveAddressSpace(size_t sz)
 907         {
 908                 return mmap(NULL, sz, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0);
 909         }
 910
 911         void ReplayAllocatorBase::UnreserveAddressSpace(void* base, void* committedEnd)
 912         {
 913                 int res = munmap(base, reinterpret_cast<char*>(committedEnd) - reinterpret_cast<char*>(base));
 914                 (void) res;
 915                 assert(res == 0);
 916         }
 917
 918         void* ReplayAllocatorBase::MapAddressSpace(void* addr, size_t sz)
 919         {
 920                 int res = mprotect(addr, sz, PROT_READ | PROT_WRITE);
 921                 return addr;
 922         }
 923 #elif CRY_PLATFORM_LINUX || CRY_PLATFORM_ANDROID
 924
 925 void* ReplayAllocatorBase::ReserveAddressSpace(size_t sz)
 926 {
 927         return mmap(NULL, sz, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0);
 928 }
 929
 930 void ReplayAllocatorBase::UnreserveAddressSpace(void* base, void* committedEnd)
 931 {
 932         int res = munmap(base, reinterpret_cast<char*>(committedEnd) - reinterpret_cast<char*>(base));
 933 }
 934
 935 void* ReplayAllocatorBase::MapAddressSpace(void* addr, size_t sz)
 936 {
 937         int res = mprotect(addr, sz, PROT_READ | PROT_WRITE);
 938         return addr;
 939 }
 940
 941 #elif CRY_PLATFORM_ORBIS
 942
 943         void* ReplayAllocatorBase::ReserveAddressSpace(size_t sz)
 944         {
 945                 return VirtualAllocator::AllocateVirtualAddressSpace(sz);
 946         }
 947
 948         void ReplayAllocatorBase::UnreserveAddressSpace(void* base, void* committedEnd)
 949         {
 950                 VirtualAllocator::FreeVirtualAddressSpace(base);
 951         }
 952
 953         void* ReplayAllocatorBase::MapAddressSpace(void* addr, size_t sz)
 954         {
 955                 for (size_t i = 0; i < sz; i += PAGE_SIZE)
 956                 {
 957                         if (!VirtualAllocator::MapPage((char*)addr + i))
 958                         {
 959                                 for (size_t k = 0; k < i; k += PAGE_SIZE)
 960                                 {
 961                                         VirtualAllocator::UnmapPage((char*)addr + k);
 962                                 }
 963                                 return NULL;
 964                         }
 965                 }
 966                 return addr;
 967         }
 968
 969 #endif
 970
 971 namespace
 972 {
 973 //helper functions to become strict aliasing warning conform
 974 ILINE void** CastCallstack(uint32* pCallstack)
 975 {
 976         return alias_cast<void**>(pCallstack);
 977 }
 978 ILINE void** CastCallstack(uint64* pCallstack)
 979 {
 980         return alias_cast<void**>(pCallstack);
 981 }
 982         #if !CRY_PLATFORM_WINDOWS && !CRY_PLATFORM_DURANGO && !CRY_PLATFORM_LINUX && !CRY_PLATFORM_ANDROID
 983 ILINE void** CastCallstack(UINT_PTR* pCallstack)
 984 {
 985         return alias_cast<void**>(pCallstack);
 986 }
 987         #endif
 988 ILINE volatile long* LongPtr(volatile int* pI)
 989 {
 990         return alias_cast<volatile long*>(pI);
 991 }
 992
 993 void RetrieveMemReplaySuffix(char* pSuffixBuffer, const char* lwrCommandLine, int bufferLength)
 994 {
 995         cry_strcpy(pSuffixBuffer, bufferLength, "");
 996         const char* pSuffix = strstr(lwrCommandLine, "-memreplaysuffix");
 997         if (pSuffix != NULL)
 998         {
 999                 pSuffix += strlen("-memreplaysuffix");
1000                 while (1)
1001                 {
1002                         if (*pSuffix == '\0' || *pSuffix == '+' || *pSuffix == '-')
1003                         {
1004                                 pSuffix = NULL;
1005                                 break;
1006                         }
1007                         if (*pSuffix != ' ')
1008                                 break;
1009                         ++pSuffix;
1010                 }
1011                 if (pSuffix != NULL)
1012                 {
1013                         const char* pEnd = pSuffix;
1014                         while (*pEnd != '\0' && *pEnd != ' ')
1015                                 ++pEnd;
1016                         cry_strcpy(pSuffixBuffer, bufferLength, pSuffix, (size_t)(pEnd - pSuffix));
1017                 }
1018         }
1019 }
1020 }
1021
1022 ReplayAllocator::ReplayAllocator()
1023 {
1024         m_heap = ReserveAddressSpace(MaxSize);
1025         if (!m_heap)
1026                 __debugbreak();
1027
1028         m_commitEnd = m_heap;
1029         m_allocEnd = m_heap;
1030 }
1031
1032 ReplayAllocator::~ReplayAllocator()
1033 {
1034         Free();
1035 }
1036
1037 void ReplayAllocator::Reserve(size_t sz)
1038 {
1039         CryAutoLock<CryCriticalSectionNonRecursive> lock(m_lock);
1040
1041         INT_PTR commitEnd = reinterpret_cast<INT_PTR>(m_commitEnd);
1042         INT_PTR newCommitEnd = std::min<INT_PTR>(commitEnd + sz, commitEnd + MaxSize);
1043
1044         if ((newCommitEnd - commitEnd) > 0)
1045         {
1046                 LPVOID res = MapAddressSpace(m_commitEnd, newCommitEnd - commitEnd);
1047                 if (!res)
1048                         __debugbreak();
1049         }
1050
1051         m_commitEnd = reinterpret_cast<void*>(newCommitEnd);
1052 }
1053
1054 void* ReplayAllocator::Allocate(size_t sz)
1055 {
1056         CryAutoLock<CryCriticalSectionNonRecursive> lock(m_lock);
1057
1058         sz = (sz + 7) & ~7;
1059
1060         uint8* alloc = reinterpret_cast<uint8*>(m_allocEnd);
1061         uint8* newEnd = reinterpret_cast<uint8*>(m_allocEnd) + sz;
1062
1063         if (newEnd > reinterpret_cast<uint8*>(m_commitEnd))
1064         {
1065                 uint8* alignedEnd = reinterpret_cast<uint8*>((reinterpret_cast<INT_PTR>(newEnd) + (PageSize - 1)) & ~(PageSize - 1));
1066
1067                 if (alignedEnd > reinterpret_cast<uint8*>(m_allocEnd) + MaxSize)
1068                         __debugbreak();
1069
1070                 LPVOID res = MapAddressSpace(m_commitEnd, alignedEnd - reinterpret_cast<uint8*>(m_commitEnd));
1071                 if (!res)
1072                         __debugbreak();
1073
1074                 m_commitEnd = alignedEnd;
1075         }
1076
1077         m_allocEnd = newEnd;
1078
1079         return alloc;
1080 }
1081
1082 void ReplayAllocator::Free()
1083 {
1084         CryAutoLock<CryCriticalSectionNonRecursive> lock(m_lock);
1085
1086         UnreserveAddressSpace(m_heap, m_commitEnd);
1087 }
1088
1089 ReplayCompressor::ReplayCompressor(ReplayAllocator& allocator, IReplayWriter* writer)
1090         : m_allocator(&allocator)
1091         , m_writer(writer)
1092 {
1093         m_zSize = 0;
1094
1095         memset(&m_compressStream, 0, sizeof(m_compressStream));
1096         m_compressStream.zalloc = &ReplayCompressor::zAlloc;
1097         m_compressStream.zfree = &ReplayCompressor::zFree;
1098         m_compressStream.opaque = this;
1099         deflateInit(&m_compressStream, 2);//Z_DEFAULT_COMPRESSION);
1100
1101         uint64 streamLen = 0;
1102         m_writer->Write(&streamLen, sizeof(streamLen), 1);
1103
1104         m_compressTarget = (uint8*) m_allocator->Allocate(CompressTargetSize);
1105 }
1106
1107 ReplayCompressor::~ReplayCompressor()
1108 {
1109         deflateEnd(&m_compressStream);
1110         m_compressTarget = NULL;
1111         m_writer = NULL;
1112 }
1113
1114 void ReplayCompressor::Flush()
1115 {
1116         m_writer->Flush();
1117 }
1118
1119 void ReplayCompressor::Write(const uint8* data, size_t len)
1120 {
1121         if (CompressTargetSize < len)
1122                 __debugbreak();
1123
1124         m_compressStream.next_in = const_cast<uint8*>(data);
1125         m_compressStream.avail_in = len;
1126         m_compressStream.next_out = m_compressTarget;
1127         m_compressStream.avail_out = CompressTargetSize;
1128         m_compressStream.total_out = 0;
1129
1130         do
1131         {
1132                 int err = deflate(&m_compressStream, Z_SYNC_FLUSH);
1133
1134                 if ((err == Z_OK && m_compressStream.avail_out == 0) || (err == Z_BUF_ERROR && m_compressStream.avail_out == 0))
1135                 {
1136                         int total_out = m_compressStream.total_out;
1137                         m_writer->Write(m_compressTarget, total_out * sizeof(uint8), 1);
1138
1139                         m_compressStream.next_out = m_compressTarget;
1140                         m_compressStream.avail_out = CompressTargetSize;
1141                         m_compressStream.total_out = 0;
1142
1143                         continue;
1144                 }
1145                 else if (m_compressStream.avail_in == 0)
1146                 {
1147                         int total_out = m_compressStream.total_out;
1148                         m_writer->Write(m_compressTarget, total_out * sizeof(uint8), 1);
1149                 }
1150                 else
1151                 {
1152                         // Shrug?
1153                 }
1154
1155                 break;
1156         }
1157         while (true);
1158
1159         Flush();
1160 }
1161
1162 voidpf ReplayCompressor::zAlloc(voidpf opaque, uInt items, uInt size)
1163 {
1164         ReplayCompressor* str = reinterpret_cast<ReplayCompressor*>(opaque);
1165         return str->m_allocator->Allocate(items * size);
1166 }
1167
1168 void ReplayCompressor::zFree(voidpf opaque, voidpf address)
1169 {
1170         // Doesn't seem to be called, except when shutting down and then we'll just free it all anyway
1171 }
1172
1173 #if REPLAY_RECORD_THREADED
1174
1175 ReplayRecordThread::ReplayRecordThread(ReplayCompressor* compressor)
1176         : m_compressor(compressor)
1177 {
1178         m_nextCommand = CMD_Idle;
1179         m_nextData = NULL;
1180         m_nextLength = 0;
1181 }
1182
1183 void ReplayRecordThread::Flush()
1184 {
1185         m_mtx.Lock();
1186
1187         while (m_nextCommand != CMD_Idle)
1188         {
1189                 m_mtx.Unlock();
1190                 CrySleep(1);
1191                 m_mtx.Lock();
1192         }
1193
1194         m_nextCommand = CMD_Flush;
1195         m_mtx.Unlock();
1196         m_cond.NotifySingle();
1197 }
1198
1199 void ReplayRecordThread::Write(const uint8* data, size_t len)
1200 {
1201         m_mtx.Lock();
1202
1203         while (m_nextCommand != CMD_Idle)
1204         {
1205                 m_mtx.Unlock();
1206                 CrySleep(1);
1207                 m_mtx.Lock();
1208         }
1209
1210         m_nextData = data;
1211         m_nextLength = len;
1212         m_nextCommand = CMD_Write;
1213         m_mtx.Unlock();
1214         m_cond.NotifySingle();
1215 }
1216
1217 void ReplayRecordThread::ThreadEntry()
1218 {
1219         RecordingThreadScope recordScope;
1220
1221         while (true)
1222         {
1223                 m_mtx.Lock();
1224
1225                 while (m_nextCommand == CMD_Idle)
1226                         m_cond.Wait(m_mtx);
1227
1228                 switch (m_nextCommand)
1229                 {
1230                 case CMD_Stop:
1231                         m_mtx.Unlock();
1232                         m_nextCommand = CMD_Idle;
1233                         return;
1234
1235                 case CMD_Write:
1236                         {
1237                                 size_t length = m_nextLength;
1238                                 const uint8* data = m_nextData;
1239
1240                                 m_nextLength = 0;
1241                                 m_nextData = NULL;
1242
1243                                 m_compressor->Write(data, length);
1244                         }
1245                         break;
1246
1247                 case CMD_Flush:
1248                         m_compressor->Flush();
1249                         break;
1250                 }
1251
1252                 m_nextCommand = CMD_Idle;
1253
1254                 m_mtx.Unlock();
1255         }
1256 }
1257
1258 void ReplayRecordThread::SignalStopWork()
1259 {
1260         m_mtx.Lock();
1261
1262         while (m_nextCommand != CMD_Idle)
1263         {
1264                 m_mtx.Unlock();
1265                 CrySleep(1);
1266                 m_mtx.Lock();
1267         }
1268
1269         m_nextCommand = CMD_Stop;
1270         m_cond.NotifySingle();
1271
1272         while (m_nextCommand != CMD_Idle)
1273         {
1274                 m_mtx.Unlock();
1275                 CrySleep(1);
1276                 m_mtx.Lock();
1277         }
1278
1279         m_mtx.Unlock();
1280 }
1281
1282 #endif
1283
1284 ReplayLogStream::ReplayLogStream()
1285         : m_isOpen(0)
1286         , m_buffer(nullptr)
1287         , m_bufferSize(0)
1288         , m_bufferEnd(nullptr)
1289         , m_uncompressedLen(0)
1290         , m_sequenceCheck(0)
1291         , m_bufferA(nullptr)
1292         , m_compressor(nullptr)
1293         #if REPLAY_RECORD_THREADED
1294         , m_bufferB(nullptr)
1295         , m_recordThread(nullptr)
1296         #endif
1297         , m_writer(nullptr)
1298 {
1299 }
1300
1301 ReplayLogStream::~ReplayLogStream()
1302 {
1303         if (IsOpen())
1304         {
1305                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
1306                 Close();
1307         }
1308 }
1309
1310 bool ReplayLogStream::Open(const char* openString)
1311 {
1312         using std::swap;
1313
1314         m_allocator.Reserve(512 * 1024);
1315
1316         while (isspace((unsigned char) *openString))
1317                 ++openString;
1318
1319         const char* sep = strchr(openString, ':');
1320         if (!sep)
1321                 sep = openString + strlen(openString);
1322
1323         char destination[32];
1324         const char* arg = "";
1325
1326         if (sep != openString)
1327         {
1328                 while (isspace((unsigned char) sep[-1]))
1329                         --sep;
1330
1331                 cry_strcpy(destination, openString, (size_t)(sep - openString));
1332
1333                 arg = sep;
1334
1335                 if (*arg)
1336                 {
1337                         ++arg;
1338                         while (isspace((unsigned char) *arg))
1339                                 ++arg;
1340                 }
1341         }
1342         else
1343         {
1344                 cry_strcpy(destination, "disk");
1345         }
1346
1347         IReplayWriter* writer = NULL;
1348
1349         if (strcmp(destination, "disk") == 0)
1350         {
1351                 writer = new(m_allocator.Allocate(sizeof(ReplayDiskWriter)))ReplayDiskWriter(arg);
1352         }
1353         else if (strcmp(destination, "socket") == 0)
1354         {
1355                 writer = new(m_allocator.Allocate(sizeof(ReplaySocketWriter)))ReplaySocketWriter(arg);
1356         }
1357
1358         if (writer && writer->Open() == false)
1359         {
1360                 fprintf(stdout, "Failed to open writer\n");
1361                 writer->~IReplayWriter();
1362                 writer = NULL;
1363
1364                 m_allocator.Free();
1365                 return false;
1366         }
1367
1368         swap(m_writer, writer);
1369
1370         m_bufferSize = 64 * 1024;
1371         m_bufferA = (uint8*) m_allocator.Allocate(m_bufferSize);
1372
1373         #if REPLAY_RECORD_THREADED
1374         m_bufferB = (uint8*) m_allocator.Allocate(m_bufferSize);
1375         #endif
1376
1377         m_buffer = m_bufferA;
1378         m_compressor = new(m_allocator.Allocate(sizeof(ReplayCompressor)))ReplayCompressor(m_allocator, m_writer);
1379
1380         {
1381                 m_bufferEnd = &m_buffer[0];
1382
1383                 // Write stream header.
1384                 const uint8 version = 5;
1385                 uint32 platform = MemReplayPlatformIds::PI_Unknown;
1386
1387         #if CRY_PLATFORM_ORBIS
1388                 platform = MemReplayPlatformIds::PI_Orbis;
1389         #elif CRY_PLATFORM_DURANGO
1390                 platform = MemReplayPlatformIds::PI_Durango;
1391         #elif CRY_PLATFORM_WINDOWS || CRY_PLATFORM_LINUX || CRY_PLATFORM_ANDROID || CRY_PLATFORM_APPLE
1392                 platform = MemReplayPlatformIds::PI_PC;
1393         #endif
1394
1395                 MemReplayLogHeader hdr(('M' << 0) | ('R' << 8) | ('L' << 16) | (version << 24), platform, sizeof(void*) * 8);
1396                 memcpy(&m_buffer[0], &hdr, sizeof(hdr));
1397                 m_bufferEnd += sizeof(hdr);
1398
1399                 CryInterlockedIncrement(&m_isOpen);
1400         }
1401
1402         return true;
1403 }
1404
1405 void ReplayLogStream::Close()
1406 {
1407         using std::swap;
1408
1409         // Flag it as closed here, to prevent recursion into the memory logging as it is closing.
1410         CryInterlockedDecrement(&m_isOpen);
1411
1412         Flush();
1413         Flush();
1414         Flush();
1415
1416         #if REPLAY_RECORD_THREADED
1417         if (m_recordThread)
1418         {
1419                 m_recordThread->SignalStopWork();
1420                 gEnv->pThreadManager->JoinThread(m_recordThread, eJM_Join);
1421                 m_recordThread->~ReplayRecordThread();
1422                 m_recordThread = NULL;
1423         }
1424         #endif
1425
1426         if (m_compressor)
1427         {
1428                 m_compressor->~ReplayCompressor();
1429                 m_compressor = NULL;
1430         }
1431
1432         m_writer->Close();
1433         m_writer = NULL;
1434
1435         m_buffer = NULL;
1436         m_bufferEnd = 0;
1437         m_bufferSize = 0;
1438
1439         m_allocator.Free();
1440 }
1441
1442 bool ReplayLogStream::EnableAsynchMode()
1443 {
1444         #if REPLAY_RECORD_THREADED
1445         // System to create thread is not running yet
1446         if (!gEnv || !gEnv->pSystem)
1447                 return false;
1448
1449         // Asynch mode already enabled
1450         if (m_recordThread)
1451                 return true;
1452
1453         // Write out pending data
1454         Flush();
1455
1456         // Try create ReplayRecord thread
1457         m_recordThread = new(m_allocator.Allocate(sizeof(ReplayRecordThread)))ReplayRecordThread(m_compressor);
1458         if (!gEnv->pThreadManager->SpawnThread(m_recordThread, "ReplayRecord"))
1459         {
1460                 CRY_ASSERT_MESSAGE(false, "Error spawning \"ReplayRecord\" thread.");
1461                 m_recordThread->~ReplayRecordThread();
1462                 m_recordThread = NULL;
1463                 return false;
1464         }
1465
1466         return true;
1467         #else
1468         return false;
1469         #endif
1470 }
1471
1472 void ReplayLogStream::Flush()
1473 {
1474         if (m_writer != NULL)
1475         {
1476                 m_uncompressedLen += m_bufferEnd - &m_buffer[0];
1477
1478 #if REPLAY_RECORD_THREADED
1479                 if (m_recordThread)
1480                 {
1481                         m_recordThread->Write(&m_buffer[0], m_bufferEnd - &m_buffer[0]);
1482                         m_buffer = (m_buffer == m_bufferA) ? m_bufferB : m_bufferA;
1483                 }
1484                 else
1485 #endif
1486                 {
1487                         RecordingThreadScope writeScope;
1488                         m_compressor->Write(&m_buffer[0], m_bufferEnd - &m_buffer[0]);
1489                 }
1490         }
1491
1492         m_bufferEnd = &m_buffer[0];
1493 }
1494
1495 void ReplayLogStream::FullFlush()
1496 {
1497 #if REPLAY_RECORD_THREADED
1498         if (m_recordThread)
1499         {
1500                 m_recordThread->Flush();
1501         }
1502         else
1503 #endif
1504         {
1505                 RecordingThreadScope writeScope;
1506                 m_compressor->Flush();
1507         }
1508 }
1509
1510 size_t ReplayLogStream::GetSize() const
1511 {
1512         return m_allocator.GetCommittedSize();
1513 }
1514
1515 uint64 ReplayLogStream::GetWrittenLength() const
1516 {
1517         return m_writer ? m_writer->GetWrittenLength() : 0ULL;
1518 }
1519
1520 uint64 ReplayLogStream::GetUncompressedLength() const
1521 {
1522         return m_uncompressedLen;
1523 }
1524
1525 #define SIZEOF_MEMBER(cls, mbr) (sizeof(reinterpret_cast<cls*>(0)->mbr))
1526
1527 static bool g_memReplayPaused = false;
1528
1529 //////////////////////////////////////////////////////////////////////////
1530 // CMemReplay class implementation.
1531 //////////////////////////////////////////////////////////////////////////
1532
1533 //////////////////////////////////////////////////////////////////////////
1534
1535 static int GetCurrentSysAlloced()
1536 {
1537         int trackingUsage = 0;//m_stream.GetSize();
1538         IMemoryManager::SProcessMemInfo mi;
1539         CCryMemoryManager::GetInstance()->GetProcessMemInfo(mi);
1540         return (uint32)(mi.PagefileUsage - trackingUsage);
1541 }
1542
1543         #if !CRY_PLATFORM_ORBIS
1544 int CMemReplay::GetCurrentExecutableSize()
1545 {
1546         return GetCurrentSysAlloced();
1547 }
1548         #endif
1549
1550 //////////////////////////////////////////////////////////////////////////
1551 static UINT_PTR GetCurrentSysFree()
1552 {
1553         IMemoryManager::SProcessMemInfo mi;
1554         CCryMemoryManager::GetInstance()->GetProcessMemInfo(mi);
1555         return (UINT_PTR)-(INT_PTR)mi.PagefileUsage;
1556 }
1557
1558 void CReplayModules::RefreshModules(FModuleLoad onLoad, FModuleUnload onUnload, void* pUser)
1559 {
1560         #if CRY_PLATFORM_WINDOWS
1561         HMODULE hMods[1024];
1562         HANDLE hProcess;
1563         DWORD cbNeeded;
1564         unsigned int i;
1565
1566         // Get a list of all the modules in this process.
1567         hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, GetCurrentProcessId());
1568         if (NULL != hProcess)
1569         {
1570                 if (SymInitialize(hProcess, NULL, TRUE))
1571                 {
1572                         decltype(&EnumProcessModules) pfEnumProcessModules;
1573                         decltype(&GetModuleFileNameEx) pfGetModuleFileNameEx;
1574                         decltype(&GetModuleInformation) pfGetModuleInformation;
1575
1576                         HMODULE hPsapiModule = ::LoadLibraryA("psapi.dll");
1577                         if (hPsapiModule)
1578                         {
1579                                 pfEnumProcessModules = (decltype(pfEnumProcessModules)) GetProcAddress(hPsapiModule, "EnumProcessModules");
1580                                 pfGetModuleFileNameEx = (decltype(pfGetModuleFileNameEx)) GetProcAddress(hPsapiModule, "GetModuleFileNameEx");
1581                                 pfGetModuleInformation = (decltype(pfGetModuleInformation)) GetProcAddress(hPsapiModule, "GetModuleInformation");
1582                         }
1583
1584                         if(pfEnumProcessModules && pfGetModuleFileNameEx && pfGetModuleInformation)
1585                         {
1586                                 if (pfEnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded))
1587                                 {
1588                                         for (i = 0; i < (cbNeeded / sizeof(HMODULE)); i++)
1589                                         {
1590                                                 TCHAR szModName[MAX_PATH];
1591                                                 // Get the full path to the module's file.
1592                                                 if (pfGetModuleFileNameEx(hProcess, hMods[i], szModName, sizeof(szModName) / sizeof(TCHAR)))
1593                                                 {
1594                                                         char pdbPath[1024];
1595                                                         cry_strcpy(pdbPath, szModName);
1596                                                         char* pPdbPathExt = strrchr(pdbPath, '.');
1597                                                         if (pPdbPathExt)
1598                                                                 strcpy(pPdbPathExt, ".pdb");
1599                                                         else
1600                                                                 cry_strcat(pdbPath, ".pdb");
1601
1602                                                         MODULEINFO modInfo;
1603                                                         pfGetModuleInformation(hProcess, hMods[i], &modInfo, sizeof(modInfo));
1604
1605                                                         IMAGEHLP_MODULE64 ihModInfo;
1606                                                         memset(&ihModInfo, 0, sizeof(ihModInfo));
1607                                                         ihModInfo.SizeOfStruct = sizeof(ihModInfo);
1608                                                         if (SymGetModuleInfo64(hProcess, (DWORD64)modInfo.lpBaseOfDll, &ihModInfo))
1609                                                         {
1610                                                                 cry_strcpy(pdbPath, ihModInfo.CVData);
1611
1612                                                                 if (ihModInfo.PdbSig70.Data1 == 0)
1613                                                                 {
1614                                                                         DWORD debugEntrySize;
1615                                                                         IMAGE_DEBUG_DIRECTORY* pDebugDirectory = (IMAGE_DEBUG_DIRECTORY*)ImageDirectoryEntryToDataEx(modInfo.lpBaseOfDll, TRUE, IMAGE_DIRECTORY_ENTRY_DEBUG, &debugEntrySize, NULL);
1616                                                                         if (pDebugDirectory)
1617                                                                         {
1618                                                                                 size_t numDirectories = debugEntrySize / sizeof(IMAGE_DEBUG_DIRECTORY);
1619                                                                                 for (size_t dirIdx = 0; dirIdx != numDirectories; ++dirIdx)
1620                                                                                 {
1621                                                                                         IMAGE_DEBUG_DIRECTORY& dir = pDebugDirectory[dirIdx];
1622                                                                                         if (dir.Type == 2)
1623                                                                                         {
1624                                                                                                 CVDebugInfo* pCVInfo = (CVDebugInfo*)((char*)modInfo.lpBaseOfDll + dir.AddressOfRawData);
1625                                                                                                 ihModInfo.PdbSig70 = pCVInfo->pdbSig;
1626                                                                                                 ihModInfo.PdbAge = pCVInfo->age;
1627                                                                                                 cry_strcpy(pdbPath, pCVInfo->pdbName);
1628                                                                                                 break;
1629                                                                                         }
1630                                                                                 }
1631                                                                         }
1632                                                                 }
1633
1634                                                                 ModuleLoadDesc mld;
1635                                                                 cry_sprintf(mld.sig, "%p, %08X, %08X, {%08X-%04X-%04X-%02X %02X-%02X %02X %02X %02X %02X %02X}, %d\n",
1636                                                                         modInfo.lpBaseOfDll, modInfo.SizeOfImage, ihModInfo.TimeDateStamp,
1637                                                                         ihModInfo.PdbSig70.Data1, ihModInfo.PdbSig70.Data2, ihModInfo.PdbSig70.Data3,
1638                                                                         ihModInfo.PdbSig70.Data4[0], ihModInfo.PdbSig70.Data4[1],
1639                                                                         ihModInfo.PdbSig70.Data4[2], ihModInfo.PdbSig70.Data4[3],
1640                                                                         ihModInfo.PdbSig70.Data4[4], ihModInfo.PdbSig70.Data4[5],
1641                                                                         ihModInfo.PdbSig70.Data4[6], ihModInfo.PdbSig70.Data4[7],
1642                                                                         ihModInfo.PdbAge);
1643
1644                                                                 cry_strcpy(mld.name, szModName);
1645                                                                 cry_strcpy(mld.path, pdbPath);
1646                                                                 mld.address = (UINT_PTR)modInfo.lpBaseOfDll;
1647                                                                 mld.size = modInfo.SizeOfImage;
1648                                                                 onLoad(pUser, mld);
1649                                                         }
1650                                                 }
1651                                         }
1652                                 }
1653
1654                                 SymCleanup(hProcess);
1655                         }
1656                 }
1657                 CloseHandle(hProcess);
1658         }
1659         #elif CRY_PLATFORM_DURANGO && 0
1660
1661         // Get a list of all the modules in this process.
1662         EnumModuleState ems;
1663         ems.hProcess = GetCurrentProcess();
1664         ems.pSelf = this;
1665         ems.onLoad = onLoad;
1666         ems.pOnLoadUser = pUser;
1667         if (NULL != ems.hProcess)
1668         {
1669                 if (SymInitialize(ems.hProcess, NULL, TRUE))
1670                 {
1671                         EnumerateLoadedModulesEx(ems.hProcess, EnumModules_Durango, &ems);
1672
1673                         SymCleanup(ems.hProcess);
1674                 }
1675         }
1676         #elif CRY_PLATFORM_LINUX || CRY_PLATFORM_ANDROID
1677         EnumModuleState ems;
1678         ems.hProcess = 0;
1679         ems.pSelf = this;
1680         ems.onLoad = onLoad;
1681         ems.pOnLoadUser = pUser;
1682         dl_iterate_phdr(EnumModules_Linux, &ems);
1683         #elif CRY_PLATFORM_ORBIS
1684         RefreshModules_Orbis(onLoad, pUser);
1685         #endif
1686 }
1687
1688         #if CRY_PLATFORM_DURANGO && 0
1689
1690 BOOL CReplayModules::EnumModules_Durango(PCSTR moduleName, DWORD64 moduleBase, ULONG moduleSize, PVOID userContext)
1691 {
1692         EnumModuleState& ems = *static_cast<EnumModuleState*>(userContext);
1693
1694         char pdbPath[1024];
1695         cry_strcpy(pdbPath, moduleName);
1696         char* pPdbPathExt = strrchr(pdbPath, '.');
1697         if (pPdbPathExt)
1698                 strcpy(pPdbPathExt, ".pdb");
1699         else
1700                 cry_strcat(pdbPath, ".pdb");
1701
1702         IMAGEHLP_MODULE64 ihModInfo;
1703         memset(&ihModInfo, 0, sizeof(ihModInfo));
1704         ihModInfo.SizeOfStruct = sizeof(ihModInfo);
1705         if (SymGetModuleInfo64(ems.hProcess, moduleBase, &ihModInfo))
1706         {
1707                 cry_strcpy(pdbPath, ihModInfo.CVData);
1708
1709                 if (ihModInfo.PdbSig70.Data1 == 0)
1710                 {
1711                         DWORD debugEntrySize;
1712                         IMAGE_DEBUG_DIRECTORY* pDebugDirectory = (IMAGE_DEBUG_DIRECTORY*)ImageDirectoryEntryToDataEx((PVOID)moduleBase, TRUE, IMAGE_DIRECTORY_ENTRY_DEBUG, &debugEntrySize, NULL);
1713                         if (pDebugDirectory)
1714                         {
1715                                 size_t numDirectories = debugEntrySize / sizeof(IMAGE_DEBUG_DIRECTORY);
1716                                 for (size_t dirIdx = 0; dirIdx != numDirectories; ++dirIdx)
1717                                 {
1718                                         IMAGE_DEBUG_DIRECTORY& dir = pDebugDirectory[dirIdx];
1719                                         if (dir.Type == 2)
1720                                         {
1721                                                 CVDebugInfo* pCVInfo = (CVDebugInfo*)((char*)moduleBase + dir.AddressOfRawData);
1722                                                 ihModInfo.PdbSig70 = pCVInfo->pdbSig;
1723                                                 ihModInfo.PdbAge = pCVInfo->age;
1724                                                 cry_strcpy(pdbPath, pCVInfo->pdbName);
1725                                                 break;
1726                                         }
1727                                 }
1728                         }
1729                 }
1730
1731                 ModuleLoadDesc mld;
1732                 cry_sprintf(mld.sig, "%p, %08X, %08X, {%08X-%04X-%04X-%02X %02X-%02X %02X %02X %02X %02X %02X}, %d\n",
1733                             moduleBase, moduleSize, ihModInfo.TimeDateStamp,
1734                             ihModInfo.PdbSig70.Data1, ihModInfo.PdbSig70.Data2, ihModInfo.PdbSig70.Data3,
1735                             ihModInfo.PdbSig70.Data4[0], ihModInfo.PdbSig70.Data4[1],
1736                             ihModInfo.PdbSig70.Data4[2], ihModInfo.PdbSig70.Data4[3],
1737                             ihModInfo.PdbSig70.Data4[4], ihModInfo.PdbSig70.Data4[5],
1738                             ihModInfo.PdbSig70.Data4[6], ihModInfo.PdbSig70.Data4[7],
1739                             ihModInfo.PdbAge);
1740
1741                 cry_strcpy(mld.name, moduleName);
1742                 cry_strcpy(mld.path, pdbPath);
1743                 mld.address = moduleBase;
1744                 mld.size = moduleSize;
1745                 ems.onLoad(ems.pOnLoadUser, mld);
1746         }
1747
1748         return TRUE;
1749 }
1750
1751         #endif
1752
1753         #if CRY_PLATFORM_LINUX || CRY_PLATFORM_ANDROID
1754 int CReplayModules::EnumModules_Linux(struct dl_phdr_info* info, size_t size, void* userContext)
1755 {
1756         EnumModuleState& ems = *reinterpret_cast<EnumModuleState*>(userContext);
1757
1758         ModuleLoadDesc mld;
1759         mld.address = info->dlpi_addr;
1760         cry_strcpy(mld.name, info->dlpi_name);
1761         cry_strcpy(mld.path, info->dlpi_name);
1762
1763         Module& module = ems.pSelf->m_knownModules[ems.pSelf->m_numKnownModules];
1764         ems.pSelf->m_numKnownModules++;
1765         module.baseAddress = info->dlpi_addr;
1766         module.timestamp = 0;
1767
1768         uint64 memSize = 0;
1769         for (int j = 0; j < info->dlpi_phnum; j++)
1770         {
1771                 memSize += info->dlpi_phdr[j].p_memsz;
1772         }
1773         mld.size = (UINT_PTR)memSize;
1774         module.size = (UINT_PTR)memSize;
1775
1776         ems.onLoad(ems.pOnLoadUser, mld);
1777
1778         return 0;
1779 }
1780         #endif
1781
1782 // Ensure IMemReplay is not destroyed during atExit() procedure which has no defined destruction order.
1783 // In some cases it was destroyed while still being used.
1784 CRY_ALIGN(8) char g_memReplay[sizeof(CMemReplay)];
1785 CMemReplay* CMemReplay::GetInstance()
1786 {
1787         static bool bIsInit = false;
1788         if (!bIsInit)
1789         {
1790                 new(&g_memReplay)CMemReplay();
1791                 bIsInit = true;
1792         }
1793
1794         return alias_cast<CMemReplay*>(g_memReplay);
1795 }
1796
1797 CMemReplay::CMemReplay()
1798         : m_allocReference(0)
1799         , m_scopeDepth(0)
1800         , m_scopeClass(EMemReplayAllocClass::UserPointer)
1801         , m_scopeSubClass(EMemReplayUserPointerClass::Unknown)
1802         , m_scopeModuleId(0)
1803 {
1804 }
1805
1806 CMemReplay::~CMemReplay()
1807 {
1808 }
1809
1810 //////////////////////////////////////////////////////////////////////////
1811 void CMemReplay::DumpStats()
1812 {
1813         CMemReplay::DumpSymbols();
1814 }
1815
1816 //////////////////////////////////////////////////////////////////////////
1817 void CMemReplay::DumpSymbols()
1818 {
1819         if (m_stream.IsOpen())
1820         {
1821                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
1822                 if (m_stream.IsOpen())
1823                 {
1824                         RecordModules();
1825
1826                         m_stream.FullFlush();
1827                 }
1828         }
1829 }
1830
1831 //////////////////////////////////////////////////////////////////////////
1832 void CMemReplay::StartOnCommandLine(const char* cmdLine)
1833 {
1834         const char* mrCmd = 0;
1835
1836         CryStackStringT<char, 2048> lwrCmdLine = cmdLine;
1837         lwrCmdLine.MakeLower();
1838
1839         if ((mrCmd = strstr(lwrCmdLine.c_str(), "-memreplay")) != nullptr)
1840         {
1841                 bool bPaused = strstr(lwrCmdLine.c_str(), "-memreplaypaused") != nullptr;
1842
1843                 //Retrieve file suffix if present
1844                 const int bufferLength = 64;
1845                 char openCmd[bufferLength] = "disk:";
1846
1847                 // Try and detect a new style open string, and fall back to the old suffix format if it fails.
1848                 if (
1849                   (strncmp(mrCmd, "-memreplay disk", 15) == 0) ||
1850                   (strncmp(mrCmd, "-memreplay socket", 17) == 0))
1851                 {
1852                         const char* arg = mrCmd + strlen("-memreplay ");
1853                         const char* argEnd = arg;
1854                         while (*argEnd && !isspace((unsigned char) *argEnd))
1855                                 ++argEnd;
1856                         cry_strcpy(openCmd, arg, (size_t)(argEnd - arg));
1857                 }
1858                 else
1859                 {
1860                         RetrieveMemReplaySuffix(openCmd + 5, lwrCmdLine.c_str(), bufferLength - 5);
1861                 }
1862
1863                 Start(bPaused, openCmd);
1864         }
1865 }
1866
1867 //////////////////////////////////////////////////////////////////////////
1868 void CMemReplay::Start(bool bPaused, const char* openString)
1869 {
1870         if (!openString)
1871         {
1872                 openString = "disk";
1873         }
1874
1875         if(m_stream.IsOpen())
1876         {
1877                 const char* label = nullptr;
1878                 if (bPaused && !g_memReplayPaused)
1879                         label = "Pausing MemReplay";
1880                 else if (!bPaused && g_memReplayPaused)
1881                         label = "Resuming MemReplay";
1882
1883                 if(label)
1884                         new(m_stream.AllocateRawEvent<MemReplayLabelEvent>(strlen(label)))MemReplayLabelEvent(label);
1885         }
1886
1887         CryAutoLock<CryCriticalSection> lock(GetLogMutex());
1888         g_memReplayPaused = bPaused;
1889
1890         if (!m_stream.IsOpen())
1891         {
1892                 if (m_stream.Open(openString))
1893                 {
1894                         s_replayLastGlobal = GetCurrentSysFree();
1895                         int initialGlobal = GetCurrentSysAlloced();
1896                         int exeSize = GetCurrentExecutableSize();
1897
1898         #if CRY_PLATFORM_ORBIS
1899                         // Also record used space in the system allocator
1900                         exeSize += CrySystemCrtGetUsedSpace();
1901         #endif
1902
1903                         m_stream.WriteEvent(MemReplayAddressProfileEvent(0xffffffff, 0));
1904                         m_stream.WriteEvent(MemReplayInfoEvent(exeSize, initialGlobal, s_replayStartingFree));
1905                         m_stream.WriteEvent(MemReplayFrameStartEvent(g_memReplayFrameCount++));
1906
1907         #if CRY_PLATFORM_DURANGO
1908                         m_stream.WriteEvent(MemReplayModuleRefShortEvent("minidump"));
1909         #endif
1910
1911         #if CRY_PLATFORM_ORBIS
1912                         m_stream.WriteEvent(MemReplayModuleRefShortEvent("orbis"));
1913         #endif
1914                 }
1915         }
1916 }
1917
1918 //////////////////////////////////////////////////////////////////////////
1919 void CMemReplay::Stop()
1920 {
1921         CryAutoLock<CryCriticalSection> lock(GetLogMutex());
1922         if (m_stream.IsOpen())
1923         {
1924                 g_memReplayPaused = false; // unpause or modules might not be recorded
1925                 RecordModules();
1926
1927                 m_stream.Close();
1928         }
1929 }
1930
1931 //////////////////////////////////////////////////////////////////////////
1932 bool CMemReplay::EnterScope(EMemReplayAllocClass cls, EMemReplayUserPointerClass subCls, int moduleId)
1933 {
1934         if (m_stream.IsOpen())
1935         {
1936                 m_scope.Lock();
1937
1938                 ++m_scopeDepth;
1939
1940                 if (m_scopeDepth == 1)
1941                 {
1942                         m_scopeClass = cls;
1943                         m_scopeSubClass = subCls;
1944                         m_scopeModuleId = moduleId;
1945                 }
1946
1947                 return true;
1948         }
1949
1950         return false;
1951 }
1952
1953 void CMemReplay::ExitScope_Alloc(UINT_PTR id, UINT_PTR sz, UINT_PTR alignment)
1954 {
1955         --m_scopeDepth;
1956
1957         if (m_scopeDepth == 0)
1958         {
1959                 if (id && m_stream.IsOpen() && ThreadIsNotFlushing() && !g_memReplayPaused)
1960                 {
1961                         CryAutoLock<CryCriticalSection> lock(GetLogMutex());
1962
1963                         if (m_stream.IsOpen())
1964                         {
1965                                 UINT_PTR global = GetCurrentSysFree();
1966                                 INT_PTR changeGlobal = (INT_PTR)(s_replayLastGlobal - global);
1967                                 s_replayLastGlobal = global;
1968
1969                                 RecordAlloc(m_scopeClass, m_scopeSubClass, m_scopeModuleId, id, alignment, sz, sz, changeGlobal);
1970                         }
1971                 }
1972         }
1973
1974         m_scope.Unlock();
1975 }
1976
1977 void CMemReplay::ExitScope_Realloc(UINT_PTR originalId, UINT_PTR newId, UINT_PTR sz, UINT_PTR alignment)
1978 {
1979         if (!originalId)
1980         {
1981                 ExitScope_Alloc(newId, sz, alignment);
1982                 return;
1983         }
1984
1985         if (!newId)
1986         {
1987                 ExitScope_Free(originalId);
1988                 return;
1989         }
1990
1991         --m_scopeDepth;
1992
1993         if (m_scopeDepth == 0)
1994         {
1995                 if (m_stream.IsOpen() && ThreadIsNotFlushing() && !g_memReplayPaused)
1996                 {
1997                         CryAutoLock<CryCriticalSection> lock(GetLogMutex());
1998
1999                         if (m_stream.IsOpen())
2000                         {
2001                                 UINT_PTR global = GetCurrentSysFree();
2002                                 INT_PTR changeGlobal = (INT_PTR)(s_replayLastGlobal - global);
2003                                 s_replayLastGlobal = global;
2004
2005                                 RecordRealloc(m_scopeClass, m_scopeSubClass, m_scopeModuleId, originalId, newId, alignment, sz, sz, changeGlobal);
2006                         }
2007                 }
2008         }
2009
2010         m_scope.Unlock();
2011 }
2012
2013 void CMemReplay::ExitScope_Free(UINT_PTR id)
2014 {
2015         --m_scopeDepth;
2016
2017         if (m_scopeDepth == 0)
2018         {
2019                 if (id && m_stream.IsOpen() && ThreadIsNotFlushing() && !g_memReplayPaused)
2020                 {
2021                         CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2022
2023                         if (m_stream.IsOpen())
2024                         {
2025                                 UINT_PTR global = GetCurrentSysFree();
2026                                 INT_PTR changeGlobal = (INT_PTR)(s_replayLastGlobal - global);
2027                                 s_replayLastGlobal = global;
2028
2029                                 PREFAST_SUPPRESS_WARNING(6326)
2030                                 RecordFree(m_scopeClass, m_scopeSubClass, m_scopeModuleId, id, changeGlobal);
2031                         }
2032                 }
2033         }
2034
2035         m_scope.Unlock();
2036 }
2037
2038 void CMemReplay::ExitScope()
2039 {
2040         --m_scopeDepth;
2041         m_scope.Unlock();
2042 }
2043
2044 //////////////////////////////////////////////////////////////////////////
2045 void CMemReplay::AddLabel(const char* label)
2046 {
2047         if (m_stream.IsOpen() && ThreadIsNotFlushing() && !g_memReplayPaused)
2048         {
2049                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2050
2051                 if (m_stream.IsOpen())
2052                 {
2053                         new(m_stream.AllocateRawEvent<MemReplayLabelEvent>(strlen(label)))MemReplayLabelEvent(label);
2054                 }
2055         }
2056 }
2057
2058 void CMemReplay::AddLabelFmt(const char* labelFmt, ...)
2059 {
2060         if (m_stream.IsOpen())
2061         {
2062                 va_list args;
2063                 va_start(args, labelFmt);
2064
2065                 char msg[256];
2066                 cry_vsprintf(msg, labelFmt, args);
2067
2068                 va_end(args);
2069
2070                 AddLabel(msg);
2071         }
2072 }
2073
2074 //////////////////////////////////////////////////////////////////////////
2075 void CMemReplay::AddFrameStart()
2076 {
2077         if (m_stream.IsOpen())
2078         {
2079                 static bool bSymbolsDumped = false;
2080                 if (!bSymbolsDumped)
2081                 {
2082                         DumpSymbols();
2083                         bSymbolsDumped = true;
2084                 }
2085
2086                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2087
2088                 if (m_stream.IsOpen())
2089                 {
2090                         m_stream.WriteEvent(MemReplayFrameStartEvent(g_memReplayFrameCount++));
2091                 }
2092         }
2093 }
2094
2095 //////////////////////////////////////////////////////////////////////////
2096 void CMemReplay::GetInfo(CryReplayInfo& infoOut)
2097 {
2098         memset(&infoOut, 0, sizeof(CryReplayInfo));
2099
2100         if (m_stream.IsOpen())
2101         {
2102                 infoOut.uncompressedLength = m_stream.GetUncompressedLength();
2103                 infoOut.writtenLength = m_stream.GetWrittenLength();
2104                 infoOut.trackingSize = m_stream.GetSize();
2105                 infoOut.filename = m_stream.GetFilename();
2106         }
2107         else
2108         {
2109                 ZeroStruct(infoOut);
2110         }
2111 }
2112
2113 //////////////////////////////////////////////////////////////////////////
2114 void CMemReplay::AllocUsage(EMemReplayAllocClass allocClass, UINT_PTR id, UINT_PTR used)
2115 {
2116         #if REPLAY_RECORD_USAGE_CHANGES
2117         if (!ptr)
2118                 return;
2119
2120         if (m_stream.IsOpen() && ThreadIsNotFlushing() && !g_memReplayPaused)
2121         {
2122                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2123                 if (m_stream.IsOpen())
2124                         m_stream.WriteEvent(MemReplayAllocUsageEvent((uint16)allocClass, id, used));
2125         }
2126         #endif
2127 }
2128
2129 void CMemReplay::AddAllocReference(void* ptr, void* ref)
2130 {
2131         if (ptr && m_stream.IsOpen() && ThreadIsNotFlushing() && !g_memReplayPaused)
2132         {
2133                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2134
2135                 if (m_stream.IsOpen())
2136                 {
2137                         MemReplayAddAllocReferenceEvent* ev = m_stream.BeginAllocateRawEvent<MemReplayAddAllocReferenceEvent>(
2138                           k_maxCallStackDepth * SIZEOF_MEMBER(MemReplayAddAllocReferenceEvent, callstack[0])
2139                           - SIZEOF_MEMBER(MemReplayAddAllocReferenceEvent, callstack));
2140
2141                         new(ev) MemReplayAddAllocReferenceEvent(reinterpret_cast<UINT_PTR>(ptr), reinterpret_cast<UINT_PTR>(ref));
2142
2143                         WriteCallstack(ev->callstack, ev->callstackLength);
2144                         m_stream.EndAllocateRawEvent<MemReplayAddAllocReferenceEvent>(ev->callstackLength * sizeof(ev->callstack[0]) - sizeof(ev->callstack));
2145                 }
2146         }
2147 }
2148
2149 void CMemReplay::RemoveAllocReference(void* ref)
2150 {
2151         if (ref && m_stream.IsOpen() && ThreadIsNotFlushing() && !g_memReplayPaused)
2152         {
2153                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2154
2155                 if (m_stream.IsOpen())
2156                         m_stream.WriteEvent(MemReplayRemoveAllocReferenceEvent(reinterpret_cast<UINT_PTR>(ref)));
2157         }
2158 }
2159
2160 IMemReplay::FixedContextID CMemReplay::AddFixedContext(EMemStatContextType type, const char* str)
2161 {
2162         const threadID threadId = CryGetCurrentThreadId();
2163         if (m_stream.IsOpen() && threadId != s_recordThreadId && !g_memReplayPaused)
2164         {
2165                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2166                 static IMemReplay::FixedContextID s_fixedContextCounter = 0;
2167                 if (m_stream.IsOpen())
2168                 {
2169                         FixedContextID id = s_fixedContextCounter++;
2170                         new(m_stream.AllocateRawEvent<MemReplayAddFixedContextEvent>(strlen(str)))
2171                                 MemReplayAddFixedContextEvent(threadId, str, type, id);
2172                         return id;
2173                 }
2174         }
2175         return -1;
2176 }
2177
2178 void CMemReplay::PushFixedContext(FixedContextID id)
2179 {
2180         const threadID threadId = CryGetCurrentThreadId();
2181         if (m_stream.IsOpen() && threadId != s_recordThreadId && !g_memReplayPaused)
2182         {
2183                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2184                 if (m_stream.IsOpen())
2185                 {
2186                         m_stream.WriteEvent(MemReplayPushFixedContextEvent(threadId, id));
2187                 }
2188         }
2189 }
2190
2191 void CMemReplay::PushContext(EMemStatContextType type, const char* str)
2192 {
2193         if (m_stream.IsOpen() && ThreadIsNotFlushing())
2194         {
2195                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2196
2197                 if (m_stream.IsOpen())
2198                 {
2199                         new(m_stream.AllocateRawEvent<MemReplayPushContextEvent>(strlen(str)))
2200                         MemReplayPushContextEvent(CryGetCurrentThreadId(), str, type);
2201                 }
2202         }
2203 }
2204
2205 void CMemReplay::PushContextV(EMemStatContextType type, const char* format, va_list args)
2206 {
2207         if (m_stream.IsOpen() && ThreadIsNotFlushing())
2208         {
2209                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2210
2211                 if (m_stream.IsOpen())
2212                 {
2213                         MemReplayPushContextEvent* ev = m_stream.BeginAllocateRawEvent<MemReplayPushContextEvent>(511);
2214                         new(ev) MemReplayPushContextEvent(CryGetCurrentThreadId(), "", type);
2215
2216                         cry_vsprintf(ev->name, 512, format, args);
2217
2218                         m_stream.EndAllocateRawEvent<MemReplayPushContextEvent>(strlen(ev->name));
2219                 }
2220         }
2221 }
2222
2223 //////////////////////////////////////////////////////////////////////////
2224 void CMemReplay::PopContext()
2225 {
2226         if (m_stream.IsOpen() && ThreadIsNotFlushing())
2227         {
2228                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2229
2230                 if (m_stream.IsOpen())
2231                 {
2232                         m_stream.WriteEvent(MemReplayPopContextEvent(CryGetCurrentThreadId()));
2233                 }
2234         }
2235 }
2236
2237 void CMemReplay::Flush()
2238 {
2239         CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2240
2241         if (m_stream.IsOpen())
2242                 m_stream.Flush();
2243 }
2244
2245 bool CMemReplay::EnableAsynchMode()
2246 {
2247         CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2248
2249         if (m_stream.IsOpen())
2250                 return m_stream.EnableAsynchMode();
2251
2252         return false;
2253 }
2254
2255 void CMemReplay::MapPage(void* base, size_t size)
2256 {
2257         if (m_stream.IsOpen() && base && size && !g_memReplayPaused)
2258         {
2259                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2260
2261                 if (m_stream.IsOpen())
2262                 {
2263                         MemReplayMapPageEvent* ev = m_stream.BeginAllocateRawEvent<MemReplayMapPageEvent>(
2264                           k_maxCallStackDepth * sizeof(void*) - SIZEOF_MEMBER(MemReplayMapPageEvent, callstack));
2265                         new(ev) MemReplayMapPageEvent(reinterpret_cast<UINT_PTR>(base), size);
2266
2267                         WriteCallstack(ev->callstack, ev->callstackLength);
2268                         m_stream.EndAllocateRawEvent<MemReplayMapPageEvent>(sizeof(ev->callstack[0]) * ev->callstackLength - sizeof(ev->callstack));
2269                 }
2270         }
2271 }
2272
2273 void CMemReplay::UnMapPage(void* base, size_t size)
2274 {
2275         if (m_stream.IsOpen() && base && size && !g_memReplayPaused)
2276         {
2277                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2278
2279                 if (m_stream.IsOpen())
2280                 {
2281                         m_stream.WriteEvent(MemReplayUnMapPageEvent(reinterpret_cast<UINT_PTR>(base), size));
2282                 }
2283         }
2284 }
2285
2286 void CMemReplay::RegisterFixedAddressRange(void* base, size_t size, const char* name)
2287 {
2288         if (m_stream.IsOpen() && base && size && name && !g_memReplayPaused)
2289         {
2290                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2291
2292                 if (m_stream.IsOpen())
2293                 {
2294                         new(m_stream.AllocateRawEvent<MemReplayRegisterFixedAddressRangeEvent>(strlen(name)))
2295                         MemReplayRegisterFixedAddressRangeEvent(reinterpret_cast<UINT_PTR>(base), size, name);
2296                 }
2297         }
2298 }
2299
2300 void CMemReplay::MarkBucket(int bucket, size_t alignment, void* base, size_t length)
2301 {
2302         if (m_stream.IsOpen() && base && length && !g_memReplayPaused)
2303         {
2304                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2305
2306                 if (m_stream.IsOpen())
2307                         m_stream.WriteEvent(MemReplayBucketMarkEvent(reinterpret_cast<UINT_PTR>(base), length, bucket, alignment));
2308         }
2309 }
2310
2311 void CMemReplay::UnMarkBucket(int bucket, void* base)
2312 {
2313         if (m_stream.IsOpen() && base && !g_memReplayPaused)
2314         {
2315                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2316
2317                 if (m_stream.IsOpen())
2318                         m_stream.WriteEvent(MemReplayBucketUnMarkEvent(reinterpret_cast<UINT_PTR>(base), bucket));
2319         }
2320 }
2321
2322 void CMemReplay::BucketEnableCleanups(void* allocatorBase, bool enabled)
2323 {
2324         if (m_stream.IsOpen() && allocatorBase && !g_memReplayPaused)
2325         {
2326                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2327
2328                 if (m_stream.IsOpen())
2329                         m_stream.WriteEvent(MemReplayBucketCleanupEnabledEvent(reinterpret_cast<UINT_PTR>(allocatorBase), enabled));
2330         }
2331 }
2332
2333 void CMemReplay::MarkPool(int pool, size_t alignment, void* base, size_t length, const char* name)
2334 {
2335         if (m_stream.IsOpen() && base && length && !g_memReplayPaused)
2336         {
2337                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2338
2339                 if (m_stream.IsOpen())
2340                 {
2341                         new(m_stream.AllocateRawEvent<MemReplayPoolMarkEvent>(strlen(name)))
2342                         MemReplayPoolMarkEvent(reinterpret_cast<UINT_PTR>(base), length, pool, alignment, name);
2343                 }
2344         }
2345 }
2346
2347 void CMemReplay::UnMarkPool(int pool, void* base)
2348 {
2349         if (m_stream.IsOpen() && base && !g_memReplayPaused)
2350         {
2351                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2352
2353                 if (m_stream.IsOpen())
2354                         m_stream.WriteEvent(MemReplayPoolUnMarkEvent(reinterpret_cast<UINT_PTR>(base), pool));
2355         }
2356 }
2357
2358 void CMemReplay::AddTexturePoolContext(void* ptr, int mip, int width, int height, const char* name, uint32 flags)
2359 {
2360         if (m_stream.IsOpen() && ptr && !g_memReplayPaused)
2361         {
2362                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2363
2364                 if (m_stream.IsOpen())
2365                 {
2366                         new(m_stream.AllocateRawEvent<MemReplayTextureAllocContextEvent>(strlen(name)))
2367                         MemReplayTextureAllocContextEvent(reinterpret_cast<UINT_PTR>(ptr), mip, width, height, flags, name);
2368                 }
2369         }
2370 }
2371
2372 void CMemReplay::AddSizerTree(const char* name)
2373 {
2374         MemReplayCrySizer sizer(m_stream, name);
2375         static_cast<CSystem*>(gEnv->pSystem)->CollectMemStats(&sizer);
2376 }
2377
2378 void CMemReplay::AddScreenshot()
2379 {
2380         #if 0
2381         if (m_stream.IsOpen() && !g_memReplayPaused)
2382         {
2383                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2384
2385                 if (m_stream.IsOpen())
2386                 {
2387                         PREFAST_SUPPRESS_WARNING(6255)
2388                         MemReplayScreenshotEvent * ev = new(alloca(sizeof(MemReplayScreenshotEvent) + 65536))MemReplayScreenshotEvent();
2389                         gEnv->pRenderer->ScreenShotBuf(8, ev->bmp);
2390                         m_stream.WriteEvent(ev, ev->bmp[0] * ev->bmp[1] * 3 + 3);
2391                 }
2392         }
2393         #endif
2394 }
2395
2396 void CMemReplay::RegisterContainer(const void* key, int type)
2397 {
2398         #if REPLAY_RECORD_CONTAINERS
2399         if (key)
2400         {
2401                 if (m_stream.IsOpen() && !g_memReplayPaused)
2402                 {
2403                         CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2404
2405                         if (m_stream.IsOpen())
2406                         {
2407                                 MemReplayRegisterContainerEvent* ev = m_stream.BeginAllocateRawEvent<MemReplayRegisterContainerEvent>(
2408                                   k_maxCallStackDepth * SIZEOF_MEMBER(MemReplayRegisterContainerEvent, callstack[0]) - SIZEOF_MEMBER(MemReplayRegisterContainerEvent, callstack));
2409
2410                                 new(ev) MemReplayRegisterContainerEvent(reinterpret_cast<UINT_PTR>(key), type);
2411
2412                                 WriteCallstack(ev->callstack, ev->callstackLength);
2413                                 m_stream.EndAllocateRawEvent<MemReplayRegisterContainerEvent>(length * sizeof(ev->callstack[0]) - sizeof(ev->callstack));
2414                         }
2415                 }
2416         }
2417         #endif
2418 }
2419
2420 void CMemReplay::UnregisterContainer(const void* key)
2421 {
2422         #if REPLAY_RECORD_CONTAINERS
2423         if (key)
2424         {
2425                 if (m_stream.IsOpen() && !g_memReplayPaused)
2426                 {
2427                         CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2428
2429                         if (m_stream.IsOpen())
2430                         {
2431                                 m_stream.WriteEvent(MemReplayUnregisterContainerEvent(reinterpret_cast<UINT_PTR>(key)));
2432                         }
2433                 }
2434         }
2435         #endif
2436 }
2437
2438 void CMemReplay::BindToContainer(const void* key, const void* alloc)
2439 {
2440         #if REPLAY_RECORD_CONTAINERS
2441         if (key && alloc)
2442         {
2443                 if (m_stream.IsOpen() && !g_memReplayPaused)
2444                 {
2445                         CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2446
2447                         if (m_stream.IsOpen())
2448                         {
2449                                 m_stream.WriteEvent(MemReplayBindToContainerEvent(reinterpret_cast<UINT_PTR>(key), reinterpret_cast<UINT_PTR>(alloc)));
2450                         }
2451                 }
2452         }
2453         #endif
2454 }
2455
2456 void CMemReplay::UnbindFromContainer(const void* key, const void* alloc)
2457 {
2458         #if REPLAY_RECORD_CONTAINERS
2459         if (key && alloc)
2460         {
2461                 if (m_stream.IsOpen() && !g_memReplayPaused)
2462                 {
2463                         CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2464
2465                         if (m_stream.IsOpen())
2466                         {
2467                                 m_stream.WriteEvent(MemReplayUnbindFromContainerEvent(reinterpret_cast<UINT_PTR>(key), reinterpret_cast<UINT_PTR>(alloc)));
2468                         }
2469                 }
2470         }
2471         #endif
2472 }
2473
2474 void CMemReplay::SwapContainers(const void* keyA, const void* keyB)
2475 {
2476         #if REPLAY_RECORD_CONTAINERS
2477         if (keyA && keyB && (keyA != keyB) && m_stream.IsOpen() && !g_memReplayPaused)
2478         {
2479                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2480
2481                 if (m_stream.IsOpen())
2482                 {
2483                         m_stream.WriteEvent(MemReplaySwapContainersEvent(reinterpret_cast<UINT_PTR>(keyA), reinterpret_cast<UINT_PTR>(keyB)));
2484                 }
2485         }
2486         #endif
2487 }
2488
2489 void CMemReplay::RecordModuleLoad(void* pSelf, const CReplayModules::ModuleLoadDesc& mld)
2490 {
2491         CMemReplay* pMR = reinterpret_cast<CMemReplay*>(pSelf);
2492
2493         const char* baseName = strrchr(mld.name, '\\');
2494         if (!baseName)
2495                 baseName = mld.name;
2496
2497         pMR->m_stream.WriteEvent(MemReplayModuleRefEvent(mld.name, mld.path, mld.address, mld.size, mld.sig));
2498
2499         pMR->PushContext(EMemStatContextType::Other, baseName);
2500
2501         pMR->RecordAlloc(
2502           EMemReplayAllocClass::UserPointer, EMemReplayUserPointerClass::CryMalloc, eCryModule,
2503           (UINT_PTR)mld.address,
2504           4096,
2505           mld.size,
2506           mld.size,
2507           0);
2508
2509         pMR->PopContext();
2510 }
2511
2512 void CMemReplay::RecordModuleUnload(void* pSelf, const CReplayModules::ModuleUnloadDesc& mld)
2513 {
2514         CMemReplay* pMR = reinterpret_cast<CMemReplay*>(pSelf);
2515
2516         PREFAST_SUPPRESS_WARNING(6326)
2517         pMR->RecordFree(EMemReplayAllocClass::UserPointer, EMemReplayUserPointerClass::CryMalloc, eCryModule, mld.address, 0);
2518         pMR->m_stream.WriteEvent(MemReplayModuleUnRefEvent(mld.address));
2519 }
2520
2521 void CMemReplay::RecordAlloc(EMemReplayAllocClass cls, EMemReplayUserPointerClass subCls, int moduleId, UINT_PTR p, UINT_PTR alignment, UINT_PTR sizeRequested, UINT_PTR sizeConsumed, INT_PTR sizeGlobal)
2522 {
2523         MemReplayAllocEvent* ev = m_stream.BeginAllocateRawEvent<MemReplayAllocEvent>(
2524           k_maxCallStackDepth * sizeof(void*) - SIZEOF_MEMBER(MemReplayAllocEvent, callstack));
2525
2526         new(ev) MemReplayAllocEvent(
2527           CryGetCurrentThreadId(),
2528           static_cast<uint16>(moduleId),
2529           static_cast<uint16>(cls),
2530           static_cast<uint16>(subCls),
2531           p,
2532           static_cast<uint32>(alignment),
2533           static_cast<uint32>(sizeRequested),
2534           static_cast<uint32>(sizeConsumed),
2535           static_cast<int32>(sizeGlobal));
2536
2537         WriteCallstack(ev->callstack, ev->callstackLength);
2538         m_stream.EndAllocateRawEvent<MemReplayAllocEvent>(sizeof(ev->callstack[0]) * ev->callstackLength - sizeof(ev->callstack));
2539 }
2540
2541 void CMemReplay::RecordRealloc(EMemReplayAllocClass cls, EMemReplayUserPointerClass subCls, int moduleId, UINT_PTR originalId, UINT_PTR newId, UINT_PTR alignment, UINT_PTR sizeRequested, UINT_PTR sizeConsumed, INT_PTR sizeGlobal)
2542 {
2543         MemReplayReallocEvent* ev = new(m_stream.BeginAllocateRawEvent<MemReplayReallocEvent>(
2544                                           k_maxCallStackDepth * SIZEOF_MEMBER(MemReplayReallocEvent, callstack[0]) - SIZEOF_MEMBER(MemReplayReallocEvent, callstack)))
2545                                     MemReplayReallocEvent(
2546           CryGetCurrentThreadId(),
2547           static_cast<uint16>(moduleId),
2548           static_cast<uint16>(cls),
2549           static_cast<uint16>(subCls),
2550           originalId,
2551           newId,
2552           static_cast<uint32>(alignment),
2553           static_cast<uint32>(sizeRequested),
2554           static_cast<uint32>(sizeConsumed),
2555           static_cast<int32>(sizeGlobal));
2556
2557         WriteCallstack(ev->callstack, ev->callstackLength);
2558         m_stream.EndAllocateRawEvent<MemReplayReallocEvent>(ev->callstackLength * sizeof(ev->callstack[0]) - sizeof(ev->callstack));
2559 }
2560
2561 void CMemReplay::RecordFree(EMemReplayAllocClass cls, EMemReplayUserPointerClass subCls, int moduleId, UINT_PTR id, INT_PTR sizeGlobal)
2562 {
2563         MemReplayFreeEvent* ev =
2564           new(m_stream.BeginAllocateRawEvent<MemReplayFreeEvent>(SIZEOF_MEMBER(MemReplayFreeEvent, callstack[0]) * k_maxCallStackDepth - SIZEOF_MEMBER(MemReplayFreeEvent, callstack)))
2565           MemReplayFreeEvent(
2566             CryGetCurrentThreadId(),
2567             static_cast<uint16>(moduleId),
2568             static_cast<uint16>(cls),
2569             static_cast<uint16>(subCls),
2570             id,
2571             static_cast<int32>(sizeGlobal));
2572
2573         if (REPLAY_RECORD_FREECS)
2574                 WriteCallstack(ev->callstack, ev->callstackLength);
2575         m_stream.EndAllocateRawEvent<MemReplayFreeEvent>(ev->callstackLength * sizeof(ev->callstack[0]) - sizeof(ev->callstack));
2576 }
2577
2578 void CMemReplay::RecordModules()
2579 {
2580         MEMSTAT_CONTEXT(EMemStatContextType::Other, "DLL Image Size (incl. Data Segment)");
2581         m_modules.RefreshModules(RecordModuleLoad, RecordModuleUnload, this);
2582 }
2583
2584 void CMemReplay::WriteCallstack(UINT_PTR* callstack, uint32& length)
2585 {
2586         if(g_cvars.memReplayRecordCallstacks)
2587         {
2588                 length = k_maxCallStackDepth;
2589                 CSystem::debug_GetCallStackRaw(CastCallstack(callstack), length);
2590         }
2591         else
2592         {
2593                 length = 1;
2594                 *callstack = 0;
2595         }
2596 }
2597
2598 void CMemReplay::WriteCallstack(UINT_PTR* callstack, uint16& length)
2599 {
2600         uint32 len;
2601         WriteCallstack(callstack, len);
2602         length = len;
2603 }
2604
2605 MemReplayCrySizer::MemReplayCrySizer(ReplayLogStream& stream, const char* name)
2606         : m_stream(&stream)
2607         , m_totalSize(0)
2608         , m_totalCount(0)
2609 {
2610         Push(name);
2611 }
2612
2613 MemReplayCrySizer::~MemReplayCrySizer()
2614 {
2615         Pop();
2616
2617         {
2618                 MEMREPLAY_SCOPE(EMemReplayAllocClass::UserPointer, EMemReplayUserPointerClass::Unknown);
2619                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2620
2621                 if (m_stream->IsOpen())
2622                 {
2623                         // Clear the added objects set within the g_replayProcessed lock,
2624                         // as memReplay won't have seen the allocations made by it.
2625                         m_addedObjects.clear();
2626                 }
2627         }
2628 }
2629
2630 size_t MemReplayCrySizer::GetTotalSize()
2631 {
2632         return m_totalSize;
2633 }
2634
2635 size_t MemReplayCrySizer::GetObjectCount()
2636 {
2637         return m_totalCount;
2638 }
2639
2640 void MemReplayCrySizer::Reset()
2641 {
2642         m_totalSize = 0;
2643         m_totalCount = 0;
2644 }
2645
2646 bool MemReplayCrySizer::AddObject(const void* pIdentifier, size_t nSizeBytes, int nCount)
2647 {
2648         bool ret = false;
2649
2650         if (m_stream->IsOpen())
2651         {
2652                 MEMREPLAY_SCOPE(EMemReplayAllocClass::UserPointer, EMemReplayUserPointerClass::Unknown);
2653                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2654
2655                 if (m_stream->IsOpen())
2656                 {
2657                         std::set<const void*>::iterator it = m_addedObjects.find(pIdentifier);
2658                         if (it == m_addedObjects.end())
2659                         {
2660                                 m_totalSize += nSizeBytes;
2661                                 m_totalCount += nCount;
2662                                 m_addedObjects.insert(pIdentifier);
2663                                 m_stream->WriteEvent(MemReplaySizerAddRangeEvent((UINT_PTR)pIdentifier, nSizeBytes, nCount));
2664                                 ret = true;
2665                         }
2666                 }
2667         }
2668
2669         return ret;
2670 }
2671
2672 static NullResCollector s_nullCollectorMemreplay;
2673
2674 IResourceCollector* MemReplayCrySizer::GetResourceCollector()
2675 {
2676         return &s_nullCollectorMemreplay;
2677 }
2678
2679 void MemReplayCrySizer::SetResourceCollector(IResourceCollector*)
2680 {
2681 }
2682
2683 void MemReplayCrySizer::Push(const char* szComponentName)
2684 {
2685         if (m_stream->IsOpen())
2686         {
2687                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2688
2689                 if (m_stream->IsOpen())
2690                 {
2691                         new(m_stream->AllocateRawEvent<MemReplaySizerPushEvent>(strlen(szComponentName)))MemReplaySizerPushEvent(szComponentName);
2692                 }
2693         }
2694 }
2695
2696 void MemReplayCrySizer::PushSubcomponent(const char* szSubcomponentName)
2697 {
2698         Push(szSubcomponentName);
2699 }
2700
2701 void MemReplayCrySizer::Pop()
2702 {
2703         if (m_stream->IsOpen())
2704         {
2705                 CryAutoLock<CryCriticalSection> lock(GetLogMutex());
2706
2707                 if (m_stream->IsOpen())
2708                 {
2709                         m_stream->WriteEvent(MemReplaySizerPopEvent());
2710                 }
2711         }
2712 }
2713
2714 #endif //CAPTURE_REPLAY_LOG