Dynamisches Nginx-Array ngx_array_t

ngx_array_t ist ein dynamisches Array, das in Nginx entworfen wurde, ähnlich wie vector Nachfolgend analysieren wir anhand von Beispielen.

1. Beispiel

<span style="font-size:18px;">#include <stdio.h>
#include "ngx_config.h"
#include "ngx_conf_file.h"
#include "nginx.h"
#include "ngx_core.h"
#include "ngx_string.h"
#include "ngx_palloc.h"
#include "ngx_queue.h"
 
volatile ngx_cycle_t  *ngx_cycle;
 
void ngx_log_error_core(ngx_uint_t level,ngx_log_t *log, ngx_err_t err,
           const char *fmt, ...)
{
}
      
void dump_pool(ngx_pool_t* pool) 
{
   while (pool)
    {
       printf("pool = 0x%x\n", pool); 
       printf("  .d\n"); 
       printf("    .last =0x%x\n", pool->d.last); 
       printf("    .end =0x%x\n", pool->d.end); 
       printf("    .next =0x%x\n", pool->d.next); 
       printf("    .failed =%d\n", pool->d.failed); 
       printf("  .max = %d\n",pool->max); 
       printf("  .current =0x%x\n", pool->current); 
       printf("  .chain =0x%x\n", pool->chain); 
       printf("  .large =0x%x\n", pool->large); 
       printf("  .cleanup =0x%x\n", pool->cleanup); 
       printf("  .log =0x%x\n", pool->log); 
       printf("available pool memory = %d\n\n", pool->d.end -pool->d.last);
             
       ngx_pool_large_t*large = pool->large;
       printf("*****large_pool*******\n");
       while(large) {
            printf("%p->",large);
            large= large->next;
       }
       printf("\n\n");
             
       pool = pool->d.next;
   } 
}
 
typedef struct {
       intarray[128]; // 128 * 4 = 512
}TestNode;
 
int main() 
{ 
   ngx_pool_t *pool; 
 
   printf("--------------------------------\n"); 
   printf("create a new pool:\n"); 
   printf("--------------------------------\n"); 
   pool = ngx_create_pool(1024, NULL); 
   dump_pool(pool); 
      
       ngx_array_t*myArray = ngx_array_create(pool, 1, sizeof(TestNode));
       printf("******ngx_array_create**********\n");
   dump_pool(pool);
      
       TestNode*t1 = ngx_array_push(myArray);
       TestNode*t2 = ngx_array_push(myArray);
       printf("******ngx_array_push**********\n");
   dump_pool(pool);
      
       ngx_array_destroy(myArray);// 这里什么也没做
       dump_pool(pool);
   ngx_destroy_pool(pool); 
   return 0; 
}</span>

Laufergebnis:

--------------------------------
create a new pool:
--------------------------------
pool = 0x95ae020
  .d
   .last = 0x95ae048
   .end = 0x95ae420
   .next = 0x0
   .failed = 0
 .max = 984
 .current = 0x95ae020
  .chain= 0x0
 .large = 0x0
 .cleanup = 0x0
 .log = 0x0
available pool memory = 984
 
*****large_pool*******
NULL
******ngx_array_create**********
pool = 0x95ae020
  .d
   .last = 0x95ae25c
   .end = 0x95ae420
   .next = 0x0
   .failed = 0
 .max = 984
 .current = 0x95ae020
 .chain = 0x0
 .large = 0x0
 .cleanup = 0x0
 .log = 0x0
available pool memory = 452
 
*****large_pool*******
NULL
******ngx_array_push**********
pool = 0x95ae020
  .d
   .last = 0x95ae264
   .end = 0x95ae420
   .next = 0x0
    .failed = 0
 .max = 984
 .current = 0x95ae020
 .chain = 0x0
 .large = 0x95ae25c
 .cleanup = 0x0
 .log = 0x0
available pool memory = 444
 
*****large_pool*******
0x95ae25c->NULL
******ngx_array_destroy******
pool = 0x95ae020
  .d
   .last = 0x95ae264
   .end = 0x95ae420
   .next = 0x0
   .failed = 0
 .max = 984
 .current = 0x95ae020
 .chain = 0x0
 .large = 0x95ae25c
 .cleanup = 0x0
 .log = 0x0
available pool memory = 444
 
*****large_pool*******
0x95ae25c->NULL

1. Anhand der Änderungen im verfügbaren Poolspeicher können wir erkennen, dass der von den Strukturen ngx_array_t und ngx_pool_large_t selbst belegte Speicher im Speicherpool zugewiesen ist.

Der Beweis kann aus dem Quellcode erhalten werden:

ngx_array_t *

ngx_array_create(ngx_pool_t *p , ngx_uint_t n, size_t size)

{

a = ngx_palloc(p, sizeof(ngx_array_t));

}

statische Leere *

ngx_palloc_large( ngx_pool_t* pool, size_t size)

{

large = ngx_palloc(pool,sizeof(ngx_pool_large_t));

}

2 Wenn ngx_array_push erweitert wird, wird der ursprünglich belegte Speicher nicht freigegeben. Sie können auf den Quellcode von ngx_array_push verweisen, der hier nicht veröffentlicht wird.

3. Wenn die Größe des zugewiesenen dynamischen Arrays die Kapazität eines Speicherpools (in diesem Fall 1024) überschreitet, wird ngx_palloc_large aufgerufen, um einen großen Speicherblock zuzuweisen.

4. Wenn der vom dynamischen Array belegte Speicher ein großer Speicherblock ist, führt ngx_array_destroy nichts aus und diese API wurde im Nginx-Kernel-Quellcode nicht aufgerufen.

Informationen zur Kompilierung finden Sie im vorherigen Artikel zur Analyse der ngx_queue_t-Struktur.

2. Referenzen:

"Vertiefendes Verständnis von Nginx" Tao Hui

http://blog.csdn.net/livelylittlefish/article/details/6586946

Das Obige stellt das dynamische Nginx-Array ngx_array_t vor, einschließlich des relevanten Inhalts. Ich hoffe, es wird für Freunde hilfreich sein, die sich für PHP-Tutorials interessieren.