Soru

Uzun bir süre boyunca her saniye tam olarak bir UNIX komutu çalıştırabilmek istiyorum .

Komutun yürütülmesi için ihtiyaç duyduğu süre nedeniyle belirli bir süre sonra geride kalmayan bir çözüme ihtiyacım var. uyku , izle ve belirli bir python betiği bu konuda başarısız oldu.

Http://Arduino.cc gibi mikrodenetleyicilerin üzerinde bunu donanım saatinde keserdim . Benzer bir zaman hassas kabuk betiği çözümü olup olmadığını bilmek istiyorum. StackExchange.com'da bulduğum tüm çözümler, eğer saatler içinde çalıştırılırsa gözle görülür bir gecikmeye neden oldu. Aşağıdaki ayrıntılara bakınız.

Pratik amaç / uygulama

ncHer 1 saniyede bir (netcat) üzerinden zaman damgası göndererek ağ bağlantımın sürekli kurulup kurulmadığını test etmek istiyorum .

Gönderen:

precise-timestamp-generator | tee netcat-sender.txt | nc $receiver $port

Alıcı:

nc -l -p $port > netcat-receiver.txt

Tamamlandıktan sonra iki kütüğü karşılaştırın:

diff netcat-sender.txt netcat-receiver.txt

Farklılıklar, aktarılmamış zaman damgaları olacaktır. Bundan ne zaman LAN / WAN / ISS'imin ne zaman sorun çıkardığını bilirim.

Çözüm SLEEP

while [ true ]; do date "+%Y-%m-%d %H:%M:%S" ; sleep 1; done | tee timelog-sleep.txt

Döngü içindeki komut da biraz zaman aldığından, zamanla belirli bir kayma alır.

Hassas

cat timelog-sleep.txt

2012-07-16 00:45:16
[...]
2012-07-16 10:20:36

Geçen Saniye: 34520

wc -l timelog-sleep.txt

Dosyadaki satırlar: 34243

Kesin özet:

• 34520-34243 = 277 zamanlama sorunları
• 34520/34243 = 1.008 =% 0.8 indirim

Çözüm REPEAT PYTHON

Bulunan: Sonsuza dek her x saniyede bir Unix komutunu tekrarla

repeat.py 1 "date '+%Y-%m-%d %H:%M:%S'" >> timelog-repeat-py.txt

Zaman ofsetinden kaçınması gerekiyor, ancak bunu yapmıyor.

Hassas

wc -l timelog-repeat-py.txt

2012-07-16 13:42:44
[...]
2012-07-16 16:45:24

Geçen saniye: 10960

wc -l timelog-repeat-py.txt

Dosyadaki satırlar: 10859

Kesin özet:

• 10960-10859 = 101 zamanlama sorunları
• 10960/10859 = 1.009 =% 0.9 indirim

Çözüm İZLE

watch -n 1 "date '+%Y-%m-%d %H:%M:%S' >> ~/Desktop/timelog-watch.txt"

Hassas

wc -l timelog-watch.txt
2012-07-16 11:04:08
[...]
2012-07-16 13:25:47

Geçen saniye: 8499

wc -l timelog-watch.txt

Dosyadaki satırlar: 8366

Kesin özet:

• 8499-8366 = 133 zamanlama problemi.
• 8499/8366 = 1.016 =% 1.6 indirim.

Yeni çırptığım bu Perl betiği nasıl çalışıyor?

#!/usr/bin/perl

use strict;
use warnings;
use Time::HiRes qw/time sleep/;

sub launch {
    return if fork;
    exec @_;
    die "Couldn't exec";
}

$SIG{CHLD} = 'IGNORE';

my $interval = shift;
my $start = time();
while (1) {
    launch(@ARGV);
    $start += $interval;
    sleep $start - time();
}

kullanın: perl timer.pl 1 date '+%Y-%m-%d %H:%M:%S'

