trace-decoder.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache 2.0
/*
 * trace-decoder.h - NexusRV Trace decoder functions and declarations
 *
 *  Copyright (C) 2025, Bo Gan <ganboing@gmail.com>
 */
 
#ifndef LIBNEXUS_RV_TRACE_DECODER_H
#define LIBNEXUS_RV_TRACE_DECODER_H
 
#include "msg-decoder.h"
#include "hist-array.h"
#include "return-stack.h"
 
typedef struct nexusrv_trace_indirect {
    uint64_t target;   
    uint64_t context;
    struct {
        uint8_t interrupt : 1; 
        uint8_t exception : 1; 
        uint8_t ownership : 1;      
        uint8_t ownership_fmt : 2;  
        uint8_t ownership_priv : 2; 
        uint8_t ownership_v : 1;    
    };
} nexusrv_trace_indirect;
 
typedef struct nexusrv_trace_sync {
    uint64_t addr;        
    struct {
        uint8_t sync : 4; 
    };
} nexusrv_trace_sync;
 
typedef struct nexusrv_trace_error {
    uint32_t ecode;        
    struct {
        uint8_t etype : 4; 
    };
} nexusrv_trace_error;
 
typedef struct nexusrv_trace_stop {
    uint8_t evcode : 4;   
} nexusrv_trace_stop;
 
enum nexusrv_trace_events {
    NEXUSRV_Trace_Event_None,
    NEXUSRV_Trace_Event_Direct,
    NEXUSRV_Trace_Event_DirectSync,
    NEXUSRV_Trace_Event_Trap,
    NEXUSRV_Trace_Event_Indirect,
    NEXUSRV_Trace_Event_IndirectSync,
    NEXUSRV_Trace_Event_Sync,
    NEXUSRV_Trace_Event_Stop,
    NEXUSRV_Trace_Event_Error,
};
 
static inline const char
*str_nexusrv_trace_event(unsigned event) {
    switch (event) {
        case NEXUSRV_Trace_Event_None:
            return "none";
        case NEXUSRV_Trace_Event_Direct:
            return "direct";
        case NEXUSRV_Trace_Event_DirectSync:
            return "direct-sync";
        case NEXUSRV_Trace_Event_Trap:
            return "trap";
        case NEXUSRV_Trace_Event_Indirect:
            return "indirect";
        case NEXUSRV_Trace_Event_IndirectSync:
            return "indirect-sync";
        case NEXUSRV_Trace_Event_Sync:
            return "sync";
        case NEXUSRV_Trace_Event_Stop:
            return "stop";
        case NEXUSRV_Trace_Event_Error:
            return "error";
        default:
            return "unknown";
    }
}
 
 
typedef struct nexusrv_trace_decoder {
    nexusrv_msg_decoder *msg_decoder;
    struct nexusrv_hist_array* res_hists;
    uint32_t res_icnt;      
    uint32_t res_tnts;      
    uint32_t consumed_icnt; 
    uint8_t consumed_tnts;  
    bool synced;            
    bool msg_present;       
    nexusrv_msg msg;        
    uint64_t full_addr;     
    uint64_t timestamp;     
    nexusrv_return_stack return_stack; 
} nexusrv_trace_decoder;
 
int nexusrv_trace_decoder_init(nexusrv_trace_decoder* decoder,
                               nexusrv_msg_decoder *msg_decoder);
 
void nexusrv_trace_decoder_fini(nexusrv_trace_decoder* decoder);
 
static inline uint64_t nexusrv_trace_time(nexusrv_trace_decoder* decoder) {
    const nexusrv_hw_cfg *hwcfg = decoder->msg_decoder->hw_cfg;
    uint64_t time = decoder->timestamp;
    if (hwcfg->ts_bits < 64)
        time &= (((uint64_t)1 << hwcfg->ts_bits) - 1);
    if (hwcfg->timer_freq) {
        unsigned __int128 normalized = time;
        normalized *= 1000UL * 1000 * 1000;
        time = normalized / hwcfg->timer_freq;
    }
    return time;
}
 
uint32_t nexusrv_trace_available_icnt(nexusrv_trace_decoder *decoder);
 
int32_t nexusrv_trace_try_retire(nexusrv_trace_decoder *decoder,
                                 uint32_t icnt,
                                 unsigned *event);
 
int nexusrv_trace_sync_reset(nexusrv_trace_decoder* decoder,
                             nexusrv_trace_sync *sync);
 
int nexusrv_trace_next_tnt(nexusrv_trace_decoder *decoder);
 
int nexusrv_trace_push_call(nexusrv_trace_decoder* decoder,
                            uint64_t callsite);
 
int nexusrv_trace_pop_ret(nexusrv_trace_decoder* decoder,
                          uint64_t *callsite);
 
unsigned nexusrv_trace_callstack_used(nexusrv_trace_decoder* decoder);
 
int nexusrv_trace_next_indirect(nexusrv_trace_decoder *decoder,
                                nexusrv_trace_indirect *indirect);
 
int nexusrv_trace_next_sync(nexusrv_trace_decoder *decoder,
                            nexusrv_trace_sync *sync);
 
int nexusrv_trace_next_error(nexusrv_trace_decoder *decoder,
                             nexusrv_trace_error *error);
 
int nexusrv_trace_next_stop(nexusrv_trace_decoder *decoder,
                            nexusrv_trace_stop *stop);
 
void nexusrv_trace_add_timestamp(nexusrv_trace_decoder *decoder,
                                 uint64_t timestamp);
 
#endif