Le langage go n'a pas standardisé l'optimisation en taille des structures. Néanmoins il existe un moyen de programmer en go les adressages sur 5 octects, au lieu de 8. Cela est suffisant pour adresser une mémoire d'un teraoctet.
Pour l'exemple on utilise un type de structure quelconque Cell. On définit la fonction µ qui convertit un pointeur de Cell en une adresse sur 5 octet, et on définit la fonction ß qui convertit une adresse sur 5 octets en un pointeur de Cell.
On utilise le type Adresse de taille variable, et deux variables globales _b_ qui est constitué de 8 octets et _c_ qui est constitué de 5 octets.
package main
import (
"encoding/binary"
"fmt"
"unsafe"
)type Cell struct{ .../... }
type Adresse []byte
var _b_ = make([]byte, 8)
var _c_ = make([]byte, 5)func µ(r Adresse) *Cell {
_b_[0] = r[0]
_b_[1] = r[1]
_b_[2] = r[2]
_b_[3] = r[3]
_b_[4] = r[4]
_b_[5] = 0
_b_[6] = 0
_b_[7] = 0
return (*Cell)(unsafe.Pointer(uintptr(binary.LittleEndian.Uint64(_b_))))
}func ß(p *Cell) Adresse {
binary.LittleEndian.PutUint64(_b_, uint64(uintptr(unsafe.Pointer(p))))
_c_[0] = _b_[0]
_c_[1] = _b_[1]
_c_[2] = _b_[2]
_c_[3] = _b_[3]
_c_[4] = _b_[4]
return _c_
}
Il est peut-être possible et plus judicieux d'écrire cette partie en C et de l'intégrer dans le programme go
Si les cellules sont toutes de même taille, alors il est plus simple de définir un tableau de `2^32` cellules qui peuvent contenir une dizaines d'adresses sur 32 bits chacune, soit 40 octets par cellules, ce qui représente un tableau d'une taille d'environ 200 Go, ce qui atteint déjà les limites d'un ordinateur individuel. Malheureusement go ne mannipule que des objets de taille inférieur à 2 Go.