Tek bir atlama olmadan 45 dakika sürüyor ve a) sistem yükü çok yüksek olmadıkça çatalın () bir saniyeden daha uzun sürdüğü veya b) artık saniye takılı olmadıkça devam edeceğinden şüpheleniyorum.

Bununla birlikte, bazı ek yükler olduğu için komutun tam saniye aralıklarla çalıştığını garanti edemez, ancak kesinti tabanlı bir çözümden çok daha kötü olduğundan şüpheliyim.

Yaklaşık bir saat date +%N(nanosaniye, GNU eklentisi) ile koştum ve üzerine bazı istatistikler koştum. En fazla gecikme 1 155 mikrosaniye idi. Ortalama (aritmetik ortalama) 216 µs, ortanca 219 µs, standart sapma 42 µs. Zamanın% 95'i 270 µs'den daha hızlı çalıştı. Bir C programı dışında onu yenebileceğini sanmıyorum.

POSIX ualarm()işlevi çekirdeği, işleminizi periyodik olarak mikrosaniye hassasiyetinde sinyal vermek üzere programlamanızı sağlar.

Basit bir program hazırlayın:

 #include<unistd.h>
 #include<signal.h>
 void tick(int sig){
     write(1, "\n", 1);
 }
 int main(){
     signal(SIGALRM, tick);
     ualarm(1000000, 1000000); //alarm in a second, and every second after that.
     for(;;)
         pause();
 }

derleme

 gcc -O2 tick.c -o tick

Ardından, periyodik olarak yapmanız gerekenlere, aşağıdaki gibi ekleyin:

./tick | while read x; do
    date "+%Y-%m-%d %H:%M:%S"
done | tee timelog-sleep.txt

watchParametre denediniz --precisemi?

watch -n 1 --precise "date '+%Y-%m-%d %H:%M:%S.%N' >> ~/Desktop/timelog-watch.txt"

Man sayfasından:

Normalde, bu aralık bir komut çalıştırmasının tamamlanması ile bir sonraki çalıştırmanın başlangıcı arasındaki zaman aralığı olarak yorumlanır. Ancak, -p veya --precise seçeneğiyle, her aralık saniyede bir komutu çalıştırma denemesi yapabilirsiniz. Ntptime ile deneyin ve kesirli saniyelerin, sürekli arttıkları normal modun aksine nasıl aynı (neredeyse) aynı kaldığını görün.

Yine de, parametre sisteminizde bulunmayabilir.

Ayrıca, programınızın yürütülmesi bir saniyeden daha uzun sürerse ne olacağını da düşünmelisiniz. Bir sonraki zamanlanmış çalıştırma atlanmalı mı, yoksa geç çalıştırılmalı mı?

Güncelleme : Senaryoyu bir süre çalıştırdım ve tek bir adım atmadı:

2561 lines
start: 2012-07-17 09:46:34.938805108
end:   2012-07-17 10:29:14.938547796

Güncelleme:--precise bayrak bir Debian ektir, yama ancak oldukça basittir: http://patch-tracker.debian.org/patch/series/view/procps/1:3.2.8-9squeeze1/watch_precision_time.patch

crontab1 dakikalık çözünürlüğe sahiptir. Bu dakika başına biriktirme ve ardından bir sonraki dakikaya sıfırlama gecikmesi konusunda sorun yoksa, bu temel fikir işe yarayabilir:

* * * * * for second in $(seq 0 59); do /path/to/script.sh & sleep 1s;done

Not script.shayrıca arka planda çalışır. Bu, döngünün her yinelemesiyle biriken gecikmeyi en aza indirmeye yardımcı olmalıdır.

sleepAncak, ne kadar gecikmenin ortaya çıktığına bağlı olarak , ikinci 59'un bir sonraki dakikadaki ikinci 0 ile üst üste gelme olasılığı vardır.

EDIT bazı sonuçlarda, soruda olduğu gibi aynı şekilde atılır:

$ cat timelog-cron
2012-07-16 20:51:01
...
2012-07-16 22:43:00

1 saat 52 dakika = 6720 saniye

$ wc -l timelog-cron
6720 timelog-cron

