Pour récupérer le repo :
git clone https://github.com/Gui-Yom/elp-go
Pour mettre à jour le repo local :
git pull
Pour commit :
git add *
git commit -m "<message>"
git push origin
> build.bat
ou
> go build -o target/elp-go.exe elp-go
Pour build le projet il est nécessaire d'installer certains paquets : https://gioui.org/doc/install/linux
$ ./build.sh
ou
$ go build -o target/elp-go elp-go
$ elp-go -h
Usage : elp-go [-args] [scenario file]
-addr value
Host to connect to.
-noconnect
Do not connect to remote server.
-nogui
Disable GUI.
-p int
Specify the port to connect or listen to. (default 32145)
-server
Start a server.
Example usage :
Start a server :
$ elp-go -server
Start a client with a scenario file :
$ elp-go scenarios/scen0.scen
Start a client with a random scenario :
$ elp-go scenarios/rng.scen
{
"map": "map0.map",
"diagonal": false,
"tasks": [
{
"x": 9,
"y": 9
}
],
"agents": [
{
"x": 0,
"y": 0
}
]
}
Il est aussi possible de générer des scénarios de manière aléatoire :
{
"map": "rand 100 100 0.2 42",
"diagonal": true,
"tasks": 128,
"agents": 4
}
10x10
x|
xxxxx x |
x |
x xxxxx |
|
|
|
|
|
|
>>>>>>> d183486ce58dc24afdcd7313eb0b8e2a110be321
CLI go test
: https://pkg.go.dev/cmd/go#hdr-Testing_flags
$ go test -c -o target/test.<name> <package>
$ target/test.<name> -test.v
$ go test -c -o target/bench.pathfinding.exe elp-go/internal/pathfinding
$ target/bench.pathfinding -test.v -test.paniconexit0 -test.bench . -test.run ^$ -test.benchtime 5s -test.benchmem
Comparer les performances depuis un certain commit :
$ benchdiff --base-ref=d1190c07f745946dd36d8894e64562874ebf32f9 --bench=AstarLinked1000$ --benchmem --benchtime=1000x --packages=elp-go/internal/pathfinding
Il est nécessaire de limiter les benchmarks pour chaque séquence de profilage. CPU :
$ target/bench.pathfinding -test.v -test.paniconexit0 -test.bench <spec> -test.run ^$ -test.benchtime 10s -test.outputdir target -test.cpuprofile pathfinding.<spec>.cpu.prof
Mémoire :
$ target/bench.pathfinding -test.v -test.paniconexit0 -test.bench <spec> -test.run ^$ -test.benchtime 10s -test.benchmem -test.outputdir target -test.memprofile pathfinding.<spec>.mem.prof
Lecture des données de profilage avec pprof. Interface web interactive avec pprof -http : cpu.prof
Pour Dijkstra :
- Priority queue (push O(n) pour la linked list et push/pop pour le pairing heap)
- Map des coûts (get/put)
- GetNeighbors (appel pour chaque tile, allocations en masse)
Pour A* (petite carte 300) :
- Map des coûts
- Priority queue
- GetNeighbors
Pour A* (grande carte 10000) :
- Map des coûts
- Map des tiles
- Priority queue & GetNeighbors (impact similaire)
On note aussi un coût non négligeable dû au boxing (interface{}) des ifaces.
- Amiliorer l'interface graphique, qu'on puisse parametrer les scénarios que l'on veut
- Plus de tâches différentes. Pour l'instant il y a que MoveTask
- Temps simulé: on prenne compte des chemins pour faire de l'attribution de tâches
Baseline : d1190c07f745946dd36d8894e64562874ebf32f9 / Current : beb57836816e4b3c4c1f3f5db5ca1a40d8494636, diff
CPU:
name | old (µs/op) | new (µs/op) | delta |
---|---|---|---|
DijkstraLinked100 | 7.94k ± 4% | 5.39k ± 4% | -32.12% |
DijkstraLinked1000 | 2.04M ± 0% | 1.46M ± 1% | -28.51% |
AstarLinked100 | 202 ± 5% | 82 ±148% | -59.30% |
AstarLinked1000 | 2.64k ± 9% | 0.60k ± 1% | -77.33% |
AstarLinked10000 | 22.5k ± 2% | 6.7k ± 4% | -70.08% |
MEM:
name | old (alloc/op) | new (alloc/op) | delta |
---|---|---|---|
DijkstraLinked100 | 3.72MB ± 0% | 1.19MB ± 0% | -68.01% |
DijkstraLinked1000 | 329MB ± 0% | 110MB ± 0% | -66.46% |
AstarLinked100 | 122kB ± 1% | 36kB ± 0% | -70.43% |
AstarLinked1000 | 1.63MB ± 0% | 0.46MB ± 0% | -71.57% |
AstarLinked10000 | 14.2MB ± 0% | 4.1MB ± 0% | -70.85% |
- Nouvelle impl HashMap Position -> Position et Position -> Coût (int64 -> int64)
- Nouvelle impl linked list pour la priority queue
- Utilisation d'un switch plutôt qu'une map pour le coût des tiles
- Prédimensionnement de certaines structures dans les algos
- Spécialisation des structures
main.go
: Point d'entrée partagé, parsing des argumentsinternal/
agent.go
: Agents et résolution des tâchesclient.go
: Code relatif au client, guinet.go
: Outils réseau et serializationscenario.go
: Scenario et tâchesserver.go
: Code relatif au serveurfastmap/
:fastmap.go
: HashMap rapide
pathfinding/
astar.go
: A*dijkstra.go
: Dijkstraheuristics.go
: fonctions heuristiques pour A*pathfinding.go
: Interfaces et utilités
queue/
queue.go
: Interface priority queueheap.go
: Queue basée sur un heaplinked.go
: Queue basée sur une linked listpairing.go
: Queue basée sur un pairing heap
world/
world.go
: Cartes et tiles
Fichiers *_test.go
: Code de test et benchmarks
- gioui : GUI cross-plateforme
- giocanvas : API Canvas pour gioui
- cbor : Serialization CBOR pour les échanges réseaux
- testify : assertions pour les tests
Client :
- Connexion au serveur
- Envoi du scénario (carte + agents + tâches + paramètres)
- Ouverture d'une fenêtre avec la carte
- Récupération des résultats
- Fermeture de la connexion
Serveur (pour chaque client) :
- Récupération du scénario
- Résolution du scénario
- Envoi des résultats (opérations + statistiques)
- Retour à l'étape 1
https://www.redblobgames.com/ de Amit Patel, http://www-cs-students.stanford.edu/~amitp/
https://doi.org/10.1137/1.9781611973198.7
Fastmap modifiée de : https://github.com/brentp/intintmap, impl originale (java) : https://github.com/mikvor/hashmapTest
- présentation générale + démo du programme -> Chaymae
- serveur, client, goroutines, test goroutines -> Guillaume
- recherche de chemins : djikstra et astar, heuristiques, test pathfinding -> Julie, Guillaume
- pistes d'amélioration -> à voir