Вот 100% рабочий код
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <time.h>
#include <string.h>

static inline uint64_t read_arm_counter() {
    uint32_t low, high;
    asm volatile("mrrc p15, 1, %0, %1, c14" : "=r"(low), "=r"(high));
    return ((uint64_t)high << 32) | low;
}

static inline uint32_t read_cntfrq() {
    uint32_t freq;
    asm volatile("mrc p15, 0, %0, c14, c0, 0" : "=r"(freq));
    return freq;
}

void format_time(char *buf, size_t size, time_t sec, uint64_t ns) {
    struct tm tm_info;
    localtime_r(&sec, &tm_info);
    strftime(buf, size, "%Y-%m-%d %H:%M:%S", &tm_info);
    size_t len = strlen(buf);
    snprintf(buf + len, size - len, ".%03llu", ns / 1000000ULL);
}

int main() {
    uint32_t freq = read_cntfrq();
    printf("Частота счётчика: %u Гц\n", freq);

    // Получаем начальное время (Unix-время + наносекунды)
    struct timespec ts_start;
    clock_gettime(CLOCK_REALTIME, &ts_start);
    uint64_t counter_start = read_arm_counter();

    for (int i = 0; i < 10; i++) {
        uint64_t start = read_arm_counter();
        unsigned int delay_us = (rand() % 1000000) + 1;
        printf("Sleeping for %u us\n", delay_us);
        usleep(delay_us);
        uint64_t end = read_arm_counter();

        // Вычисляем прошедшие наносекунды
        uint64_t elapsed_ns = ((end - start) * 1000000000ULL) / freq;

        // Вычисляем абсолютное время
        uint64_t counter_elapsed = end - counter_start;
        uint64_t ns_elapsed = (counter_elapsed * 1000000000ULL) / freq;
        uint64_t current_ns = ts_start.tv_nsec + ns_elapsed;
        time_t current_sec = ts_start.tv_sec + current_ns / 1000000000ULL;
        current_ns %= 1000000000ULL;

        // Форматируем время
        char time_buf[64];
        format_time(time_buf, sizeof(time_buf), current_sec, current_ns);

        printf("Время: %s | Итерация %d: %llu мс\n", 
               time_buf, i+1, elapsed_ns / 1000000ULL);
    }
    return 0;
}

НО У меня были такие фугкции, оставь их и поменяй на указанный выше
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>
#include <math.h>
#include <stdint.h>
#include <inttypes.h>
#include <unistd.h>
#include <semaphore.h>
#include <pthread.h>

#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/pixdesc.h>
#include <libswscale/swscale.h>
#include <libavutil/imgutils.h>

#include "rknn_api.h"  // Заголовочный файл RKNN SDK

#define LABEL_NALE_TXT_PATH "./coco_80_labels_list.txt"

// person car dog длинна строки
#define OBJ_NAME_MAX_SIZE 64
//Максимальное количество объектов (детектированных результатов)
#define OBJ_NUMB_MAX_SIZE 30
#define PROP_BOX_SIZE 80 // Обычно 5 + 80 классов

//Значение 0.45 означает, что боксы с перекрытием более 45% считаются дублирующими
#define NMS_THRESH        0.01

//начение 0.25 означает, что детекции с вероятностью (confidence) менее 25% будут отброшены.
#define BOX_THRESH        0.20

#define MODEL_PATH "./model.rknn"  	// Путь к RKNN модели
#define RKNN_WIDTH 640
#define RKNN_HEIGHT 640
// Кол-во классов модели
#define OBJ_CLASS_NUM 3
// Макс выходов, выставьте по факту у моделей обычно 3
#define MAX_OUTPUT_NUM 3


// Счётчик циклов ARM Cortex-A
static inline uint64_t read_cycle_counter() {
    uint32_t cycle_low, cycle_high;
    asm volatile("mrrc p15, 1, %0, %1, c14" : "=r"(cycle_low), "=r"(cycle_high));
    return ((uint64_t)cycle_high << 32) | cycle_low;
}

// Конвертация циклов в наносекунды (исходя из частоты 1.2 ГГц)
uint64_t cycles_to_ns(uint64_t cycles) {
	// cycles * 1_000_000_000 / 1_200_000_000 
    return (cycles * 1000000000ULL) / 1200000000ULL;
}

// Для GLOBAL_TIME — базовый отсчёт циклов (инициализируется при первом вызове)
static uint64_t base_cycles = 0;
static uint64_t base_unix_time = 0;

uint64_t start_ns() {
    if (base_cycles == 0) {
        base_cycles = read_cycle_counter();

        struct timespec ts;
        clock_gettime(CLOCK_REALTIME, &ts);
        base_unix_time = (uint64_t)ts.tv_sec * 1000000000ULL + ts.tv_nsec;
    }
    uint64_t delta_cycles = read_cycle_counter() - base_cycles;
    return base_unix_time + cycles_to_ns(delta_cycles);
}

static void _stop_ms(char *buffer, size_t bufsize, uint64_t start_cycles) {
    uint64_t elapsed = start_ns() - start_cycles;
    snprintf(buffer, bufsize, "%.6f s", (double)elapsed / 1e9);
}


const char* stop_ms(uint64_t start_cycles) {
    static __thread char buf[21];
    _stop_ms(buf, sizeof(buf), start_cycles) ;
    return buf;
}

void GLOBAL_TIME(char *buffer, size_t bufsize) {
    uint64_t current_ns = start_ns();

    uint64_t ns_part = current_ns % 1000000000ULL;

		struct tm tm_info;
		time_t current_sec = time(NULL);
		localtime_r(&current_sec, &tm_info);
		strftime(buffer, bufsize, "%Y-%m-%d %H:%M:%S", &tm_info);

    size_t len = strlen(buffer);
    snprintf(buffer + len, bufsize - len, ".%09llu", (unsigned long long)ns_part);
}

const char* GLOBAL_TIME_PRINT() {
    static __thread char buf[64];
    GLOBAL_TIME(buf, sizeof(buf)) ;
    return buf;
}

int main() {
		for(int i=0;i<5;i++) {
		uint64_t xx = read_cycle_counter();
		printf("%lld\r\n",xx); 
		
			 
		uint64_t start_time = start_ns();
		sleep(1);
		printf("%s: %d decode time: %s\r\n", 
			GLOBAL_TIME_PRINT(), 
			i, 
			stop_ms(start_time)
		);
		}

    return 0;
}