[.net] Memoria Condivisa

[adidas_2012]

ciao a tutti ho seguito vari post ma ancora non ne sono venuto a capo.. ..voglio in pratica avere due programmi scritti in C# che interagiscono con Vb,i due programmi in C interagiscono sulla memoria condivisa, RAM la form in Vb pasa solo i dati e richiamo le funzioni in C... piu in pratica:

Ho un programma in vb che dalla textbox mi fa inserire una frase ad esempio "ciao" quindi lo passa al programma C# che non fa altro che inizializzare una zona di memoria Ram scriverci sopra la stringa "ciao"

il secondo programma deve leggere la stessa zona di memoria prelevare la variabile e immetterla in una textbox.
da notare i processi sono separati e indipendenti,in rete si trova qualcosa ma parliamo di uno stesso programma che scrive e legge nello stesso processo,a me serve un mano se qualcuno me la può dare nel fare la stessa cosa

http://blogs.ugidotnet.org/fpranio/a...-processi.aspx

questo è il link dell'articolo molto bene fatto.

spero sia chiaro cosa deve fare...

[oregon]

Lavorare con quel tipo di API mi sembra eccessivo.

Se i tuoi processi si devono scambiare dati, lo possono fare molto più semplicemente con un socket.

[adidas_2012]

Certo,oregon ma il programma percui sto scrivendo questo tipo di applicazione è molto piu complesso qui ho solo cercato di esplicitare il problema,i socket sono troppo lenti rispetto Ram per questo ho bisogno di questa soluzione cmq accetto consigli a riguardo

[oregon]

Se lo scambio avviene localmente (tra due processi nella stessa macchina) non dovresti avere problemi di velocità con i socket (dato che non esiste reale comunicazione di rete ma i dati sono scambiati in memoria tra strutture interne).

In ogni caso, se dai maggiori dettagli del problema/applicazione, si può dare un aiuto più preciso ...

[adidas_2012]

Certo cerchero di essere un po piu esplicativo cercando di rispondere a tutte le domande del caso:

1) perche la memoria condivisa e non i socket
due processi si scambiano grandi quantità di dati e la lettura devono essere molto veloci, e parliamo di software in contesti dove la sicurezza è un requisito ad alta priorità, gestione di un impianto industriale in real time.

2) Software che si vuole sviluppare.

immagina questo un processo legge dei dati da alcuni sensori che regolano il funzionamento di un macchinario, e li devi inviare ad una macchina che supervisiona il lavoro, come nell'articolo che vi ho postato dove è molto spiegato bene,ora come i dati dei sensori sono elaborati non è un problema, e neanche coma la macchina legge e interpreta i dati ,(leviamo un po di problematiche a monte al fine di semplificare il discorso)

diciamo questo ho due processi fondamentalmente:

io creo una windows form con un txtbox e un pulsante, l'utente immette una stringa nel txtbox e quando premo il pulsante "vorrei" richiamare il mio applicativo in c# a cui passo questa stringa, che,inizializza una zona di memoria sulla RAM la riserva,con privilegi di lettura e scrittura, e scrive questa stringa.


un'altra form che parte da un secondo programma , ha sempre una txtbox e ed un pulsante ,che invece legge,alla pressione del pulsante "vorrei" che viene richiamato un applicativo in c# che, riesce ad accedere alla stessa zona di memoria,legge la stringa e la visualizza nella txtbox.

spero di essere stato piu chiaro,seguendo il link dell'articolo si capisce cosa voglio fare,ora,quello che ho postato ha una limitazione lettore e scrittore sono nello stesso programma,percui non si creano problemi,perchè "mi sembra" che il processo sia lo stesso,di fatti ho ricopiato il codice e testato ed in effetti funziona, ma se io "volessi"
separare lettore e scrittore su due form diverse??

sperando di essere stato un pò più chiaro ti ringrazio in anticpo.

[oregon]

Premesso che ho realizzato un software del genere (con molti processi relativi a codice C/C++ che acquisivano dati ad alta velocità e un programma in C#, altro processo, che li gestiva tramite memoria condivisa), le cose non sono semplicissime, anzi.

1) perche la memoria condivisa e non i socket
due processi si scambiano grandi quantità di dati e la lettura devono essere molto veloci, e parliamo di software in contesti dove la sicurezza è un requisito ad alta priorità, gestione di un impianto industriale in real time.

Ho molte perplessità :

a) Windows (e le relative applicazioni) non è un sistema operativo "real time" e i tempi di elaborazione non sono deterministici. E' comunque un sistema soggetto a ritardi imprevedibili che possono pregiudicare certi tipi di lavoro;

b) in ogni caso il sistema è esposto a malfunzionamenti di qualsiasi genere (non ultimi, crash del sistema operativo) e quindi non è affatto adatto in un ambiente industriale critico (dovresti usare sistemi appositamente progettati e dedicati al mondo industriale)

c) per lo scambio di dati in memoria condivisa tra due processi, devi implementare un sistema "robusto" di sincronizzazione, in modo che il processo "consumatore" non legga dati che non sono ancora stati scritti totalmente o che non riesca a "star dietro" al produttore. Dovrai quindi avere a che fare con mutex, semafori e affini.

immagina questo un processo legge dei dati da alcuni sensori che regolano il funzionamento di un macchinario, e li devi inviare ad una macchina che supervisiona il lavoro,

Dipende dalla velocità di acquisizione dei dati e dalla loro quantità.
Nel software di cui ti parlavo e che ho scritto per delle misurazioni industriali, l'acquisizione era molto veloce.

