https://github.com/martinus/qmars
QMars stands for Quicker Mars. It is a completely new implementation of a mars simulator
https://github.com/martinus/qmars
corewars
Last synced: 3 months ago
JSON representation
QMars stands for Quicker Mars. It is a completely new implementation of a mars simulator
- Host: GitHub
- URL: https://github.com/martinus/qmars
- Owner: martinus
- License: other
- Created: 2019-11-12T10:33:03.000Z (almost 6 years ago)
- Default Branch: master
- Last Pushed: 2019-11-12T10:55:24.000Z (almost 6 years ago)
- Last Synced: 2025-03-02T19:49:38.521Z (8 months ago)
- Topics: corewars
- Language: C++
- Homepage: https://martin.ankerl.com/2006/07/29/corwars-simulators-overview/
- Size: 22.5 KB
- Stars: 1
- Watchers: 3
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# qmars
QMars stands for Quicker Mars. It is a completely new implementation of a mars simulator, which is an interpreter of the Assembler-like language RedCode, which is used in CoreWars. QMars is heavily optimized to be as fast as possible. Here are the main advantages/disadvantages of QMars:
| pros | cons |
|---|---|
| completely written in C++ | slow compilation: with full optimization over 1 minute (on a AMD Duron 650). |
| simple interface | huge amount of RAM needed during compilation (with full optimization: 110MB) |
| fastest simulator on planet | does not support LDP, STP (but should not be difficult to add) |
| small executeable, low RAM-usage | less tested than other simulators |
| extensible: using Template Metaprogramming techniques, the behaviour (output, debugging) of the simulator can easily be modified | |
IMHO QMars is a nice addition to other existing mars simulators. pmars has a lot of features and a nice user interface, exhaust is a lightweight simulator written in C.
The source is under a BSDish licence. This is not as restrictive as GPL (you can even sell this program, if you want...).
## Benchmarks
Both projects are compiled using g++ 2.95.3 and this command-line option -O9 -fomit-frame-pointer -fforce-mem -fforce-addr -finline-functions -funroll-loops -mcpu=i686 -march=i686.
```
pmars 0.9.2 QMars
Fixed vs Fixed 24.93 16.65 66.8%
Jaguar vs Fixed 29.16 18.92 64.9%
Jaguar vs Jaguar 43.21 27.47 63.6%
Stalker vs Fixed 24.84 17.56 70.7%
Stalker vs Jaguar 26.06 18.52 71.1%
Stalker vs Stalker 21.12 15.40 72.9%
nPaperII vs Fixed 35.46 23.18 65.4%
nPaperII vs Jaguar 44.55 30.14 67.7%
nPaperII vs Stalker 30.33 20.48 67.5%
nPaperII vs nPaperII 50.75 32.89 64.8%
-------------------------------------------------
Sum 330.28 221.21
100% 67.0%
```
As you can see, QMars takes only 67% of the time that pmars uses. pmars can do 10*2000/330.28 = 60.6 fights/seconds, QMars 90.4. This makes QMars (90.4-60.6)/60.6 = 49.2% faster than pmars :-)
## Usage
QMars is very easy to use, which makes it a good choice for Evolvers. What follows is a perfectly workable code:
```cpp
#include
#include
#include "warrior.hpp"
#include "qmars.hpp"
#include "parser.hpp"
using namespace std;
int main(int argc, char* argv[])
{
const ulong cWarriors = 2;
const ulong cCoreSize = 8000;
const ulong cCycles = 80000;
const ulong cProcesses = 8000;
const ulong cWarriorDist = 100;
Parser p;
// create mars for redcode-standard. It should not output anything.
Mars m;
// create array of pointers warriors. The simulator will use this array
vector warriors(2);
// create an Imp
Warrior* imp = new Warrior;
imp->code.push_back(Code(eMov, eI, eDir, 0, eDir, 1));
// parse a warrior (the parser needs the output of pmars)
warriors[0] = imp;
warriors[1] = p.parse("warriors/jaguar.rc", cCoreSize);
// simulate warriors with 1000 fights
m.simulate(warriors, 1000);
// print scores
cout << imp->win << " " << imp->tie << endl
<< warriors[1]->win << " " << warriors[1]->tie << endl;
}
```