Posts written by GILA75

view post Posted: 18/2/2020, 18:42 Perplessità processi (c,java,python, generico) - Informatica.
Ok Dario...
Domanda: allora perchè a volte si deve ricorrere ai processi, thread o altre cose complicatucce ???

So de coccio lo so.... :D :D
view post Posted: 18/2/2020, 18:21 Perplessità processi (c,java,python, generico) - Informatica.
CITAZIONE
Mi viene da dire che è più semplice farlo senza processi... :) (e non ho avuto modo di provare la cosa in Windows, purtroppo...)

Finchè non mi decido a buttar giù un po' di codice d'esempio per poter parlare è dura mi sa.
Però si è fatto l'esempio dei timer che lasciano libere le altre operazioni NON congelando tutto.
In C questi timer non li ho, quindi sono obbligato a usare i processi credo.
Per esempio, ho visto un codice del gioco guardie e ladri dove vengono usati i processi.
Se la guardia e il ladro si muovono velocemente allora credo si possa fare senza processi, ma supponiamo che uno
debba aspettare molto tempo.
Proprio non mi riesce di capire come una macchina a stati finiti possa aggirare una temporizzazione nuda e cruda :wb:
Supponiamo con un microcontrollore: parte il programma principale, nel frattempo faccio partire un timer (quindi indipendente). Il timer non fa nulla, va per i fatti suoi.
Non è la stessa cosa di un processo ?
Molto probabilmente mi sfugge il fatto che le macchine a stati finiti possano aggirare solo alcuni "congelamenti",
ma non tutti.
Appena posso butto giù 2 righe.
Certo fare il bruco a processi e pipes non è semplice...ma male non mi fa.
Finchè non fai, non puoi arrivare a capire: ammazza tutto sto giro e mi sono complicato la vita.
Impensabile se hai consegne, ma da hobbista:

a) ti fa capire molte cose...a scapito un po' del tempo
b) se non picchi la testa non capisci.
Tutto ha un limite ovvio, non devi intestardirti su idee balorde...(magari la mia lo è...spero di no!!!)
view post Posted: 15/2/2020, 09:28 Perplessità processi (c,java,python, generico) - Informatica.
Accantono un attimo il discorso delle macchine a stati finiti, voglio farlo con calma.
Ora sono preso con i processi per il gioco del bruco...che non è facile.
Sembra una stupidata, ma con i processi non lo è mica tanto.
Avrei bisogno di un consiglio.
Per ora ho implementato una routine che muove il bruco, temporizzata con un processo, in modo tale che se il ritardo
(movimento) del bruco è alto, tipo un secondo non congelo tutto.
è solo una prova per vedere se tutto funziona.
la routine deve controllare alcune cose:

1) Avanzamento valido: deve essere nei limiti del terminale, sia alto basso che dx,e sx, anche se in futuro farò in modo che
oltrepassando i limiti sbuchi dalla parte opposta...più figo direi.
2) deve controllare che se il bruco avanza a dx, il movimento random successivo non può essere sx, altrimenti andrebbe
in retro, idem alto e basso.

Per ora come dicevo, lo faccio solo muovere in modo random e controllo che la stampa sia corretto e quant'altro.
Non so bene come gestire i processi.
Avevo pensato di dare al padre la gestione della stampa, un figlio si occupa del movimento e intercettazione tasti.
questo processo dovrebbe fare:
il bruco avanza a oltranza nella sua direzione (quindi il figlio aggiorna le posizioni, temporeggia e spedisce la struttura al
padre che stampa). Se viene intercettato un tasto, la direzione deve cambiare.
L'altro figlio lo userei per mettere le mele (sempre distribuite in modo random) nel terminale...
Ma non so, un pezzo alla volta, sembra ma devi gestire molte cose.
Consigli ?
view post Posted: 9/2/2020, 20:27 Perplessità processi (c,java,python, generico) - Informatica.
Jonny Stecchino con tutto l'intreccio di equivoci era semplicemente pazzesco , geniale!!! Visto mille volte ma non stanca mai.Francamente Benigni nei monologhi non mi e' mai piaciuto
view post Posted: 9/2/2020, 19:47 Perplessità processi (c,java,python, generico) - Informatica.
CITAZIONE
Ho scaricato un github di qualcosa di simile a ncurses, ma come tutte le cose di github e dei nerd ;) è un casino di file e ciarpame..

