RTOS/TDA3LA: IPU SMP load computation

/*
 * Copyright (c) 2016, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 *  ======== LoadTest2.c ========
 *  A simple test to check Task loads on two cores.  The load tasks should
 *  have loads of about 25% (core 0) and 35% (core 1).  The corresponding
 *  idle task loads should be about 75% and 65%.  This test can be used to
 *  verify that the Load module computes the correct load, even if timers
 *  are not initialized until after main().
 */

#include <xdc/std.h>

#define ti_sysbios_utils_Load__internalaccess 1

#include <xdc/runtime/Assert.h>

#include <xdc/runtime/System.h>
#include <xdc/runtime/Timestamp.h>
#include <xdc/runtime/Types.h>

#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Clock.h>
#include <ti/sysbios/knl/Task.h>

#include <ti/sysbios/utils/Load.h>

#include <xdc/cfg/global.h>

#define NLOOPS        3

#define TASKLOAD_0 25   /* For a load of about 25% */
#define IDLELOAD_0 (100 - TASKLOAD_0)

#define TASKLOAD_1 35   /* For a load of about 35% */
#define IDLELOAD_1 (100 - TASKLOAD_1)

#define THRESHOLD 2
#define WITHIN_THRESHOLD(v, p) \
        (((v) - THRESHOLD < (p)) && ((v) < ((p) + THRESHOLD)))


Void loadTask0Fxn(UArg arg1, UArg arg2);
Void loadTask1Fxn(UArg arg1, UArg arg2);
Void printLoads(UArg arg1, UArg arg2);

Task_Handle loadTask_0, loadTask_1;
Int updateCount = 0;

static struct Load_Module_State *Load_module;



/*
 *  ======== main ========
 */
Int main(Int argc, Char* argv[])
{
    Task_Params taskParams;

    Task_Params_init(&taskParams);
    taskParams.affinity = 0;
    loadTask_0 = Task_create(loadTask0Fxn, &taskParams, NULL);

    taskParams.affinity = 1;
    loadTask_1 = Task_create(loadTask1Fxn, &taskParams, NULL);

    /*
     *  The Load module's t0 is initialized to 0 in Load.xs.  This is the
     *  start of the Load update window.  We need to initialize the start
     *  of the update window start time to the current time.
     *  This should prevent the Load module from doing an update too early.
     *  Eg, with ducati timestamp, the counter may be at some verify high
     *  value, which would cause an immediate update from the Load idle
     *  function.
     */
    Load_module = (Load_Module_State *)&ti_sysbios_utils_Load_Module__state__V;
    Load_module->t0 = Timestamp_get32();

    BIOS_start();

    return (0);
}

/*
 *  ======== loadTask0Fxn ========
 */
Void loadTask0Fxn(UArg arg1, UArg arg2)
{
    UInt32 startTicks;
    UInt32 curTicks;

    for (;;) {
        Task_sleep(IDLELOAD_0);

        curTicks = startTicks = Clock_getTicks();

        while (curTicks - startTicks < TASKLOAD_0) {
            curTicks = Clock_getTicks();
        }
    }
}

/*
 *  ======== loadTask1Fxn ========
 */
Void loadTask1Fxn(UArg arg1, UArg arg2)
{
    UInt32 startTicks;
    UInt32 curTicks;

    for (;;) {
        Task_sleep(IDLELOAD_1);

        curTicks = startTicks = Clock_getTicks();

        while (curTicks - startTicks < TASKLOAD_1) {
            curTicks = Clock_getTicks();
        }
    }
}

/*
 *  ======== printLoads ========
 */
Void printLoads(UArg arg1, UArg arg2)
{
    Load_Stat stat;
    UInt      idlTaskLoad_0;
    UInt      loadTaskLoad_0;
    UInt      idlTaskLoad_1;
    UInt      loadTaskLoad_1;

    updateCount++;

    if (updateCount > NLOOPS) {
        System_printf("LoadTest2 finished!\n");
        BIOS_exit(0);
    }

    /* Check loads on core 0 */
    Load_getTaskLoad(Task_getIdleTaskHandle(0), &stat);
    idlTaskLoad_0 = Load_calculateLoad(&stat);

    Load_getTaskLoad(loadTask_0, &stat);
    loadTaskLoad_0 = Load_calculateLoad(&stat);

    if (!WITHIN_THRESHOLD(loadTaskLoad_0, TASKLOAD_0)) {
        System_printf("Core 0 Load Task load: %d\n", loadTaskLoad_0);
    }
    if (!WITHIN_THRESHOLD(idlTaskLoad_0, IDLELOAD_0)) {
        System_printf("Core 0 Idle Task load: %d\n", idlTaskLoad_0);
    }

    /* Check loads on core 1 */
    Load_getTaskLoad(Task_getIdleTaskHandle(1), &stat);
    idlTaskLoad_1 = Load_calculateLoad(&stat);

    Load_getTaskLoad(loadTask_1, &stat);
    loadTaskLoad_1 = Load_calculateLoad(&stat);

    if (!WITHIN_THRESHOLD(loadTaskLoad_1, TASKLOAD_1)) {
        System_printf("Core 1 Load Task load: %d\n", loadTaskLoad_1);
    }
    if (!WITHIN_THRESHOLD(idlTaskLoad_1, IDLELOAD_1)) {
        System_printf("Core 1 Idle Task load: %d\n", idlTaskLoad_1);
    }

    Assert_isTrue(WITHIN_THRESHOLD(loadTaskLoad_0, TASKLOAD_0), NULL);
    Assert_isTrue(WITHIN_THRESHOLD(idlTaskLoad_0, IDLELOAD_0), NULL);

    Assert_isTrue(WITHIN_THRESHOLD(loadTaskLoad_1, TASKLOAD_1), NULL);
    Assert_isTrue(WITHIN_THRESHOLD(idlTaskLoad_1, IDLELOAD_1), NULL);
}