Optymalizacja programu pod kątem wydajność i ”wielozadaniowości” jako praktyczne i konieczne zastosowanie

[Mati294]

Artykuł pokazuje jedną z prostszych i skuteczniejszych metod optymalizowania programu pod względem czasu w jakim procesor wykona dane działania, uzyskiwania „dodatkowych wolnych cykli” względem niezoptymalizowanego programu.

Zacznijmy od:

Na wstępie musimy zadać sobie pytanie czy piszemy prostu program typu „Blink” czy coś bardziej skomplikowanego. Jeżeli już uświadomimy sobie że to bardziej skomplikowany projekt z zależnościami czasowymi musimy zapomnieć o używaniu delay(); na rzecz millis();

Oczywiście możemy użyć jednej z wielu bibliotek robiących „magie” za nas i zastępujących delay() ALE to rozwiązuje tylko problem zatrzymywania się wykonywania programu na określony czas a nie rozwiązuje kwestii optymalizacji jego działania.

Ten artykuł bierze udział w naszym konkursie! 
Na zwycięzców czekają karty podarunkowe Allegro, m.in.: 2000 zł, 1000 zł i 500 zł.

Potrafisz napisać podobny poradnik? Opublikuj go na forum i zgłoś się do konkursu!
Czekamy na ciekawe teksty związane z elektroniką i programowaniem. Sprawdź szczegóły »

Kiedy i gdzie?

Z pozoru mogło by się wydawać że tylko tam gdzie bardzo zależy nam żeby program chociaż w pewnym stopniu wykonywał się w czasie rzeczywistym albo do nauki nowych funkcji.

Jak pokazuje w bardzo uproszczonej i mającej pokazać obrazowo wersji powinno się tak naprawdę stosować wszędzie i zawsze gdzie tylko jest to możliwe. Jest to podyktowane dobrym nawykiem ale też co wydaję się ważniejsze koniecznością przy pisaniu coraz to bardziej skomplikowanych programów.

Szczególnie często będziemy potrzebować tego przy własnych systemów inteligentnego domu gdzie programy będą musiały obsługiwać bardzo dużo zdarzeń i komunikować się między sobą.

 

Dlaczego?

Jest to znacznie skuteczniejsza metoda od zwiększania częstotliwości taktowania procesora, przy pracy na baterii możemy wtedy nawet zmniejszyć taktowanie i przez to przedłużyć prace wtedy też możemy skorzystać z usypiania procesora co jeszcze bardziej wydłuży czas pracy.

Może dać nam przy dobrym wykorzystaniu efekty lepsze o 100 czy nawet 1000 razy lepsze niż zwiększenie częstotliwości pracy procesora.

 

Potrzebne do doświadczeń

dowolna płytka ARDUINO (w moim przypadku Mega 2560)

rezystor 1K

fotorezystor (opcjonalnie potencjometr)

komputer

ok 30 min wolnego czasu

kilka kabelków

płytka stykowa

Opcjonalnie:

kilka rezystorów i led jednak są opcjonalne ze względu na brak wpływu na czasy

 

Eksperyment ułatwiający zrozumienie problemu

Zacznijmy od założenia że co jakiś czas w miarę szybko musimy odczytywać wartość z fotorezystora i według niej sterować diodami pokazującymi wartość oświetlenia w pokoju. Mamy prosty program mający pobierać dane z fotorezystora (pin A0). Stosując ten prosty program spełnimy założenie ale utrudnimy sobie implementacje funkcji mających wykonywać bardzo dużo obliczeń w określonym czasie. Dla przejrzystości nie ma tam innych obliczeń na zmiennych.

Dla ułatwienia zamiast fotorezystora użyłem potencjometru

Innymi słowy funkcja „sterowanieLed()” będzie zużywała ogromną ilość czasu procesora czyli zasoby

