Linux Linux FIFO 예약 정책에서 처리 방법

Linux 프로세스를 실시간 FIFO 스케줄링으로 실행하려면 Sudo Chrt -F 99 ./App 또는 Configing Crogram에서 Sched_Fifo 및 우선 순위 매개 변수를 구성하는 동시에 CAP_SYSSYS 기능 또는 ROTCOSS를 통해 CAP_SYS _NICE 기능 및 SPOLLOCUS 및 SPOLLOCISS 및 SPOLLOCIONS 및 SPOLLOCIONS 및 SPORTORIONS 및 SPOLLOCIONS 및 SPORTIONS 및 SPORTION을 보장하는 Sudo Chrt -F 99 ./App 또는 Configing과 같은 Sudule 정책 및 우선 순위를 설정하려면 Chrt Command 또는 Sched_SetScheduler 시스템 호출을 사용해야합니다. Limits.conf 실수를 보장하고 우선 순위 반전을 피하려면 우선 순위 상속을 지원하는 뮤트를 사용해야합니다.

Linux Systems에서 프로세스를 실시간 모드로 실행하고 FIFO (First-Aut) 스케줄링 전략을 채택하기 위해 핵심은 특정 시스템 호출 또는 도구를 사용하여 프로세스의 스케줄링 속성을 변경하여 우선 순위가 높고 선불 (동일한 우선 순위) 실행 보증을 제공하는 것입니다. 이는 일반적으로 프로세스가 CPU 시간을 최대한 빨리 얻고 일단 실행되면 CPU를 적극적으로 포기하거나 우선 순위가 높은 실시간 프로세스에 의해 선점되지 않는 한 이동 중에 실행됩니다.

Linux에서 실시간 프로세스를 구현하고 FIFO 스케줄링 전략을 적용하려면 다음과 같은 방법으로 운영 할 수 있습니다.

해결책

가장 직접적인 방법은 사용하는 것입니다

 Chrt

프로그램에서 명령 또는 사용

 sched_setscheduler

시스템 호출.

1. Chrt 사용 명령 (명령 줄 도구)

    Chrt

   이 명령을 사용하면 실행중인 프로세스의 실시간 스케줄링 속성을 쿼리하거나 수정하거나 특정 스케줄링 정책 및 우선 순위로 새 프로그램을 시작할 수 있습니다.

   • FIFO 실시간 스케줄링을위한 새로운 프로세스를 설정하십시오.

      sudo chrt -f 99 ./my_realtime_app

     여기,

      -에프

     지정된 FIFO 예약 정책 (

      Sched_fifo

     ),)

      99

     우선 순위입니다 (범위는 일반적으로 1-99, 99가 가장 높음).

      ./my_realtime_app

     실행하려는 실시간 응용 프로그램입니다.

   • 실행 프로세스의 일정 정책과 우선 순위를 수정하십시오. 첫째, 프로세스의 PID를 알아야합니다.

      Sudo chrt -f -p 99 <Pid>

     이는 지정된 PID로 프로세스를 FIFO 정책으로 99의 우선 순위로 설정합니다.

   • 프로세스 예약 정보 확인 :

      chrt -p <pid>

     또는에 의해

      PS -EO PID, CLS, RTPRIO, COMM

     볼 명령.

      CLS

     스케줄링 카테고리가 표시됩니다 (예 :

      TS

     대표하다

      일정 _other

     ,,,

      FF

     대표하다

      Sched_fifo

     ).