0 zamanlama problemi,% 0 indirim. Herhangi bir zaman birikimi her dakika sıfırlanır.

Sorununuz, en son uyuduğunuzdan bu yana geçen süreyi dikkate almadan, programınızı çalıştırdıktan sonra belirli bir süre boyunca uyumanızdır.

Bunu bash veya başka bir programlama dili yapabilirsiniz, ancak anahtar sonraki uykuyu ne kadar zamanlayacağınızı belirlemek için saati kullanmaktır. Uyumadan önce, saati kontrol edin, ne kadar zamanınız kaldığını görün ve farkı uyuyun.

Süreç zamanlama riskleri nedeniyle, saatin sağ tarafında uyanmak için garanti edilmez, ancak oldukça yakın olmanız gerekir (boşaltılmamış birkaç ms içinde veya yük altında birkaç yüz ms içinde). Ve zamanla hata biriktirmezsiniz çünkü her uyku döngüsünde her seferinde yeniden senkronize olur ve biriken hataları giderirsiniz.

Saat tam olarak tıklatmanız gerekiyorsa, aradığınız şey tam olarak bu amaç için tasarlanmış gerçek zamanlı bir işletim sistemidir .

Her zaman sadece tam olarak aralıklarla bir şeylerin çalışmasından vazgeçtim . Bir C programı yazmanız gerekecek ve 1 saniyelik aralığın bir kısmını kendi kodunuzla aşmamaya özen gösterin. Muhtemelen bunun işe yaraması için iş parçacığı veya çoklu, iletişim kurma süreçlerini kullanmanız gerekecektir. Diş açma veya işlem başlatma süresinin ek yükünden kaçının.

İlgili gibi görünen bir referans 1993'e dayanmaktadır: CPU Kullanımı Tahmini ve Kod Profillemesi için Rastgele Örnekleme Saati Zaman aralıklarını nasıl doğru bir şekilde ölçtüklerini ve “uyanma” larını görmek için "İstenmeyen Kaynak Kodu" ekine göz atmak istersiniz. programlarını sadece doğru zamanda. Kod 19 yaşında olduğundan muhtemelen doğrudan veya kolay şekilde taşınmaz, ancak okuyup anlamaya çalışırsanız, ilgili ilkeler kodunuzu yönlendirebilir.

EDIT: Yardımcı olabilecek başka bir referans buldum: Saat Çözünürlüğünün, herhangi bir teorik arka planda size yardımcı olması gereken Etkileşimli ve Yumuşak Gerçek Zamanlı Süreçlerin Zamanlaması Üzerindeki Etkileri .

Nanosleep () 'e bakınız ( http://linux.about.com/library/cmd/blcmdl2_nanosleep.htm adresinden ). Programınızı 1 saniye uykuda bırakmak yerine, uyku moduna geçirin (1 - çalışması gereken miktar). Daha iyi bir çözünürlük elde edersiniz.

Komutunuzu arka planda çalıştırmayı deneyin, böylece döngü zamanlamasını çok fazla etkilemez, ancak uzun bir süre boyunca herhangi bir birikim istemiyorsanız bile yeterli olmaz, çünkü bununla ilişkili birkaç milisaniye maliyeti vardır.

Yani, bu muhtemelen daha iyi, ama yine de muhtemelen yeterince iyi değil:

while [ true ]; do date "+%Y-%m-%d %H:%M:%S" & sleep 1; done | 
tee timelog-sleep.txt

Bilgisayarımda bu 20 dakikada 2 veya dakikada 0,1 hata verdi, bu da koşunuzda kabaca beş kat daha düzelme oldu.

Çirkin ama işe yarıyor. Böyle bir döngüye ihtiyacınız varsa, muhtemelen programınızın tasarımını yeniden düşünmelisiniz. Temel olarak, mevcut saniyenin önceki kontrol edilene eşit olup olmadığını kontrol eder ve saniyenin değişmesinden bu yana nanosaniye sayısını yazdırır. Doğruluk uykudan etkilenir .001.

