So verwenden Sie Shared Memory in Nginx

Die Verwendung der Datei ngx_shmem

ngx_shmem.c/h ist nur eine sehr einfache Kapselung des Systemaufrufs mmap()/munmap() oder shmget()/shmdt(). Implementierung der Basisbibliothek im NGX-Stil, die einen kontinuierlichen gemeinsam genutzten Speicherbereich beantragen und freigeben kann. Es wird im Allgemeinen für gemeinsam genutzte Daten fester Länge verwendet. Die Datenlänge ist fest und wird während der Verwendung nicht erweitert oder verkleinert.

typedef struct {
  u_char   *addr;
  size_t    size;
  ...
} ngx_shm_t;
ngx_int_t ngx_shm_alloc(ngx_shm_t *shm);
void ngx_shm_free(ngx_shm_t *shm);

Der Nutzungsprozess des gemeinsam genutzten Speichers in ngxin wird im Allgemeinen vom Master-Prozess erstellt, und der Arbeitsprozess erhält den Speicherzeiger durch Vererbung.

Bezüglich der Verwendung von ngx_shmem können Sie auf einige Snippets in ngx_event_module_init() verweisen. Dieser Teil des Codes erstellt mehrere Variablen im gemeinsamen Speicher, um die Anzahl der Anfragen in jedem Status (akzeptiert/lesend/schreibend...) aufzuzeichnen. , und in Mehrere wichtige Ereigniseinträge in ngx_event_module führen statistische Additions- und Subtraktionsoperationen für diese Variablen durch. Implementieren Sie Statistiken zum aktuellen Anforderungsstatus aller Worker-Prozesse.

shm.size = size;
ngx_str_set(&shm.name, "nginx_shared_zone");
shm.log = cycle->log;

if (ngx_shm_alloc(&shm) != ngx_ok) {
  return ngx_error;
}

shared = shm.addr;
...
ngx_stat_accepted = (ngx_atomic_t *) (shared + 3 * cl);
ngx_stat_handled = (ngx_atomic_t *) (shared + 4 * cl);
ngx_stat_requests = (ngx_atomic_t *) (shared + 5 * cl);
ngx_stat_active = (ngx_atomic_t *) (shared + 6 * cl);
ngx_stat_reading = (ngx_atomic_t *) (shared + 7 * cl);
ngx_stat_writing = (ngx_atomic_t *) (shared + 8 * cl);
ngx_stat_waiting = (ngx_atomic_t *) (shared + 9 * cl);

Weitere Informationen zu dieser Funktion finden Sie im Code zur Makrodefinition ngx_stat_stub und im Code ngx_http_stub_status_module.

ngx_slab-Nutzung

ngx_shmem ist ein minimalistisches Paket, das die Grundfunktionen des Shared Memory implementiert. Die meisten gemeinsam genutzten Szenendaten in unserem Programm haben jedoch keine Struktur mit fester Größe, sondern sind eher eine Datenstruktur mit variabler Größe wie ngx_array, ngx_list, ngx_queue und ngx_rbtree.

Wir hoffen, einen Speicherpool zu haben, der wie ngx_pool_t dynamisch Speicherplatz beantragen und freigeben kann. ngx_slab ist eine solche Struktur und ähnelt im Prinzip dem malloc() des Systems, da es eine Reihe von Algorithmen verwendet, um Speichersegmente zu beantragen und freizugeben. Es ist nur so, dass das von ngx_slab betriebene Objekt ein gemeinsam genutzter Speicher ist, der auf ngx_shmem basiert.

Schauen Sie sich zunächst die Schnittstelle von ngx_slab an

typedef struct {
  ngx_shmtx_t    mutex;
  ...
  void       *data; /* 一般存放从pool中申请获得的根数据地址（pool中第一个申请的数据接口） */
  void       *addr; /* 使用ngx_shmem申请获得的共享内存基地址 */
} ngx_slab_pool_t;

void ngx_slab_init(ngx_slab_pool_t *pool);
void *ngx_slab_alloc(ngx_slab_pool_t *pool, size_t size);
void *ngx_slab_alloc_locked(ngx_slab_pool_t *pool, size_t size);
void *ngx_slab_calloc(ngx_slab_pool_t *pool, size_t size);
void *ngx_slab_calloc_locked(ngx_slab_pool_t *pool, size_t size);
void ngx_slab_free(ngx_slab_pool_t *pool, void *p);
void ngx_slab_free_locked(ngx_slab_pool_t *pool, void *p);

Sie können sehen, dass die Schnittstelle nicht kompliziert ist. Der Unterschied zwischen alloc und calloc besteht darin, ob das von der Anwendung erhaltene Speichersegment gelöscht werden soll pool hat die Sperre erworben. In der Struktur ngx_slab_pool_t gibt es einen ngx_shmtx_t-Mutex, der zum Synchronisieren des gleichzeitigen Szenarios mehrerer Prozesse verwendet wird, die gleichzeitig auf den Pool zugreifen. Beachten Sie, dass ngx_slab_alloc() zuerst die Sperre erhält, dann Speicherplatz beantragt und schließlich die Sperre aufhebt. Und ngx_slab_alloc_locked() beantragt direkt den Speicherplatz und geht davon aus, dass das Programm die Sperre in einer anderen Logik erhalten hat.

Die Verwendung von ngx_shmem in der Nginx-Entwicklung erfordert im Allgemeinen die Befolgung des folgenden Initialisierungsprozesses:

• Das Modul ruft während des Konfigurationsanalyseprozesses die Schnittstelle ngx_shared_memory_add() auf, um einen gemeinsam genutzten Speicher zu registrieren. Stellt Rückruffunktionen für die Größe des gemeinsam genutzten Speichers und die Speicherinitialisierung bereit.

• Das Framework verwendet ngx_shmem in ngx_init_cycle(), um Speicher zu beantragen, ngx_slab zu initialisieren und dann die vom Modul registrierte Initialisierungsfunktion zurückzurufen

• Das Modul verwendet die Anwendungs-/Ob-Schnittstelle von ngx_slab

In An diesem Prozess sind die Schnittstelle ngx_shared_memory_add und die entsprechende Struktur ngx_shm_zone_t beteiligt.

struct ngx_shm_zone_s {
  void           *data;
  ngx_shm_t         shm;
  ngx_shm_zone_init_pt   init;
  void           *tag;
  void           *sync;
  ngx_uint_t        noreuse; /* unsigned noreuse:1; */
};
ngx_shm_zone_t *ngx_shared_memory_add(ngx_conf_t *cf, ngx_str_t *name,
  size_t size, void *tag);

Eines der erwähnenswerten Dinge ist das noreuse-Attribut. Dieses Attribut steuert, ob der gemeinsam genutzte Speicher während des Neuladevorgangs von Nginx erneut angewendet wird.

Da die Funktion ngx_init_cycle() lang ist, kann dieser Prozess angezeigt werden, indem man nach dem Kommentar /* Shared Memory erstellen */ oder dem Objekt Cycle->shared_memory sucht, um den relevanten Code anzuzeigen.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Shared Memory in Nginx. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!