#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
#include <sys/time.h>
#include <time.h>
#ifndef  __linux__
#include <sys/neutrino.h>
#else
#include <atomic>
#endif
#include <cassert>
#include <iostream>
#include <fstream>
#include <ios>
#include <stdlib.h>
#define SIZEOF_ARRAY(a) (sizeof(a) / sizeof((a)[0]))
#define RING_BUFF_SIZE 4096
class CRingBuff
{
#ifdef  __linux__
    std::atomic<size_t> m_tail, m_head; // необходимо учесть модель памяти
#else
    size_t m_tail, m_head;
#endif
    uint8_t m_buff[RING_BUFF_SIZE];
    inline size_t Capacity() const { return SIZEOF_ARRAY(m_buff); }
    inline size_t Have() const { return m_head >= m_tail ? m_head - m_tail : Capacity() + m_head - m_tail; }
    inline size_t Left() const { return Capacity() - Have(); }
public:
     CRingBuff(): m_tail(0), m_head(0) {}
     inline bool Empty() const { return m_head == m_tail; }
     size_t putData( const uint8_t *data, size_t len );
     size_t getData( uint8_t *data, const size_t max_size );
};
size_t CRingBuff::putData( const uint8_t * data, size_t len )
{
    if (Left() <= len)          // <= защита от переполнения
        return 0;
    size_t capacity = Capacity();
    if (m_head + len > capacity)
    {
        size_t del = capacity - m_head;
        memcpy(m_buff + m_head, data, del);
        memcpy(m_buff, data + del, len - del);
    }
    else
    {
        memcpy(m_buff + m_head, data, len);
    }
    m_head = (m_head + len) % capacity;
    return len;
}
size_t CRingBuff::getData( uint8_t * data, size_t max_size )
{
    if (Empty())
        return 0;
    size_t have = Have();
    if (have > max_size)
        have = max_size;
    size_t capacity = Capacity();
    if (m_tail + have > capacity)
    {
        size_t del = capacity - m_tail;
        memcpy(data, m_buff + m_tail, del);
        memcpy(data + del, m_buff, have - del);
    }
    else
    {
        memcpy(data, m_buff + m_tail, have);
    }
    m_tail = (m_tail + have) % capacity;
    return have;
}
void dummy() {}
void do_something()             // -- работа на десятки микросекунд
{
    volatile int i;
    for (i = 0; i < 21000; i++)
    {
        dummy();
    }
}
struct sData
{
    uint32_t t1, t2;
    sData(): t1(0), t2(0) {}
};
CRingBuff RingBuff;
int iexit = 0;
const char sFileName[] = "elapsed.csv"; // имя файла для обсчёта в Excel
// функция второстепенного потока сохраняющая результаты измерения
void *flusher(void *arg)
{
    uint32_t step(0);
    while (!iexit)
    {
        if (!RingBuff.Empty())
        {
            uint8_t buff[RING_BUFF_SIZE];
            size_t len = RingBuff.getData(buff, sizeof(buff));
            if (!len)
            {
                printf("ringbuff logic 1 error\n");
                exit(1);
            }
            if (len % sizeof(sData))
            {
                printf("ringbuff logic 2 error\n");
                exit(1);
            }
            size_t sz = len / (sizeof(sData));
            sData *ptr = reinterpret_cast < sData * >(buff);
            for (size_t i = 0; i < sz; i++)
            {
                double t1 = ptr[i].t1 * 1e-7; // перевод из 100 нс интервалов в секунды
                double t2 = ptr[i].t2 * 1e-7;
                printf("%u). duration: %f elapsed: %f\n", step, t1, t2);
                std::ofstream myfile;
                myfile.open(sFileName, std::ios::out | std::ios::app);
                if (myfile.good())
                {
                    myfile << step << ';' << t1 << ';' << t2 << ";\n";
                    myfile.close();
                }
                step++;
            }
        }
        usleep(10 * 1000);      // выгребаем результаты каждые 10 мс
    }
    return NULL;
}
#define USECS_PER_SEC (1000 * 1000)
#ifdef  __linux__
inline uint64_t ClockCycles() // В QNX имеется такая функция, а для Linux собственная реализация.
{
    unsigned int low, high;
    asm volatile ("rdtsc\n":"=a" (low), "=d"(high));
    return ((uint64_t) high << 32) | low;
}
#endif
// Класс подсчёта времени в тактах частоты процессора
class Cycles
{
    uint32_t m_CyclesPerUs;        // Количество тактов за 1 мкс.
    uint32_t m_CyclesPer100Ns;    // Количество тактов за 100 нс.
    CRingBuff m_Values;
public:
    Cycles( uint32_t N ) : m_CyclesPerUs(1), m_CyclesPer100Ns(1)
    {
        if (N < 2)
        {
            N = 2;
        }
        uint32_t dc(0);
        for (int i = 0; i < N; i++)  // Замеряем N раз 1 секунду
        {
            uint32_t c = (uint32_t)ClockCycles();
            usleep(USECS_PER_SEC);
            dc = (uint32_t)ClockCycles() - c;
            printf("%d). Cycles: %u\n", i, dc);
            dc /= USECS_PER_SEC;
            m_Values.putData(reinterpret_cast<const uint8_t*>(&dc), sizeof(dc));
        }
        for (int i = 0; i < N - 1; i++) // Проверяем результаты
        {
            uint32_t val;
            m_Values.getData(reinterpret_cast <uint8_t*>(&val), sizeof(val));
            if (val != dc) // Все результаты замеров секунды должны совпадать
            {
                printf("CyclesPerUs error %u %u\n", val, dc);
                exit(1);
            }
        }
        m_CyclesPerUs = (uint32_t)dc;
        m_CyclesPer100Ns = m_CyclesPerUs / 10;
        printf("Cycles_per_us:%u\nCycles_per_100ns:%u\n", m_CyclesPerUs, m_CyclesPer100Ns);
    }
    uint32_t getCycPerUs() const { return m_CyclesPerUs; }
    uint32_t getCycPer100Ns() const { return m_CyclesPer100Ns; }
    // 32 бита, т.о. считывание тактов атомарно для 32-х разрядных сиситем
    static uint32_t getCycles() { return (uint32_t) ClockCycles(); }
    uint32_t calc100Ns( const uint32_t cycles ) const { return cycles / m_CyclesPer100Ns; }
    uint32_t calcUs( const uint32_t cycles ) const { return cycles / m_CyclesPerUs; }
};
const unsigned long sleep_us = 500;
int elapsed( void )
{
    double clock_res;
    // Для QNX меняем квант системного таймера
#ifndef __linux__
    {
        const unsigned long system_resolution_ns = 10 * 1000;
        {
            struct _clockperiod nres;
            nres.fract = 0;
            nres.nsec = system_resolution_ns;
            if (ClockPeriod(CLOCK_REALTIME, &nres, NULL, 0) < 0)
            {
                printf("ClockPeriod error\n");
                exit(1);
            }
        }
        // Проверяем установленный системный квант
        struct timespec res;
        if (clock_getres(CLOCK_REALTIME, &res) < 0) {
            printf(" get system resolution error\n");
            exit(1);
        }
        clock_res = res.tv_sec * 1e9;
        clock_res = clock_res + res.tv_nsec * 1e-9;
        printf("clock_getres: %f sec\n", clock_res);
    }
#endif
    // Порождаем второстепенный поток и устанавливаем максимальный приоритет для основного потока
    {
        // удаляем файл резульнатов измерений с прошлого запуска
        remove(sFileName);
pthread_t tid;
        pthread_create(&tid, NULL, flusher, NULL);
        struct sched_param sp;
#ifndef __linux__
        sp.sched_priority = 255;        // максимальный приоритет в QNX
#else
        sp.sched_priority = 99;         // максимальный приоритет в Linux
#endif
        int rt = sched_setscheduler(0, SCHED_FIFO, &sp);
        if (rt) {
            printf("set scheduler error\n");
            exit(1);
        }
    }
    const uint32_t N(5);
    Cycles cyc(N);
    // Сохранение условий эксперимента
    {
        std::ofstream myfile;
        myfile.open(sFileName, std::ios::out | std::ios::app);
        if (myfile.good())
        {
            myfile << "Resolution (sec)" << ';' << "Cycles per us" << ';' <<"Cycles per 100ns" << ";\n";
            myfile << clock_res << ';' << cyc.getCycPerUs() << ';' << cyc.getCycPer100Ns() << ";\n";
            myfile << "Step" << ';' << "job (sec)" << ';' << "Sleep (sec)" << ";\n";
            myfile.close();
        }
    }
    uint32_t start = cyc.getCycles();
    do
    {
        do_something();         // задача длительностью десятки микросекунд
        sData data;
        uint32_t mid = cyc.getCycles() - start;
        data.t1 = cyc.calc100Ns(mid);
        usleep(sleep_us - cyc.calcUs(mid));
        uint32_t end = cyc.getCycles();
        data.t2 = cyc.calc100Ns(end - start);
        RingBuff.putData(reinterpret_cast < const uint8_t * >(&data), sizeof(data));
        start = end;
    } while (1);
    return 0;
}
int main(int argc, const char **argv)
{
    return elapsed();
}

function stat_summary(name, data)
    m = mean(data);
    s = std(data);
    mi = min(data);
    ma = max(data);
    printf("%40s [us]: min=%6.1f; max=%7.1f; avr=%6.1f; med=%6.1f; std=%7.3f; err=%6.3f; r_err=%6.2f %%; r_d=%6.2f %%; r_max=%6.2f %%\n", name, mi, ma, m, median(data), s, 3*s, 3 * s / m * 100.0, (ma - mi) / m * 100.0, (ma - m) / m * 100);
end