/*
 * @licence app begin@
 * SPDX license identifier: MPL-2.0
 *
 * Copyright (C) 2011-2015, BMW AG
 *
 * This file is part of GENIVI Project DLT - Diagnostic Log and Trace.
 *
 * This Source Code Form is subject to the terms of the
 * Mozilla Public License (MPL), v. 2.0.
 * If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * For further information see http://www.genivi.org/.
 * @licence end@
 */

/*!
 * \author Sven Hassler <sven_hassler@mentor.com>
 *
 * \copyright Copyright © 2011-2015 BMW AG. \n
 * License MPL-2.0: Mozilla Public License version 2.0 http://mozilla.org/MPL/2.0/.
 *
 * \file dlt-test-init-free.c
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#include "dlt_common.h"
#include "dlt_user.h"

void exec(const char *cmd, char *buffer, size_t length);
void printMemoryUsage();
char *occupyMemory(uint size);
void do_example_test();
void do_dlt_test();

int num_repetitions;

int main(int argc, char **argv)
{
    if (argc > 1)
        num_repetitions = strtol(argv[1], 0, 10);
    else
        num_repetitions = 1000;

    printf("Will do %d repetitions.\n", num_repetitions);

    /*do_example_test(); */
    do_dlt_test();

    printf("Done.\n");

    return 0;
}

/* Should increase and then decrease memory amount. */
void do_example_test()
{
    const int immediatelyFree = 0;

    int numBufs = 1024;
    int sizePerBuf = 1024 * 1024; /* 1MB */

    char **bufs = (char **)malloc(numBufs * sizeof(char *));

    for (int i = 0; i < numBufs; i++) {
        bufs[i] = occupyMemory(sizePerBuf);

        printf("after alloc: ");
        printMemoryUsage();

        if (immediatelyFree) {
            free(bufs[i]);

            printf("after free: ");
            printMemoryUsage();
        }
    }

    printf("deleting memory:\n");

    if (!immediatelyFree)
        for (int i = 0; i < numBufs; i++) {
            /*for (int i = numBufs - 1; i >= 0; i--) // other way round works, too */
            free(bufs[i]);

            printf("after free: ");
            printMemoryUsage();
        }

    free(bufs);
}

/* Should give stable amount of memory across all iterations. */
void do_dlt_test()
{
    for (int i = 0; i < num_repetitions; i++) {
        dlt_init();
        dlt_free();

        printf("Iteration %d) - currently used memory amount: ", i);
        printMemoryUsage();
    }
}

void exec(const char *cmd, char *buffer, size_t length)
{
    FILE *pipe = NULL;
    strncpy(buffer, "ERROR", length);

    if ((pipe = popen(cmd, "r")) == NULL)
        return;

    while (fgets(buffer, length, pipe) != NULL);

    if (pipe != NULL)
        pclose(pipe);
}

void printMemoryUsage()
{
    char result[128] = { 0 };
    char command[128] = { 0 };

    snprintf(command, sizeof(command), "pmap %d | grep total", getpid());

    exec(command, result, sizeof(result));

    printf("%s", result);
}

char *occupyMemory(uint size)
{
    char *buf = (char *)malloc(size * sizeof(char));

    for (int i = 0; i < 1; i++)
        buf[i] = 1;

    return buf;
}