libqemu/test_guest_2.c

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* This program benchmarks a QEMUD pipe to exchange data with a test
 * server.
 *
 * See test_host_1.c for the corresponding server code, which simply
 * sends back anything it receives from the client.
 */
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include "test_util.h"

#define  PIPE_NAME  "pingpong"

char* progname;

static void usage(int code)
{
    printf("Usage: %s [options]\n\n", progname);
    printf(
      "Valid options are:\n\n"
      "  -? -h --help  Print this message\n"
      "  -pipe <name>  Use pipe name (default: " PIPE_NAME ")\n"
      "  -tcp <port>   Use local tcp port\n"
      "  -size <size>  Specify packet size\n"
      "\n"
    );
    exit(code);
}

int main(int argc, char** argv)
{
    Pipe        pipe[1];
    const char* tcpPort = NULL;
    int         localPort = 0;
    const char* pipeName = NULL;
    const char* packetSize = NULL;
    int         port = 8012;
    int         maxCount   = 1000;
    int         bufferSize = 16384;
    uint8_t*    buffer;
    uint8_t*    buffer2;
    int         nn, count;
    double      time0, time1;

    /* Extract program name */
    {
        char* p = strrchr(argv[0], '/');
        if (p == NULL)
            progname = argv[0];
        else
            progname = p+1;
    }

    /* Parse options */
    while (argc > 1 && argv[1][0] == '-') {
        char* arg = argv[1];
        if (!strcmp(arg, "-?") || !strcmp(arg, "-h") || !strcmp(arg, "--help")) {
            usage(0);
        } else if (!strcmp(arg, "-pipe")) {
            if (argc < 3) {
                fprintf(stderr, "-pipe option needs an argument! See --help for details.\n");
                exit(1);
            }
            argc--;
            argv++;
            pipeName = argv[1];
        } else if (!strcmp(arg, "-tcp")) {
            if (argc < 3) {
                fprintf(stderr, "-tcp option needs an argument! See --help for details.\n");
                exit(1);
            }
            argc--;
            argv++;
            tcpPort = argv[1];
        } else if (!strcmp(arg, "-size")) {
            if (argc < 3) {
                fprintf(stderr, "-tcp option needs an argument! See --help for details.\n");
                exit(1);
            }
            argc--;
            argv++;
            packetSize = argv[1];
        } else {
            fprintf(stderr, "UNKNOWN OPTION: %s\n\n", arg);
            usage(1);
        }
        argc--;
        argv++;
    }

    /* Check arguments */
    if (tcpPort && pipeName) {
        fprintf(stderr, "You can't use both -pipe and -tcp at the same time\n");
        exit(2);
    }

    if (tcpPort != NULL) {
        localPort = atoi(tcpPort);
        if (localPort <= 0 || localPort > 65535) {
            fprintf(stderr, "Invalid port number: %s\n", tcpPort);
            exit(2);
        }
    } else if (pipeName == NULL) {
        /* Use default pipe name */
        pipeName = PIPE_NAME;
    }

    if (packetSize != NULL) {
        int  size = atoi(packetSize);
        if (size <= 0) {
            fprintf(stderr, "Invalid byte size: %s\n", packetSize);
            exit(3);
        }
        bufferSize = size;
    }

    /* Open the pipe */
    if (tcpPort != NULL) {
        if (pipe_openSocket(pipe, localPort) < 0) {
            fprintf(stderr, "Could not open tcp socket!\n");
            return 1;
        }
        printf("Connected to tcp:localhost:%d\n", port);
    }
    else {
        if (pipe_openQemuPipe(pipe, pipeName) < 0) {
            fprintf(stderr, "Could not open '%s' pipe: %s\n", pipeName, strerror(errno));
            return 1;
        }
        printf("Connected to '%s' pipe\n", pipeName);
    }

    /* Allocate buffers, setup their data */
    buffer  = malloc(bufferSize);
    buffer2 = malloc(bufferSize);

    for (nn = 0; nn < bufferSize; nn++) {
        buffer[nn] = (uint8_t)nn;
    }

    /* Do the work! */
    time0 = now_secs();

    for (count = 0; count < maxCount; count++) {
        int ret = pipe_send(pipe, buffer, bufferSize);
        int pos, len;

        if (ret < 0) {
            fprintf(stderr,"%d: Sending %d bytes failed: %s\n", count, bufferSize, strerror(errno));
            return 1;
        }

#if 1
        /* The server is supposed to send the message back */
        pos = 0;
        len = bufferSize;
        while (len > 0) {
            ret = pipe_recv(pipe, buffer2 + pos, len);
            if (ret < 0) {
                fprintf(stderr, "Receiving failed (ret=%d): %s\n", ret, strerror(errno));
                return 3;
            }
            if (ret == 0) {
                fprintf(stderr, "Disconnection while receiving!\n");
                return 4;
            }
            pos += ret;
            len -= ret;
        }

        if (memcmp(buffer, buffer2, bufferSize) != 0) {
            fprintf(stderr, "Message content mismatch!\n");
            const int maxAvail = 16;
            const int maxLines = 12;
            int numLines = 0;
            for (nn = 0; nn < bufferSize; ) {
                int avail = bufferSize - nn;
                int mm;
                if (avail > maxAvail)
                    avail = maxAvail;

                if (memcmp(buffer+nn, buffer2+nn, avail) != 0) {
                    if (++numLines >= maxLines) {
                        printf(".... to be continued ...\n");
                        break;
                    }
                    printf("%04x:", nn);

                    for (mm = 0; mm < avail; mm++)
                        printf(" %02x", buffer[nn+mm]);
                    for ( ; mm < maxAvail; mm++ )
                        printf("   ");

                    printf( " -- " );

                    for (mm = 0; mm < avail; mm++)
                        printf(" %02x", buffer2[nn+mm]);

                    printf ("\n");
                }
                nn += avail;
            }
            return 6;
        }

#endif

        if (count > 0 && (count % 200) == 0) {
            printf("... %d\n", count);
        }
    }

    time1 = now_secs();

    printf("Closing pipe\n");
    pipe_close(pipe);

    printf("Total time: %g seconds\n", time1 - time0);
    printf("Total bytes: %g bytes\n", 1.0*maxCount*bufferSize);
    printf("Bandwidth: %g MB/s\n", (maxCount*bufferSize/(1024.0*1024.0))/(time1 - time0) );
    return 0;
}