#define iloscLed 50
unsigned long obliczanieCzasu[3];
long doWydajnosci[5];
int zmiennaPomocnicza;
int wartoscSwiatla;
void setup() {
  Serial.begin(9600);
  pinMode(A0,INPUT);
  for(int i=0;i<=iloscLed;i++){//inicjalizacja pinow pod ledy majace sluzyc jako przyklad ich montaz jest opcjonalny
    pinMode(4+i,OUTPUT);
  }

zmiennaPomocnicza=1024/iloscLed;//automtyczne skalowanie do ilosc led
}
void loop() {
  wartoscSwiatla=analogRead(A0);
  int zmiennaPomocnicza2=0;
  for(int i=0;i<=iloscLed;i++){
    digitalWrite(i,0);//ustawia stan dla wszystkich led po kolei na LOW
    zmiennaPomocnicza2= zmiennaPomocnicza2+zmiennaPomocnicza;//
    if(zmiennaPomocnicza2>=wartoscSwiatla)
    digitalWrite(i,1);
    /* ustawia stan wyjscia dla led po kolei co warotsc "zmiennaPomocnicza" czyli
     *  cykl1 zmiennaPomocnicza2=0+120
     *  cykl2 zmiennaPomocnicza2=120+120
     *  cykl3 zmiennaPomocnicza2=240+120
     *  cykl4 zmiennaPomocnicza2=360+120
     *  itd...
     */
  }

 doWydajnosci[0]++;// wykonuje sie tylko raz na petle proceseora
 
  obliczanieCzasu[0] = millis();
  obliczanieCzasu[1] = obliczanieCzasu[0] - obliczanieCzasu[2];
  if (obliczanieCzasu[1] >= 10UL) {//wykona sie co 10 ms
    obliczanieCzasu[2] = obliczanieCzasu[0];
    
doWydajnosci[1]=doWydajnosci[0];
doWydajnosci[0]=0;                           //co 10ms liczik jest resetowany
Serial.println(doWydajnosci[1]);

}
}

A oto wyniki bez optymalizacji:

W przykładzie korzystamy z wewnętrznego zegara i funkcji millis().

Standardowo procesor ma taktowanie 16MHz co nie znaczy że jedna linijka kodu oznacza jeden cykl.

Dane jakie uzyskamy na serial monitorze mogą się odrobinę różnić od prezentowanych.

UWAGA: Polecenia mają różną od siebie ilość potrzebnych cykli procesora na wykonanie.

UWAGA: Jeden cykl procesora ≠ Jeden cykl programu(w rozumieniu wykonania jednego cyklu przejścia pętli „loop”).

#define iloscLed 50
unsigned long obliczanieCzasu[3];
long doWydajnosci[5];
int zmiennaPomocnicza;
int wartoscSwiatla;
void setup() {
  Serial.begin(9600);
  pinMode(A0, INPUT);
  for (int i = 0; i <= iloscLed; i++) { //inicjalizacja pinow pod ledy majace sluzyc jako przyklad ich montaz jest opcjonalny
    pinMode(4 + i, OUTPUT);
  }
  zmiennaPomocnicza = 1024 / iloscLed; //automtyczne skalowanie do ilosc led
}
void loop() {
  doWydajnosci[0]++;// wykonuje sie tylko raz na petle proceseora

  obliczanieCzasu[0] = millis();
  obliczanieCzasu[1] = obliczanieCzasu[0] - obliczanieCzasu[2];
  if (obliczanieCzasu[1] >= 10UL) {//wykona sie co 10 ms
    obliczanieCzasu[2] = obliczanieCzasu[0];
    doWydajnosci[1] = doWydajnosci[0];
    doWydajnosci[0] = 0;                         //co 10ms liczik jest resetowany
    Serial.println(doWydajnosci[1]);

sterowanieLed();
  }
}
void sterowanieLed() {
  wartoscSwiatla = analogRead(A0);
  int zmiennaPomocnicza2 = 0;
  for (int i = 0; i <= iloscLed; i++) {
    digitalWrite(i, 0); //ustawia stan dla wszystkich led po kolei na LOW
    zmiennaPomocnicza2 = zmiennaPomocnicza2 + zmiennaPomocnicza; //
    if (zmiennaPomocnicza2 >= wartoscSwiatla)
      digitalWrite(i, 1);
    /* ustawia stan wyjscia dla led po kolei co warotsc "zmiennaPomocnicza" czyli
        cykl1 zmiennaPomocnicza2=0+120
        cykl2 zmiennaPomocnicza2=120+120
        cykl3 zmiennaPomocnicza2=240+120
        cykl4 zmiennaPomocnicza2=360+120
        itd...
    */
  }
}