:D :D mitico!!!
Io non ci capisco mai una mazza da quei tizi. saranno anche bravi...bho
view post Posted: 9/2/2020, 19:36 Perplessità processi (c,java,python, generico) - Informatica.
Ok, approfondiremo, non c'è modo migliore che farlo con esempi e un po' di codice.
Se hai voglia, per curiosità, provi a vedere se va su Windows ? Se puoi, non star li a diventare matto.
Dovrei fare delle migliorie, alcune cose proprio non mi piacciono, ma più che altro quello che mi premeva era
capire come gestire ste cacchio di pipe
view post Posted: 9/2/2020, 18:45 Perplessità processi (c,java,python, generico) - Informatica.
Mi piacerebbe approfondire il discorso perche' non mi e' tanto chiaro come fare ad aggirare una sleep().
Appena posso, posto un programmino semplice, e se avete voglia mi fate vedere come fareste voi.
Comunque l'esempio che ho postato a processi funziona bene, non lascia zombie o processi "pendenti"... O cose strane. Vediamo, magari ora posso passare al gioco bruco.
Comunque Dario ncurses, se non erro gira sotto Windows, ma non ne sono sicuro
view post Posted: 9/2/2020, 17:33 Perplessità processi (c,java,python, generico) - Informatica.
CITAZIONE
Durante l'esecuzione di questa istruzione il programma resta fermo per 30msec, che non sono un'eternità ma rendono il tutto poco fluido e, nel caso di applicazioni veloci, creerebbero problemi a non finire.

Mi sa che non sto capendo.
Allora, giustamente 30 ms per un microcontrollore credo sia paragonabile a ore per noi esseri umani: impensabile.
Però credo che stiamo dicendo 2 cose diverse, o forse (moto probabilmente) sono io a non capire.

Voi (Robo e Dario) credo che vediate la cosa dal punto di vista di un sistema embedded dove con un core solo non ha nemmeno senso parlare di processi forse. Il cervello è uno solo, e la contemporaneità o è illusoria o è data da moduli hardware ecc, giusto ?
Io sto parlando di programmazione C su un pc, quindi non ho timer, interrupt (se non internamente gestiti dal kernel) , ma non ne so nulla.
Lo sleep che dite l'ho messo apposta, per fare prove con processi. Di fatto ho simultaneità.
Forse con pic e mu si può impostare timer, settare dei flag ecc.
Ma il timer a sua volta è un modulo hardware che va per i fatti suoi, al pari di un processo.
Non so come spiegare cosa intendo...e non so nemmeno se il mio ragionamento è giusto.
In definitiva, ho l'impressione che gli approcci tra un micro e un pc, siano parecchio diversi, correggetemi nel caso


CITAZIONE
o preferivo cmq il "Fess 'e Soreta e Mammeta" accennato sopra!!

Ci arriviamo prima o poi :) Sempre che abbiate voglia di spiegarmi.
view post Posted: 9/2/2020, 09:41 Perplessità processi (c,java,python, generico) - Informatica.
Domanda: apriamo un nuovo 3d per le macchine a stati finiti ?

Ecco, nel frattempo ho finito la mia prova con processi e pipe.
Sembra funzionare bene...un esercizio, ma ho capito e imparato un po' di cose. Che alla fine è importante.
Il programma è una sciocchezza: una guardia e un ladro si muovono random nel terminale ncurses.
Se si scontrano i processi figli muoiono.
Ho usato le pipe per fare la comunicazione tra i figli e il padre.
I figli scrivono (tutto "impacchettato" in una struttura) e il padre legge e aggiorna il terminale.
é sicuramente migliorabile, soprattutto le funzioni di ncurses, che non conosco bene.
La cancellazione e l'aggiornamento è un po' così casereccio. Ma le migliorie provo dopo.
Ecco :
CODICE
//***********************************************************************************
// programma di prova per gestione processi e pipes.
// piccolo gioco: guardia e ladro si muovono in modo random nel terminale ncurses.
// se si scontrano il programma finisce
// gestione: 1 pipe che susano in comune guardia e ladri per scrivere al padre
// le relative posizioni
// il padre (sempre con la stessa pipe) legge.
// se guardia e ladro occupano la stessa posizione, si esce dalle funzioni
// e vongono "uccisi" i figli"
// gila febb/2020
//***********************************************************************************







