Observing Lists

Kan System.Threading.Timer ikke bruges ?

Jo det kan den men spørgsmålet er hvorvidt den er brugbar i et system som er meget tids/drifts kritisk. Der findes en masse realtime design patterns har bare desværre ikke erfaring med hvilke der er gode. Der er jo isuses som deadlocks osv, og tasks skulle gerne være ude præcis det millisekund hvor den er sat til. Timers er jo så vidt jeg ved ikke super præcise. Specielt ikke hvis der bliver fyret en hel bunke af effter hianden. Men måske det er vejen frem. Søger lidt nogen som har prøvet det her før og måske har lidt erfaring de kan give af sig.

Jeg har ikke så meget forstand op real time systemer.

Umiddelbart ville jeg tro at Microsoft havde lavet Timer så god som den nu kunne
laves givet det underliggende operativ system og hardware (Windows på x86).

Men jeg kan tage fejl.

PS: C# og real time ?? Jeg troede ikke at man bruge sprog med garbage collection
    til real time kode !

Det kan sagtens være du har ret jeg ved det faktisk ikke. Jeg kan ikke selv se nogle alternativer til en timer andet en noget meget processor krævende whiles osv. Men ville lige høre om der var andre syn på sagen. Arne har du selv lavet løsninger med noget observer der tjekker en liste eller lignende igennem hele tiden og tjekker på nogle kreteria? Hvis et kriteria er der skal se noget 16.00 så skal det virkelig være meget tæt på.

Jeg har aldrig arbejdet med real time programmering.

Prøv først sætte et krav op.. hvor præcist skal det kunne være? Og hvornår skal tiden måles fra? (Når tråden/programmet begynder opgaven kl. 16:00:00 - eller skal opgaven være færdig kl. 16:00:00) Hvad er konsekvensen hvis det bliver kørt +/- 100 ms, 1 sec eller 2 sec ?

Derefter kan du jo prøve at lave et simpelt system der henter næste job, ser hvor længe der er til, og derefter kalder Thread.Sleep() eller brugeren timeren, til at "dvale" indtil det er nødvendigt at vågne op. Hvorefter den kan udføre jobbet og gøre samme procedure igen.

Mon ikke det dækker det?

// Ibleif

Det var også noget i den kaliber jeg selv kunne tænke mig til. men kunne være .NET tilbød noget til sådan opgaver. Tænkte lidt COM+ med object pooling osv. måske man kunne vinde noget med det. men kan godt være jeg gør det mere avanceret end det er.

Må man høre hvad det er for nogle opgaver der skal udføres?

// Ibleif

Ved ikke hvor meget i dybden jeg må gå med det men lad mig sige at vigtigheden er MEGET stor. Med dette menes et job må ikke blive forsinket eller ikke blive sendt af sted. Det ville mildest talt være meget uheldigt.

Men kort fortalt har vi nogle beskeder der skal sendes ud. De ligger i en liste hvor der står et tidspunkt hvorpå de udsendes i en liste af en eller anden art. Så i bund og grund er det rimeligt simpelt men det skal bare være meget præcist og en timer må ik pludselig være "væk". Kan i begge lige smide et svar. Er glad for i gider komme med jeres syn på sagen.

well, jeg gentog jo egentlig bare lidt omkring arne´s idé, så syntes da bare han skal have de point!

// Ibleif

Jeg prøvede lige ta måle lidt på timer.

Jeg ved ikke hvor god testen er men her er program og output:

using System;
using System.Text;
using System.Threading;

public class MainClass
{
    private static int count;
    private static long last;
    private static long expected;
    private static double dev;
    public static void Main(string[] args)
    {
        Test(1000);
        Test(100);
        Test(10);
        Test(1);
        TestGC(1000);
        TestGC(100);
        TestGC(10);
        TestGC(1);
    }
    static void Test(int msec)
    {
        count = 0;
        last = 0;
        expected = msec * 10000;
        dev = 0;
        Timer t = new Timer(new TimerCallback(DoIt), null, 0, msec);
        while(count < 10000/msec) {
            Thread.Sleep(1);
        }
        t.Dispose();
        Console.WriteLine(String.Format("{0:d} msec intervals : error = {1:0.00}%",msec,(dev/count)/expected));
    }
    static void TestGC(int msec)
    {
        count = 0;
        last = 0;
        expected = msec * 10000;
        dev = 0;
        Timer t = new Timer(new TimerCallback(DoIt), null, 0, msec);
        while(count < 10000/msec)
        {
            StringBuilder sb = new StringBuilder("ABC");
        }
        t.Dispose();
        Console.WriteLine(String.Format("{0:d} msec intervals (GC) : error = {1:0.00}%",msec,(dev/count)/expected));
    }
    static void DoIt(Object o)
    {
        if(last == 0)
        {
            last = DateTime.Now.Ticks;
        }
        else
        {
            long t = DateTime.Now.Ticks;
            dev += Math.Abs(t - last - expected);
            count++;
            last = t;
        }
    }
}

1000 msec intervals : error = 0,00%
100 msec intervals : error = 0,10%
10 msec intervals : error = 0,60%
1 msec intervals : error = 14,65%
1000 msec intervals (GC) : error = 0,11%
100 msec intervals (GC) : error = 0,28%
10 msec intervals (GC) : error = 2,53%
1 msec intervals (GC) : error = 21,83%

og et svar

Ser ud som om timeren er en anelse mere upræcis end en while med en sleep i. Tak for hjælpen.