while true; do T=$( date +%s ); while [[ $T -eq $( date +%s ) ]]; do sleep .001; done; date "+%N nanoseconds late"; done

Doğruluk, 'yükün' date "+%N nanoseconds late"sadece bir saniyeden daha uzun sürmemesi şartıyla milisaniyededir . Uyku süresini artırarak veya gerçekten uyku komutunu değiştirmenin sakıncası yoksa CPU yükünü azaltabilirsiniz true.

002112890 nanoseconds late
001847692 nanoseconds late
002273652 nanoseconds late
001317015 nanoseconds late
001650504 nanoseconds late
002180949 nanoseconds late
002338716 nanoseconds late
002064578 nanoseconds late
002160883 nanoseconds late

Bu kötü bir uygulamadır çünkü temel olarak size bir olay için CPU anketi yaparsınız ve CPU çevrimlerini boşa harcarsınız. Muhtemelen bir zamanlayıcı kesmesine (bash'tan mümkün değildir) takmak veya bir mikrodenetleyici gibi özel donanım kullanmak istiyorsunuz. Bir PC ve işletim sistemi yüksek zamanlama doğruluğu için tasarlanmamıştır.

Başka bir yöntem, bir döngü içinde bir askıya alma kullanmak ve kesin bir harici programdan SIGCONT göndermek olacaktır. Bir sinyal göndermek çok hafiftir ve bir şeyi yapmaktan çok daha az gecikme süresi olacaktır. Ayrıca "at" komutuyla bir grup komuttan önce sıraya girebilirsin, artık hiç kimsede kullanmaz "de" artık ne kadar kesin olduğundan emin değilim.

Eğer hassasiyet kritik öneme sahipse ve bu konuda ciddi olmak istiyorsanız, bu, RT-Preempt yamalı çekirdeği ile Linux altında yapılabilecek RTOS'u kullanacağınız uygulama türüne benziyor. kontrolü kesintiye uğrat, ancak değdiğinden daha fazla rahatsız edici olabilir.

https://rt.wiki.kernel.org/index.php/RT_PREEMPT_HOWTO

Xenomai de yardımcı olabilir, bu tam bir RTOS uygulamasıdır ve x86 ve x86_64 için taşınır, ancak bazı programlamalar vardır.

http://www.xenomai.org/index.php/Main_Page

İle ksh93(kayan nokta $SECONDSve bir yerleşik olan sleep)

typeset -F SECONDS=0
typeset -i i=0
while true; do
   cmd
   sleep "$((++i - SECONDS))"
done

Aynı komut dosyası da aynı şekilde çalışır, zshancak sisteminizin sleepkomutunu çağırır . yerleşik zshbir zselectyapıya sahiptir, ancak yalnızca 1/100 çözünürlüğe sahiptir.

Küçük bir C programı ile giderdim:

#include <sys/time.h>
#include <unistd.h>

int main(int argc, char **argv, char **envp)
{
    struct timeval start;
    int rc = gettimeofday(&start, NULL);
    if(rc != 0)
            return 1;

    for(;;)
    {
        struct timeval now;
        rc = gettimeofday(&now, NULL);
        useconds_t delay;
        if(now.tv_usec < start.tv_usec)
            delay = start.tv_usec - now.tv_usec;
        else
            delay = 1000000 - now.tv_usec + start.tv_usec;
        usleep(delay);
        pid_t pid = fork();
        if(pid == -1)
            return 1;
        if(pid == 0)
            _exit(execve(argv[1], &argv[1], envp));
    }
}

Bu program, programın ilk argüman olarak tam yolla çağırmasını bekler ve kalan tüm argümanları iletir. Komutun bitmesini beklemeyecek, bu yüzden mutlu bir şekilde birden çok örneği başlatacak.

Ayrıca, buradaki kodlama stili gerçekten özensizdir ve uygulanabilir standartlar tarafından garanti edilebilecek veya garanti edilemeyecek bir takım varsayımlar yapılmıştır, yani bu kodun kalitesi "benim için işe yarar" dır.

Bu program, saat NTP veya manuel olarak ayarlanarak ayarlandığında biraz daha uzun veya daha kısa aralıklarla olur. Programın bunu ele alması gerekiyorsa, POSIX timer_create(CLOCK_MONOTONIC, ...)bundan etkilenmeyen olanı sağlar .

Geçerli saati takip etmeli ve başlangıç ​​zamanı ile karşılaştırmalısınız. Bu nedenle, her bir yinelemede sabit bir miktar değil, hesaplanan bir süre uyudunuz. Bu şekilde zamanlama hatalarını biriktirmez ve olması gereken yerden uzağa kaymazsınız, çünkü zamanlamalarınızı her döngüden baştan itibaren mutlak süreye sıfırlarsınız.

Ayrıca, bazı uyku fonksiyonları bir kesinti olursa erken döndüğünden, bu durumda, tam zaman geçene kadar uyku yönteminizi tekrar çağırmanız gerekecektir.

İşte bir bash betiği ve son derece hassas olanı. Mikrosaniye hassasiyet için uykuda kullanır.

http://wiki.junkemailfilter.com/index.php/How_to_run_a_Linux_script_every_few_seconds_under_cron

Orada 3 tane senaryo var. En alttaki birine bak. Makul bir hassasiyetle dakikada yaklaşık 2400 infaz gerçekleştirir. Ve bu gerçekten basit.

Bu, saniyede en az 100 defa çok kesin çözünürlükte çalışabilir.

Dakikadaki döngü sayısı dizininin varlığı programı yaratır. Bu sürüm, bilgisayarınızın başa çıkabileceğini varsayarak mikrosaniye çözünürlüğünü destekler. Dakikada infaz sayısı 60 ile eşit şekilde bölünmek zorunda değildir ve 60 ile sınırlı değildir, bunu 6000'e kadar test ettim ve çalışır.

Bu sürüm /etc/init.d dizinine kurulabilir ve bir servis olarak çalıştırılabilir.

#! /bin/sh

# chkconfig: 2345 91 61
# description: This program is used to run all programs in a directory in parallel every X times per minute. \
#              Think of this program as cron with microseconds resolution.

# Microsecond Cron
# Usage: cron-ms start
# Copyright 2014 by Marc Perkel
# docs at http://wiki.junkemailfilter.com/index.php/How_to_run_a_Linux_script_every_few_seconds_under_cron"
# Free to use with attribution

# The scheduling is done by creating directories with the number of"
# executions per minute as part of the directory name."

# Examples:
#   /etc/cron-ms/7      # Executes everything in that directory  7 times a minute
#   /etc/cron-ms/30     # Executes everything in that directory 30 times a minute
#   /etc/cron-ms/600    # Executes everything in that directory 10 times a second
#   /etc/cron-ms/2400   # Executes everything in that directory 40 times a second

basedir=/etc/cron-ms

case "$1" in

   start|restart|reload)
   $0 stop
   mkdir -p /var/run/cron-ms
   for dir in $basedir/* ; do
      $0 ${dir##*/} &
   done
   exit
   ;;

   stop)
   rm -Rf /var/run/cron-ms
   exit
   ;;

esac

# Loops per minute is passed on the command line

loops=$1
interval=$((60000000/$loops))

# Just a heartbeat signal that can be used with monit to verify it's alive

touch /var/run/cron-ms

# After a restart the PIDs will be different allowing old processes to terminate

touch /var/run/cron-ms/$$

# Sleeps until a specific part of a minute with microsecond resolution. 60000000 is full minute

usleep $(( $interval - 10#$(date +%S%N) / 1000 % $interval ))

# Deleting the PID files exit the program

if [ ! -f /var/run/cron-ms/$$ ]
then
   exit
fi

# Run all the programs in the directory in parallel

for program in $basedir/$loops/* ; do
   if [ -x $program ] 
   then
      $program &> /dev/null &
   fi
done

exec $0 $loops