example.conf

// This is an example configuration file for Yardstick.
// This example can be used as a template for new users, and documents each configuration option.
// Yardstick uses HOCON for its configuration. For more information about this configuration format, see:
// https://github.com/lightbend/config
yardstick {

    // These directories let Yardstick's experiment runner know where to find or place files.
    // There is typically no reason to change these.
    // Note: It's the user's responsibility to create these directories.
    directories {
        // Directory containing static benchmark input such as Minecraft executable JAR files and configuration files.
        input = "input"
        // Directory containing .conf files.
        // When .conf files are present, they are independently merged with this file, and each represents one
        // configuration of the benchmark. This allows running the benchmark with several parameter configurations.
        // When no .conf files are present, this file is named 'default' and is used as the only config.
        configs = "configs"
        // Directory for collecting raw output files (e.g., stdout from Minecraft JAR).
        raw-output = "raw-output"
        // Directory containing scripts to transform the raw output into processed output.
        raw-output-scripts = "raw-output-scripts"
        // Directory containing processed output files, ready for plotting.
        output = "output"
    }

    // Number of benchmark iterations to use for each benchmark configuration.
    iterations = 1

    // Specifies how to provision nodes for the Minecraft-like service and player emulation.
    provisioning {
        // The provisioning method. Options are:
        // das5
        //      Provisions nodes on the DAS5 super-computer. Relies on SSH being available via $PATH and a SSH config
        //      which allows connecting to DAS5 without manual (password) authentication.
        // static
        //      Assumes pre-provisioned available nodes reachable via SSH. Relies on SSH being available via $PATH.
        //      Allows running experiments on localhost by specifying 'localhost' as a node address.
        method = "das5"
        // The location of the experiment runner binary, relative to ${yardstick.directories.input}.
        // The experiment runner is copied to the remote node and started in *worker* mode.
        // The binary must have an architecture suitable for the remote node (typically linux).
        worker-binary = "ys-linux-amd64"
        // Used only when ${yardstick.provisioning.method} == "das5"
        das5 {
            // The username to use when SSH-ing to DAS5.
            user = "<username>"
            // The hostname to use when SSH-ing to DAS5.
            // The experiment runner cannot perform SSH authentication.
            // Running `ssh <user>@<host>` should successfully log into the DAS5 headnode without prompt for
            // authentication. Authentication must be performed using the SSH config, or the user's keychain.
            host = "<das5-hostname>"
        }
        // Used only when ${yardstick.provisioning.method} == "static"
        static {
            // The username used to SSH into the remote nodes.
            user = foo
            // The key used to authenticate when SSH-ing into the remote nodes.
            key = /path/to/key
            // The IP addresses of the remote nodes.
            // Specifying "localhost" lets users run experiments on their local machine.
            ips = ["node", "hostnames", "e.g.,", "localhost"]
        }
    }

    // Configuration for the Minecraft-like service
    game {
        // Archiceture of the Minecraft-like service. Options are:
        // jar
        //      A single-machine Minecraft-like game packaged as a JAR archive.
        // servo
        //      A serverless Minecraft-like game prototype, developed by the Opencraft team.
        architecture = "jar"
        // Only used when ${yardstick.game.architecture} == "jar"
        jar {
            path {
                // Location of the Minecraft-service's executable JAR, relative to ${yardstick.directories.input}.
                local = "server.jar"
                // Specify 'remote = "foo.jar"' if the the JAR should be called 'foo.jar' on the remote node.
            }
            // JVM options used when running the Minecraft-like service.
            jvm.options = [
                "-Xms2G",
                "-Xmx2G",
            ]
            // Arguments passed to the executable JAR.
            arguments = [
                "--nogui"
            ]
            // Additional resources that should be copied to the remote node before running the Minecraft-like service.
            // 'local' specifies a local path, relative to ${yardstick.directories.input}
            // 'remote', when present', specifies the path and filename used when copied to the remote node that runs
            // the Minecraft-like service, relative to its working directory.
            // if 'remote' is not present, the filename is copied to the working directory of the remote with the same
            // filename it has locally.
            resources = [
                { local = "eula.txt" },
                { local = "server.properties" },
            ]
        }
        // Only used when ${yardstick.game.architecture} == "servo"
        // Note that Servo itself also uses HOCON for its configuration. Configuration that should be passed to Servo
        // directly should be placed under a ${servo} object (at the root of this config).
        servo {
            // Servo is a prototype under active development. The version number tracks compatibility-breaking changes /
            // in its deployment.
            version = 1
            // Configuration for building Servo.
            build {
                // The git repository containing the Servo source code.
                git = "git@repo.git"
                // The commit hash of the Servo version to use in this experiment.
                commit = "c0ffee"
            }
            // Environment variables used in Servo's (AWS) deployment script.
            // See Servo's repository for documentation.
            environment {
                AWS_ACCOUNT_ID = 1234567890
                AWS_REGION = eu-central-1
                LAMBDA_MEMORY = 512
                FARGATE_MEMORY = 8192
                FARGATE_CPU = 2048
            }
        }
    }

    // Configuration for Yardstick's player emulation component.
    player-emulation {
        // Location of the player emulation JAR archive, relative to ${yardstick.directories.input}.
        path = "yardstick.jar"
        // JVM options used when running the player emulation JAR.
        jvm.options = [
            "-Xms32G",
            "-Xmx32G",
        ]
        // Configuration options parsed by the player emulation component.
        arguments {
            // The architecture of the Minecraft-like game the player emulation connects to.
            game-architecture = ${yardstick.game.architecture}
            // Set to true if Yardstick should capture an application-level message track for each connected player.
            // Can consume significant amounts of storage and may cause computational overhead.
            packet-trace = false
            // Duration of the player emulation. Player emulation should gracefully exit after this time.
            duration = 300s
            // Player behavior program and parameters.
            behavior {
                // Name of the player behavior program.
                name = "12"
                // Parameters for player behavior program 12.
                // Only used when ${yardstick.player-emulation.arguments.behavior.name} == "12"
                "12" {
                    // Duration of the program. Players should disconnect after this time.
                    duration = ${yardstick.player-emulation.arguments.duration}
                    // Amount of time in between players joining the game.
                    joininterval = 1s
                    // The number of players that join simultaneously.
                    numbotsperjoin = 1
                    // The player movement model.
                    movementModel = "box"
                    // A movement model that lets players walk around within a square (i.e., box) perimeter. Does not
                    // limit player vertical travel.
                    // Only used when ${yardstick.player-emulation.arguments.behavior."12".movementModel} == "box"
                    box {
                        // The height/width of the square.
                        diameter = 32
                        // How to determine the center of the square. Options are:
                        // absolute
                        //      The user gives an x and z coordinate specifying the center of the square.
                        // spawn
                        //      The world's spawn location is used as the center of the square.
                        // player
                        //      The player's spawn location is used as the center of the square.
                        //      Note that some Minecraft-like services may spawn players in a random location close to
                        //      the world's spawn location to avoid avatar clipping.
                        center.type = "absolute"
                        // Only used when center.type == "absolute"
                        // Specifies the location of the square's center.
                        center.absolute {
                            x = 256
                            z = 256
                        }
                    }
                }
            }
        }
    }
}