ma se io "volessi"
separare lettore e scrittore su due form diverse??

Due form o due processi?

E' differente ...

In ogni caso, cosa hai scritto ? Hai già del codice che non funziona ?

[MItaly]

La domanda è: quanti sono questi "tanti dati" da scambiare, almeno a livello di ordine di grandezza? Perché se non ci sono problemi di prestazioni io eviterei la memoria condivisa come la peste per i motivi di sincronizzazione citati da oregon - e questo vale in particolare se si tratta di un'applicazione industriale che non si deve intoppare nella maniera più assoluta; scegliere di perdere qualcosa in prestazioni (purché ovviamente restino accettabili) ma evitare il rischio di race conditions e deadlock a mio avviso è la cosa più ragionevole per avere un sistema robusto.
Inoltre, come detto, un socket locale non fa altro che passare i dati in memoria, per cui le prestazioni sono comunque elevate; ma soprattutto, è il sistema operativo che ti dà delle garanzie di sincronizzazione (quindi non rischi di fare errori nell'implementare il tuo), ed è un modello di sincronizzazione sufficientemente semplice/prevedibile da non darti particolari preoccupazioni. Infine, se per qualche motivo in futuro dovessi spostare uno dei due processi su un'altra macchina, non devi cambiare quasi nulla della logica del programma.

[adidas_2012]

rispondiamo con calma a partire da Oregon:
1) CITAZIONE Le tue perplessità nei punti a e b sono giustissime, con real time mi sono espresso male intendendo altro, ma cmq non soffermiamoci sul discorso potrebbe durare mesi e in ogni caso purtroppo su windows devo lavorare, per quanto riguarda il punto c hai colto l'essenza voglio creare un software "robusto" scendo nei dettagli per chiarire ,
la mia idea per la sincronizzazione tra lettura e scrittura e questa:
crare un mapping della memoria condivisa, e una coda di scrittura,ogni volta che inserisco un valore questo finisce nella mia coda di scrittura, che successivamente vado a scrivere nella mia memoria condivisa(ho gia codice che ti vorrei mostrare per discuterne e valutare errori)
2) CITAZIONE i velocità mi preoccupa meno, ma quantità di dati che devo elaborare sono molteplici
cerco che potrei valutare la soluzione implementata da te,e come adeguarla alla mia esigenza
3) CITAZIONE ho stra-sbagliato io a scrivere parlo di processi differenti,con le form sarebbe tutto più semplice e ho gia visto la soluzione nell'articolo che ho postato.

ho del codice abb. lungo ma non so come poterlo condividere con voi per studiarlo insieme....suggerimenti??


---per Mitaly---- hai ragione nel tuo post, ma oltre alla grande mole di dati che vado ad utilizzare questa parte del progetto memoria condivisa va ad integrarsi con altri task,per questo i socket non sono un ipotesi che ho valutato ecco tutto qua.


GRAZIE AD ENTRAMBI PER LA CORTESIA CHE MI STATE DIMOSTRANDO.

[oregon]

Beh ... anche se è lungo, cominciamo a vedere il codice nelle parti fondamentali ...

P.S. Sarebbe meglio farlo in C#, se non altro perché preferisco la sintassi ...

[adidas_2012]

public class Memoria Condivisa
    {

        [DllImport("kernel32.dll")]
        static extern IntPtr CreateFileMapping(IntPtr hFile, IntPtr lpAttributes, uint fProtect, uint dwMaximumSizeHigh, uint dwMaximumSizeLow, string lpName);
        [DllImport("kernel32.dll")]
        static extern IntPtr OpenFileMapping(uint dwDesiredAccess, bool bInheritHandle, string lpName);
        [DllImport("kernel32.dll")]
        static extern IntPtr MapViewOfFile(IntPtr handle, uint dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow, uint dwNumerOfBytesToMap);
        [DllImport("kernel32.dll")]
        static extern bool UnmapViewOfFile(IntPtr lpBaseAddress);
        [DllImport("kernel32.dll")]
        static extern bool CloseHandle(IntPtr hObject);

        static readonly IntPtr INVALID_HANDLE_VALUE = (IntPtr)(-1);
        const uint PAGE_READWRITE = 0x04;
        const uint FILE_MAP_READ = 0x0004;
        const uint FILE_MAP_WRITE = 0x0002;
        const int NMAX_ELEMENTS = 128;

        IntPtr mapHandle;
        IntPtr DIT1MemPtr;          //puntatore alla zona di mem condivisa
        IntPtr Q1MemPtr;            // coda

        // SharedData values;          //struttura alla quale è ricondotta la memoria non strutturata

        uint dataSize;

        [StructLayout(LayoutKind.Sequential)]
        private struct SharedData
        {
            public long readValue;
            public long writeValue;

            public bool readState;
            public bool writeState;
            //public bool exceptionState; //NON UTILIZZATO

            public SharedData(long d, bool b1, bool b2)
            {
                readValue = d;
                readState = b1;
                writeState = b2;
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct WriteQueue
        {
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = NMAX_ELEMENTS)]
            public int[] queueWrite; //indici all'interno della DIT
            int start;               //indice di lettura
            int end;                 //indice di scrittura

        }

        [StructLayout(LayoutKind.Sequential)]
        private struct Dit
        {
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = NMAX_ELEMENTS)]
            public SharedData[] DIT1;
            public WriteQueue Q1;
        }