I już z optymalizacją:

Jak widzimy między obiema eksperymentami jest niewielka różnica dla skrajnych wartości (dla wartości „iloscLed 50 „ wygląda to jeszcze gorzej i jest na poziomie 27-17). Ale już po drobnej sztuczce wygląda to już zupełnie inaczej i mamy ok 30 razy więcej „wolnych” przejść pętli. Stwarza to ogromny potencjał na dalsze prace przy programie i układzie.

czw.2:

dowolna płytka ARDUINO (w moim przypadku UNO )

dowolną ilość modułów przekaźników (zawsze możemy rozszerzyć projekt)

kilka kabli

źródło zasilania np. powerbank

czytnik linii papilarnych

30 min wolnego czasu

Praktyczne zastosowanie jako automatyka domowa

Prezentowany przykład zastosowania korzystającego z przedstawionej metody z powodzeniem działa i po dodaniu fragmentu z komunikacją może zostać dodany do innych urządzeń inteligentnego domu. Te praktyczne zastosowanie działa u mnie od lat i obecnie pracuje nad kolejna wersją już jako smart dom.

Prezentowany program służy do sterowania elektromagnesem i oświetleniem w pokoju jako automatyka domowa.

#include <Adafruit_Fingerprint.h>
SoftwareSerial mySerial(2, 3);
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
unsigned long obliczanieCzasu[3];
bool P[3];
void setup()
{
  pinMode(4,OUTPUT);
  pinMode(5,OUTPUT);
  pinMode(6,OUTPUT);
  Serial.begin(9600);
  finger.begin(57600);
  delay(5);
  finger.getTemplateCount();
}

void loop()
{
  obliczanieCzasu[0] = millis();
  obliczanieCzasu[1] = obliczanieCzasu[0] - obliczanieCzasu[2];
  if (obliczanieCzasu[1] >= 50UL) {//wykona sie co 10 ms
    obliczanieCzasu[2] = obliczanieCzasu[0];

    int fingerprintID = getFingerprintIDez();

    if (fingerprintID == 1) {
      P[0] = !P[0];
    }
    if (fingerprintID == 2) {
      P[1] = !P[1];
    }
    if (fingerprintID == 3) {
      P[2] = !P[2];
    }
digitalWrite(4,P[0]); //co 50 ms ustawia stan HIGH albo LOW 
digitalWrite(5,P[1]);
digitalWrite(6,P[2]);
  }
}
uint8_t getFingerprintID() {
  uint8_t p = finger.getImage();
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image taken");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.println("No finger detected");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Imaging error");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }
  p = finger.image2Tz();
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image converted");
      break;
    case FINGERPRINT_IMAGEMESS:
      Serial.println("Image too messy");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      Serial.println("Could not find fingerprint features");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      Serial.println("Could not find fingerprint features");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }

  // OK converted!
  p = finger.fingerFastSearch();
  if (p == FINGERPRINT_OK) {
    Serial.println("Found a print match!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Communication error");
    return p;
  } else if (p == FINGERPRINT_NOTFOUND) {
    Serial.println("Did not find a match");
    return p;
  } else {
    Serial.println("Unknown error");
    return p;
  }
  Serial.print("Found ID #"); Serial.print(finger.fingerID);
  Serial.print(" with confidence of "); Serial.println(finger.confidence);

  return finger.fingerID;
}
int getFingerprintIDez() {
  uint8_t p = finger.getImage();
  if (p != FINGERPRINT_OK)  return -1;

  p = finger.image2Tz();
  if (p != FINGERPRINT_OK)  return -1;

  p = finger.fingerFastSearch();
  if (p != FINGERPRINT_OK)  return -1;
  Serial.print("Found ID #"); Serial.print(finger.fingerID);
  Serial.print(" with confidence of "); Serial.println(finger.confidence);
  return finger.fingerID;
}

 

Coś o mnie:

Uczę się programowania w wolnych chwilach od lat a aktualnie pracuje nad projektem "inteligentnego" pokoju. Ma on w sobie zawierać automatyczne otwieranie zamykanie drzwi sterowanie wentylacją temperaturą wraz z wymiennikiem ciepła własnej roboty i zbieraniem info meteorologicznych.Jak już będzie tak daleko to pochwale się efektami.

