Vous concevez un nouveau langage de programmation ésotérique et l'une des fonctionnalités que vous avez décidé d'ajouter est un allocateur de mémoire dynamique. Votre langue spécifie un espace d'adressage virtuel dédié spécial pour l'espace programme de l'utilisateur. Ceci est distinct de l'espace d'adressage utilisé par l'allocateur de mémoire pour tout état interne.
Pour réduire le coût de distribution de votre implémentation, la taille du code doit être aussi petite que possible.
Interface
Vous devez fournir trois fonctions: initialisation, allocation et désallocation.
Initialisation
Cette fonction prend un seul paramètre entier positif N. Cela signifie que le programme d'un utilisateur a des Noctets dans son espace d'adressage à partir desquels il y a des N-1octets pour allouer de la mémoire. L'adresse 0est réservée à "null".
Il est garanti que cette fonction sera appelée exactement une fois avant tout appel d'allocation / désallocation.
Notez que cette fonction n'a pas besoin d'allouer de mémoire physique pour l'espace d'adressage virtuel du programme utilisateur; vous créez essentiellement le "look and feel" d'un allocateur de mémoire creux.
Allouer
La fonction d'allocation doit accepter une demande du nombre d'octets de mémoire à allouer. L'entrée est garantie positive.
Votre fonction doit renvoyer une adresse entière au début du bloc alloué, ou 0pour indiquer qu'il n'y a pas de bloc contigu de la taille demandée disponible. Si un bloc contigu de la taille disponible est disponible n'importe où dans l'espace d'adressage, vous devez allouer!
Vous devez vous assurer qu'aucun deux blocs alloués ne se chevauchent.
Désallouer
La fonction de désallocation doit prendre une adresse du début d'un bloc alloué et peut également prendre la taille du bloc donné.
La mémoire qui a été désallouée est à nouveau disponible pour l'allocation. Il est supposé que l'adresse d'entrée est une adresse valide.
Exemple d'implémentation Python
Notez que vous pouvez choisir n'importe quelle méthode pour garder une trace de l'état interne; dans cet exemple, l'instance de classe en garde la trace.
class myallocator:
def __init__(self, N):
# address 0 is special, it's always reserved for null
# address N is technically outside the address space, so use that as a
# marker
self.addrs = [0, N]
self.sizes = [1, 0]
def allocate(self, size):
for i,a1,s1,a2 in zip(range(len(self.addrs)),
self.addrs[:-1], self.sizes[:-1],
self.addrs[1:]):
if(a2 - (a1+s1) >= size):
# enough available space, take it
self.addrs.insert(i+1, a1+s1)
self.sizes.insert(i+1, size)
return a1+s1
# no contiguous spaces large enough to take our block
return 0
def deallocate(self, addr, size=0):
# your implementation has the option of taking in a size parameter
# in this implementation it's not used
i = self.addrs.index(addr)
del self.addrs[i]
del self.sizes[i]
Notation
C'est le golf de code; le code le plus court en octets gagne. Vous n'avez pas à vous soucier de manquer de mémoire pour tout état interne requis par votre allocateur.
Des trous de boucle standard s'appliquent.
Classement
To help reduce the cost of distributing your implementation the size of the code must be as small as possibleou pourrait-il être efficace (petit et efficace ne sont pas les mêmes) que possible? : D