<div dir="ltr"><br><div class="gmail_extra"><br><div class="gmail_quote">2016-05-25 18:02 GMT+01:00 alessandro medici <span dir="ltr"><<a href="mailto:alexxandro.medici@gmail.com" target="_blank">alexxandro.medici@gmail.com</a>></span>:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir="ltr"><div class="gmail_extra"><div class="gmail_quote"><span class=""><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left-style:solid;border-left-color:rgb(204,204,204);padding-left:1ex"><div dir="ltr"><div class="gmail_extra"><div class="gmail_quote"><br><div><br></div><div>Scusa... parliamoci chiaro. Diciamo che hai scritto un allocatore che lavora su un chunk di memoria condivisa. </div><div>Che vuole anche dire condivisa fra piu' processi (se no non e' particolarmente interessante).</div><div><br></div><div>Mi spieghi come hai intenzione di fare si che tutto questo non si rompa male *senza* usare lock?</div></div></div></div></blockquote><div><br></div></span><div>Scrivendoci sopra solo quando NON ho altri processi che ci lavorano. </div></div></div></div></blockquote><div><br></div><div>Scusa, e come fai a sapere che gli altri processi *non* ci lavorano? </div><div><br></div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir="ltr"><div class="gmail_extra"><div class="gmail_quote"><div>Per esempio lanciando</div><div>gli altri processi dopo averci scritto sopra, ed ovviamente non parlo</div><div>di allocare nello heap di python (faccio riferimento al primo esempio nella pagina).</div></div></div></div></blockquote><div><br></div><div>Quindi stiamo parlando di un oggetto che scrivi in questa area condivisa (qui c'e' un solo processo).</div><div>Poi crei altri processi, che pero' non possono fare *nulla* con quell'oggetto. Perche'? Perche' anche semplicemente fare f(obj) ha effetto sul reference counting.</div><div>Ma anche o = obj.</div><div><br></div><div>Quindi gli altri processi non possono manco referenziare sto oggetto; non lo possono vedere. </div><div><br></div><div>Ok... sto barando. Potresti avere questo oggetto "magico" nell'area condivisa e poi passarti oggettini che sono solo riferimenti a quell'oggetto (ma che a loro volta non sono condivisi).</div><div><br></div><div>Il problema sarebbe che non hai la semantica di Python (e.g., non puoi aggiungere, togliere un attributo...). Sarebbe un oggetto puramente immutabile. Immutabilissimo.</div><div>E allora quale e' il vantaggio di averlo cacciato in memoria condivisa? Puoi fare cose piu' semplici.</div><div><br></div><div>E non puoi nemmeno avere cose tipo il creatore modifica. Perche'? Perche' dovresti garantire che tutte le modifiche sono atomiche. Ora, siccome non hai lock, non puoi "rendere atomica dal punto di vista di chi legge".</div><div>Puoi *solo* usare cose atomiche per davvero. Tipo, non puoi facilmente avere un dizionario Python... in Python molte operazioni sui dizionari sono atomiche, perche' hai il GIL. Ma in questo caso... il GIL non ce lo hai. Quindi....</div><div><br></div><div>Quindi per fare qualcosa di vagamente utile dovresti risolvere gli stessi problemi che devono risolvere quelli che vogliono levare il GIL. </div><div><br></div><div>Perche' scusa... se sai fare una libreria che ti consente di avere oggetti condivisi fra processi *senza* bisogno di lock, allora direi che sai anche fare una libreria che ti consente di condividere oggetti fra thread *senza* bisogno di lock.</div><div>E a questo punto hai finito, hai vinto. Hai ucciso il GIL.</div><div><br></div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir="ltr"><div class="gmail_extra"><br></div></div></blockquote></div><div><br></div>-- <br><div class="gmail_signature"> .<br>..: -enrico-</div>
</div></div>