[Treker (Damian Szymański)]

@Mati294 witam na forum! Wpis został właśnie zaakceptowany i jest już widoczny publicznie

[_LM_]

Zamiast switch() i długich wyrażeń if...else if lepiej wyniki wpisać w tablicę dwuwymiarową. https://ucgosu.pl/2019/07/tablice-przyspieszajace-wyszukiwanie-elementow/

[ethanak]

38 minut temu, _LM_ napisał:

lepiej wyniki wpisać w tablicę dwuwymiarową

No, ale tu chodzi o wykonanie akcji zależnej od wyniku, a to już nie jest takie proste. Owszem, możemy sobie zastosować tablicę funkcji, ale przy stosunkowo niewielkiej ilości przypadków w instrukcji switch nie robi to wielkiej różnicy (w przypadku Arduino każdy case to dwie instrukcje maszynowe). I może okazać się, że switch/case będzie szybszy niż zabawa z wywołaniem funkcji i powrotem.

 

Dnia 6.04.2021 o 19:50, Mati294 napisał:

Jeżeli już uświadomimy sobie że to bardziej skomplikowany projekt z zależnościami czasowymi musimy zapomnieć o używaniu delay(); na rzecz millis();

No, to baaaaaardzo duże uproszczenie.

Zawsze twierdziłem, że są trzy stopnie wtajemniczenia: na początku używa się delay(), potem rezygnuje się z delay() i używa millis(), a na końcu używa się tego co w danym miejscu jest właściwe

 

[_LM_]

Żeby nie być gołosłownym  zakładam że FINGERPRINT_OK czy FINGERPRINT_IMAGEMESS.... itd są poukładane w kolejności o 0 wzwyż wtedy twój program mógłby wyglądać:

const char s1[] = "Str1"; // tab komunikatow
const char s2[] = "Str2";
const char s3[] = "Str3";

const char * const pStr[] = {s1,s2,s3}; // tab wskaznikow do komunikatow

p = finger.fingerFastSearch();
Serial.prinlnt(pStr[p]);
return p;

Gdyby polecenia nie były w kolejności należy je przemapować na indeksy znajdujące się w tablicy wskaźników tak samo należy zabepieczyć się przed wyjściem poza tę tablicę

Edytowano Kwiecień 9, 2021 przez _LM_

[_LM_]

9 minut temu, ethanak napisał:

No, ale tu chodzi o wykonanie akcji zależnej od wyniku, a to już nie jest takie proste. Owszem, możemy sobie zastosować tablicę funkcji, ale przy stosunkowo niewielkiej ilości przypadków w instrukcji switch nie robi to wielkiej różnicy (w przypadku Arduino każdy case to dwie instrukcje maszynowe). I może okazać się, że switch/case będzie szybszy niż zabawa z wywołaniem funkcji i powrotem.

Owszem trzeba pilnować wskaźników i innych rzeczy aby nie wyszły poza rozmiar tablicy itd. Jednak przy wielu możliwościach wyboru rozwiązanie z tablicami wydaje się być bardziej przejrzyste. A jak już do wskaźników na napis masz dołożony wskaźnik na funkcję (oczywiście jeśli zachodzi taka potrzeba) to już w ogóle wypas  A czy różni się to wydajnościowo? hmmm przy większych programach na pewno. Poza tym zauważ że w załączonym przeze mnie pseudokodzie wykonuję tylko raz funkcję print co zaś przełoży się na rozmiar kodu.

Skoro post kolegi @Mati294 dotyczy pisania wydajnych programów sądzę iż zasadne jest pokazanie innych technik programowania

Edytowano Kwiecień 9, 2021 przez _LM_

[ethanak]

23 minuty temu, _LM_ napisał:

wtedy twój program mógłby wyglądać:

Strasznie komplikujesz prostą sprawę.

A nie można po prostu:

const char * const pStr[]={"Str1", "Str2", "Str3"};

