Comment mettre en œuvre malloc déterministe

Lors de l'écriture de code de fiabilité élevée, la pratique habituelle consiste à éviter que MALLOC et une autre allocation de mémoire dynamique. Un compromis parfois utilisé est de faire toute cette allocation que pendant l'initialisation du système.

Je me demande ce que vous essayez d'atteindre. Si votre processus est déterministe, le modèle d'allocation / distribution doit être identique.

La seule différence possible pourrait être l'adresse renvoyée par malloc code>. Mais vous ne devriez probablement pas en dépendre d'eux (le moyen le plus simple n'utilise pas les pointeurs comme une carte clé ou une autre structure de données). Et même alors, il ne devrait y avoir de différence que si l'allocation n'est pas effectuée via sbrk code> (l'utilisation de glibc utilise anonyme mmap code> pour les grandes allocations), ou si vous utilisez MMAP code> (Comme par défaut, l'adresse est sélectionnée par le noyau). p>

Si vous souhaitez vraiment avoir exactement la même adresse, une option est d'avoir un grand tampon statique et d'écrire une vue personnalisée. Allocator qui utilise la mémoire de ce tampon. Cela a l'inconvénient de vous obliger à connaître à l'avance la quantité maximale de mémoire dont vous aurez besoin. Dans un exécutable non-tartre ( GCC -FNO-PIE -NO-PIE CODE>), un tampon statique aura la même adresse à chaque fois. Pour une exécutable à tarte, vous pouvez désactiver le noyau Adresse Space Disposition Randomisation pour le chargement de programmes. Dans une bibliothèque partagée, désactivant l'ASLR et l'exécution du même programme deux deux fois, il convient de conduire aux mêmes choix par la liaison dynamique pour où cartographier les bibliothèques. P>

Si vous ne savez pas avant la taille maximale de la mémoire de la mémoire. Vous souhaitez utiliser ou si vous ne voulez pas recompiler chaque fois cette taille de taille, vous pouvez également utiliser mmap code> pour mapper un grand tampon anonyme à une adresse fixe. Il vous suffit de passer la taille du tampon et de l'adresse à utiliser comme paramètre à votre processus et utilisez la mémoire renvoyée pour implémenter votre propre malloc code> sur le dessus de celui-ci. P>

static void* malloc_buffer = NULL;
static size_t malloc_buffer_len = 0;

void* malloc(size_t size) {
    // Use malloc_buffer & malloc_buffer_len to implement your
    // own allocator. If you don't read uninitialized memory,
    // it can be deterministic.
    return memory;
}

int main(int argc, char** argv) {
    size_t buf_size = 0;
    uintptr_t buf_addr = 0;
    for (int i = 0; i < argv; ++i) {
        if (strcmp(argv[i], "--malloc-size") == 0) {
            buf_size = atoi(argv[++i]);
        }
        if (strcmp(argv[i], "--malloc-addr") == 0) {
            buf_addr = atoi(argv[++i]);
        }
    }

    malloc_buffer = mmap((void*)buf_addr, buf_size, PROT_WRITE|PROT_READ,
                         MAP_FIXED|MAP_PRIVATE, 0, 0);
    // editor's note: omit MAP_FIXED since you're checking the result anyway
    if (malloc_buffer == MAP_FAILED || malloc_buffer != (void*)but_addr) {
        // Could not get requested memory block, fail.
        exit(1);
    }

    malloc_size = buf_size;
}