调度问题 C++ windows

Question

I have a scheduler code to perform some task as per given time. I have a table in database of name config , where different time is given to every row which have time in second to read data from a different table. I gave time in the format like. 20, 40, 50, 60 seconds.

Code should run in such a way that when I start my program after every 20 second that column should execute which have 20 second, after every 40 second that column should execute which have 40 second and so on. But it is not executing in that way. Scheduler is not working as per given seconds, it is skipping and mismatching time

Below is a code where I am trying to read data as per time given in config table

void plac::worker_thread(void)
{
    try {
        std::chrono::steady_clock::time_point   tick_time               = std::chrono::steady_clock::now();
        std::uint32_t                           tick_count              = 1;
        plac::scheduling_struct                 scheduling_struct;
        bool                                    executing_backlog;
        bool                                    tick_iteration_complete = true;
        std::uint32_t current_iteration;
        while (1)
        {
            executing_backlog = false;
            if (not this->scheduler_backlog.empty())
            {
                {
                    std::lock_guard<std::mutex> lck(this->mtx2);
                    current_iteration = this->scheduler_backlog.front();
                    this->scheduler_backlog.pop();
                }
                //executing_backlog = true;
            }
            if (not executing_backlog and tick_iteration_complete) {
                //tick_time = std::chrono::steady_clock::now();
                //std::this_thread::sleep_until(tick_time + std::chrono::milliseconds(1000));   //1 second delay
                tick_time = std::chrono::steady_clock::now();
                std::this_thread::sleep_until(std::chrono::steady_clock::now() + std::chrono::milliseconds(1000));  //1 second delay
                tick_iteration_complete = false;
                if (++tick_count > this->scan_rate_max)
                    tick_count = 1;
            }
            {
                std::lock_guard<std::mutex> lck(this->mtx1);
                if (not executing_backlog) 
                {
                    current_iteration = this->scheduler_iteration;
                    if (++this->scheduler_iteration >= this->scheduler_list.size())
                        this->scheduler_iteration = 0;
                }
                scheduling_struct = this->scheduler_list.at(current_iteration);
            }
            if (tick_count % scheduling_struct.scan_rate == 0)
            {
                //std::cout << "hello" << std::endl;
                if (this->_plac.find(scheduling_struct.ip) == this->_plac.end())
                {
                    std::string error = fmt::format("No recored found in map at location {}", scheduling_struct.ip);
#ifdef _DEBUG
                    spdlog::error(error);
#endif // _DEBUG
                    LOG_ERROR << error;
                    continue;
                }

                if (not this->client.at(this->_plac.at(scheduling_struct.ip).client_location).read_progress)
                {
                    const plac_common::config_struct config = this->_plac.at(scheduling_struct.ip).read_vector.at(scheduling_struct.config_serial_no);              
                    if (not this->read_data(scheduling_struct))
                    {
                        spdlog::error("read data failed");
                    }
                    continue;
                    //this->read_data(current_iteration, client_location, config.area_type, config.area_number, config.read_location, config.read_length, config.word_length);
                }
                else
                {
                    std::lock_guard<std::mutex> lck(this->mtx2);
                    this->scheduler_backlog.push(current_iteration);
                }
            }
            tick_iteration_complete = true;
        }
    }
    catch (const std::exception& ex) {
#ifdef _DEBUG
        spdlog::error("Exception in worker thread. Exception : {}", ex.what());
#endif // _DEBUG
        LOG_ERROR << ex.what();
    }
}

OS - Windows 10 64 bit Home

Visual Studio - 15.9.19

Database - PostgreSQL

Answer 1

I think it maybe that if (++tick_count > this->scan_rate_max) causes that problem. When ++tick_count , it leads to change tick_count from 1 to 2. So, tick_count in if (tick_count % scheduling_struct.scan_rate == 0) is bigger than expected. I suggest that you can try to change ++tick_count to tick_count++ .

if (not executing_backlog and tick_iteration_complete) {
                //tick_time = std::chrono::steady_clock::now();
                //std::this_thread::sleep_until(tick_time + std::chrono::milliseconds(1000));   //1 second delay
                tick_time = std::chrono::steady_clock::now();
                std::this_thread::sleep_until(std::chrono::steady_clock::now() + std::chrono::milliseconds(1000));  //1 second delay
                tick_iteration_complete = false;
                if (tick_count++ > this->scan_rate_max)
                    tick_count = 1;
            }