profile.h

Go to the documentation of this file.

/*
** Jo Sega Saturn Engine
** Copyright (c) 2012-2026, Johannes Fetz (johannesfetz@gmail.com)
** 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 the Johannes Fetz 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 Johannes Fetz 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.
*/
 
#ifndef __JO_PROFILE_H__
# define __JO_PROFILE_H__

typedef enum
{
    JO_PROFILE_FRAME = 0,
    JO_PROFILE_CALLBACKS,
    JO_PROFILE_WAIT_SLAVE,
    JO_PROFILE_SLAVE,
    JO_PROFILE_VDP1_SORT,
    JO_PROFILE_VDP1_COPY,
    JO_PROFILE_VDP1_WAIT,
    JO_PROFILE_VSYNC,
    JO_PROFILE_VDP1_DRAW,
    JO_PROFILE_VBLANKS,
    JO_PROFILE_VDP1_COMMANDS,
    JO_PROFILE_POLYGONS,
    JO_PROFILE_3D_POLYGON_COUNT,
    JO_PROFILE_3D_VERTEX_COUNT,
    JO_PROFILE_3D_VERTICES,
    JO_PROFILE_3D_POLYGONS,
    JO_PROFILE_3D_CLIP,
    JO_PROFILE_3D_LIGHT,
    JO_PROFILE_3D_PIXELS,
    JO_PROFILE_FIRST_USER,
    JO_PROFILE_COUNT = JO_PROFILE_FIRST_USER + 8
}                                   jo_profile_slot;

# define JO_PROFILE_USER(N)         ((jo_profile_slot)(JO_PROFILE_FIRST_USER + (N)))

# define JO_PROFILE_FRAMES          (32)
 
#ifdef JO_COMPILE_WITH_PROFILER_SUPPORT

typedef struct
{
    unsigned int                    sum[JO_PROFILE_COUNT];      // Never reset (the differences are computed)
    unsigned int                    max[JO_PROFILE_COUNT];
    unsigned short                  start[JO_PROFILE_COUNT];    // See jo_profile_begin()
}                                   jo_profile_cpu;

extern jo_profile_cpu               __jo_profile_cpu[2];

static  __jo_force_inline unsigned int  jo_profile_ticks(void)
{
    unsigned int                    high;
 
    // The high byte must be read first (the low byte is latched)
    high = *(volatile unsigned char *)0xFFFFFE12;
    return ((high << 8) | *(volatile unsigned char *)0xFFFFFE13);
}

static  __jo_force_inline jo_profile_cpu *__jo_profile_current_cpu(void)
{
    unsigned int                    sp;
 
    __asm__ volatile ("mov r15, %0" : "=r" (sp));
    return (&__jo_profile_cpu[(sp & 0x000FFFFF) < 0x4000 ? 1 : 0]);
}

static  __jo_force_inline void      __jo_profile_add(jo_profile_cpu * const cpu, const jo_profile_slot slot, const unsigned int value)
{
    // (through the cache: a read without the cache cost about 10 cycles for each measure, several per object drawn)
    cpu->sum[slot] += value;
    if (value > cpu->max[slot])
        cpu->max[slot] = value;
}

static  __jo_force_inline void      jo_profile_begin(const jo_profile_slot slot)
{
    __jo_profile_current_cpu()->start[slot] = (unsigned short)jo_profile_ticks();
}

static  __jo_force_inline void      jo_profile_end(const jo_profile_slot slot)
{
    jo_profile_cpu                  *cpu;
 
    cpu = __jo_profile_current_cpu();
    __jo_profile_add(cpu, slot, (jo_profile_ticks() - cpu->start[slot]) & 0xFFFF);
}

static  __jo_force_inline void      jo_profile_count(const jo_profile_slot slot, const unsigned int value)
{
    __jo_profile_add(__jo_profile_current_cpu(), slot, value);
}

bool                                jo_profile_get(const jo_profile_slot slot, unsigned int *average, unsigned int *maximum);

void                                jo_profile_count_pixels(const bool enabled);
extern bool                         __jo_profile_pixels;

void                                jo_profile_set_name(const jo_profile_slot slot, const char * const name);

void                                jo_profile_print(const int x, const int y);

# define JO_PROFILE_SAMPLING_CODE_START     (0x06004000)
# define JO_PROFILE_SAMPLING_BIN_SIZE       (16)
# define JO_PROFILE_SAMPLING_BINS           (16384)

void                                jo_profile_sampling_start(unsigned int *master_histogram, unsigned int *slave_histogram);

void                                __jo_profile_slave_job(void);

void                                __jo_profile_init(void);

void                                __jo_profile_end_frame(void);

void                                __jo_profile_vdp1_start(void);
 
#else
 
# define jo_profile_begin(SLOT)                 do {} while (0)
# define jo_profile_end(SLOT)                   do {} while (0)
# define jo_profile_count(SLOT, VALUE)          do {} while (0)
# define jo_profile_set_name(SLOT, NAME)        do {} while (0)
# define jo_profile_print(X, Y)                 do {} while (0)
# define jo_profile_count_pixels(ENABLED)       do {} while (0)
# define jo_profile_sampling_start(M, S)        do {} while (0)
# define __jo_profile_slave_job()               do {} while (0)
 
#endif /* !JO_COMPILE_WITH_PROFILER_SUPPORT */
 
#endif /* !__JO_PROFILE_H__ */
 
/*
** END OF FILE
*/