#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/wait.h>
#include <string.h>
#include <time.h>
#include <ncurses.h>
#define ROW 24
#define COL 80
#define WRITE 1
#define READ 0

int dir_lat[4]={1,-1,0,0}; // array per direzioni (variabili globali)
int dir_up_down[4]={0,0,-1,1};

void prova_pipe_g(int pipe_out,int start_x_g,int start_y_g);
void prova_pipe_l(int pipe_out,int start_x_l,int start_y_l);
void prova_pipe_r(int pipe_in);



//**********************************************************************
// FUNZIONE GUARDIA        
// genera la struct guardia, pesca a caso una direzione:
// se valida aggiorna posizione e scrive al padre
//**********************************************************************

void prova_pipe_g(int pipe_out,int start_x_g,int start_y_g) //guardia
{
       struct
       {
               int x;
               int y;
               int rnd;
               char name;
       }st_guardia={.x=start_x_g,.y=start_y_g,.name='g'}; // struct guardia

       int rnd,i;
       while(1)
       {
               rnd=rand()%4;
               for (i=0; i<7; i++)
               {
                       if ( (st_guardia.x+dir_lat[rnd]>ROW-1 ||st_guardia.x+dir_lat[rnd]<0)
                               || (st_guardia.y+dir_up_down[rnd]>COL-1 ||st_guardia.y+dir_up_down[rnd]<0))
                               break;

                       else
                       {
                               st_guardia.x+=dir_lat[rnd];
                               st_guardia.y+=dir_up_down[rnd];
                               st_guardia.rnd=rnd;
                               write(pipe_out, &st_guardia, sizeof(st_guardia)); // scrivo  al padre
                               usleep(30000);
                       }
               }
       }
}
               
       
//**********************************************************************
// FUNZIONE LADRO        
// genera la struct guardia, pesca a caso una direzione:
// se valida aggiorna posizione e scrive al padre
//**********************************************************************

void prova_pipe_l(int pipe_out,int start_x_l,int start_y_l) //ladro
{
       srand((unsigned) time(NULL));
       struct
       {
               int x;
               int y;
               int rnd;
               char name;
       }st_ladro={.x=start_x_l,.y=start_y_l,.name='l'}; // NOTA
       
       int rnd,i;
       
       while(1)
       {
               rnd=rand()%4;
               for (i=0; i<7; i++)
               {
                       if ( (st_ladro.x+dir_lat[rnd]>ROW-1 ||st_ladro.x+dir_lat[rnd]<0)
                               || (st_ladro.y+dir_up_down[rnd]>COL-1 ||st_ladro.y+dir_up_down[rnd]<0))
                               break;
                       else
                       {
                               st_ladro.x+=dir_lat[rnd];
                               st_ladro.y+=dir_up_down[rnd];
                               st_ladro.rnd=rnd;
                               write(pipe_out, &st_ladro, sizeof(st_ladro)); // scrivo  al padre
                               usleep(30000);
                       }
               }
       }
}

//**********************************************************************
// FUNZIONE PADRE
//  riceve le posizioni dai figli.
// se ladro e guardia si scontrano, ritorna dove troverà kill
// che uccide i processi
//**********************************************************************





void prova_pipe_r(int pipe_in) // pipe padre(legge)
{
       srand((unsigned) time(NULL));
       struct
       {
               int x;
               int y;
               int rnd;
               char name;
       }st_padre; // NOTA


       
       while(1)
       {
               read(pipe_in,&st_padre,sizeof(st_padre));        // Leggo l'evento
               if (st_padre.name=='g')
               {
                       if (mvinch(st_padre.x,st_padre.y) == 'L') // se spostameno occupato da ladro
                               return ;
                       move(st_padre.x,st_padre.y);
                       addch('G');
                       move (st_padre.x-dir_lat[st_padre.rnd], st_padre.y-dir_up_down[st_padre.rnd]);
                       addch(' ');
               }

               if (st_padre.name=='l')
               {
                       if (mvinch(st_padre.x,st_padre.y) == 'G') // se spostameno occupato da guardia
                               return;        
                       move(st_padre.x,st_padre.y);
                       addch('L');
                       move (st_padre.x-dir_lat[st_padre.rnd], st_padre.y-dir_up_down[st_padre.rnd]);
                       addch(' ');
               }
               refresh();
               
       }
}
       

