Poids mouche en Go

Le poids mouche est un patron de conception structurel qui permet à des programmes de limiter leur consommation de mémoire malgré un très grand nombre d’objets.

Ce patron est obtenu en partageant des parties de l’état d’un objet à plusieurs autres objets. En d’autres termes, le poids mouche économise de la RAM en mettant en cache les données identiques chez différents objets.

En savoir plus sur la patron Poids mouche

Exemple conceptuel

Dans une partie de Counter-Strike, les terroristes et les contre-terroristes sont habillés différemment. Pour faire plus simple, disons que chaque camp n’a qu’un seul type de tenue. L’objet Tenue est imbriqué dans l’objet joueur comme ci-dessous.

Voici la struct pour un joueur. Nous pouvons observer que la tenue est imbriquée dans la struct joueur :

type player struct {
    dress      dress
    playerType string // Peut être un T ou CT
    lat        int
    long       int
}

Prenons 5 terroristes et 5 contre-terroristes, donc 10 joueurs au total. Nous avons maintenant 2 possibilités pour les tenues.

Chacun des 10 objets joueur crée un objet tenue différent et l’imbrique. Au total, 10 objets tenue seront créés.
Nous créons deux objets tenue :
- Un unique objet tenue pour terroriste. Il sera partagé entre les 5 terroristes.
- Un unique objet tenue pour contre-terroriste. Il sera partagé entre les 5 contre-terroristes.

Comme vous pouvez le constater, dans la première approche, un total de 10 objets tenue sont créés, alors que dans la seconde, on se contente de deux. La seconde approche est celle suggérée par le patron de conception poids mouche. Les deux objets tenue que nous avons créés s’appellent les objets poids mouche.

Le patron de conception poids mouche retire les morceaux communs et crée des objets poids mouche. Ces objets (tenues) peuvent ensuite être partagés entre de multiples objets (joueurs). Nous réduisons ainsi drastiquement le nombre d’objets tenue et de plus, même si vous ajoutez plus de joueurs, les deux objets tenue restent suffisants.

Dans le patron poids mouche, nous stockons les objets poids mouche dans l’attribut de la table de hachage. Dès que d’autres objets qui partagent ces objets poids mouche sont créés, ces derniers sont récupérés depuis la table de hachage.

Regardons quelles parties de ce dispositif seront les états intrinsèques et extrinsèques :

État intrinsèque : La tenue fait partie de l’état intrinsèque, car elle peut être partagée entre plusieurs terroristes ou contre-terroristes.
État extrinsèque : La position de chaque joueur et son arme font partie de l’état extrinsèque, car elles sont différentes pour chaque objet.

dressFactory.go: Fabrique poids mouche

package main

import "fmt"

const (
	//TerroristDressType terrorist dress type
	TerroristDressType = "tDress"
	//CounterTerrroristDressType terrorist dress type
	CounterTerrroristDressType = "ctDress"
)

var (
	dressFactorySingleInstance = &DressFactory{
		dressMap: make(map[string]Dress),
	}
)

type DressFactory struct {
	dressMap map[string]Dress
}

func (d *DressFactory) getDressByType(dressType string) (Dress, error) {
	if d.dressMap[dressType] != nil {
		return d.dressMap[dressType], nil
	}

	if dressType == TerroristDressType {
		d.dressMap[dressType] = newTerroristDress()
		return d.dressMap[dressType], nil
	}
	if dressType == CounterTerrroristDressType {
		d.dressMap[dressType] = newCounterTerroristDress()
		return d.dressMap[dressType], nil
	}

	return nil, fmt.Errorf("Wrong dress type passed")
}

func getDressFactorySingleInstance() *DressFactory {
	return dressFactorySingleInstance
}

dress.go: Interface poids mouche

package main

type Dress interface {
	getColor() string
}

terroristDress.go: Objet poids mouche concret

package main

type TerroristDress struct {
	color string
}

func (t *TerroristDress) getColor() string {
	return t.color
}

func newTerroristDress() *TerroristDress {
	return &TerroristDress{color: "red"}
}

counterTerroristDress.go: Objet poids mouche concret

package main

type CounterTerroristDress struct {
	color string
}

func (c *CounterTerroristDress) getColor() string {
	return c.color
}

func newCounterTerroristDress() *CounterTerroristDress {
	return &CounterTerroristDress{color: "green"}
}

player.go: Contexte

package main

type Player struct {
	dress      Dress
	playerType string
	lat        int
	long       int
}

func newPlayer(playerType, dressType string) *Player {
	dress, _ := getDressFactorySingleInstance().getDressByType(dressType)
	return &Player{
		playerType: playerType,
		dress:      dress,
	}
}

func (p *Player) newLocation(lat, long int) {
	p.lat = lat
	p.long = long
}

game.go: Code client

package main

type game struct {
	terrorists        []*Player
	counterTerrorists []*Player
}

func newGame() *game {
	return &game{
		terrorists:        make([]*Player, 1),
		counterTerrorists: make([]*Player, 1),
	}
}

func (c *game) addTerrorist(dressType string) {
	player := newPlayer("T", dressType)
	c.terrorists = append(c.terrorists, player)
	return
}

func (c *game) addCounterTerrorist(dressType string) {
	player := newPlayer("CT", dressType)
	c.counterTerrorists = append(c.counterTerrorists, player)
	return
}

main.go: Code client

package main

import "fmt"

func main() {
	game := newGame()

	//Add Terrorist
	game.addTerrorist(TerroristDressType)
	game.addTerrorist(TerroristDressType)
	game.addTerrorist(TerroristDressType)
	game.addTerrorist(TerroristDressType)

	//Add CounterTerrorist
	game.addCounterTerrorist(CounterTerrroristDressType)
	game.addCounterTerrorist(CounterTerrroristDressType)
	game.addCounterTerrorist(CounterTerrroristDressType)

	dressFactoryInstance := getDressFactorySingleInstance()

	for dressType, dress := range dressFactoryInstance.dressMap {
		fmt.Printf("DressColorType: %s\nDressColor: %s\n", dressType, dress.getColor())
	}
}

output.txt: Résultat de l’exécution

DressColorType: ctDress
DressColor: green
DressColorType: tDress
DressColor: red

Basé sur: Golang By Example