Totò, Peppino e il Watchdog – come scrivere un Watchdog in C, C++ e Go – pt.3

T

Totò, Peppino e il Watchdog
come scrivere un Watchdog in C, C++ e Go – pt.3

Mezzacapa: Acqua, vento... e nebbia! Eh... nebbia, nebbia!
Totò: Ah, questo m'impressiona! Tutto, ma la nebbia.
Mezzacapa: A Milano, quando c'è la nebbia non si vede.
Totò: Perbacco... e chi la vede?
Mezzacapa: Cosa?
Totò: Questa nebbia, dico?
Mezzacapa: Nessuno.
Totò: Ma, dico, se i milanesi, a Milano, quando c'è la nebbia, non vedono, come si fa a vedere che c'è la nebbia a Milano?
Mezzacapa: No, ma per carità, ma quella non è una cosa che si può toccare.
Peppino: Ah, ecco.
Totò: Non si tocca... non si tocca.
Peppino: Ma io, a parte questa nebbia, io non la tocco per carità... Ma adesso se noi dobbiamo incontrare a nostro nipote, questa cantante, come li vediamo, dove li troviamo?
Totò: Già! Eh già, non ci avevo pensato.
Mezzacapa: È facile, la cantante, quella c'ha il nome sul manifesto.
Totò: Hai capito, a Milano quando c'è la nebbia, mettono i nomi sui manifesti. Dice, chi mi vuol trovare, io sto qua.

E finalmente siamo arrivati alla terza ed ultima parte della nostra avventura con il Watchdog (la prima e la seconda parte le trovate qui e qui). Anche in questo caso il surreale dialogo tra Totò, Peppino e Mezzacapa ci fornisce un indizio e una ispirazione: prendiamo il Watchdog in C e, a maggior ragione, quello in C++, mettiamo un po’ di nebbia per omettere il superfluo et voilà! Il Watchdog ridotto all’osso è servito, scritto in un vero linguaggio ad alto livello, il Go.

watchdog

…Ah, questo m’impressiona! Tutto, ma il Watchdog in Go…

Dunque, vediamo: la presentazione di oggi è più “ristretta” di quelle precedenti, perché abbiamo un main() d’uso e un file di implementazione, e niente header, questo è il Go, gente! Cominciamo con l’implementazione, allora, vai col codice!

package main

import (
    "fmt"
    "sync"
    "time"
)

const MAX_WATCH = 32    // numero massimo di watch in uso

// Watch - tipo per watch nel watchdog
type Watch struct {
    ID     int          // identificatore del watch (numero)
    name   string       // identificatore del watch (stringa)
    active bool         // flag di attività (true=attivo)
}

// Watchdog - tipo per watchdog
type Watchdog struct {
    watchList  [MAX_WATCH]*Watch    // lista di watch
    watchMutex sync.Mutex           // mutex per operazioni add/set/check
}

// delete - elimina tutti i watch
func (wdg *Watchdog) delete() {

    // rilascia le risorse allocate
    for i := 0; i < MAX_WATCH; i++ {
        // check se il watch è disponibile
        if wdg.watchList[i] != nil {
            // cancella un watch
            wdg.delWatch(i)
        }
    }
}

// check - check di tutti i watch nella lista watch
func (wdg *Watchdog) check(
    waitSec time.Duration) {   // sleep del loop interno in secondi

    // loop infinito di check watch
    for {
        // lock di questo blocco per uso thread-safe
        wdg.watchMutex.Lock()

        // check di tutti i watch nella lista watch
        for i := 0; i < MAX_WATCH; i++ {
            // check solo dei watch in uso
            if wdg.watchList[i] != nil {
                // check del watch
                if wdg.watchList[i].active {
                    // watch attivo: reset flag active
                    wdg.watchList[i].active = false
                } else {
                    // watch inattivo: mostro l'errore
                    fmt.Printf("check: watch %d: %s goroutine inattiva\n",
                               wdg.watchList[i].ID, wdg.watchList[i].name)
                }
            }
        }

        // unlock del blocco
        wdg.watchMutex.Unlock()

        // sleep del loop
        time.Sleep(time.Second * waitSec)
    }
}

// addWatch - aggiunge un watch nella watch list
func (wdg *Watchdog) addWatch(
    name string) int {      // watch name

    // lock per uso thread-safe
    wdg.watchMutex.Lock()
    defer wdg.watchMutex.Unlock()

    // loop sulla watch list per trovare il primo watch disponibile
    for i := 0; i < MAX_WATCH; i++ {
        // check se il watch è disponibile
        if wdg.watchList[i] == nil {
            // aggiunge un watch in watch list
            wdg.watchList[i] = new(Watch)

            // set valori
            wdg.watchList[i].ID     = i
            wdg.watchList[i].name   = name
            wdg.watchList[i].active = false
            fmt.Printf("addWatch: watch aggiunto: ID=%d name=%s\n", i, name)

            // return ID
            return i
        }
    }

    // return errore
    fmt.Printf("addWatch: non ci sono più watch disponibili\n")
    return -1
}

