mirror of https://github.com/red-prig/fpPS4.git
821 lines
33 KiB
PHP
821 lines
33 KiB
PHP
{
|
|
|
|
Fast Memory Manager: Options Include File
|
|
|
|
Set the default options for FastMM here.
|
|
|
|
}
|
|
|
|
{$define IgnoreMemoryAllocatedBefore}
|
|
|
|
{---------------------------Miscellaneous Options-----------------------------}
|
|
|
|
{Enable Align16Bytes define to align all data blocks on 16 byte boundaries,
|
|
or enable Align32Bytes define to align all blocks on 32 byte boundaries,
|
|
so aligned SSE instructions can be used safely.
|
|
|
|
If neither of these options are enabled, then some of the
|
|
smallest block sizes will be 8-byte aligned instead which may result in a
|
|
reduction in memory usage.
|
|
|
|
Even when small blocks are aligned by 8 bytes
|
|
(no Align16Bytes or Align32Bytes are defined),
|
|
Medium and large blocks are always 16-byte aligned.
|
|
|
|
If you enable AVX, then the alignment will always be 32 bytes. However, if your
|
|
CPU supports "Fast Short REP MOVSB" (Ice Lake or newer), you can disable AVX,
|
|
and align by just 8 bytes, and this may even be faster because less memory is
|
|
wasted on alignment}
|
|
|
|
{.$define Align16Bytes}
|
|
{.$define Align32Bytes}
|
|
|
|
|
|
{Enable to use faster fixed-size move routines when upsizing small blocks.
|
|
These routines are much faster than the Borland RTL move procedure since they
|
|
are optimized to move a fixed number of bytes. This option may be used
|
|
together with the FastMove library for even better performance.
|
|
You may define "DontUseCustomFixedSizeMoveRoutines" to undef this option}
|
|
|
|
{$define UseCustomFixedSizeMoveRoutines}
|
|
|
|
|
|
{Enable this option to use an optimized procedure for moving a memory block of
|
|
an arbitrary size. Disable this option when using the Fastcode move
|
|
("FastMove") library. Using the Fastcode move library allows your whole
|
|
application to gain from faster move routines, not just the memory manager. It
|
|
is thus recommended that you use the Fastcode move library in conjunction with
|
|
this memory manager and disable this option.
|
|
You may define "DontUseCustomVariableSizeMoveRoutines" to undef this option.}
|
|
|
|
{$define UseCustomVariableSizeMoveRoutines}
|
|
|
|
|
|
{Enable this option to only install FastMM as the memory manager when the
|
|
application is running inside the Delphi IDE. This is useful when you want
|
|
to deploy the same EXE that you use for testing, but only want the debugging
|
|
features active on development machines. When this option is enabled and
|
|
the application is not being run inside the IDE debugger, then the default
|
|
Delphi memory manager will be used (which, since Delphi 2006, is FastMM
|
|
without FullDebugMode.}
|
|
|
|
{.$define InstallOnlyIfRunningInIDE}
|
|
|
|
|
|
{Due to QC#14070 ("Delphi IDE attempts to free memory after the shutdown code
|
|
of borlndmm.dll has been called"), FastMM cannot be uninstalled safely when
|
|
used inside a replacement borlndmm.dll for the IDE. Setting this option will
|
|
circumvent this problem by never uninstalling the memory manager.}
|
|
|
|
{.$define NeverUninstall}
|
|
|
|
|
|
{Set this option when you use runtime packages in this application or library.
|
|
This will automatically set the "AssumeMultiThreaded" option. Note that you
|
|
have to ensure that FastMM is finalized after all live pointers have been
|
|
freed - failure to do so will result in a large leak report followed by a lot
|
|
of A/Vs. (See the FAQ for more detail.) You may have to combine this option
|
|
with the NeverUninstall option.}
|
|
|
|
{.$define UseRuntimePackages}
|
|
|
|
|
|
|
|
{-----------------------Concurrency Management Options------------------------}
|
|
|
|
{Enable to always assume that the application is multithreaded. Enabling this
|
|
option will cause a significant performance hit with single threaded
|
|
applications. Enable if you are using multi-threaded third-party tools that do
|
|
not properly set the IsMultiThread variable. Also set this option if you are
|
|
going to share this memory manager between a single threaded application and a
|
|
multi-threaded DLL. Since the primary goal of FastMM4-AVX is improvement in
|
|
multi-threaded applications, this option is enabled by default. However, if you
|
|
know for sure that your application is Single-Threaded, undefine this to improve
|
|
performance - this will save yo from unnecessary locking!
|
|
You can define "ForceSingleThreaded" to undefine "AssumeMultiThreaded"}
|
|
|
|
{$define AssumeMultiThreaded}
|
|
|
|
|
|
{Enable to always assume that the CPU supports "pause" instruction and Windows
|
|
supports SwitchToThread() API call. This option has no effect for 64-bit target,
|
|
since it is always assumed under 64-bit that both "pause" and SwitchToThread()
|
|
are supported. So it is only relevant for 32-bit platforms with very old CPUs.
|
|
If you are sure that "pause" and SwithchToThread() are always avaialbe, the
|
|
program may skip checking and improve speed. However, if you define
|
|
"DisablePauseAndSwitchToThread", then "AssumePauseAndSwitchToThreadAvailable"
|
|
will be automatically undefined}
|
|
|
|
{.$define AssumePauseAndSwitchToThreadAvailable}
|
|
|
|
|
|
{ If you disable "pause" and SwitchToThread() by defining the
|
|
DisablePauseAndSwitchToThread, then EnterCriticalSection/LeaveCriticalSection
|
|
calls will be used instead }
|
|
|
|
{.$define DisablePauseAndSwitchToThread}
|
|
|
|
|
|
{Enable this option to not call Sleep when a thread contention occurs. This
|
|
option will improve performance if the ratio of the number of active threads
|
|
to the number of CPU cores is low (typically < 2). With this option set a
|
|
thread will usually enter a "busy waiting" loop instead of relinquishing its
|
|
timeslice when a thread contention occurs, unless UseSwitchToThread is
|
|
also defined (see below) in which case it will call SwitchToThread instead of
|
|
Sleep.
|
|
|
|
*** Note: This option was added in FastMM 4 version Version 4.68
|
|
on 3 July 2006, is provided only if you wish to restore old
|
|
functionality (e.g. for testing, etc.), and is not recommended
|
|
for FastMM4-AVX, since this it provides suboptimal performance compare
|
|
to the new locking mechanism implemented in the FastMM4-AVX.
|
|
This option has no effect when SmallBlocksLockedCriticalSection/
|
|
MediumBlocksLockedCriticalSection/LargeBlocksLockedCriticalSection is enabled}
|
|
|
|
{.$define NeverSleepOnThreadContention}
|
|
|
|
|
|
{Set this option to call SwitchToThread instead of sitting in a "busy waiting"
|
|
loop when a thread contention occurs. This is used in conjunction with the
|
|
NeverSleepOnThreadContention option, and has no effect unless
|
|
NeverSleepOnThreadContention is also defined. This option may improve
|
|
performance with many CPU cores and/or threads of different priorities. Note
|
|
that the SwitchToThread API call is only available on Windows 2000 and later,
|
|
but FastMM4 loads it dynamically, so it would not fail even under very old
|
|
versions of Windows.
|
|
|
|
*** Note: This option was added in FastMM 4 version Version 4.97
|
|
on 30 September 2010, is provided only if you wish to restore old
|
|
functionality (e.g. for testing, etc.), and is not recommended
|
|
for FastMM4-AVX, since this it provides suboptimal performance compare
|
|
to the new locking mechanism implemented in the FastMM4-AVX.
|
|
This option has no effect when SmallBlocksLockedCriticalSection/
|
|
MediumBlocksLockedCriticalSection/LargeBlocksLockedCriticalSection is enabled}
|
|
|
|
{.$define UseSwitchToThread}
|
|
|
|
|
|
{This option uses a simpler instruction to acquire a lock: "lock xchg", instead
|
|
of "lock cmpxchg" used in earlier versions of FastMM4: there is actually no
|
|
reason to use "cmpxchg", because the simple instruction - "xchg" - perfectly
|
|
suits our need. Although "xchg" has exactly the same latency and costs in terms
|
|
of CPU cycles as "cmpxghg", it is just simper way to do the lock that we need,
|
|
and, according to the Occam's razor principle, simple things are better. If you
|
|
wish to restore old functionality of FastMM4 version 4.992, disable this option,
|
|
e.g. by defining "DontUseSimplifiedInterlockedExchangeByte" }
|
|
|
|
{$define SimplifiedInterlockedExchangeByte}
|
|
|
|
|
|
{These 3 options make FastMM4-AVX use a new approach to waiting for a lock:
|
|
CriticalSections or "pause"-based spin-wait loops instead of Sleep() or
|
|
SwitchToThread().
|
|
Using Sleep(0) or SwitchToThread() while waiting for a lock is a default
|
|
approach in the original version of FastMM.
|
|
With the new approach, the Sleep() will never be called, and SwitchToThread()
|
|
may only be called after 5000 cycles of "pause"-based spin-wait loop.
|
|
Testing has shown that the new approach provides significant gain in
|
|
multi-threaded scenarios, especially in situations when the number of threads
|
|
working with the memory manager is the same or higher than the number of
|
|
physical cores.
|
|
Critical Sections or "pause"-based spin-wait loops implemented as
|
|
"test, test-and-set" are much more CPU-friendly and have definitely lower
|
|
latency than Sleep() or SwitchToThread().
|
|
|
|
When these options are enabled, FastMM4-AVX checks:
|
|
- whether the CPU supports SSE2 and thus the "pause" instruction, and
|
|
- whether the operating system has the SwitchToThread() API call, and,
|
|
if both of the above conditions are met, uses
|
|
"pause"-based spin-wait loops for 5000 iterations and then
|
|
SwitchToThread() instead of critical sections; If a CPU doesn't have the
|
|
"pause" instrcution or Windows doesn't have the SwitchToThread() API
|
|
function, it will use EnterCriticalSection/LeaveCriticalSection.
|
|
|
|
If you wound not define the 3 options below, you will get the locking
|
|
mechanism from the original FastMM4.
|
|
|
|
Since these options are defined by default, you may define
|
|
DontUseSmallBlocksLockedCriticalSection,
|
|
DontUseMediumBlocksLockedCriticalSection and
|
|
DontUseLargeBlocksLockedCriticalSection, respectively, to undefine these
|
|
options }
|
|
|
|
{$define SmallBlocksLockedCriticalSection}
|
|
{$define MediumBlocksLockedCriticalSection}
|
|
{$define LargeBlocksLockedCriticalSection}
|
|
|
|
|
|
|
|
{ Use this option if you need that releasing a lock on data structure,
|
|
i.e. writing to a synchronization variable, to use bus-locking memory store
|
|
(lock xchg) rather than just the normal memory store (mov).
|
|
Using bus-locking memory store to release a lock on data structure is
|
|
an old approach of the original FastMM4, and is not recommended
|
|
for FastMM4-AVX. Look for "using normal memory store" in the comment section
|
|
at the beginning of the main .pas file for the discussion }
|
|
|
|
{.$define InterlockedRelease}
|
|
|
|
|
|
{-----------------------------Debugging Options-------------------------------}
|
|
|
|
{Enable this option to suppress the generation of debug info for the
|
|
FastMM4.pas unit. This will prevent the integrated debugger from stepping into
|
|
the memory manager code.}
|
|
|
|
{$define NoDebugInfo}
|
|
|
|
|
|
{Enable this option to suppress the display of all message dialogs. This is
|
|
useful in service applications that should not be interrupted.}
|
|
|
|
{$define NoMessageBoxes}
|
|
|
|
|
|
{Set this option to use the Windows API OutputDebugString procedure to output
|
|
debug strings on startup/shutdown and when errors occur.}
|
|
|
|
{.$define UseOutputDebugString}
|
|
|
|
|
|
{Set this option to use the assembly language version of GetMem and FreeMem
|
|
which is faster than the pascal version. Disable only for debugging purposes.
|
|
Setting the CheckHeapForCorruption option automatically disables this option.
|
|
You may also define DontUseASMVersion to disable this option. }
|
|
|
|
{$define ASMVersion}
|
|
|
|
|
|
{Set this option to disable any inline assembly at all. However, it would not
|
|
be able to use efficient locking without inline assembly.}
|
|
|
|
{.$define PurePascal}
|
|
|
|
|
|
{Define the "EnableAsmCodeAlign" to allow using ".align" assembler
|
|
directive for the 32-bit or 64-bit inline assembly.
|
|
Delphi 32-bit or 64-bit compiler incorrectly encodes conditional jumps
|
|
(used 6-byte instructions instead of just 2 bytes, so it prevents branch
|
|
predicions. So for Embarcadero (former Borland) 32-bit or 64-bit
|
|
Delphi, EnableAsmCodeAlign will have no effect. However, undre FreePascal
|
|
it turns on using the ".align". To force using it under Delphi, define
|
|
"ForceAsmCodeAlign".
|
|
|
|
To disable this option, define "DisableAsmCodeAlign",
|
|
which affects both "EnableAsmCodeAlign" and "ForceAsmCodeAlign" }
|
|
|
|
|
|
{$define EnableAsmCodeAlign}
|
|
{.$define ForceAsmCodeAlign}
|
|
|
|
|
|
{Allow pascal code alignment, use "DisablePasCodeAlign" to disable this option}
|
|
|
|
{$define PasCodeAlign}
|
|
|
|
|
|
{FastMM always catches attempts to free the same memory block twice, however it
|
|
can also check for corruption of the memory heap (typically due to the user
|
|
program overwriting the bounds of allocated memory). These checks are
|
|
expensive, and this option should thus only be used for debugging purposes.
|
|
If this option is set then the ASMVersion option is automatically disabled.}
|
|
|
|
{.$define CheckHeapForCorruption}
|
|
|
|
|
|
{Enable this option to catch attempts to perform MM operations after FastMM has
|
|
been uninstalled. With this option set when FastMM is uninstalled it will not
|
|
install the previous MM, but instead a dummy MM handler that throws an error
|
|
if any MM operation is attempted. This will catch attempts to use the MM
|
|
after FastMM has been uninstalled.
|
|
You may define "DontDetectMMOperationsAfterUninstall" to disable this option}
|
|
|
|
{.$define DetectMMOperationsAfterUninstall}
|
|
|
|
|
|
{Set the following option to do extensive checking of all memory blocks. All
|
|
blocks are padded with both a header and trailer that are used to verify the
|
|
integrity of the heap. Freed blocks are also cleared to ensure that they
|
|
cannot be reused after being freed. This option slows down memory operations
|
|
dramatically and should only be used to debug an application that is
|
|
overwriting memory or reusing freed pointers. Setting this option
|
|
automatically enables CheckHeapForCorruption and disables ASMVersion.
|
|
Very important: If you enable this option your application will require the
|
|
FastMM_FullDebugMode.dll library. If this library is not available you will
|
|
get an error on startup.}
|
|
|
|
{.$define FullDebugMode}
|
|
|
|
|
|
{Set this option to perform "raw" stack traces, i.e. check all entries on the
|
|
stack for valid return addresses. Note that this is significantly slower
|
|
than using the stack frame tracing method, but is usually more complete. Has
|
|
no effect unless FullDebugMode is enabled}
|
|
|
|
{.$define RawStackTraces}
|
|
|
|
|
|
{Set this option to check for user code that uses an interface of a freed
|
|
object. Note that this will disable the checking of blocks modified after
|
|
being freed (the two are not compatible). This option has no effect if
|
|
FullDebugMode is not also enabled.}
|
|
|
|
{.$define CatchUseOfFreedInterfaces}
|
|
|
|
|
|
{Set this option to log all errors to a text file in the same folder as the
|
|
application. Memory errors (with the FullDebugMode option set) will be
|
|
appended to the log file. Has no effect if "FullDebugMode" is not set.}
|
|
|
|
{.$define LogErrorsToFile}
|
|
|
|
|
|
{Set this option to log all memory leaks to a text file in the same folder as
|
|
the application. Memory leak reports (with the FullDebugMode option set)
|
|
will be appended to the log file. Has no effect if "LogErrorsToFile" and
|
|
"FullDebugMode" are not also set. Note that usually all leaks are always
|
|
logged, even if they are "expected" leaks registered through
|
|
AddExpectedMemoryLeaks. Expected leaks registered by pointer may be excluded
|
|
through the HideExpectedLeaksRegisteredByPointer option.}
|
|
|
|
{.$define LogMemoryLeakDetailToFile}
|
|
|
|
|
|
{Deletes the error log file on startup. No effect if LogErrorsToFile is not
|
|
also set.}
|
|
|
|
{.$define ClearLogFileOnStartup}
|
|
|
|
|
|
{Loads the FASTMM_FullDebugMode.dll dynamically. If the DLL cannot be found
|
|
then stack traces will not be available. Note that this may cause problems
|
|
due to a changed DLL unload order when sharing the memory manager. Use with
|
|
care.}
|
|
|
|
{.$define LoadDebugDLLDynamically}
|
|
|
|
{.$define MemoryLoadLibrarySupport}
|
|
{Uses MemoryLoadLibrary to allow loading FastMM_FullDebugMode.dll from
|
|
Ressource if no DLL is found.}
|
|
|
|
{.$define IncludeResource}
|
|
(*Include Platform depending FullDebugMode.dll in JCLDebug-Mode.
|
|
This has no effect without LoadDebugDLLDynamically or MemoryLoadLibrarySupport.
|
|
If not defined linking can be done from Project-File:
|
|
{$IFDEF Win64}
|
|
{$R FastMM_FullDebugMode64.res}
|
|
{$ELSE}
|
|
{$R FastMM_FullDebugMode.res}
|
|
{$ENDIF}
|
|
*)
|
|
|
|
{.$define IncludeResource_madExcept}
|
|
(*Include Platform depending FullDebugMode.dll in madExcept-Mode.
|
|
This has no effect without LoadDebugDLLDynamically or MemoryLoadLibrarySupport.
|
|
If not defined linking can be done from Project-File:
|
|
{$IFDEF Win64}
|
|
{$R FastMM_FullDebugMode_madExcept64.res}
|
|
{$ELSE}
|
|
{$R FastMM_FullDebugMode_madExcept.res}
|
|
{$ENDIF}
|
|
*)
|
|
|
|
{.$define DoNotInstallIfDLLMissing}
|
|
{If the FastMM_FullDebugMode.dll file is not available then FastMM will not
|
|
install itself. No effect unless FullDebugMode and LoadDebugDLLDynamically
|
|
are also defined.}
|
|
|
|
{.$define RestrictDebugDLLLoadPath}
|
|
{Allow to load debug dll only from host module directory.}
|
|
|
|
|
|
{FastMM usually allocates large blocks from the topmost available address and
|
|
medium and small blocks from the lowest available address (This reduces
|
|
fragmentation somewhat). With this option set all blocks are always
|
|
allocated from the highest available address. If the process has a >2GB
|
|
address space and contains bad pointer arithmetic code, this option should
|
|
help to catch those errors sooner.}
|
|
|
|
{.$define AlwaysAllocateTopDown}
|
|
|
|
|
|
{Disables the logging of memory dumps together with the other detail for
|
|
memory errors.}
|
|
|
|
{.$define DisableLoggingOfMemoryDumps}
|
|
|
|
|
|
{If FastMM encounters a problem with a memory block inside the FullDebugMode
|
|
FreeMem handler then an "invalid pointer operation" exception will usually
|
|
be raised. If the FreeMem occurs while another exception is being handled
|
|
(perhaps in the try.. finally code) then the original exception will be
|
|
lost. With this option set FastMM will ignore errors inside FreeMem when an
|
|
exception is being handled, thus allowing the original exception to
|
|
propagate.}
|
|
|
|
{.$define SuppressFreeMemErrorsInsideException}
|
|
|
|
|
|
{Adds support for notification of memory manager events in FullDebugMode.
|
|
With this define set, the application may assign the OnDebugGetMemFinish,
|
|
OnDebugFreeMemStart, etc. callbacks in order to be notified when the
|
|
particular memory manager event occurs.}
|
|
|
|
{.$define FullDebugModeCallBacks}
|
|
|
|
|
|
|
|
{---------------------------Memory Leak Reporting-----------------------------}
|
|
|
|
{Set the option EnableMemoryLeakReporting to enable reporting of memory leaks.
|
|
Combine it with the two options below for further fine-tuning.}
|
|
|
|
{$ifndef DisableMemoryLeakReporting}
|
|
{.$define EnableMemoryLeakReporting}
|
|
{$endif}
|
|
|
|
|
|
{Set this option to suppress the display and logging of expected memory leaks
|
|
that were registered by pointer. Leaks registered by size or class are often
|
|
ambiguous, so these expected leaks are always logged to file (in
|
|
FullDebugMode with the LogMemoryLeakDetailToFile option set) and are never
|
|
hidden from the leak display if there are more leaks than are expected.}
|
|
|
|
{$define HideExpectedLeaksRegisteredByPointer}
|
|
|
|
|
|
{Set this option to require the presence of the Delphi IDE to report memory
|
|
leaks. This option has no effect if the option "EnableMemoryLeakReporting"
|
|
is not also set.}
|
|
|
|
{.$define RequireIDEPresenceForLeakReporting}
|
|
|
|
|
|
{Set this option to require the program to be run inside the IDE debugger to
|
|
report memory leaks. This option has no effect if the option
|
|
"EnableMemoryLeakReporting" is not also set. Note that this option does not
|
|
work with libraries, only EXE projects.}
|
|
|
|
{$define RequireDebuggerPresenceForLeakReporting}
|
|
|
|
|
|
{Set this option to require the presence of debug info ($D+ option) in the
|
|
compiled unit to perform memory leak checking. This option has no effect if
|
|
the option "EnableMemoryLeakReporting" is not also set.}
|
|
|
|
{.$define RequireDebugInfoForLeakReporting}
|
|
|
|
|
|
{Set this option to enable manual control of the memory leak report. When
|
|
this option is set the ReportMemoryLeaksOnShutdown variable (default = false)
|
|
may be changed to select whether leak reporting should be done or not. When
|
|
this option is selected then both the variable must be set to true and the
|
|
other leak checking options must be applicable for the leak checking to be
|
|
done.}
|
|
|
|
{.$define ManualLeakReportingControl}
|
|
|
|
|
|
{Set this option to disable the display of the hint below the memory leak
|
|
message.}
|
|
|
|
{.$define HideMemoryLeakHintMessage}
|
|
|
|
|
|
{Set this option to use QualifiedClassName equivalent instead of ClassName
|
|
equivalent during memory leak reporting.
|
|
This is useful for duplicate class names (like EConversionError, which is in
|
|
units Data.DBXJSONReflect, REST.JsonReflect and System.ConvUtils,
|
|
or TClipboard being in Vcl.Clibprd and WinAPI.ApplicationModel.DataTransfer }
|
|
|
|
{$define EnableMemoryLeakReportingUsesQualifiedClassName}
|
|
|
|
|
|
{--------------------------Instruction Set Options----------------------------}
|
|
|
|
{Set this option to enable the use of MMX instructions. Disabling this option
|
|
will result in a slight performance hit, but will enable compatibility with
|
|
AMD K5, Pentium I and earlier CPUs. MMX is currently only used in the variable
|
|
size move routines, so if UseCustomVariableSizeMoveRoutines is not set then
|
|
this option has no effect.}
|
|
|
|
{$define EnableMMX}
|
|
|
|
|
|
{$ifndef DontForceMMX}
|
|
|
|
{Set this option (ForceMMX) to force the use of MMX instructions without checking
|
|
whether the CPU supports it. If this option is disabled then the CPU will be
|
|
checked for compatibility first, and if MMX is not supported it will fall
|
|
back to the FPU move code. Has no effect unless EnableMMX is also set.}
|
|
{$define ForceMMX}
|
|
|
|
{$endif}
|
|
|
|
{$ifndef DisableAVX}
|
|
|
|
{Set this option (EnableAVX) to enable use of AVX instructions under 64-bit mode.
|
|
This option has no effect under 32-bit mode. If enabled, the code will check
|
|
whether the CPU supports AVX or AVX2, and, if yes, will use the 32-byte YMM
|
|
registers for faster memory copy. Besides that, if this option is enabled,
|
|
all allocated memory blocks will be aligned by 32 bytes, that will incur
|
|
addition memory consumption overhead. Besides that, with this option, memory
|
|
copy will be slightly more secure, because all XMM/YMM registers used to copy
|
|
memory will be cleared by vxorps/vpxor at the end of a copy routine, so the
|
|
leftovers of the copied memory data will not be kept in the XMM/YMM registers
|
|
and will not be exposed. This option properly handles AVX-SSE transitions to not
|
|
incur the transition penalties, only calls vzeroupper under AVX1, but not under
|
|
AVX2, since it slows down subsequent SSE code under Kaby Lake}
|
|
|
|
{$define EnableAVX}
|
|
|
|
{$endif}
|
|
|
|
|
|
{$ifdef EnableAVX}
|
|
{If AVX is enabled, you can optionally disable one or more
|
|
of the following AVX modes:
|
|
- the first version - initial AVX (DisableAVX1); or
|
|
- the second version AVX2 (DisableAVX2); or
|
|
- AVX-512 (DisableAVX512);
|
|
but you cannot disable all of the above modes at once.
|
|
|
|
If you define DisableAVX1, it will not add to FastMM4 the instructions from
|
|
the initial (first) version of the Advanced Vector Extensions instruction set,
|
|
officially called just "AVX", proposed by Intel in March 2008 and first
|
|
supported by Intel with the Sandy Bridge processor shipping in Q1 2011
|
|
and later, on by AMD with the Bulldozer processor shipping in Q3 2011.
|
|
|
|
If you define DisableAVX2, it will not add to FastMM4 the instructions from
|
|
the second version of the Advanced Vector Extensions - officially called
|
|
"AVX2", also known as Haswell New Instructions, which is an expansion of the
|
|
AVX instruction set introduced in Intel's Haswell microarchitecture.
|
|
Intel has shipped first processors with AVX2 on June 2, 2013: Core i7 4770,
|
|
Core i5 4670, etc., and AMD has shipped first processors with AVX in Q2 2015
|
|
(Carrizo processor). AMD Ryzen processor (Q1 2017) also supports AVX2.
|
|
We use separate code for AVX1 and AVX2 because AVX2 doesn't use "vzeroupper"
|
|
and uses the new, faster instruction "vpxor" which was not available in the
|
|
initial AVX, which, in its turn, uses "vxorps" and "vzeroupper" before and
|
|
after any AVX code to counteract the AVX-SSE transition penalties.
|
|
FastMM4 checks whether AVX2 is supported by the CPU, and, if supported, never
|
|
calls AVX1 functions, since calling "vzeroupper" even once in a thread
|
|
significantly slows down all subsequent SSE code, which is not documented:
|
|
neither in the Intel 64 and IA-32 Architectures Software Developers Manual
|
|
nor in the Intel 64 and IA-32 Architectures Optimization Reference Manual.
|
|
|
|
The code of AVX1 is grouped separately from the code of AVX2, to not scatter
|
|
the cache}
|
|
|
|
|
|
{.$define DisableAVX1}
|
|
{.$define DisableAVX2}
|
|
{$define DisableAVX512}
|
|
{$endif}
|
|
|
|
|
|
{$ifndef DisableERMS}
|
|
|
|
{Set this option (EnableERMS) to enable Enhanced Rep Movsb/Stosb CPU feature,
|
|
which improves speed of medium and large block memory copy
|
|
under 32-bit or 64-bit modes after checking the corresponding CPUID bit}
|
|
|
|
{$define EnableERMS}
|
|
|
|
{$endif}
|
|
|
|
|
|
{$ifndef DisableFSRM}
|
|
|
|
{Set this option (EnableFSRM) to enable Fast Short REP MOVSB CPU feature,
|
|
introduced by the Ice Lake microarchitecture, which improves speed of small
|
|
block memory copy under 64-bit mode after checking the corresponding CPUID bit}
|
|
|
|
{$define EnableFSRM}
|
|
|
|
{$endif}
|
|
|
|
{$ifndef DisableWaitPKG}
|
|
|
|
{Set this option (EnableWaitPKG) to enable user mode wait (WaitPKG)
|
|
instructions: umonitor/umwait, introduced by Alder Lake microarchitecture,
|
|
launched in 2021, to wait for a synchronization variable
|
|
instead of pause-based loop;
|
|
however these instuctions for FastMM synchronization are not as efficient
|
|
as pause-based loop, so only enable it if your tests show clear benefit
|
|
in your scenarios }
|
|
|
|
{.$define EnableWaitPKG}
|
|
{$endif}
|
|
|
|
{-----------------------Memory Manager Sharing Options------------------------}
|
|
|
|
{Allow sharing of the memory manager between a main application and DLLs that
|
|
were also compiled with FastMM. This allows you to pass dynamic arrays and
|
|
long strings to DLL functions provided both are compiled to use FastMM.
|
|
Sharing will only work if the library that is supposed to share the memory
|
|
manager was compiled with the "AttemptToUseSharedMM" option set. Note that if
|
|
the main application is single threaded and the DLL is multi-threaded that you
|
|
have to set the IsMultiThread variable in the main application to true or it
|
|
will crash when a thread contention occurs. Note that statically linked DLL
|
|
files are initialized before the main application, so the main application may
|
|
well end up sharing a statically loaded DLL's memory manager and not the other
|
|
way around. }
|
|
|
|
{.$define ShareMM}
|
|
|
|
|
|
{Allow sharing of the memory manager by a DLL with other DLLs (or the main
|
|
application if this is a statically loaded DLL) that were also compiled with
|
|
FastMM. Set this option with care in dynamically loaded DLLs, because if the
|
|
DLL that is sharing its MM is unloaded and any other DLL is still sharing
|
|
the MM then the application will crash. This setting is only relevant for
|
|
DLL libraries and requires ShareMM to also be set to have any effect.
|
|
Sharing will only work if the library that is supposed to share the memory
|
|
manager was compiled with the "AttemptToUseSharedMM" option set. Note that
|
|
if DLLs are statically linked then they will be initialized before the main
|
|
application and then the DLL will in fact share its MM with the main
|
|
application. This option has no effect unless ShareMM is also set.}
|
|
|
|
{.$define ShareMMIfLibrary}
|
|
|
|
|
|
{Define this to attempt to share the MM of the main application or other loaded
|
|
DLLs in the same process that were compiled with ShareMM set. When sharing a
|
|
memory manager, memory leaks caused by the sharer will not be freed
|
|
automatically. Take into account that statically linked DLLs are initialized
|
|
before the main application, so set the sharing options accordingly.}
|
|
|
|
{.$define AttemptToUseSharedMM}
|
|
|
|
|
|
{Define this to enable backward compatibility for the memory manager sharing
|
|
mechanism used by Delphi 2006 and 2007, as well as older FastMM versions.}
|
|
|
|
{$define EnableBackwardCompatibleMMSharing}
|
|
|
|
|
|
|
|
{-----------------------Security Options------------------------}
|
|
|
|
{Windows clears physical memory before reusing it in another process. However,
|
|
it is not known how quickly this clearing is performed, so it is conceivable
|
|
that confidential data may linger in physical memory longer than absolutely
|
|
necessary. If you're paranoid about this kind of thing, enable this option to
|
|
clear all freed memory before returning it to the operating system. Note that
|
|
this incurs a noticeable performance hit.}
|
|
|
|
{.$define ClearMemoryBeforeReturningToOS}
|
|
|
|
|
|
{With this option enabled freed memory will immediately be cleared inside the
|
|
FreeMem routine. This incurs a big performance hit, but may be worthwhile for
|
|
additional peace of mind when working with highly sensitive data. This option
|
|
supersedes the ClearMemoryBeforeReturningToOS option.}
|
|
|
|
{.$define AlwaysClearFreedMemory}
|
|
|
|
|
|
|
|
{----------------------------Lock Contention Logging--------------------------}
|
|
|
|
{Define this to lock stack traces for all occasions where GetMem/FreeMem
|
|
go to sleep because of lock contention (IOW, when memory manager is already
|
|
locked by another thread). At the end of the program execution top 10 sites
|
|
(locations with highest occurrence) will be logged to the _MemoryManager_EventLog.txt
|
|
file.
|
|
This options works with FullDebugMode or without it, but requires
|
|
FastMM_FullDebugMode.dll to be present in both cases.}
|
|
|
|
{.$define LogLockContention}
|
|
|
|
{If a block cannot be released immediately during a FreeMem call the block will
|
|
added to a list of blocks that will be freed later, either in the background cleanup
|
|
thread or during the next call to FreeMem.}
|
|
|
|
{.$define UseReleaseStack}
|
|
|
|
{--------------------------------Option Grouping------------------------------}
|
|
|
|
{Enabling this option enables FullDebugMode, InstallOnlyIfRunningInIDE and
|
|
LoadDebugDLLDynamically. Consequently, FastMM will install itself in
|
|
FullDebugMode if the application is being debugged inside the Delphi IDE.
|
|
Otherwise the default Delphi memory manager will be used (which is equivalent
|
|
to the non-FullDebugMode FastMM since Delphi 2006.)}
|
|
|
|
{.$define FullDebugModeInIDE}
|
|
|
|
|
|
{Combines the FullDebugMode, LoadDebugDLLDynamically and
|
|
DoNotInstallIfDLLMissing options. Consequently FastMM will only be installed
|
|
(In FullDebugMode) when the FastMM_FullDebugMode.dll file is available. This
|
|
is useful when the same executable will be distributed for both debugging as
|
|
well as deployment.}
|
|
|
|
{.$define FullDebugModeWhenDLLAvailable}
|
|
|
|
|
|
{Group the options you use for release and debug versions below}
|
|
{$ifdef Release}
|
|
{Specify the options you use for release versions below}
|
|
{.$undef FullDebugMode}
|
|
{.$undef CheckHeapForCorruption}
|
|
{.$define ASMVersion}
|
|
{.$undef EnableMemoryLeakReporting}
|
|
{.$undef UseOutputDebugString}
|
|
{$else}
|
|
{Specify the options you use for debugging below}
|
|
{.$define FullDebugMode}
|
|
{.$define EnableMemoryLeakReporting}
|
|
{.$define UseOutputDebugString}
|
|
{$endif}
|
|
|
|
{--------------------Compilation Options For borlndmm.dll---------------------}
|
|
{If you're compiling the replacement borlndmm.dll, set the defines below
|
|
for the kind of dll you require.}
|
|
|
|
{Set this option when compiling the borlndmm.dll}
|
|
{.$define borlndmmdll}
|
|
|
|
{Set this option if the dll will be used by the Delphi IDE}
|
|
{.$define dllforide}
|
|
|
|
{Set this option if you're compiling a debug dll}
|
|
{.$define debugdll}
|
|
|
|
{Do not change anything below this line}
|
|
{$ifdef borlndmmdll}
|
|
{$define AssumeMultiThreaded}
|
|
{$undef HideExpectedLeaksRegisteredByPointer}
|
|
{$undef RequireDebuggerPresenceForLeakReporting}
|
|
{$undef RequireDebugInfoForLeakReporting}
|
|
{$define DetectMMOperationsAfterUninstall}
|
|
{$undef ManualLeakReportingControl}
|
|
{$undef ShareMM}
|
|
{$undef AttemptToUseSharedMM}
|
|
{$ifdef dllforide}
|
|
{$define NeverUninstall}
|
|
{$define HideMemoryLeakHintMessage}
|
|
{$undef RequireIDEPresenceForLeakReporting}
|
|
{$ifndef debugdll}
|
|
{$undef EnableMemoryLeakReporting}
|
|
{$endif}
|
|
{$else}
|
|
{$define EnableMemoryLeakReporting}
|
|
{$undef NeverUninstall}
|
|
{$undef HideMemoryLeakHintMessage}
|
|
{$define RequireIDEPresenceForLeakReporting}
|
|
{$endif}
|
|
{$ifdef debugdll}
|
|
{$define FullDebugMode}
|
|
{$define RawStackTraces}
|
|
{$undef CatchUseOfFreedInterfaces}
|
|
{$define LogErrorsToFile}
|
|
{$define LogMemoryLeakDetailToFile}
|
|
{$undef ClearLogFileOnStartup}
|
|
{$else}
|
|
{$undef FullDebugMode}
|
|
{$endif}
|
|
{$endif}
|
|
|
|
{Move BCB related definitions here, because CB2006/CB2007 can build borlndmm.dll
|
|
for tracing memory leaks in BCB applications with "Build with Dynamic RTL"
|
|
switched on}
|
|
{------------------------------Patch BCB Terminate----------------------------}
|
|
{To enable the patching for BCB to make uninstallation and leak reporting
|
|
possible, you may need to add "BCB" definition
|
|
in "Project Options->Pascal/Delphi Compiler->Defines".
|
|
(Thanks to JiYuan Xie for implementing this.)}
|
|
|
|
{$ifdef BCB}
|
|
{$ifdef CheckHeapForCorruption}
|
|
{$define PatchBCBTerminate}
|
|
{$else}
|
|
{$ifdef DetectMMOperationsAfterUninstall}
|
|
{$define PatchBCBTerminate}
|
|
{$else}
|
|
{$ifdef EnableMemoryLeakReporting}
|
|
{$define PatchBCBTerminate}
|
|
{$endif}
|
|
{$endif}
|
|
{$endif}
|
|
|
|
{$ifdef PatchBCBTerminate}
|
|
{$define CheckCppObjectType}
|
|
{$undef CheckCppObjectTypeEnabled}
|
|
|
|
{$ifdef CheckCppObjectType}
|
|
{$define CheckCppObjectTypeEnabled}
|
|
{$endif}
|
|
|
|
{Turn off "CheckCppObjectTypeEnabled" option if neither "CheckHeapForCorruption"
|
|
option or "EnableMemoryLeakReporting" option were defined.}
|
|
{$ifdef CheckHeapForCorruption}
|
|
{$else}
|
|
{$ifdef EnableMemoryLeakReporting}
|
|
{$else}
|
|
{$undef CheckCppObjectTypeEnabled}
|
|
{$endif}
|
|
{$endif}
|
|
{$endif}
|
|
{$endif}
|