Entfernen posix shared memory, wenn nicht in Gebrauch?

Nicht - zumindest auf Linux, der kernel nicht enthalten alles, was, die dies tun können. Es ist bis auf einige Anwendungen zu nennen shm_unlink() irgendwann loswerden ein shared-memory-segment.

Nehmen wir an, die meisten komplizierten Fall:

• Mehrere Prozesse kommunizieren über gemeinsamen Speicher
• Sie können start und Ziel jederzeit, auch mehrere Male. Das bedeutet, dass es keine master-Prozess, noch ist es mit einem eigenen "ersten" Prozess, initialisiert das shared memory.
• Das bedeutet z.B., es gibt keinen Punkt, wo man sicher unlink shared memory, also weder Sergej ' s noch Hristo ist Antworten arbeiten.

Sehe ich zwei mögliche Lösungen und würde gern feedback auf Sie, denn das internet ist schrecklich leise auf diese Frage:

1. Speichern die pid (oder eine weitere spezifische Prozess-id, wenn Sie eine haben), der Letzte Prozess, der schrieb an den gemeinsamen Speicher im shared memory als eine Sperre. Dann könnten Sie tun, sth. wie der folgende pseudo-code:

   int* pshmem = open shared memory()
   
   while(true) 
       nPid = atomic_read(pshmem)
       if nPid = 0 
          //your shared memory is in a valid state
          break
       else 
          //process nPid holds a lock to your shared memory
          //or it might have crashed while holding the lock
          if process nPid still exists 
            //shared memory is valid
            break
          else 
            //shared memory is corrupt
            //try acquire lock 
            if atomic_compare_exchange(pshmem, nPid, my pid) 
               //we have the lock
               reinitialize shared memory
               atomic_write(pshem, 0) //release lock
            else 
               //somebody else got the lock in the meantime
               //continue loop

   Dadurch wird sichergestellt, dass die letzten Schriftsteller starben nicht während des Schreibens. Shared memory ist immer noch anhaltende länger als alle Ihre Prozesse.

2. Verwenden reader - /writer-lock-Datei, um herauszufinden, wenn jeder Prozess ist der erste Prozess der öffnung des shared memory-Objekts. Der erste Prozess kann dann erneut initialisieren des shared memory:

   //try to get exclusive lock on lockfile
   int fd = open(lockfile, O_RDONLY | O_CREAT | O_EXLOCK | O_NONBLOCK, ...)
   if fd == -1
       //didn't work, somebody else has it and is initializing shared memory
       //acquire shared lock and wait for it
       fd = open(lockfile, O_RDONLY | O_SHLOCK)
       //open shared memory
   else 
       //we are the first
       //delete shared memory object
       //possibly delete named mutex/semaphore as well
   
       //create shared memory object (& semaphore)
       //degrade exclusive lock to a shared lock
       flock(fd, LOCK_SH)

   Datei sperren scheint die einzige (?) Mechanismus auf POSIX-Systemen, deaktiviert sich automatisch, wenn der Prozess stirbt. Leider die Liste der Vorbehalte, Sie zu verwenden ist sehr, sehr lange. Der Algorithmus setzt Voraus flock ist gestützt auf das zugrundeliegende Dateisystem zumindest auf der lokalen Maschine. Der Algorithmus kümmert sich nicht, wenn die sperren sind eigentlich sichtbar für andere Prozesse, die auf NFS-Dateisysteme oder nicht. Sie ist nur sichtbar für alle Prozesse, die Zugriff auf das shared memory Objekt.

Für die shared-memory -, erstellt mit sysV-API ist es möglich, solch ein Verhalten. Nur mit Linux. Es ist nicht POSIX-shared-memory, sondern kann für Sie arbeiten.

In dem Buch The Linux Programming Interface eine der möglichen Parameter für shmctl() beschrieben wird, auf folgende Weise.

IPC_RMID
Markieren Sie die shared-memory-segment und seine zugeordneten shmid_ds
die Daten Struktur für die Löschung. Wenn keine Prozesse, die gegenwärtig die
segment angeschlossen, erfolgt die Löschung sofort, andernfalls ist das segment
entfernt werden, nachdem alle Prozesse losgelöst haben von ihm (d.h., wenn die
Wert der shm_nattch Feld in der shmid_ds-Daten-Struktur fällt
0). In einigen Anwendungen können wir sicherstellen, dass eine shared-memory
segment ordentlich abgeräumt auf Beendigung der Anwendung durch Markierung
es für die Löschung unverzüglich nach Ablauf befestigt
Ihre virtuellen Adressraum mit shmat(). Dies ist Analog zu
aufheben der Verknüpfung einer Datei, sobald wir geöffnet haben, es. Auf Linux, wenn ein freigegebenes segment
der zum löschen markiert wurde mit IPC_RMID, aber noch nicht
entfernt, weil manche Verfahren noch immer ist es angebracht, dann ist es
möglich für einen anderen Prozess anfügen, dass segment. Jedoch, diese
Verhalten ist nicht tragbar: die meisten UNIX-Implementierungen zu verhindern, dass neue
legt auf ein segment zum löschen markiert. (SUSv3 ist still auf das, was
Verhalten dürfte in diesem Szenario.) Ein paar Linux-Anwendungen haben
Vertrauen auf dieses Verhalten, das ist der Grund, warum Linux wurde nicht
geändert, um mit anderen UNIX-Implementierungen.

Nicht sicher, ob das unten funktioniert oder machbar ist. Aber meine versuchen.

Warum nicht Sie führen das Helfer-Programm, die ausgeführt wird, jedes mal das Programm abgestürzt.

ie:

/proc/sys/kernel/core_pattern  to  /path/to/Myprogram %p

Myprogram wird ausgeführt, wenn der Prozess abstürzt, und wahrscheinlich kann man noch mehr ausprobieren.

sehen

man 5 core.  for more information. 

Hoffe, dass dies hilft, um einige zu verlängern.