// delWatch - cancella un watch nella watch list
func (wdg *Watchdog) delWatch(
    ID int) {               // watch ID

    // lock per uso thread-safe
    wdg.watchMutex.Lock()
    defer wdg.watchMutex.Unlock()

    // cancella un watch
    fmt.Printf("delWatch: cancella un watch: ID=%d name=%s\n",
               wdg.watchList[ID].ID, wdg.watchList[ID].name)
    wdg.watchList[ID] = nil
}

// setWatch - set a watch
func (wdg *Watchdog) setWatch(
    ID int) {               // watch ID

    // lock per uso thread-safe
    wdg.watchMutex.Lock()
    defer wdg.watchMutex.Unlock()

    // set a true del flag active
    if wdg.watchList[ID] != nil {
        wdg.watchList[ID].active = true
    }
}

Il Go permette una notevole libertà di stile di implementazione, e in questo caso ho scelto di scrivere un Watchdog che usa metodi invece di funzioni e, vista l’assenza di classi, il risultato è un po’ una via di mezzo tra la versione in C e quella in C++, anche considerando che le due strutture usate sono quasi identiche a quelle scritte in C. I metodi realizzati sono molto (ma molto) simili a quelli delle altre versioni e, come avrete notato, con c’è un metodo di setup o di costruzione, visto che non c’era nulla da inizializzare. Non credo che ci sia più nulla da aggiungere sull’implementazione, sia perché è, al solito, ben commentata, sia perché è veramente molto simile a quelle viste nelle prime due parti dell’articolo.

E allora passiamo al punto più interessante, il main(). Vediamolo!

package main

import (
    "fmt"
    "time"
    "sync"
)

// main() - LocalController main function
func main() {

    // crea il watchdog
    watchdog := Watchdog{}

    // waitgroup di attesa terminazione goroutine
    var wg sync.WaitGroup
    wg.Add(2)

    // avvio goroutine A e B
    go myGoroutineA(&wg, &watchdog)
    go myGoroutineB(&wg, &watchdog)

    // avvio check watchdog (contiene un loop infinito)
    watchdog.check(1);      // sleep interna di 1 sec

    // attesa terminazione goroutine
    wg.Wait()
    fmt.Printf("main: goroutine terminate\n")
}

// goroutine A
func myGoroutineA(wg *sync.WaitGroup, watchdog *Watchdog) {

    // all'uscita decremento il waitgroup
    defer wg.Done()

    // aggiunge un watch per questa goroutine
    watchID := watchdog.addWatch("myGoroutineA")
    if watchID < 0 {
        // errore: non posso usare il watch
        fmt.Printf("myGoroutineA: non posso usare il watch: fermo la goroutine A")
        return
    }

    // loop della goroutine
    fmt.Printf("goroutine A partita\n")
    i := 0
    for {
        // la goroutine fa cose...

        // ...

        // TEST: ogni 5 secondi simulo un blocco della goroutine
        i++
        if i == 500 {
            fmt.Printf("goroutine A: sleep di 5 sec\n")
            i = 0
            time.Sleep(time.Second * 5)
        }

        // rinfresco il watch della goroutine
        watchdog.setWatch(watchID)

        // sleep della goroutine (10 ms)
        time.Sleep(time.Millisecond * 10)
    }

    // la goroutine esce
    fmt.Printf("goroutine A finita\n")
}

// goroutine B
func myGoroutineB(wg *sync.WaitGroup, watchdog *Watchdog) {

    // all'uscita decremento il waitgroup
    defer wg.Done()

    // aggiunge un watch per questa goroutine
    watchID := watchdog.addWatch("myGoroutineB")
    if watchID < 0 {
        // errore: non posso usare il watch
        fmt.Printf("myGoroutineB: non posso usare il watch: fermo la goroutine B")
        return
    }

    // loop della goroutine
    fmt.Printf("goroutine B partita\n")
    i := 0
    for {
        // la goroutine fa cose...

        // ...

        // TEST: ogni 15 secondi simulo un blocco della goroutine
        i++
        if i == 1500 {
            fmt.Printf("goroutine B: sleep di 5 sec\n")
            i = 0
            time.Sleep(time.Second * 5)
        }

        // rinfresco il watch della goroutine
        watchdog.setWatch(watchID)

        // sleep della goroutine (10 ms)
        time.Sleep(time.Millisecond * 10)
    }

    // la goroutine esce
    fmt.Printf("goroutine B finita\n")
}

Inutile soffermarsi sulle due goroutine che sono perfettamente equivalenti ai thread delle versioni C e C++, quindi andiamo direttamente alla funzione main() che è di una semplicità veramente sorprendente, ed è così compatta (e commentata) che dubito che ci sia qualcosa da spiegare. Praticamente l’unica parte “strana”, per chi non è molto pratico del Go, potrebbe essere il sync.WaitGroup, che poi non è nient’altro che una semplicissima maniera di raggruppare le goroutine che si useranno per sorvegliarne la terminazione: una operazione equivalente alla join del C/C++ ma più semplificata, quindi. 

