Библиотечная функция sleep() библиотека unistd.h

Вопрос для тех кто использовал функцию Sleep() - засыпание процесса.

Для работы активного процесса диспетчер процессов дает ему дискреты времени.
Меня интересует как процесс переходит в режим сна?
После использования своей дискреты или отдает неиспользованное время другому процессу.

Вопрос возник при подключении шагового привода к RaspberryPi. Максимальная частота переключений
фаз шагового двигателя 1 кГц. Без использования прерываний удалось с помощью двух независимых процессов
(один выставлял на порту 0, другой 1) получить сигнал с периодом 18 милисекунд. Хочу поднять до 1000 Герц.
В линукc реализована вытесняющая многозадачность, и переключением контекста ядерный планировщик. Величина квантования, насколько я помню, указывается при компиляции ядра. (Возможно, в какой-то момент я мог что-нибудь упустить и в современных ядрах это можно делать и через sysctl или как-то иначе. Сейчас сходу ничего такого не нашел, а врать не хочу). Поэтому никакой процесс не может по своей инициативе передать остатки времени другому.
То есть, все переключения кратны явно установленному кванту и не могут быть меньше.
Для более точного управления событиями кроме sleep() есть еще nanosleep() (определена в time.h)
удалось с помощью двух независимых процессов
Без синхронизации, что плоучилось?
В общем, есть цикл. В нем чередуются 0 и 1. Время подобрать с помощью тучи пустых команд ну или тупым mov из регистра в регистр мусора. Есть в ассемблерах такая (типа noop)
ivand
Без синхронизации, что получилось?
sleep(0) - Это не синхронизация а команда перехода процесса с активного состояния в режим ожидания до получения сигнала пробуждения
от другого процесса.
Время для работы процесса выделяемое диспетчером около 9 милисекунд для каждого процесса. А так как у нас работают два процесса по очереди
то получаем период 18 милисекунд. Мне нужен сигнал 1 милисекунда. Ограничение идет от тайминга процесса.
Отсюда и вопрос по работе команды sleep(0). Как диспетчер процессов ведет себя по получении сигнала от процесса.
1. Он сразу переключается на другой процесс.
2. Ждет пока закончится время выделенное для данного процесса и переводит его в режим ожидания.
В первом случае мы получим выиграш по частоте, а во втором результат должен остаться без изменений.
Хотел проверить это в железе не нашел описания по wakeup() - сигнал пробуждения от другого процесса.
kurych
Поэтому никакой процесс не может по своей инициативе передать остатки времени другому.
То есть, все переключения кратны явно установленному кванту и не могут быть меньше.
Для более точного управления событиями кроме sleep() есть еще nanosleep() (определена в time.h)

Он не передает своего времени другому, а по логике должен закончится раньше. Диспетчер процессов должен получить сообщение
от процесса и на это отреагировать.
Функции sleep i nanosleep - да это задержки по времени. Функция sleep(0) переводит процесс в ожидание сигнала активации (пробуждения)
от другого процесса функцией wakeup(name). Где - name имя процесса который необходимо активировать.
Я не буду спорить, так как достаточно давно ушел из цеха программистов. Но на основании своего прошлого опыта склонен считать, что налицо путаница с библиотечными интерфейсами, используемыми в Windows. В Linux sleep(0), похоже, просто игнорируется. А для взаимодействия между процессами используются совершенно иные механизмы.
А для освобождения процессора для других задач в linux используют функцию sched_yield() из "sched.h".
ps: Немножко погуглил, нашел это в подтверждение моих слов.
pps: если покопаться в документации (или просто сходить по ссылкам в топике, на который я выше сослался, то и в windows sleep(0) работает совсем не так, как вы это интерпретируете.
Тююю, вам предложил пустышку исполняющуюся за ОДЫН такт проца
Но, что та такое, что нет их в ARM-ах
Потому mov r1, r1 -- типа аналога, мож 2 такта
Реально смотрите nanosleep, может помочь
А синхронизация -- процессы при многозадачности НЕ ОБЯЗАНЫ чередоваться -- от - переполненные буферы и усе
К вашим реалтаймам nice еще
В сети есть UART на ассембле, гуглите
ivand
Тююю, вам предложил пустышку исполняющуюся за ОДЫН такт проца
Но, что та такое, что нет их в ARM-ах
Потому mov r1, r1 -- типа аналога, мож 2 такта
Реально смотрите nanosleep, может помочь
А синхронизация -- процессы при многозадачности НЕ ОБЯЗАНЫ чередоваться -- от - переполненные буферы и усе
К вашим реалтаймам nice еще
В сети есть UART на ассембле, гуглите

Сформировать импульсы в одном процессе я сам умею. У меня задача вияснить максимальную частоту переключений
между двумя процессами. Вот я и пробую это реализовать с помощью функции sleep().
У меня задача вияснить максимальную частоту переключений
между двумя процессами.
Ну, и это решается не слипом, а уж тем более не в порту
kurych вам сказал, где надо искать сискалльную функцию возвращающую значение кванта времени -- планировщик
Атомарных deadlock-ов вам
ivand
Ну, и это решается не слипом, а уж тем более не в порту
kurych вам сказал, где надо искать сискалльную функцию возвращающую значение кванта времени -- планировщик
Атомарных deadlock-ов вам

Причем здесь порт? Внимательно почитайте выше для чего используется порт.
У меня есть RaspberryPi и порт используется для того чтобы я на осцилографе смог увидеть
сколько работает процесс.
Мне не нужна функция которая возвращает значение кванта времени.

kurych
А для освобождения процессора для других задач в linux используют функцию sched_yield() из "sched.h".
ps: Немножко погуглил, нашел это в подтверждение моих слов.
pps: если покопаться в документации (или просто сходить по ссылкам в топике, на который я выше сослался, то и в windows sleep(0) работает совсем не так, как вы это интерпретируете.

Попробовал функцию sched_yield(). Фактически почти то что надо. Она мена не удовлетворила тем, что освобождает процессор после отработки всего кванта времени.
Похоже что sleep(0) игнорируется системой, или проблема в том что у меня два процесса и оба спят. Диспетчер делает их по очереди активными.
Почитал информацию по Вашей ссылке. Там не все так однозначно по функции sleep().

Использовал функцию sleep(1) в своих 2 программах. Запустил две программы. Получил результат: Первая функция работает 1 секунду, а вторая около 10 микросекунд.
Это при кванте времени диспетчера около 9 милисекунд. Это по моему свет в конце тунеля. Данный эксперимент показывает, что c помощью функции sllep() можно прервать работу процесса до окончания выделенного кванта времени диспетчером.

Если я с увиденного сделал не правильные выводы поправте меня.

Теперь хочу разбудить уснувший процесс с помощью функции wakeup(*<имя процесса>). Не знаю как получить ссылку на имя процесса.
Помогите!!!.
 
Зарегистрироваться или войдите чтобы оставить сообщение.