{"payload":{"feedbackUrl":"https://github.com/orgs/community/discussions/53140","repo":{"id":691024060,"defaultBranch":"main","name":"Sync","ownerLogin":"SimoneRemoli","currentUserCanPush":false,"isFork":false,"isEmpty":false,"createdAt":"2023-09-13T10:57:47.000Z","ownerAvatar":"https://avatars.githubusercontent.com/u/118252611?v=4","public":true,"private":false,"isOrgOwned":false},"refInfo":{"name":"","listCacheKey":"v0:1706081963.0","currentOid":""},"activityList":{"items":[{"before":"7af8f7cdd8a37033f832be151349132d1ae8c188","after":"f582a3797cc6452f3dfab914853fc57f1b058c0c","ref":"refs/heads/main","pushedAt":"2024-06-26T12:18:05.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"Update README.md","shortMessageHtmlLink":"Update README.md"}},{"before":"280ad56a33b9d34657470f85eaa9927ab8017b3f","after":"7af8f7cdd8a37033f832be151349132d1ae8c188","ref":"refs/heads/main","pushedAt":"2024-04-25T16:46:31.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"[Mappa Mentale] - Corso completo.\n\nCorso ridotto all'osso.","shortMessageHtmlLink":"[Mappa Mentale] - Corso completo."}},{"before":"6f2ed03e1deded768a692e45aff054b4a993d373","after":"280ad56a33b9d34657470f85eaa9927ab8017b3f","ref":"refs/heads/main","pushedAt":"2024-04-25T16:43:30.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"Sistemi_Operativi_Windows_Oggetti\n\nCorso di Sistemi Operativi tenuto dal Prof.Francesco Quaglia presso l'Università degli Studi di Roma Tor Vergata.\r\nLingua: Italiano\r\nPrima Parte: Windows","shortMessageHtmlLink":"Sistemi_Operativi_Windows_Oggetti"}},{"before":"fcfe44152186fc7407800398151ef677885766f1","after":"6f2ed03e1deded768a692e45aff054b4a993d373","ref":"refs/heads/main","pushedAt":"2024-04-25T16:39:48.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"Sistemi_Operativi_6\n\nCorso di Sistemi Operativi tenuto dal Prof.Francesco Quaglia presso l'Università degli Studi di Roma Tor Vergata.\r\nLingua: Italiano\r\nPrima Parte: Gestione della Memoria","shortMessageHtmlLink":"Sistemi_Operativi_6"}},{"before":"b7cf77a997fe94e1e6861cbc889abb9da59292ad","after":"fcfe44152186fc7407800398151ef677885766f1","ref":"refs/heads/main","pushedAt":"2024-04-25T16:32:57.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"Corso_Sistemi_Operativi_5\n\nCorso di Sistemi Operativi tenuto dal Prof.Francesco Quaglia presso l'Università degli Studi di Roma Tor Vergata.\r\nLingua: Italiano\r\nPrima Parte: Le Pipes","shortMessageHtmlLink":"Corso_Sistemi_Operativi_5"}},{"before":"a3d64301a2c19b011938bbca49afce111fff3f02","after":"b7cf77a997fe94e1e6861cbc889abb9da59292ad","ref":"refs/heads/main","pushedAt":"2024-04-25T16:27:15.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"Corso_Sistemi_Operativi_4\n\nCorso di Sistemi Operativi tenuto dal Prof.Francesco Quaglia presso l'Università degli Studi di Roma Tor Vergata.\r\nLingua: Italiano\r\nPrima Parte: Virtual_File_System","shortMessageHtmlLink":"Corso_Sistemi_Operativi_4"}},{"before":"db5b6b5a19b6af71b984ebf071b74bc1e70d18bf","after":"a3d64301a2c19b011938bbca49afce111fff3f02","ref":"refs/heads/main","pushedAt":"2024-04-25T16:19:55.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"Corso_Sistemi_Operativi_3\n\nCorso di Sistemi Operativi tenuto dal Prof.Francesco Quaglia presso l'Università degli Studi di Roma Tor Vergata.\r\nLingua: Italiano\r\nPrima Parte: Scheduling","shortMessageHtmlLink":"Corso_Sistemi_Operativi_3"}},{"before":"5f1f7a9d5b3626fcf5825864eb67a9a8296d712e","after":"db5b6b5a19b6af71b984ebf071b74bc1e70d18bf","ref":"refs/heads/main","pushedAt":"2024-04-25T16:14:24.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"Corso_Sistemi_Operativi\n\nCorso di Sistemi Operativi tenuto dal Prof.Francesco Quaglia presso l'Università degli Studi di Roma Tor Vergata.\r\nLingua: Italiano\r\nPrima Parte: Processi e Threads.","shortMessageHtmlLink":"Corso_Sistemi_Operativi"}},{"before":"2e05fdb5f058884ba0de3f85fb1f5a5f0d8c2178","after":"5f1f7a9d5b3626fcf5825864eb67a9a8296d712e","ref":"refs/heads/main","pushedAt":"2024-04-25T16:11:55.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"Introduzione_Corso_Sistemi_Operativi\n\nCorso di Sistemi Operativi tenuto dal Prof.Francesco Quaglia presso l'Università degli Studi di Roma Tor Vergata.\r\nLingua: Italiano\r\nPrima Parte: Introduzione e storia","shortMessageHtmlLink":"Introduzione_Corso_Sistemi_Operativi"}},{"before":"090e8b0c58c818af61cc69f49e56e6be444dc93f","after":"2e05fdb5f058884ba0de3f85fb1f5a5f0d8c2178","ref":"refs/heads/main","pushedAt":"2024-02-08T12:58:58.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"26_01_2024\n\nScrivere un programma che riceva in input tramite argv[] un insime di N\r\nstringhe, con N maggiore o uguale ad 1, che indicheremo con S1 ... SN.\r\nIl main thread del programma dovra' leggere indefinitamente stringhe dallo standard input\r\ne per ogni nuova stringa letta S dovra' attivare un nuovo thread, che riferiamo come T, \r\npassando a questo nuovo thread la stringa S letta come parametro.\r\n\r\n\r\nQuesto thread T dovra' controllare se la stringa S sia uguale a ciascuna\r\ndelle N stringhe S1 ... SN originariamente ricevute in input dal programma. Per ogni \r\nstringa trovata uguale all'atto del controllo, dovra' essere incrementato un contatore\r\napposito (si presuppne quindi che il programma gestisca N di questi contatori, uno per \r\nognuna delle stringhe S1 ... SN ricevute tramite argv[]).\r\n\r\nL'applicazione dovra' gestire il segnale  SIGINT (o CTRL_C_EVENT nel caso WinAPI) \r\nin modo tale che quando il processo venga colpito il suo main thread dovra' \r\nriportare su standard output il valore degli N contatori, su linee diverse dello \r\nstream di output, associando nel messaggio di output ciascuno dei valori alla relativa \r\nstringa S1 ... SN. La stessa informazione dovra' essere scritta all'interno di un file \r\ndal nome \"output.txt\" in modo che questo contenga sempre e solo i valori dei contatori \r\npiu' aggionati all'atto del processamento del segnale ricevuto.","shortMessageHtmlLink":"26_01_2024"}},{"before":"03299801dbc0d97f8c2a939b4b8ad6d4d1114d8d","after":"090e8b0c58c818af61cc69f49e56e6be444dc93f","ref":"refs/heads/main","pushedAt":"2024-01-24T07:39:23.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"17_10_2019\n\nImplementare una programma che riceva in input, tramite argv[], il nomi\r\ndi N file (con N maggiore o uguale a 1).\r\n\r\nPer ogni nome di file F_i ricevuto input dovra' essere attivato un nuovo thread T_i.\r\nIl main thread dovra' leggere indefinitamente stringhe dallo standard-input \r\ne dovra' rendere ogni stringa letta disponibile ad uno solo degli altri N thread\r\nsecondo uno schema circolare.\r\n\r\nCiascun thread T_i a sua volta, per ogni stringa letta dal main thread e resa a lui disponibile, \r\ndovra' scriverla su una nuova linea del file F_i. \r\n\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando il processo venga colpito esso dovra' \r\nriversare su standard-output e su un apposito file chiamato \"output-file\" il \r\ncontenuto di tutti i file F_i gestiti dall'applicazione \r\nricostruendo esattamente la stessa sequenza di stringhe (ciascuna riportata su \r\nuna linea diversa) che era stata immessa tramite lo standard-input.\r\n\r\nIn caso non vi sia immissione di dati sullo standard-input, l'applicazione dovra' utilizzare \r\nnon piu' del 5% della capacita' di lavoro della CPU.","shortMessageHtmlLink":"17_10_2019"}},{"before":"928434a36de8d75b77a412514326d724e472d6dc","after":"03299801dbc0d97f8c2a939b4b8ad6d4d1114d8d","ref":"refs/heads/main","pushedAt":"2024-01-23T17:02:04.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"07_09_2021\n\nScrivere un programma che riceva in input tramite argv[] N coppie di stringhe \r\ncon N maggiore o uguale a 1, in cui la prima stringa della coppia indica il \r\nnome di un file. \r\n\r\nPer ogni coppia di strighe dovra' essere attivato un processo che dovra' creare \r\nil file associato alla prima delle stringhe della coppia e poi ogni 5 secondi \r\ndovra' effettuare il controllo su quante volte la seconda delle stringhe della \r\ncoppia compare nel file, riportando il risultato su standard output.\r\n\r\n\r\nIl main thread del processo originale dovra' leggere lo stream da standard input in \r\nmodo indefinito, e dovra' scrivere i byte letti in uno dei file identificati \r\ntramite i nomi passati con argv[]. \r\n\r\nLa scelta del file dove scrivere dovra' \r\navvenire in modo circolare a partire dal primo file identificato tramite argv[], \r\ne il cambio del file destinazione dovra' avvenire qualora venga ricevuto il \r\nsegnale SIGINT (o CTRL_C_EVENT nel caso WinAPI).\r\n\r\n\r\n\r\nSe il segnale SIGINT (o CTRL_C_EVENT nel caso WinAPI) colpira' invece uno degli \r\naltri processi, questo dovra' riportare il contenuto del file che sta gestendo \r\nsu standard output.","shortMessageHtmlLink":"07_09_2021"}},{"before":"0c690bb0fca90a9bd3187309d865795507f519a1","after":"928434a36de8d75b77a412514326d724e472d6dc","ref":"refs/heads/main","pushedAt":"2024-01-23T14:26:37.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"07_09_2021\n\nScrivere un programma che riceva in input tramite argv[] N coppie di stringhe \r\ncon N maggiore o uguale a 1, in cui la prima stringa della coppia indica il \r\nnome di un file. \r\n\r\nPer ogni coppia di strighe dovra' essere attivato un processo che dovra' creare \r\nil file associato alla prima delle stringhe della coppia e poi ogni 5 secondi \r\ndovra' effettuare il controllo su quante volte la seconda delle stringhe della \r\ncoppia compare nel file, riportando il risultato su standard output.\r\n\r\n\r\nIl main thread del processo originale dovra' leggere lo stream da standard input in \r\nmodo indefinito, e dovra' scrivere i byte letti in uno dei file identificati \r\ntramite i nomi passati con argv[]. \r\n\r\nLa scelta del file dove scrivere dovra' \r\navvenire in modo circolare a partire dal primo file identificato tramite argv[], \r\ne il cambio del file destinazione dovra' avvenire qualora venga ricevuto il \r\nsegnale SIGINT (o CTRL_C_EVENT nel caso WinAPI).\r\n\r\n\r\n\r\nSe il segnale SIGINT (o CTRL_C_EVENT nel caso WinAPI) colpira' invece uno degli \r\naltri processi, questo dovra' riportare il contenuto del file che sta gestendo \r\nsu standard output.","shortMessageHtmlLink":"07_09_2021"}},{"before":"b1b7142e149fc8eb780f7be1fbdb40b741807895","after":"0c690bb0fca90a9bd3187309d865795507f519a1","ref":"refs/heads/main","pushedAt":"2024-01-22T10:26:39.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"18_07_2018_B\n\nImplementare un programma che riceva in input tramite argv[] i pathname \r\nassociati ad N file, con N maggiore o uguale ad 1. Per ognuno di questi\r\nfile generi un thread (quindi in totale saranno generati N nuovi thread \r\nconcorrenti). \r\nSuccessivamente il main-thread acquisira' stringhe da standard input in \r\nun ciclo indefinito, ed ognuno degli N thread figli dovra' scrivere ogni\r\nstringa acquisita dal main-thread nel file ad esso associato.\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso \r\nWinAPI) in modo tale che quando uno qualsiasi dei thread dell'applicazione\r\nvenga colpito da esso dovra' stampare a terminale tutte le stringhe gia' \r\nimmesse da standard-input e memorizzate nei file destinazione.","shortMessageHtmlLink":"18_07_2018_B"}},{"before":"a4c5cda9509027b4ba56f3a7dad2b7a30efe223c","after":"b1b7142e149fc8eb780f7be1fbdb40b741807895","ref":"refs/heads/main","pushedAt":"2024-01-22T09:18:37.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"7_09_2018\n\nImplementare un'applicazione che riceva in input tramite argv[] il \r\nnome di un file F ed una stringa indicante un valore numerico N maggiore\r\no uguale ad 1.\r\nL'applicazione, una volta lanciata dovra' creare il file F ed attivare \r\nN thread. Inoltre, l'applicazione dovra' anche attivare un processo \r\nfiglio, in cui vengano attivati altri N thread. \r\nI due processi che risulteranno attivi verranno per comodita' identificati\r\ncome A (il padre) e B (il figlio) nella successiva descrizione.\r\n\r\nCiascun thread del processo A leggera' stringhe da standard input. \r\nOgni stringa letta dovra' essere comunicata al corrispettivo thread \r\ndel processo B tramite memoria condivisa, e questo la scrivera' su una \r\nnuova linea del file F. Per semplicita' si assuma che ogni stringa non\r\necceda la taglia di 4KB. \r\n\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando il processo A venga colpito esso dovra' \r\ninviare la stessa segnalazione verso il processo B. Se invece ad essere \r\ncolpito e' il processo B, questo dovra' riversare su standard output il \r\ncontenuto corrente del file F.","shortMessageHtmlLink":"7_09_2018"}},{"before":"c519d78a33e1da958073d6ad2e5617f2622030d9","after":"a4c5cda9509027b4ba56f3a7dad2b7a30efe223c","ref":"refs/heads/main","pushedAt":"2024-01-21T14:19:29.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"26_06_2021_6CFU\n\n26_06_2021_6CFU\r\nImplementare una programma che riceva in input, tramite argv[], il nome\r\ndi un file F. Il programma dovra' creare il file F e popolare il file\r\ncon lo stream proveniente da standard-input. Il programma dovra' generare\r\nanche un ulteriore processo il quale dovra' riversare il contenuto del file F\r\nsu un altro file denominato shadow_F, inserendo mano a mano in shadow_F soltanto \r\ni byte che non erano ancora stati prelevati in precedenza da F. L'operazione \r\ndi riversare i byte di F su shadow_F dovra' avvenire con una periodicita' di 10\r\nsecondi.  \r\n\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando un qualsiasi processo (parent o child) venga colpito si\r\ndovra' immediatamente riallineare il contenuto del file shadow_F al contenuto\r\ndel file F sempre tramite operazioni che dovra' eseguire il processo child.","shortMessageHtmlLink":"26_06_2021_6CFU"}},{"before":"aa06065b28c00e830a4850e0eb826c65899506e2","after":"c519d78a33e1da958073d6ad2e5617f2622030d9","ref":"refs/heads/main","pushedAt":"2024-01-21T12:22:36.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"23_01_2019\n\nImplementare una programma che riceva in input, tramite argv[], il nome\r\ndi un file F ed N stringhe S_1 .. S_N (con N maggiore o uguale\r\nad 1.\r\n\r\nPer ogni stringa S_i dovra' essere attivato un nuovo thread T_i, che fungera'\r\nda gestore della stringa S_i.\r\nIl main thread dovra' leggere indefinitamente stringhe dallo standard-input. \r\nOgni nuova stringa letta dovra' essere comunicata a tutti i thread T_1 .. T_N\r\ntramite un buffer condiviso, e ciascun thread T_i dovra' verificare se tale\r\nstringa sia uguale alla stringa S_i da lui gestita. In caso positivo, ogni\r\ncarattere della stringa immessa dovra' essere sostituito dal carattere '*'.\r\nDopo che i thread T_1 .. T_N hanno analizzato la stringa, ed eventualmente questa\r\nsia stata modificata, il main thread dovra' scrivere tale stringa (modificata o non)\r\nsu una nuova linea del file F. \r\nIn altre parole, la sequenza di stringhe provenienti dallo standard-input dovra' \r\nessere riportata su file F in una forma 'epurata'  delle stringhe S1 .. SN, \r\nche verranno sostituite da strighe  della stessa lunghezza costituite esclusivamente\r\nda sequenze del carattere '*'.\r\nInoltre, qualora gia' esistente, il file F dovra' essere troncato (o rigenerato) \r\nall'atto del lancio dell'applicazione.\r\n\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando il processo venga colpito esso dovra' \r\nriversare su standard-output il contenuto corrente del file F.","shortMessageHtmlLink":"23_01_2019"}},{"before":"c5c670f823d3028a096339cdeb565fbdf4974bb7","after":"aa06065b28c00e830a4850e0eb826c65899506e2","ref":"refs/heads/main","pushedAt":"2024-01-20T16:13:47.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"21_07_2021_6_CFU\n\nImplementare una programma che riceva in input, tramite argv[], il nome\r\ndi un file F e un insieme di N stringhe (con N almeno pari ad 1). Il programa dovra' creare \r\nil file F e popolare il file con le stringhe provenienti da standard-input. \r\nOgni stringa dovra' essere inserita su una differente linea del file.\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando il processo venga colpito si\r\ndovranno  generare N thread concorrenti ciascuno dei quali dovra' analizzare il contenuto\r\ndel file F e verificare, per una delle N stringhe di input, quante volte tale stringa \r\nsia presente nel file. Il risultato del controllo dovra' essere comunicato su standard\r\noutput tramite un messaggio. Quando tutti i thread avranno completato questo controllo, \r\nil contenuto del file F dovra' essere inserito in \"append\" in un file denominato \"backup\"\r\ne poi il file F dovrà essere troncato.","shortMessageHtmlLink":"21_07_2021_6_CFU"}},{"before":"f293ee147a4a063b4a44c3a68b32595ec3cf45f1","after":"c5c670f823d3028a096339cdeb565fbdf4974bb7","ref":"refs/heads/main","pushedAt":"2024-01-18T18:29:58.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"26_06_2018_A\n\nImplementare un programma che riceva in input tramite argv[1] un numero\r\nintero N maggiore o uguale ad 1 (espresso come una stringa di cifre \r\ndecimali), e generi N nuovi thread. Ciascuno di questi, a turno, dovra'\r\ninserire in una propria lista basata su memoria dinamica un record\r\nstrutturato come segue:\r\n\r\ntypedef struct _data{\r\n\tint val;\r\n\tstruct _data* next;\r\n} data; \r\n\r\nI record vengono generati e popolati dal main thread, il quale rimane\r\nin attesa indefinita di valori interi da standard input. Ad ogni nuovo\r\nvalore letto avverra' la generazione di un nuovo record, che verra'\r\ninserito da uno degli N thread nella sua lista. \r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando il processo venga colpito esso dovra' \r\nstampare a terminale il contenuto corrente di tutte le liste (ovvero \r\ni valori interi presenti nei record correntemente registrati nelle liste\r\ndi tutti gli N thread).","shortMessageHtmlLink":"26_06_2018_A"}},{"before":"65590b23cbb9f7d4214b22d7b905110eda9ca344","after":"f293ee147a4a063b4a44c3a68b32595ec3cf45f1","ref":"refs/heads/main","pushedAt":"2024-01-18T17:37:08.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"19_09_2018\n\nImplementare un programma che riceva in input tramite argv[] i pathname\r\nassociati ad N file (F1 ... FN), con N maggiore o uguale ad 1.\r\nPer ognuno di questi file generi un thread che gestira' il contenuto del file.\r\nDopo aver creato gli N file ed i rispettivi N thread, il main thread dovra'\r\nleggere indefinitamente la sequenza di byte provenienti dallo standard-input.\r\nOgni 5 nuovi byte letti, questi dovranno essere scritti da uno degli N thread\r\nnel rispettivo file. La consegna dei 5 byte da parte del main thread\r\ndovra' avvenire secondo uno schema round-robin, per cui i primi 5 byte\r\ndovranno essere consegnati al thread in carico di gestire F1, i secondi 5\r\nbyte al thread in carico di gestire il F2 e cosi' via secondo uno schema\r\ncircolare.\r\n\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando il processo venga colpito esso dovra',\r\na partire dai dati correntemente memorizzati nei file F1 ... FN, ripresentare\r\nsullo standard-output la medesima sequenza di byte di input originariamente\r\nletta dal main thread dallo standard-input.","shortMessageHtmlLink":"19_09_2018"}},{"before":"a4f74ded13433728e5f45ba178d7e95929ef1a8f","after":"65590b23cbb9f7d4214b22d7b905110eda9ca344","ref":"refs/heads/main","pushedAt":"2024-01-18T14:05:20.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"18_07_2018_A\n\nImplementare un programma che riceva in input tramite argv[] i pathname \r\nassociati ad N file, con N maggiore o uguale ad 1.\r\n\r\nPer ognuno di questi file generi un processo che legga tutte le stringhe contenute in quel file\r\ne le scriva in un'area di memoria condivisa con il processo padre. Si \r\nsupponga per semplicita' che lo spazio necessario a memorizzare le stringhe\r\ndi ognuno di tali file non ecceda 4KB. \r\nIl processo padre dovra' attendere che tutti i figli abbiano scritto in \r\nmemoria il file a loro associato, e successivamente dovra' entrare in pausa\r\nindefinita.\r\nD'altro canto, ogni figlio dopo aver scritto il contenuto del file nell'area \r\ndi memoria condivisa con il padre entrera' in pausa indefinita.\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando il processo padre venga colpito da esso dovra' \r\nstampare a terminale il contenuto corrente di tutte le aree di memoria \r\ncondivise anche se queste non sono state completamente popolate dai processi \r\nfigli.","shortMessageHtmlLink":"18_07_2018_A"}},{"before":"afb512a08359145d88fdd993c479ca106a5b41e0","after":"a4f74ded13433728e5f45ba178d7e95929ef1a8f","ref":"refs/heads/main","pushedAt":"2024-01-18T12:53:03.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"21_07_2021_9_CFU\n\nImplementare una programma che riceva in input, tramite argv[], il nome\r\ndi un file F e un insieme di N stringhe (con N almeno pari ad 1). Il programa dovra' creare \r\nil file F e popolare il file con le stringhe provenienti da standard-input. \r\nOgni stringa dovra' essere inserita su una differente linea del file.\r\n\r\n\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando il processo venga colpito si\r\ndovranno  generare N processi concorrenti ciascuno dei quali dovra' analizzare il contenuto\r\ndel file F e verificare, per una delle N stringhe di input, quante volte la inversa di tale stringa \r\nsia presente nel file. Il risultato del controllo dovra' essere comunicato su standard\r\noutput tramite un messaggio. Quando tutti i processi avranno completato questo controllo, \r\nil contenuto del file F dovra' essere inserito in \"append\" in un file denominato \"backup\"\r\ne poi il file F dova' essere troncato.\r\n\r\nQualora non vi sia immissione di input o di segnali, l'applicazione dovra' utilizzare \r\nnon piu' del 5% della capacita' di lavoro della CPU.","shortMessageHtmlLink":"21_07_2021_9_CFU"}},{"before":"3a6dedd781d75aedc2411a5566eed39cefeeb343","after":"afb512a08359145d88fdd993c479ca106a5b41e0","ref":"refs/heads/main","pushedAt":"2024-01-17T15:08:15.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"26_06_2021_9CFU\n\nImplementare una programma che riceva in input, tramite argv[], il nome\r\ndi un file F. Il programa dovra' creare il file F e popolare il file\r\ncon lo stream priveniente da standard-input. Il programma dovra' generare\r\nanche un ulteriore processo il quale dovra' riversare il contenuto  che \r\nviene inserito in F su un altro file denominato shadow_F, tale inserimento\r\ndovra' essere realizzato in modo concorrente rispetto all'inserimento dei dati su F.\r\n\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando un qualsiasi processo (parent o child) venga colpito si\r\ndovra' immediatamente emettere su standard-output il contenuto del file \r\nche il processo child sta popolando.","shortMessageHtmlLink":"26_06_2021_9CFU"}},{"before":"eca96e3fb23ff5a9b05a807a7793048ad1fe6c86","after":"3a6dedd781d75aedc2411a5566eed39cefeeb343","ref":"refs/heads/main","pushedAt":"2024-01-17T13:01:45.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"19_09_2018\n\nImplementare un programma che riceva in input tramite argv[] i pathname\r\nassociati ad N file (F1 ... FN), con N maggiore o uguale ad 1.\r\nPer ognuno di questi file generi un thread che gestira' il contenuto del file.\r\nDopo aver creato gli N file ed i rispettivi N thread, il main thread dovra'\r\nleggere indefinitamente la sequenza di byte provenienti dallo standard-input.\r\nOgni 5 nuovi byte letti, questi dovranno essere scritti da uno degli N thread\r\nnel rispettivo file. La consegna dei 5 byte da parte del main thread\r\ndovra' avvenire secondo uno schema round-robin, per cui i primi 5 byte\r\ndovranno essere consegnati al thread in carico di gestire F1, i secondi 5\r\nbyte al thread in carico di gestire il F2 e cosi' via secondo uno schema\r\ncircolare.\r\n\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando il processo venga colpito esso dovra',\r\na partire dai dati correntemente memorizzati nei file F1 ... FN, ripresentare\r\nsullo standard-output la medesima sequenza di byte di input originariamente\r\nletta dal main thread dallo standard-input.","shortMessageHtmlLink":"19_09_2018"}},{"before":"d9a05b0c5d75c20f0159f03d65693d8acb8dd5a9","after":"eca96e3fb23ff5a9b05a807a7793048ad1fe6c86","ref":"refs/heads/main","pushedAt":"2024-01-17T10:12:39.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"18_09_2019\n\nImplementare una programma che riceva in input, tramite argv[], un insieme di\r\nstringhe S_1 ..... S_n con n maggiore o uguale ad 1. \r\n\r\nPer ogni stringa S_i dovra' essere attivato un thread T_i.\r\nIl main thread dovra' leggere indefinitamente stringhe dallo standard-input.\r\nOgni stringa letta dovra' essere resa disponibile al thread T_1 che dovra' \r\neliminare dalla stringa ogni carattere presente in S_1, sostituendolo con il \r\ncarattere 'spazio'.\r\nSuccessivamente T_1 rendera' la stringa modificata disponibile a T_2 che dovra' \r\neseguire la stessa operazione considerando i caratteri in S_2, e poi la passera' \r\na T_3 (che fara' la stessa operazione considerando i caratteri in S_3) e cosi' \r\nvia fino a T_n. \r\n\r\nT_n, una volta completata la sua operazione sulla stringa ricevuta da T_n-1, dovra'\r\npassare la stringa ad un ulteriore thread che chiameremo OUTPUT il quale dovra' \r\nstampare la stringa ricevuta su un file di output dal nome output.txt.\r\nSi noti che i thread lavorano secondo uno schema pipeline, sono ammesse quindi \r\noperazioni concorrenti su differenti stringhe lette dal main thread dallo \r\nstandard-input.\r\n\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando il processo venga colpito esso dovra' \r\nstampare il contenuto corrente del file output.txt su standard-output.","shortMessageHtmlLink":"18_09_2019"}},{"before":"7feb16891244fb3475f81cb5e78f7e87122cb10a","after":"d9a05b0c5d75c20f0159f03d65693d8acb8dd5a9","ref":"refs/heads/main","pushedAt":"2024-01-16T17:42:59.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"7_09_2021\n\nScrivere un programma che riceva in input tramite argv[] N coppie di stringhe \r\ncon N maggiore o uguale a 1, in cui la prima stringa della coppia indica il \r\nnome di un file. \r\n\r\nPer ogni coppia di strighe dovra' essere attivato un processo che dovra' creare \r\nil file associato alla prima delle stringhe della coppia e poi ogni 5 secondi \r\ndovra' effettuare il controllo su quante volte la seconda delle stringhe della \r\ncoppia compare nel file, riportando il risultato su standard output.\r\n\r\n\r\nIl main thread del processo originale dovra' leggere lo stream da standard input in \r\nmodo indefinito, e dovra' scrivere i byte letti in uno dei file identificati \r\ntramite i nomi passati con argv[]. \r\n\r\nLa scelta del file dove scrivere dovra' \r\navvenire in modo circolare a partire dal primo file identificato tramite argv[], \r\ne il cambio del file destinazione dovra' avvenire qualora venga ricevuto il \r\nsegnale SIGINT (o CTRL_C_EVENT nel caso WinAPI).\r\n\r\n\r\n\r\nSe il segnale SIGINT (o CTRL_C_EVENT nel caso WinAPI) colpira' invece uno degli \r\naltri processi, questo dovra' riportare il contenuto del file che sta gestendo \r\nsu standard output.","shortMessageHtmlLink":"7_09_2021"}},{"before":"7d3c4d1c3c23ab21992681e22a28ccb8bee5178d","after":"7feb16891244fb3475f81cb5e78f7e87122cb10a","ref":"refs/heads/main","pushedAt":"2024-01-16T14:57:52.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"26_06_2018_B\n\nImplementare un programma che riceva in input tramite argv[2] un numero\r\nintero N maggiore o uguale ad 1 (espresso come una stringa di cifre \r\ndecimali), e generi N nuovi processi. Ciascuno di questi leggera' in modo \r\ncontinuativo un valore intero da standard input, e lo comunichera' al\r\nprocesso padre tramite memoria condivisa. Il processo padre scrivera' ogni\r\nnuovo valore intero ricevuto su di un file, come sequenza di cifre decimali. \r\nI valori scritti su file devono essere separati dal carattere ' ' (blank).\r\nIl pathname del file di output deve essere comunicato all'applicazione \r\ntramite argv[1].\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che se il processo padre venga colpito il contenuto\r\ndel file di output venga interamente riversato su standard-output.\r\nNel caso in cui non vi sia immissione in input, l'applicazione non deve \r\nconsumare piu' del 5% della capacita' di lavoro della CPU.","shortMessageHtmlLink":"26_06_2018_B"}},{"before":"cacfa93ea0ba72a15fdcb689fa5d9c734780b0c1","after":"7d3c4d1c3c23ab21992681e22a28ccb8bee5178d","ref":"refs/heads/main","pushedAt":"2024-01-16T13:22:30.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"21_01_2020\n\nImplementare una programma che ricevendo in input tramite argv[] una stringa S\r\nesegua le seguenti attivita'.\r\nIl main thread dovra' attivare due nuovi thread, che indichiamo con T1 e T2.\r\nSuccessivamente il main thread dovra' leggere indefinitamente caratteri dallo \r\nstandard input, a blocchi di 5 per volta, e dovra' rendere disponibili i byte \r\nletti a T1 e T2. \r\nIl thread T1 dovra' inserire di volta in volta i byte ricevuti dal main thread \r\nin coda ad un file di nome S_diretto, che dovra' essere creato. \r\nIl thread T2 dovra' inserirli invece nel file S_inverso, che dovra' anche esso \r\nessere creato, scrivendoli ogni volta come byte iniziali del file (ovvero in testa al \r\nfile secondo uno schema a pila).\r\n\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando il processo venga colpito esso dovra' \r\ncalcolare il numero dei byte che nei due file hanno la stessa posizione ma sono\r\ntra loro diversi in termini di valore. Questa attivita' dovra' essere svolta attivando \r\nper ogni ricezione di segnale un apposito thread.","shortMessageHtmlLink":"21_01_2020"}},{"before":"b7332e1cb8e05296d37e97651445beedb70df592","after":"cacfa93ea0ba72a15fdcb689fa5d9c734780b0c1","ref":"refs/heads/main","pushedAt":"2024-01-15T10:03:37.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"17_10_2019_NewVersion\n\nImplementare una programma che riceva in input, tramite argv[], il nomi\r\ndi N file (con N maggiore o uguale a 1).\r\n\r\nPer ogni nome di file F_i ricevuto input dovra' essere attivato un nuovo thread T_i.\r\nIl main thread dovra' leggere indefinitamente stringhe dallo standard-input \r\ne dovra' rendere ogni stringa letta disponibile ad uno solo degli altri N thread\r\nsecondo uno schema circolare.\r\n\r\nCiascun thread T_i a sua volta, per ogni stringa letta dal main thread e resa a lui disponibile, \r\ndovra' scriverla su una nuova linea del file F_i. \r\n\r\nL'applicazione dovra' gestire il segnale SIGINT (o CTRL_C_EVENT nel caso\r\nWinAPI) in modo tale che quando il processo venga colpito esso dovra' \r\nriversare su standard-output e su un apposito file chiamato \"output-file\" il \r\ncontenuto di tutti i file F_i gestiti dall'applicazione \r\nricostruendo esattamente la stessa sequenza di stringhe (ciascuna riportata su \r\nuna linea diversa) che era stata immessa tramite lo standard-input.\r\n\r\nIn caso non vi sia immissione di dati sullo standard-input, l'applicazione dovra' utilizzare \r\nnon piu' del 5% della capacita' di lavoro della CPU.","shortMessageHtmlLink":"17_10_2019_NewVersion"}},{"before":"8d511239c629358ce2fe09d408d05913439d2a00","after":"b7332e1cb8e05296d37e97651445beedb70df592","ref":"refs/heads/main","pushedAt":"2024-01-13T17:01:55.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"SimoneRemoli","name":"Simone Remoli","path":"/SimoneRemoli","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/118252611?s=80&v=4"},"commit":{"message":"17_09_2021\n\nScrivere un programma che riceva in input tramite argv[] il nome di un file\r\nF e una stringa S contenente un numero arbitrario di caratteri. \r\nIl main thread dell'applicazione dovra' creare il file F e poi leggere indefinitamente \r\nstringhe dallo standard input per poi scriverle, una per riga, all'interno del file.\r\n\r\nQualora venga ricevuto il segnale SIGINT (o CTRL_C_EVENT nel caso WinAPI), dovra'\r\nessere lanciato un nuovo thread che riporti il contenuto del file F all'interno di un \r\naltro file con lo stesso nome, ma con suffisso \"_shadow\", sostituendo tutte le stringhe\r\nche coincidono con la stringha S ricevuta dall'applicazione tramite argv[] con \r\nuna stringha della stessa lunghezza costituita da una sequenza di caratteri '*'.\r\nIl lavoro di questo thread dovra' essere incrementale, ovvero esso dovra' riportare \r\nsul file shadow solo le parti del file originale che non erano state riportate in \r\nprecedenza. Al termine di questa operazione, il thread dovra' indicare su standard \r\noutput il numero di stringhe che sono state sostituite in tutto.","shortMessageHtmlLink":"17_09_2021"}}],"hasNextPage":true,"hasPreviousPage":false,"activityType":"all","actor":null,"timePeriod":"all","sort":"DESC","perPage":30,"cursor":"djE6ks8AAAAEb7CceQA","startCursor":null,"endCursor":null}},"title":"Activity · SimoneRemoli/Sync"}