zamiast tworzenia niepotrzebnych zupełnie bytów, jak s1 i tak dalej? Takie konstrukcje są dobre jeśli używasz PROGMEM, ale wtedy masz kolejny galimatias z wydłubywaniem stringów z flasha i kombinowaniem, jak by tu je wypisać. Tam, gdzie sekcja stałych we flashu jest mapowana bezpośrednio do przestrzeni adresowej (np. ESP) wystarczy deklaracja const.

 

[_LM_]

30 minut temu, ethanak napisał:

Strasznie komplikujesz prostą sprawę.

A nie można po prostu:

const char * const pStr[]={"Str1", "Str2", "Str3"};

 

Co kto lubi Powiedzmy że jest to kwestia nawyków i przyzwyczajeń, jako zaletę "mojego" rozwiązania mogę wymienić to że tworząc bardziej rozbudowane struktury, nie muszę liczyć pod którym indeksem znajduje się dany napis, a za to mogę odwołać się poprzez skróconą nazwę - wskaźnik. Oczywiście nie upieram się który zapis jest lepszy wszystko zależy co w danym momencie robimy

Edytowano Kwiecień 9, 2021 przez _LM_

[ethanak]

6 minut temu, _LM_ napisał:

Powiedzmy że jest to kwestia nawyków i przyzwyczajeń

Co nie oznacza, że pStr nie powinien być const char *const

 

[_LM_]

Tyz prowda - poprawiłem 

Edytowano Kwiecień 9, 2021 przez _LM_

[Mati294]

Zacznę od tego że nie spodziewałem się takiego odzewu a teraz po kolei.

1 godzinę temu, ethanak napisał:

I może okazać się, że switch/case będzie szybszy niż zabawa z wywołaniem funkcji i powrotem.

Moim zdaniem instrukcja switch jest dużo bardziej czytelna a do przeważnie nie trzeba się zastanawiać co dana funkcja robi. W razie czego też zawsze można wyrzucić całość do innej karty. Wydaje się być też prostsza w debagu.

1 godzinę temu, ethanak napisał:

No, to baaaaaardzo duże uproszczenie.

Zawsze twierdziłem, że są trzy stopnie wtajemniczenia: na początku używa się delay(), potem rezygnuje się z delay() i używa millis(), a na końcu używa się tego co w danym miejscu jest właściwe

Tak w pełni się z tym zgadzam jednak z delay() (moim zdaniem) jest jak z goto bez prawdziwej potrzeby lepiej nie używać. Co do uproszczenia to wolałem je zastosować tak żeby początkujący mogli z tego skorzystać.

 

1 godzinę temu, _LM_ napisał:

A czy różni się to wydajnościowo? hmmm przy większych programach na pewno.

Przy większych programach (przynajmniej u mnie) większy problem stanowi wydajność a co do rozmiaru kodu no to niestety coś za coś.

Co do reszty jeżeli chodzi o fingerprint to aktualnie powstaje duuuużo bardziej zaawansowana wersja tego projektu gdzie sam czujnik i jego oprogramowanie stanowi tylko drobną cześć całości. Za jakiś czas powinien pojawić się osobny post dotyczącego tego projektu.

 

[_LM_]

33 minuty temu, Mati294 napisał:

Przy większych programach (przynajmniej u mnie) większy problem stanowi wydajność

Zatem chyba najwyższy czas poznać funkcje zwrotne wraz z timerami programowymi i przydzielaniem zadań. Nawet na małym AVR można zbudować aplikacje "wielowątkowe"

[Mati294]

3 minuty temu, _LM_ napisał:

Zatem chyba najwyższy czas poznać funkcje zwrotne wraz z timerami programowymi i przydzielaniem zadań. Nawet na małym AVR można zbudować aplikacje "wielowątkowe"

U mnie w większości odpowiada za to biblioteka do obsługi ekranu dotykowego jednak prędzej czy później będę musiał się tym zająć. Można prosić jakiś link do strony o tym z wykorzystaniem arduino?

[_LM_]

Cóż nie zajmowałem się tym od strony bibliotek Arduino ale powinieneś szukać pod nazwami arduino callback timer, callback, EVENT itd.

https://arjenstens.com/timer-callback-library-for-multitasking-arduino/ najprostszym sposobem jest wykorzystanie biblioteki ticker.h