2. C/C 프로그램에서 sched_setscheduler를 사용하십시오 시스템 호출

   보다 세분화 된 제어가 필요한 응용 프로그램의 경우 코드에 직접 설정하는 것이 더 일반적인 관행입니다.

    #include <stdio.h>
   #include <stdlib.h>
   #include <sched.h>
   #include <unistd.h>
   #include <sys/type.h>
   
   int main () {
       struct sched_param param;
       int max_prio, min_prio;
   
       // sched_fifo max_prio = sched_get_priority_max (sched_fifo)의 최대 및 최소 우선 순위를 얻습니다.
       min_prio = sched_get_priority_min (sched_fifo);
   
       if (max_prio == -1 || min_prio == -1) {
           Perror ( "우선 순위 범위를 얻는 오류");
           반환 1;
       }
   
       printf ( "sched_fifo 우선 순위 범위 : %d ~ %d \ n", min_prio, max_prio);
   
       // 우선 순위를 설정하면 일반적으로 더 높은 값을 선택하지만 조심해야합니다. // 예를 들어, 최대 우선 순위 뺀 10으로 설정하십시오
   
       // 현재 프로세스를 sched_fifo 스케줄링 정책으로 설정하려고 시도합니다. if (sched_setscheduler (0, sched_fifo, & param) == -1) {
           Perror ( "오류 설정 스케줄러 정책");
           // 불충분 한 권한은 일반적으로 실패의 이유이며, 루트 권한 또는 cap_sys_nice 기능이 필요한 경우 (errno == eperm) {
               fprintf (stderr, "허가 거부. Sudo 또는 Check 기능으로 실행해보십시오. \ n");
           }
           반환 1;
       }
   
       printf ( "우선 순위 %d. \ n", param.sched_priority가있는 sched_fifo로 설정된 프로세스);
   
       // 실시간 작업을 시뮬레이션합니다. 긴 카운터 = 0;
       (1) {
           카운터;
           // 실시간 작업 논리를 여기에 배치 할 수 있습니다. // 무한 루프를 피하고 CPU를 포기하지 않으면 시스템의 다른 부분이 실제 애플리케이션에서 반응이 없을 수 있습니다. // 실제 응용 프로그램에서 // Sched_Yield ()가 포함되거나 이벤트가 포함되거나 (Coun
               // sched_yield (); // 우선 순위가 동일하거나 낮은 프로세스가 실행할 가능성이 있도록 CPU를 적절하게 포기하십시오}
       }
   
       반환 0;
   }

   컴파일 및 실행 :

    gcc -o realtime_app realtime_app.c
   sudo ./realtime_app

   실시간 프로세스를 실행하려면 일반적으로 필요합니다

    뿌리

   권한 또는 프로세스가 소유합니다

    CAP_SYS_NICE

   능력.

Linux 실시간 프로세스 스케줄링에서 Sched_Fifo와 Sched_RR의 차이점은 무엇입니까?

Linux의 실시간 일정에 대해 이야기 할 때

 Sched_fifo

(첫 번째, 첫 번째) 및

 스케줄 _rr

(라운드 로빈)은 항상 비교됩니다. 내 경험상, 그들은 모두 실시간 일정 범주에 속하며 평범한 것보다 우선 순위가 높습니다.

 일정 _other

(또한 호출

 Sched_normal

또는

 일정 _ts

) 프로세스이지만 행동에는 주요 차이가있어 실시간 시스템을 설계하기 위해 선택한 방법에 직접적인 영향을 미칩니다.

 Sched_fifo

, 이름에서 알 수 있듯이, "첫 번째, 먼저"입니다. 한 번

 Sched_fifo

