remplacement de Windows tcmalloc avec le projet statique reliant

Question

A C++ rencontre le problème de la fragmentation de la mémoire, et avons essayé suivante:

1. nedmalloc- n'a pas passé le test de stress (écrasements après 15 heures), ce qui signifie qu'il fonctionne le plus de cas mais pas le tout. Et plus d'utilisation de la mémoire que d'autres allocateurs.

2. jemalloc- Pas encore prêt pour Windows?

3. tcmalloc- Compilé avec le code hôte avec liaison statique, mais en conflit avec les symboles CRT. Puis-je simplement utiliser l'alias comme tc_malloc (...) pour créer mon propre wrapper pour l'allocation? Comment faire ça?

Un commentaire? Merci d'avance.

Answer 1

il y a quelques autres allocataires disponibles aussi, comme doug lea's malloc (dlmalloc) ou the horde allocator

---

nedmalloc- N'a pas passé le test de stress (après 15 heures écrasements), qui signifie qu'il fonctionne dans le plus de cas mais pas le tout.

voir si vous pouvez découvrir d'où et pourquoi il est écrasé avant de abbandoning, il peut juste être une erreur de votre part, vérifier le repo SVN défini également, il pourrait déjà être une solution à votre problème.

tcmalloc- Compilé avec le code hôte avec liaison statique, mais le conflit avec les symboles CRT . Puis-je simplement utiliser l'alias comme tc_malloc (...) pour créer mon propre wrapper pour l'allocation? Comment faire cela?

Je dirais que son mieux pour garder les symboles CRT intacts (juste au cas où), alors allez-y et modifier au projet afin que les symboles de confilicating suivent plutôt une convention que vous désirez (vous avez la source pour une raison après tout)

Answer 2

Configurez votre projet pour utiliser le tas Windows Low Fragmentation (LFH) en utilisant this API au début du programme. Cela peut résoudre votre problème sans plus de travail sur les implémentations personnalisées.

Exemple de code, pris directement à partir de MSDN:

#include <windows.h> 
#include <tchar.h> 
#include <stdio.h> 

#define HEAP_LFH 2 

int __cdecl _tmain() 
{ 
    BOOL bResult; 
    HANDLE hHeap; 
    ULONG HeapInformation; 

    // 
    // Note: The HeapSetInformation function is available on Windows 2000 with SP4 
    // only if hotfix KB 816542 is installed. To run this example on Windows 2000, 
    // use GetProcAddress to get a pointer to the function if available. 
    // 

    // 
    // Enable heap terminate-on-corruption. 
    // A correct application can continue to run even if this call fails, 
    // so it is safe to ignore the return value and call the function as follows: 
    // (void)HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0); 
    // If the application requires heap terminate-on-corruption to be enabled, 
    // check the return value and exit on failure as shown in this example. 
    // 
    bResult = HeapSetInformation(NULL, 
           HeapEnableTerminationOnCorruption, 
           NULL, 
           0); 

    if (bResult != FALSE) { 
     _tprintf(TEXT("Heap terminate-on-corruption has been enabled.\n")); 
    } 
    else { 
     _tprintf(TEXT("Failed to enable heap terminate-on-corruption with LastError %d.\n"), 
       GetLastError()); 
     return 1; 
    } 

    // 
    // Create a new heap with default parameters. 
    // 
    hHeap = HeapCreate(0, 0, 0); 
    if (hHeap == NULL) { 
     _tprintf(TEXT("Failed to create a new heap with LastError %d.\n"), 
       GetLastError()); 
     return 1; 
    } 

    // 
    // Enable the low-fragmenation heap (LFH). Starting with Windows Vista, 
    // the LFH is enabled by default but this call does not cause an error. 
    // 
    HeapInformation = HEAP_LFH; 
    bResult = HeapSetInformation(hHeap, 
           HeapCompatibilityInformation, 
           &HeapInformation, 
           sizeof(HeapInformation)); 
    if (bResult != FALSE) { 
     _tprintf(TEXT("The low-fragmentation heap has been enabled.\n")); 
    } 
    else { 
     _tprintf(TEXT("Failed to enable the low-fragmentation heap with LastError %d.\n"), 
       GetLastError()); 
     return 1; 
    } 

    return 0; 
} 

Answer 3

TBB Intel fournit un allocateur qui peut fonctionner. http://threadingbuildingblocks.org/download.php

Answer 4

Il y a le projet de jemalloc pour Visual Studio 2008, 2010 et 2013. https://github.com/shines77/jemalloc-win32

Je suppose que cela implique jemalloc peut être utilisé dans les fenêtres.

Mais je ne l'ai pas encore essayé. Vérifiez par vous-même.