Hoard Memory Manager

Question

How can I use Hoard Memory Manager in Delphi? I am looking for an alternative to FastMM, which is hopeless for serious multithreaded server applications. I looked at ScaleMM2 but it's not stable in 64 bit.

How can I statically link the Hoard Memory Manager. Since it comes with an OBJ file.

Answer 1

You cannot realistically hope to statically link Hoard because it is implemented in C++ and so needs a C++ runtime. You cannot expect to put a C++ runtime in your Delphi program.

So you need to build the Hoard memory manager in a DLL, for instance with Visual Studio. That DLL must export malloc, free and realloc. Do that with a .def file. Then you create a simple Delphi unit that links to the DLL and installs a memory manager based on these imported functions. Use my answer to the other question to guide you. As always, make the memory manager unit be the first unit in your .dpr file's uses list.

Do make sure you adhere to the license. You'll need to pay for a commercial license, or license your software under the GPL if I recall correctly.

FWIW, I use the malloc from the system C runtime in msvcrt.dll which scales better than FastMM.

Answer 2

As David mentioned, you need a .dll version. If you can't build it yourself, you can find pre-built versions. A quick search only turned up an older version, though.

André Mussche modified the FastCode MM Challenge to add Hoard in 2011. If you browse the source code, you will see examples of how it's used, including another precompiled copy of winhoard.dll. However, performance and memory usage weren't great in these tests.

Answer 3

Since everyone FAILED to provide a detailed solution. Here is a solution that actually works.

1: Open libhoard.cpp 2: Add the following lines to the code.

extern "C"{

__declspec(dllexport) void* scalable_malloc (size_t size)
{
    return malloc(size);
}

__declspec(dllexport) void* scalable_realloc (void* ptr, size_t size)
{
    return realloc(ptr, size);
}

__declspec(dllexport) void scalable_free (void* ptr)
{
    free(ptr);
}

}

3: Compile with nmake windows

4: Use it

unit hoard_mm;

interface

implementation

type
  size_t = Cardinal;

const
  hoardDLL = 'libhoard.dll';

function scalable_malloc(Size: size_t): Pointer; cdecl; external hoardDLL;
function scalable_realloc(P: Pointer; Size: size_t): Pointer; cdecl; external hoardDLL;
procedure scalable_free(P: Pointer); cdecl; external hoardDLL;

function GetMem(Size: NativeInt): Pointer; inline;
begin
  Result := scalable_malloc(size);
end;

function FreeMem(P: Pointer): Integer; inline;
begin
  scalable_free(P);
  Result := 0;
end;

function ReallocMem(P: Pointer; Size: NativeInt): Pointer; inline;
begin
  Result := scalable_realloc(P, Size);
end;

function AllocMem(Size: NativeInt): Pointer; inline;
begin
  Result := GetMem(Size);
  if Assigned(Result) then
  FillChar(Result^, Size, 0);
end;

function RegisterUnregisterExpectedMemoryLeak(P: Pointer): Boolean; inline;
begin
  Result := False;
end;

const
  MemoryManager: TMemoryManagerEx = (
    GetMem: GetMem;
    FreeMem: FreeMem;
    ReallocMem: ReallocMem;
    AllocMem: AllocMem;
    RegisterExpectedMemoryLeak: RegisterUnregisterExpectedMemoryLeak;
    UnregisterExpectedMemoryLeak: RegisterUnregisterExpectedMemoryLeak
  );

initialization
  SetMemoryManager(MemoryManager);

end.