int main(int argc, char *argv[])
{
       
       int pid[2];
       int my_pipe[2];
       int start_x_g=10;// guardia
       int start_y_g=10;
       int start_x_l=20; //ladro
       int start_y_l=20;
       int x,status;

       initscr();
       cbreak();
       noecho();
       curs_set(0);
       intrflush(stdscr, TRUE);
       keypad(stdscr, TRUE);
       
       
       if (pipe(my_pipe)==-1)
       {
               puts("erroer");
               return -1;
       }

       
       
//********************************************
//                        figlio 1 guardia
//********************************************
       
       pid[0] = fork();
       if ( pid[0] == -1 )
       {
               printf ("Impossibile creare un nuovo processo\n");
               exit(1);
       }

       if ( pid[0] == 0 )
       {
               close (my_pipe[READ]);
               prova_pipe_g(my_pipe[WRITE],start_x_g,start_y_g); //passo descrittore pipe scrittura
               exit(0);
       }    


//********************************************
//                        figlio 2 ladro
//********************************************
       
       pid[1] = fork();
       if ( pid[1] == -1 )
       {
               printf ("Impossibile creare un nuovo processo\n");
               exit(1);
       }

       if ( pid[1] == 0 )
       {
               close (my_pipe[READ]);
               prova_pipe_l(my_pipe[WRITE],start_x_l,start_y_l); //passo descrittore pipe scrittura
               exit(0);
       }


       else // entro nel padre (main)
       {
               
               prova_pipe_r(my_pipe[READ]);
       }

       kill(pid[0],15);
       x=wait(&status);
       printf ("processo %d uscito con %d\n",x,status);
       kill(pid[1],15);
       x=wait(&status);
       printf ("processo %d uscito con %d\n",x,status);
       sleep(3);
       endwin();
       return 0;

}


so che questo è più un forum sull'elettronica. Tutti questi post miei un po' teorici, magari annoiano un po'...lo so.
Ma anche a me piacerebbe riprendere in mano oscilloscopio e quant'altro, ma mi risulta impossibile.
Il mio contributo purtroppo si riduce a questo...spero comunque che un pochino v'interessi

EDIT

Non so se può funzionare per Windows...fatemi sapere nel caso. Ma non credo...

Edited by GILA75 - 9/2/2020, 09:58
view post Posted: 6/2/2020, 22:21 Perplessità processi (c,java,python, generico) - Informatica.
Lascio un attimo in stand-by il 3d per mancanza di tempo, ma con il vostro aiuto, mi piacerebbe davvero approfondire le macchine a stati finiti, appurato che gli automi da me postati, non sono la stessa cosa. Anche se sono molto interessanti anche quelli e ci sarebbe il "mondo" da studiare!!!
view post Posted: 4/2/2020, 21:07 Perplessità processi (c,java,python, generico) - Informatica.
Ci provo, ma la vedo dura. Non pensare minimamente che io abbia l'abilità di programmazione tua e di Robo67...purtroppo.
Comunque, il concetto che ho esposto è quello che intendete voi ?
Io automi a stati finiti e macchine a stati finiti in internet li ho trovati come sinonimi poi bho...
Questo è un discorso parallelo interessantissimo ma cerco comunque di realizzare il gioco a processi...non voglio abbandonare lo studio e le prove. Poi se mi viene, sarebbe bello provare a fare un multitask dei poveri come dici tu.
Sono curioso di capire se i "miei" automi corrispondono alla macchina a stati finiti intesa da te e Robo