Riepiloghiamo: il main() della versione C era molto compatto e lineare, e usava la classica e un po’ verbosa gestione degli errori del C. Il main() della versione C++ era apparentemente ancora più sintetico ma, come ben evidenziato nell’articolo precedente, la gestione delle eccezioni sugli oggetti creati nasconde molte insidie, quindi il codice finale reale era, in realtà, molto più complesso. Il main() della versione Go è, invece, veramente semplice e non c’è da aggiungere nient’altro rispetto a quello mostrato. Una vera sciccheria!

Considerazioni finali: per trasformare in codice reale di produzione gli esempi semplificati (C, C++ e Go) visti, non c’è, in realtà, molto lavoro aggiuntivo da eseguire, e posso dare qualche consiglio valido (più o meno) per tutti e tre i linguaggi:

  1. La funzione di check dovrebbe avere una condizione di uscita (il loop dovrebbe essere pseudo-infinito). Ad esempio si potrebbe decidere che quando tutti i thread sorvegliati sono bloccati o terminati (bene o per errore) la funzione dovrebbe uscire segnalando il problema e avviare la chiusura controllata del processo main.
  2. Anche i thread (o goroutine) da sorvegliare dovrebbero avere una condizione di uscita, per permettere la chiusura controllata del processo main. Potrebbe anche essere una buona idea eseguire il detach dei thread e controllare l’uscita solo attraverso il Watchdog.
  3. Bisognerebbe sofisticare adeguatamente (come già accennato nella parte 1 dell’articolo) la funzione di check in maniera di poter gestire in maniera adeguata thread veloci e thread lenti: dovrebbe essere compito del thread stesso comunicare la cadenza di sorveglianza nella fase di registrazione al Watchdog.

La nostra avventura col Watchdog in tre linguaggi è terminata. Credo di aver fornito abbastanza materiale per poter scrivere un codice di produzione in C, C++ e Go. Ognuno può evidentemente scegliere la versione più opportuna in base alle proprie preferenze, inclinazioni ed esigenze di progetto. Io propendo sempre (inutile nasconderlo) per scrivere nel mio amato C (che è un vero linguaggio 4WD, solidissimo e multiuso), ma ultimamente il Go mi intriga molto.

Sul C++ ho già fatto le mie considerazioni in altri articoli, preferisco non infierire… anzi si, infierisco e vi lascio con un estratto di una bella introduzione al linguaggio Go da parte di uno dei suoi tre autori, Rob Pike (gli altri due sono il mitico Ken Thompson e Robert Griesmer). L’articolo si chiama “Less is exponentially more”, ed è, già nel titolo, una presentazione di intenti del linguaggio Go: consiglio a tutti di leggerlo per intero. La parte che ho estratto spiega, in maniera divertente, che uno degli impulsi alla creazione di Go è stato, paradossalmente, l’uscita del C++11… (…oops: mi dicono dalla regia che è possibile che alcuni colleghi informatici non conoscano Rob Pike o Ken Thompson… e vabbè, continuiamo così, facciamoci del male). Vai Rob!

"...Back around September 2007, I was doing some minor but central work on an 
enormous Google C++ program, one you've all interacted with, and my compilations 
were taking about 45 minutes on our huge distributed compile cluster. An 
announcement came around that there was going to be a talk presented by a couple 
of Google employees serving on the C++ standards committee. They were going to 
tell us what was coming in C++0x, as it was called at the time. (It's now known 
as C++11).

In the span of an hour at that talk we heard about something like 35 new features 
that were being planned. In fact there were many more, but only 35 were described 
in the talk. Some of the features were minor, of course, but the ones in the talk 
were at least significant enough to call out. Some were very subtle and hard to 
understand, like rvalue references, while others are especially C++-like, such as 
variadic templates, and some others are just crazy, like user-defined literals.

At this point I asked myself a question: Did the C++ committee really believe that
was wrong with C++ was that it didn't have enough features? Surely, in a variant 
of Ron Hardin's joke, it would be a greater achievement to simplify the language 
rather than to add to it. Of course, that's ridiculous, but keep the idea in mind..."

                                     da "Less is exponentially more", Rob Pike, 2012

Quindi ricordate: less is exponentially more! E ho detto tutto!

Ciao, e al prossimo post!

A proposito di me

Aldo Abate

È un Cinefilo prestato alla Programmazione in C. Per mancanza di tempo ha rinunciato ad aprire un CineBlog (che richiede una attenzione quasi quotidiana), quindi ha deciso di dedicarsi a quello che gli riesce meglio con il poco tempo a disposizione: scrivere articoli sul suo amato C infarcendoli di citazioni Cinematografiche. Il risultato finale è ambiguo e spiazzante, ma lui conta sul fatto che il (si spera) buon contenuto tecnico induca gli appassionati di C a leggere ugualmente gli articoli ignorando la parte Cinefila.
Ma in realtà il suo obiettivo principale è che almeno un lettore su cento scopra il Cinema grazie al C...

Di Aldo Abate

I nostri Partner

Gli articoli più letti

Articoli recenti

Commenti recenti