프로세스는 스케줄러에 의해 선택되어 실행을 시작하며 CPU를 적극적으로 포기할 때까지 계속 실행됩니다 (예 :

 sched_yield ()

또는 I/O, Semaphore, Mutex 등을 기다리거나 우선 순위가 높은 실시간 프로세스로 선점됩니다. 이것은 우선 순위가 높다는 것을 의미합니다

 Sched_fifo

작업은 CPU를 적극적으로 포기하지 않고 컴퓨팅 집약적 인 루프에 들어갑니다. CPU는 오랫동안 CPU를 "점유"할 수 있으며 동일한 우선 순위 또는 우선 순위가 낮은 실시간 작업에 대한 장기 실패로 이어질 수 있습니다. 이 동작은 특정 신호 처리, 데이터 수집 또는 제어 루프와 같은 엄격한 시간 요구 사항을 충족시키기 위해 연속적이고 중단되지 않은 실행이 필요한 작업에 유용합니다. 나는 개인적으로 일부 임베디드 시스템 또는 산업 제어 응용 프로그램에서 작업합니다. 작업이 주기적 작업을 독점적으로 완료해야한다고 결정하면

 Sched_fifo

그것은 나의 첫 번째 선택입니다.

그리고

 스케줄 _rr

즉, "시간 조각 회전"입니다

 Sched_fifo

이를 바탕으로 타임 슬라이스가 추가됩니다. 언제 a

 스케줄 _rr

프로세스가 실행 될 예정인 경우 지정된 시간 슬라이스 내에 실행됩니다. 타임 슬라이스가 소비 된 후에, CPU를 적극적으로 포기하지 않더라도 스케줄러가 일시 중지하고 다른 우선 순위의 다른 사람을 허용합니다.

 스케줄 _rr

프로세스는 실행할 기회가 있습니다. 이것은 각 프로세스가 CPU 시간을 얻기 위해 교대가 걸리는 루프 대기열과 같습니다. 이 전략은 동등한 우선 순위의 여러 실시간 작업이 존재할 때 CPU 자원에 공정한 액세스 권한을 가지고 있으며, 작업이 오랫동안 CPU를 독점적으로 소유하는 상황을 피합니다. 여러 실시간 작업이있는 경우 모두 빠르게 응답해야하지만 오랫동안 서로를 차단할 수는 없습니다.

 스케줄 _rr

일반적으로 더 나은 선택입니다. 예를 들어, 여러 센서 데이터를 동시에 처리하고 해당 제어 로직을 실행 해야하는 시스템,

 스케줄 _rr

모든 센서 처리 작업이 적시에 처리 될 수 있도록 할 수 있습니다.

요컨대,

 Sched_fifo

우리가 추구하는 것은 "우리가 시작되면 방해하지 말아라"는 것입니다. 이는 지속적인 실행에 대한 강한 요구가 강하고 작업 자체가 CPU 사용을 합리적으로 관리 할 수있는 시나리오에 적합합니다. 그리고

 스케줄 _rr

우리가 추구하는 것은 "모든 사람이 동등한 우선 순위에 따라 교대로 차례 차례 차례 대다"입니다. 선택해야 할 것은 주로 작업에 대한 실시간 요구 사항, 작업 간의 종속성 및 CPU 리소스에 대한 사용 패턴에 달려 있습니다.

중요한 응용 프로그램에 대한 Linux FIFO 실시간 스케줄링을 안전하게 구성하는 방법은 무엇입니까?

주요 응용 프로그램에 대한 Linux FIFO 실시간 스케줄링 구성은 간단하게 들리지만 실제 작동에서는주의를 기울이지 않으면 새로운 문제를 도입하고 시스템 불안정성을 초래할 수 있습니다. 나는 보통 이것이 우선 순위를 설정하는 것이 아니라 시스템 리소스의 할당, 권한 관리 및 잠재적 위험을 피하는 것임을 강조합니다.

우선, 권한 관리는 초석입니다 . 기본적으로 비

 뿌리

사용자는 실시간 예약 정책 및 우선 순위를 설정할 수 없습니다. 직접 시도하면 만나게됩니다

 eperm

실수. 일반적으로 두 가지 솔루션이 있습니다. 하나는 직접적입니다

 뿌리

사용자는 응용 프로그램을 실행합니다 (그러나 일반적으로 권장되지 않습니다.

 뿌리

권한이 너무 크고 보안 위험이 있습니다). 두 번째는 응용 프로그램 또는 사용자에게 특정 기능을 제공하는 것입니다.

 CAP_SYS_NICE

프로세스가 자신의 우선 순위를 수정하고 정책을 예약 할 수있는 기능. 당신은 통과 할 수 있습니다

 세트 캡

실행 파일 에이 기능을 제공하도록 명령 :

 sudo setcap cap_sys_nice ep/path/to/your/realtime_app

이렇게하면 응용 프로그램이 될 수 있습니다

 뿌리

실시간 스케줄링은 사용자로 설정됩니다. 그러나 남용을 기억하십시오

 CAP_SYS_NICE

프로세스가 전체 시스템 스케줄링 동작에 영향을 줄 수있는 전력을 제공하기 때문에 마찬가지로 위험합니다.

둘째, 자원 제약 (

ULIMIT

)이 중요합니다 . Linux 시스템이 통과합니다

 ulimit

실시간 우선 순위 및 메모리 잠금을 포함하여 사용자 프로세스의 리소스 사용량을 제한하십시오. 실시간 프로세스를 안정적으로 실행하려면 필요한 메모리를 잠그고 스와핑을 방지 할 수 있는지 확인해야합니다. 이는 실시간 작업에 치명적입니다. 수정해야합니다

 /etc/security/limits.conf

다음 줄을 파일, 추가 또는 수정하십시오.

 @your_group 하드 rtprio 99
@your_group 소프트 rtprio 99
@your_group 하드 멤버 무제한
@your_group 소프트 멤버 무제한

할 것이다

 your_group

사용자 그룹으로 교체하고

 99

허용되는 최대 실시간 우선 순위입니다.

 Memlock Unlimited

프로세스가 모든 메모리를 잠글 수 있습니다. 수정 후 사용자는 다시 로그인하여 설정을 적용하도록해야합니다.

또한 우선 순위를 신중하게 선택하십시오 . 하지만

 Sched_fifo

우선 순위 범위는 일반적으로 1-99이지만 항상 가장 높은 우선 순위 99를 사용할 필요는 없습니다. 과도한 우선 순위로 인해 시스템의 다른 중요한 프로세스 (예 : 네트워크 서비스, 로깅 및 쉘 자체)가 CPU 시간을 잃어 시스템을 반응하지 않게 만듭니다. 저의 조언은 실시간 요구에 충분한 우선 순위가 낮은 우선 순위로 테스트를 시작한 다음 최적의 성능이 달성 될 때까지 점차 개선하는 것입니다. 동시에 우선 순위 역전 문제에주의하십시오.이 문제는 실시간 시스템에서 고전적인 문제입니다.

 Sched_fifo

완전히 피할 수는 없습니다. 우선 순위가 높은 실시간 작업이 우선 순위가 낮은 작업 (예 : MUTEX)이 보유한 리소스를 기다려야하는 경우 우선 순위가 낮은 작업이 자원을 방출 할 때까지 우선 순위가 높은 작업이 차단됩니다. 이것은 실시간을 파괴 할 것입니다. 솔루션은 일반적으로 우선 순위 상속 또는 우선 순위 상한을 지원하는 뮤텍스를 사용하는 것입니다 (예 :

 pthread_mutex_t

맞잡다

 pthread_prio_inherit

재산).

마지막으로 모니터링 및 테스트는 필수 불가결합니다 . 구성이 완료되면 엄격한 스트레스 테스트 및 실시간 검증을 수행하십시오. 사용

 대기 시간

,,,

 ftrace

또는 실시간 작업의 지연과 지터를 측정하기위한 사용자 정의 타이밍 도구. 다른 비실한 작업이 여전히 제대로 작동하는지 확인하기 위해 무거운 하중에서 시스템의 동작을 관찰하십시오. 잘못 구성된 실시간 프로세스는 시스템을 신뢰할 수있는 워크 스테이션에서 "벽돌"으로 바꿀 수 있습니다. 안전한 구성의 핵심은 그 영향을 이해하고 여러 예방 조치를 취하는 것입니다.

Linux 커널은 실시간 프로세스의 우선 순위 반전 문제를 어떻게 관리합니까?

우선 순위 반전은 우리가 사용하더라도 실시간 시스템에서 악명 높은 퍼즐입니다.

 Sched_fifo

이러한 강력한 실시간 예약 전략은 실시간 보증을 조용히 파괴 할 수 있습니다. 간단히 말해서, 우선 순위 반전은 우선 순위가 높은 작업 (h)이 우선 순위가 낮은 작업 (L)에 의해 보유 된 공유 리소스 (예 : 뮤텍스)에 대한 액세스가 필요할 때 발생합니다. 이 시점에서 H 작업은 L 작업이 리소스를 해제 할 때까지 기다려야합니다. 리소스를 유지하는 동안 중간 우선 순위 작업 (M)에 의해 L 작업이 선점되는 경우, H 작업은 L 작업이 완료 될 때까지 기다려야하며 L 작업은 M 작업에 의해 차단됩니다. 결과적으로, 높은 우선 순위 H 작업은 실제로 중간 우선 순위 M 작업에 의해 간접적으로 차단되며, 이는 H 과제에 우선 순위가 높은 원래 의도와 완전히 상반됩니다.

Linux 커널은 주로 두 가지 메커니즘을 사용하여 우선 순위 반전 문제를 완화하거나 해결합니다 : 우선 순위 상속 및 우선 순위 상한 .

우선 상속 (PI) 은 Linux 커널에서 가장 일반적으로 사용되는 솔루션입니다.

 futex

(빠른 사용자 공간 mutex) 및

 RT_MUTEX

(실시간 MUTEX)가 구현되고 있습니다. 우선 순위가 높은 작업 H가 우선 순위가 낮은 작업 L에 의해 유지되는 Mutex Lock을 획득하려고 시도하고 L 작업의 우선 순위가 H 작업보다 낮 으면 커널은 L 작업의 우선 순위를 H 작업의 우선 순위로 일시적으로 제기합니다. 이런 식으로 L 작업은 H 작업의 우선 순위 수준에서 실행되고 가능한 빨리 공유 리소스에 대한 액세스를 완료하고 MUTEX를 해제 할 수 있습니다. L 작업이 뮤트를 풀면 우선 순위가 원래 값으로 복원됩니다. 이 메커니즘은 중요한 리소스를 보유한 작업이 우선 순위가 낮은 작업에 의해 선점되지 않도록하여 우선 순위 반전을 피합니다. 존재하다

 pthread

라이브러리에서 Mutex의 속성을 설정할 수 있습니다.

 pthread_prio_inherit

우선 순위 상속을 가능하게하려면 :

 #include <pthread.h>
// ...
pthread_mutexattr_tmutex_attr;
pthread_mutexattr_init (& mutex_attr);
pthread_mutexattr_setprotocol (& mutex_attr, pthread_prio_inherit);
pthread_mutex_init (& my_mutex, & mutex_attr);
// ...

이것은 공유 리소스가 필요한 실시간 응용 프로그램을 설계 할 때 거의 확실하게 고려하고 사용하는 기능입니다.

PCP (Priority Cleiling Protocol)는 우선 순위 반전의 또 다른 솔루션입니다. Linux 커널의 일반적인 Mutex 구현에서 우선 순위 상속만큼 일반적이지는 않지만 특정 특정 실시간 운영 체제 또는 RTO에 적용됩니다. PCP는 각 공유 리소스 (또는 해당 리소스를 보호하는 Mutex)가 "우선 순위 상한"을 할당해야하며, 이는 일반적으로 리소스에 액세스 할 수있는 모든 작업에서 가장 높은 우선 순위 값입니다. 작업이 뮤트를 획득하면 뮤텍스의 우선 순위 한계까지 우선 순위가 즉시 제기됩니다. 이러한 방식으로,이 작업을 상한선 미만으로 선점하려는 작업은 성공할 수 없으므로 우선 순위 반전을 피할 수 있습니다. 우선 순위 상속과 달리, PCP는 높은 우선 순위 작업이 차단 될 때까지 대기하지 않고 작업이 잠금을 획득 할 때 우선 순위를 높입니다. 이는 잠재적 인 캐스케이드 차단 문제를 피할 수 있지만 불필요한 우선 순위 개선으로 이어질 수 있습니다.

실제 Linux 실시간 프로그래밍에서 우리는 주로 제공된 커널에 의존합니다.

 futex

그리고

 RT_MUTEX

메커니즘, 이러한 메커니즘은 바닥에서 우선 순위 상속을 구현합니다. 이러한 메커니즘이 어떻게 작동하는지 이해하고 응용 프로그램에서 우선 순위 상속을 지원하는 동기화 프리미티브를 올바르게 사용하십시오 (예 :

 pthread_mutex_t

그리고

 pthread_prio_inherit

)는 강력하고 안정적인 Linux 실시간 시스템을 구축하는 열쇠입니다. 우선 순위 반전이 무시되는 경우, 일정 전략과 우선 순위를 신중하게 설계하더라도 실시간 작업은 예상치 못한 지연을 경험할 수 있습니다.

위 내용은 Linux Linux FIFO 예약 정책에서 처리 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!