view post Posted: 4/2/2020, 19:42 Perplessità processi (c,java,python, generico) - Informatica.
Premetto che forse sarebbe meglio aprire un altro 3d per parlare di macchine o automi a stati finiti.
Ma per ora facciamo qui.
Devo ancora leggere e rileggere il tuo post Robo,mi scuserai, ma il tempo è quello che è.
Come detto gli automi a stati finiti (o macchine a stati finiti, da ricerche, dovrebbero essere la stessa cosa),
io li ho usati e studiati un po' come metodo per la valutazione di stringhe, ma credo che possano fare altro.
Se non erro, ma dovrei ripassare, si possono dividere in deterministici e non deterministici. Nel caso approfondiremo.
A volte può capitare di dover analizzare una stringa e accettarla solo in determinate condizioni. Es:
la "a" può essere seguita solo da una b, ma 2 'a' consecutive ti concedono la' b' e via dicendo....
Si rischia d'impazzire a suon di if...e qualche caso garantito al 100% ti sfugge sempre.
Si può ricorrere allora agli automi.
Nel programmino seguente, la stringa è accetta solo se non contiene a seguito da b (banale, ma è un esempio)
Se non ricordo male, per far ciò si ricorre ad un grafo orientato e pesato.
Orientato nel senso che si va da un punto all'altro con un verso e pesato nel senso che l'arco che li congiunge è legato
ad un evento.
con questo grafico si vede come ho realizzato l'automa "ab". Molto probabilmente si può fare molto meglio con meno nodi,ma erano le prime prove:
E questa è il programma:
CODICE
#include <stdio.h>
#include <stdlib.h>
//--------------------------------------------------------------------
int isvalue(char* s)
{
       char ttable[8][4] =           {{1,3,6,7},
                                               {1,7,2,7},
                                               {1,3,2,7},
                                               {4,3,5,7},
                                               {4,7,3,7},
                                               {3,7,5,7},
                                               {1,3,6,7},
                                               {7,7,7,7}};
       int event;
       int stat = 0;
       while(*s)
       {
           char c = *s++;
               if      (c=='a')           event = 0;
               else if (c=='b')           event = 1;
               else if (c>='c' && c<='z') event = 2;
     
               else                       event = 3;
               stat = ttable[stat][event];  
       }
       return stat==1 || stat==2 || stat==3 || stat==4 || stat==5 || stat==6;
}
//--------------------------------------------------------------------
int  main(void)
{
       char st[128] = "sto abbastanza bene";
       int res;
       res= isvalue(st);
       if (res!=0)
               printf ("stringa accettata\n");
       else
               printf ("stringa NON accettata\n");
       return 0;
               
}


Non so se tutto questo è quello che intendete, e nel caso devo capire bene come lo adattate a quello che dite
view post Posted: 4/2/2020, 19:40 Perplessità processi (c,java,python, generico) - Informatica.
Premetto che forse sarebbe meglio aprire un altro 3d per parlare di macchine o automi a stati finiti.
Ma per ora facciamo qui.
Devo ancora leggere e rileggere il tuo post Robo,mi scuserai, ma il tempo è quello che è.
Come detto gli automi a stati finiti (o macchine a stati finiti, da ricerche, dovrebbero essere la stessa cosa),
io li ho usati e studiati un po' come metodo per la valutazione di stringhe, ma credo che possano fare altro.
Se non erro, ma dovrei ripassare, si possono dividere in deterministici e non deterministici. Nel caso approfondiremo.
A volte può capitare di dover analizzare una stringa e accettarla solo in determinate condizioni. Es:
la "a" può essere seguita solo da una b, ma 2 'a' consecutive ti concedono la' b' e via dicendo....
Si rischia d'impazzire a suon di if...e qualche caso garantito al 100% ti sfugge sempre.
Si può ricorrere allora agli automi.
Nel programmino seguente, la stringa è accetta solo se non contiene a seguito da b (banale, ma è un esempio)
Se non ricordo male, per far ciò si ricorre ad un grafo orientato e pesato.
Orientato nel senso che si va da un punto all'altro con un verso e pesato nel senso che l'arco che li congiunge è legato
ad un evento.
con questo grafico si vede come ho realizzato l'automa "ab". Molto probabilmente si può fare molto meglio con meno nodi,ma erano le prime prove:
view post Posted: 3/2/2020, 21:44 Perplessità processi (c,java,python, generico) - Informatica.
Grazie Robo, oggi e domani ho poco tempo. Ma rileggo bene. Avevo studiato tempo gli automi a stati finiti, e mi sa che grosso modo sono la stessa cosa. Postero' un vecchio codice e dei grafici. Vediamo se intendo bene.
Anche nel caso fosse giusto pero' devo capire bene come utilizzate la cosa voi.
Io gli automi a stati finiti li ho sperimentati al posto delle espressioni regolari.
Magari domani se riesco metto qualcosa, ma dubito
1581 replies since 4/11/2007