Return to ngx_cpuinfo.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / core

Annotation of embedaddon/nginx/src/core/ngx_cpuinfo.c, revision 1.1

1.1     ! misho       1: 
        !             2: /*
        !             3:  * Copyright (C) Igor Sysoev
        !             4:  * Copyright (C) Nginx, Inc.
        !             5:  */
        !             6: 
        !             7: 
        !             8: #include <ngx_config.h>
        !             9: #include <ngx_core.h>
        !            10: 
        !            11: 
        !            12: #if (( __i386__ || __amd64__ ) && ( __GNUC__ || __INTEL_COMPILER ))
        !            13: 
        !            14: 
        !            15: static ngx_inline void ngx_cpuid(uint32_t i, uint32_t *buf);
        !            16: 
        !            17: 
        !            18: #if ( __i386__ )
        !            19: 
        !            20: static ngx_inline void
        !            21: ngx_cpuid(uint32_t i, uint32_t *buf)
        !            22: {
        !            23: 
        !            24:     /*
        !            25:      * we could not use %ebx as output parameter if gcc builds PIC,
        !            26:      * and we could not save %ebx on stack, because %esp is used,
        !            27:      * when the -fomit-frame-pointer optimization is specified.
        !            28:      */
        !            29: 
        !            30:     __asm__ (
        !            31: 
        !            32:     "    mov    %%ebx, %%esi;  "
        !            33: 
        !            34:     "    cpuid;                "
        !            35:     "    mov    %%eax, (%1);   "
        !            36:     "    mov    %%ebx, 4(%1);  "
        !            37:     "    mov    %%edx, 8(%1);  "
        !            38:     "    mov    %%ecx, 12(%1); "
        !            39: 
        !            40:     "    mov    %%esi, %%ebx;  "
        !            41: 
        !            42:     : : "a" (i), "D" (buf) : "ecx", "edx", "esi", "memory" );
        !            43: }
        !            44: 
        !            45: 
        !            46: #else /* __amd64__ */
        !            47: 
        !            48: 
        !            49: static ngx_inline void
        !            50: ngx_cpuid(uint32_t i, uint32_t *buf)
        !            51: {
        !            52:     uint32_t  eax, ebx, ecx, edx;
        !            53: 
        !            54:     __asm__ (
        !            55: 
        !            56:         "cpuid"
        !            57: 
        !            58:     : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (i) );
        !            59: 
        !            60:     buf[0] = eax;
        !            61:     buf[1] = ebx;
        !            62:     buf[2] = edx;
        !            63:     buf[3] = ecx;
        !            64: }
        !            65: 
        !            66: 
        !            67: #endif
        !            68: 
        !            69: 
        !            70: /* auto detect the L2 cache line size of modern and widespread CPUs */
        !            71: 
        !            72: void
        !            73: ngx_cpuinfo(void)
        !            74: {
        !            75:     u_char    *vendor;
        !            76:     uint32_t   vbuf[5], cpu[4], model;
        !            77: 
        !            78:     vbuf[0] = 0;
        !            79:     vbuf[1] = 0;
        !            80:     vbuf[2] = 0;
        !            81:     vbuf[3] = 0;
        !            82:     vbuf[4] = 0;
        !            83: 
        !            84:     ngx_cpuid(0, vbuf);
        !            85: 
        !            86:     vendor = (u_char *) &vbuf[1];
        !            87: 
        !            88:     if (vbuf[0] == 0) {
        !            89:         return;
        !            90:     }
        !            91: 
        !            92:     ngx_cpuid(1, cpu);
        !            93: 
        !            94:     if (ngx_strcmp(vendor, "GenuineIntel") == 0) {
        !            95: 
        !            96:         switch ((cpu[0] & 0xf00) >> 8) {
        !            97: 
        !            98:         /* Pentium */
        !            99:         case 5:
        !           100:             ngx_cacheline_size = 32;
        !           101:             break;
        !           102: 
        !           103:         /* Pentium Pro, II, III */
        !           104:         case 6:
        !           105:             ngx_cacheline_size = 32;
        !           106: 
        !           107:             model = ((cpu[0] & 0xf0000) >> 8) | (cpu[0] & 0xf0);
        !           108: 
        !           109:             if (model >= 0xd0) {
        !           110:                 /* Intel Core, Core 2, Atom */
        !           111:                 ngx_cacheline_size = 64;
        !           112:             }
        !           113: 
        !           114:             break;
        !           115: 
        !           116:         /*
        !           117:          * Pentium 4, although its cache line size is 64 bytes,
        !           118:          * it prefetches up to two cache lines during memory read
        !           119:          */
        !           120:         case 15:
        !           121:             ngx_cacheline_size = 128;
        !           122:             break;
        !           123:         }
        !           124: 
        !           125:     } else if (ngx_strcmp(vendor, "AuthenticAMD") == 0) {
        !           126:         ngx_cacheline_size = 64;
        !           127:     }
        !           128: }
        !           129: 
        !           130: #else
        !           131: 
        !           132: 
        !           133: void
        !           134: ngx_cpuinfo(void)
        !           135: {
        !           136: }
        !           137: 
        !           138: 
        !           139: #endif