Transition most JIT stats to the mono_counters infrastructure. Make the updates to...

diff --git a/mono/mini/aot-runtime.c b/mono/mini/aot-runtime.c
index cd71b8ee2f4e3cce98993b92b4c1acd8a3ef8c4d..64a23d409cacbbf3767c8a2959b6702b7b2afde3 100644 (file)
--- a/mono/mini/aot-runtime.c
+++ b/mono/mini/aot-runtime.c
@@ -2621,7 +2621,7 @@ load_method (MonoDomain *domain, MonoAotModule *amodule, MonoImage *image, MonoM
 
        mono_aot_lock ();
 
-       mono_jit_stats.methods_aot++;
+       InterlockedIncrement (&mono_jit_stats.methods_aot);
 
        amodule->methods_loaded [method_index / 32] |= 1 << (method_index % 32);
 

diff --git a/mono/mini/declsec.c b/mono/mini/declsec.c
index 65e38d7f8fe5b29cb3e0b517954faace3cd71875..be7feebe79b4a8bc7981239874f45ee257226274 100644 (file)
--- a/mono/mini/declsec.c
+++ b/mono/mini/declsec.c
@@ -17,7 +17,7 @@
 MonoBoolean
 mono_method_has_declsec (MonoMethod *method)
 {
-       mono_jit_stats.cas_declsec_check++;
+       InterlockedIncrement (&mono_jit_stats.cas_declsec_check);
 
        if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
                method = mono_marshal_method_from_wrapper (method);
@@ -116,7 +116,7 @@ mono_declsec_linkdemand_standard (MonoDomain *domain, MonoMethod *caller, MonoMe
 {
        MonoDeclSecurityActions linkclass, linkmethod;
 
-       mono_jit_stats.cas_linkdemand++;
+       InterlockedIncrement (&mono_jit_stats.cas_linkdemand);
 
        if (mono_declsec_get_linkdemands (callee, &linkclass, &linkmethod)) {
                MonoAssembly *assembly = mono_image_get_assembly (caller->klass->image);
@@ -190,7 +190,7 @@ mono_declsec_linkdemand_aptc (MonoDomain *domain, MonoMethod *caller, MonoMethod
        MonoAssembly *assembly;
        guint32 size = 0;
 
-       mono_jit_stats.cas_linkdemand_aptc++;
+       InterlockedIncrement (&mono_jit_stats.cas_linkdemand_aptc);
 
        /* A - Applicable only if we're calling into *another* assembly */
        if (caller->klass->image == callee->klass->image)
@@ -262,7 +262,7 @@ mono_declsec_linkdemand_pinvoke (MonoDomain *domain, MonoMethod *caller, MonoMet
 {
        MonoAssembly *assembly = mono_image_get_assembly (caller->klass->image);
 
-       mono_jit_stats.cas_linkdemand_pinvoke++;
+       InterlockedIncrement (&mono_jit_stats.cas_linkdemand_pinvoke);
 
        /* Check for P/Invoke flag for the assembly */
        if (!MONO_SECMAN_FLAG_INIT (assembly->unmanaged)) {
@@ -321,7 +321,7 @@ mono_declsec_linkdemand_icall (MonoDomain *domain, MonoMethod *caller, MonoMetho
 {
        MonoAssembly *assembly;
 
-       mono_jit_stats.cas_linkdemand_icall++;
+       InterlockedIncrement (&mono_jit_stats.cas_linkdemand_icall);
 
        /* check if the _icall_ is defined inside an ECMA signed assembly */
        assembly = mono_image_get_assembly (icall->klass->image);

diff --git a/mono/mini/linear-scan.c b/mono/mini/linear-scan.c
index df681a68ac1bfe2210099fb04e1d977c4aa78bc3..c0b58e5c77113251243c2d2cc834aba8c401206c 100644 (file)
--- a/mono/mini/linear-scan.c
+++ b/mono/mini/linear-scan.c
@@ -222,7 +222,7 @@ mono_linear_scan (MonoCompile *cfg, GList *vars, GList *regs, regmask_t *used_ma
                }
        }
 
-       mono_jit_stats.regvars += n_regvars;
+       cfg->stat_n_regvars = n_regvars;
 
        /* Compute used regs */
        used_regs = 0;
@@ -493,7 +493,7 @@ mono_linear_scan2 (MonoCompile *cfg, GList *vars, GList *regs, regmask_t *used_m
                }
        }
 
-       mono_jit_stats.regvars += n_regvars;
+       cfg->stat_n_regvars = n_regvars;
 
        /* Compute used regs */
        used_regs = 0;

diff --git a/mono/mini/method-to-ir.c b/mono/mini/method-to-ir.c
index bc39292094c0529bcf6e6d05d7e36e24dcb2a9e6..d9993c8988292d88741cc6d242d5d9aa943c81d3 100644 (file)
--- a/mono/mini/method-to-ir.c
+++ b/mono/mini/method-to-ir.c
@@ -4852,7 +4852,7 @@ inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig,
                printf ("INLINE START %p %s -> %s\n", cmethod,  mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
 
        if (!cmethod->inline_info) {
-               mono_jit_stats.inlineable_methods++;
+               cfg->stat_inlineable_methods++;
                cmethod->inline_info = 1;
        }
 
@@ -4937,7 +4937,7 @@ inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig,
                if (cfg->verbose_level > 2)
                        printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
                
-               mono_jit_stats.inlined_methods++;
+               cfg->stat_inlined_methods++;
 
                /* always add some code to avoid block split failures */
                MONO_INST_NEW (cfg, ins, OP_NOP);
@@ -5739,7 +5739,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
        ip = (unsigned char*)header->code;
        cfg->cil_start = ip;
        end = ip + header->code_size;
-       mono_jit_stats.cil_code_size += header->code_size;
+       cfg->stat_cil_code_size += header->code_size;
        init_locals = header->init_locals;
 
        seq_points = cfg->gen_seq_points && cfg->method == method;
@@ -6011,7 +6011,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
        if (security && (cfg->method == method)) {
                MonoInst *args [2];
 
-               mono_jit_stats.cas_demand_generation++;
+               cfg->stat_cas_demand_generation++;
 
                if (actions.demand.blob) {
                        /* Add code for SecurityAction.Demand */

diff --git a/mono/mini/mini-alpha.c b/mono/mini/mini-alpha.c
index aa4e016f1be17f480c42682c36ce9f0aea24a836..fb0b687f3f13d50f25b3c55216e0596f78e7ec64 100644 (file)
--- a/mono/mini/mini-alpha.c
+++ b/mono/mini/mini-alpha.c
@@ -1745,7 +1745,7 @@ mono_arch_emit_epilog (MonoCompile *cfg)
     {
       cfg->code_size *= 2;
       cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-      mono_jit_stats.code_reallocs++;
+      cfg->stat_code_reallocs++;
     }
   
   code = (unsigned int *)(cfg->native_code + cfg->code_len);
@@ -1845,7 +1845,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
     {
       cfg->code_size *= 2;
       cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-      mono_jit_stats.code_reallocs++;
+      cfg->stat_code_reallocs++;
     }
   
   code = (unsigned int *)((char *)cfg->native_code + cfg->code_len);
@@ -2189,7 +2189,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
           cfg->code_size *= 2;
           cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
           code = (unsigned int *)(cfg->native_code + offset);
-          mono_jit_stats.code_reallocs++;
+          cfg->stat_code_reallocs++;
         }
          
        mono_debug_record_line_number (cfg, ins, offset);

diff --git a/mono/mini/mini-amd64.c b/mono/mini/mini-amd64.c
index 593451065676b69f8e5b90c6516cd4524161b038..e1b304ebc8f4b4e07a1b95655fab6198288a10d1 100644 (file)
--- a/mono/mini/mini-amd64.c
+++ b/mono/mini/mini-amd64.c
@@ -3932,7 +3932,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
                        cfg->code_size *= 2;
                        cfg->native_code = mono_realloc_native_code(cfg);
                        code = cfg->native_code + offset;
-                       mono_jit_stats.code_reallocs++;
+                       cfg->stat_code_reallocs++;
                }
 
                if (cfg->debug_info)
@@ -6660,7 +6660,7 @@ mono_arch_emit_prolog (MonoCompile *cfg)
                                cfg->code_size *= 2;
                        cfg->native_code = mono_realloc_native_code (cfg);
                        code = cfg->native_code + offset;
-                       mono_jit_stats.code_reallocs++;
+                       cfg->stat_code_reallocs++;
                }
 
                while (remaining_size >= 0x1000) {
@@ -7112,7 +7112,7 @@ mono_arch_emit_epilog (MonoCompile *cfg)
        while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = mono_realloc_native_code (cfg);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = cfg->native_code + cfg->code_len;
@@ -7283,7 +7283,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
        while (cfg->code_len + code_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = mono_realloc_native_code (cfg);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = cfg->native_code + cfg->code_len;

diff --git a/mono/mini/mini-arm.c b/mono/mini/mini-arm.c
index 62319be27cb82368a118ec6280f84cbfad624b80..e6f0a5d0ed130aef92cb3a9876b1bb4fb5f0a751 100644 (file)
--- a/mono/mini/mini-arm.c
+++ b/mono/mini/mini-arm.c
@@ -5128,7 +5128,7 @@ mono_arch_emit_epilog (MonoCompile *cfg)
        while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        /*
@@ -5258,7 +5258,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
        while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = cfg->native_code + cfg->code_len;

diff --git a/mono/mini/mini-hppa.c b/mono/mini/mini-hppa.c
index 264a86c78db9f018b6a613fb09695d4c0f3366cf..b1ee64467423281a7afacae331ffda148f341b21 100644 (file)
--- a/mono/mini/mini-hppa.c
+++ b/mono/mini/mini-hppa.c
@@ -1264,7 +1264,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
                        cfg->code_size *= 2;
                        cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
                        code = (guint32*)(cfg->native_code + offset);
-                       mono_jit_stats.code_reallocs++;
+                       cfg->stat_code_reallocs++;
                }
                code_start = (guint8*)code;
                //      if (ins->cil_code)
@@ -2595,7 +2595,7 @@ mono_arch_emit_epilog (MonoCompile *cfg)
        while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = (guint32*)(cfg->native_code + cfg->code_len);
@@ -2751,7 +2751,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
        while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = cfg->native_code + cfg->code_len;

diff --git a/mono/mini/mini-ia64.c b/mono/mini/mini-ia64.c
index 83d8d7c9b96be31df338e042b0041f948a83e511..d686e6b1a7befda7afd8776933ceb2cd0b8c78d5 100644 (file)
--- a/mono/mini/mini-ia64.c
+++ b/mono/mini/mini-ia64.c
@@ -2070,7 +2070,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
                        cfg->code_size *= 2;
                        cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
                        code_start = cfg->native_code + offset;
-                       mono_jit_stats.code_reallocs++;
+                       cfg->stat_code_reallocs++;
 
                        ia64_codegen_init (code, code_start);
                }
@@ -4061,7 +4061,7 @@ mono_arch_emit_epilog (MonoCompile *cfg)
        while (cfg->code_len + max_epilog_size > cfg->code_size) {
                cfg->code_size *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        /* FIXME: Emit unwind info */
@@ -4175,7 +4175,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
        while (cfg->code_len + code_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        ia64_codegen_init (code, cfg->native_code + cfg->code_len);

diff --git a/mono/mini/mini-mips.c b/mono/mini/mini-mips.c
index 9f9c079581ff18555c4bb0e86ecdb93146d6be41..95854fc989cbcd2ea3c00d4b3bb54cb0312a87c1 100644 (file)
--- a/mono/mini/mini-mips.c
+++ b/mono/mini/mini-mips.c
@@ -5164,7 +5164,7 @@ mono_arch_emit_epilog_sub (MonoCompile *cfg, guint8 *code)
        while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        /*
@@ -5332,7 +5332,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
        while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = cfg->native_code + cfg->code_len;

diff --git a/mono/mini/mini-ppc.c b/mono/mini/mini-ppc.c
index 727561c53eab833b1b5c9b99559616b8218568f0..aaaa405cfbf757c4b9a6983cd175ee35aa7c4a74 100644 (file)
--- a/mono/mini/mini-ppc.c
+++ b/mono/mini/mini-ppc.c
@@ -5173,7 +5173,7 @@ mono_arch_emit_epilog (MonoCompile *cfg)
        while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        /*
@@ -5339,7 +5339,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
        while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = cfg->native_code + cfg->code_len;

diff --git a/mono/mini/mini-s390.c b/mono/mini/mini-s390.c
index ad46d271a3c1776977be656cfff2efef5afe74c0..67e502633e866cd265014dc58237022b792431f1 100644 (file)
--- a/mono/mini/mini-s390.c
+++ b/mono/mini/mini-s390.c
@@ -4782,7 +4782,7 @@ mono_arch_emit_epilog (MonoCompile *cfg)
        while ((cfg->code_len + max_epilog_size) > (cfg->code_size - 16)) {
                cfg->code_size  *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = cfg->native_code + cfg->code_len;
@@ -4843,7 +4843,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
        while ((cfg->code_len + code_size) > (cfg->code_size - 16)) {
                cfg->code_size  *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++; 
+               cfg->stat_code_reallocs++; 
        }
 
        code = cfg->native_code + cfg->code_len;

diff --git a/mono/mini/mini-s390x.c b/mono/mini/mini-s390x.c
index 9ed850f119ad580cf0b0dec74866576ece904265..ce7557e7bc27e5b1940d9dcbedb0868083281d41 100644 (file)
--- a/mono/mini/mini-s390x.c
+++ b/mono/mini/mini-s390x.c
@@ -5238,7 +5238,7 @@ mono_arch_emit_epilog (MonoCompile *cfg)
        while ((cfg->code_len + max_epilog_size) > (cfg->code_size - 16)) {
                cfg->code_size  *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = cfg->native_code + cfg->code_len;
@@ -5301,7 +5301,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
        while ((cfg->code_len + code_size) > (cfg->code_size - 16)) {
                cfg->code_size  *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++; 
+               cfg->stat_code_reallocs++; 
        }
 
        code = cfg->native_code + cfg->code_len;

diff --git a/mono/mini/mini-sparc.c b/mono/mini/mini-sparc.c
index 513da502a58484ef1fee2029ae04c9a6bd1e694e..3812922658cf17d15a51b63439ee302e20a99c5f 100644 (file)
--- a/mono/mini/mini-sparc.c
+++ b/mono/mini/mini-sparc.c
@@ -4120,7 +4120,7 @@ mono_arch_emit_epilog (MonoCompile *cfg)
        while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = (guint32*)(cfg->native_code + cfg->code_len);
@@ -4210,7 +4210,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
        while (cfg->code_len + code_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = (guint32*)(cfg->native_code + cfg->code_len);

diff --git a/mono/mini/mini-x86.c b/mono/mini/mini-x86.c
index 31db943fc6f330a728f1dd7072b6f30910db4050..c78e2bedbc3cfa6ba54e4f889ffb4c65ebfc8fbf 100644 (file)
--- a/mono/mini/mini-x86.c
+++ b/mono/mini/mini-x86.c
@@ -2426,7 +2426,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
                        cfg->code_size *= 2;
                        cfg->native_code = mono_realloc_native_code(cfg);
                        code = cfg->native_code + offset;
-                       mono_jit_stats.code_reallocs++;
+                       cfg->stat_code_reallocs++;
                }
 
                if (cfg->debug_info)
@@ -5106,7 +5106,7 @@ mono_arch_emit_prolog (MonoCompile *cfg)
                                cfg->code_size *= 2;
                        cfg->native_code = mono_realloc_native_code(cfg);
                        code = cfg->native_code + offset;
-                       mono_jit_stats.code_reallocs++;
+                       cfg->stat_code_reallocs++;
                }
                while (remaining_size >= 0x1000) {
                        x86_alu_reg_imm (code, X86_SUB, X86_ESP, 0x1000);
@@ -5222,7 +5222,7 @@ mono_arch_emit_epilog (MonoCompile *cfg)
        while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = mono_realloc_native_code(cfg);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = cfg->native_code + cfg->code_len;
@@ -5403,7 +5403,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
        while (cfg->code_len + code_size > (cfg->code_size - 16)) {
                cfg->code_size *= 2;
                cfg->native_code = mono_realloc_native_code(cfg);
-               mono_jit_stats.code_reallocs++;
+               cfg->stat_code_reallocs++;
        }
 
        code = cfg->native_code + cfg->code_len;

diff --git a/mono/mini/mini.c b/mono/mini/mini.c
index 45d34347c47070d0b31b194c60f83633eb6e9775..d5e47117c7a73a63a03ec170e05b0934aba6fa4b 100644 (file)
--- a/mono/mini/mini.c
+++ b/mono/mini/mini.c
@@ -1107,7 +1107,7 @@ mono_compile_create_var_for_vreg (MonoCompile *cfg, MonoType *type, int opcode,
                memset (&cfg->vars [orig_count], 0, (cfg->varinfo_count - orig_count) * sizeof (MonoMethodVar));
        }
 
-       mono_jit_stats.allocate_var++;
+       cfg->stat_allocate_var++;
 
        MONO_INST_NEW (cfg, inst, opcode);
        inst->inst_c0 = num;
@@ -1947,7 +1947,7 @@ mono_allocate_stack_slots2 (MonoCompile *cfg, gboolean backward, guint32 *stack_
                        g_list_free (vtype_stack_slots [i].active);
        }
 
-       mono_jit_stats.locals_stack_size += offset;
+       cfg->stat_locals_stack_size += offset;
 
        *stack_size = offset;
        return offsets;
@@ -2189,7 +2189,7 @@ mono_allocate_stack_slots (MonoCompile *cfg, gboolean backward, guint32 *stack_s
                        g_list_free (vtype_stack_slots [i].active);
        }
 
-       mono_jit_stats.locals_stack_size += offset;
+       cfg->stat_locals_stack_size += offset;
 
        *stack_size = offset;
        return offsets;
@@ -4130,7 +4130,7 @@ mini_method_compile (MonoMethod *method, guint32 opts, MonoDomain *domain, gbool
        gboolean try_generic_shared, try_llvm = FALSE;
        MonoMethod *method_to_compile, *method_to_register;
 
-       mono_jit_stats.methods_compiled++;
+       InterlockedIncrement (&mono_jit_stats.methods_compiled);
        if (mono_profiler_get_events () & MONO_PROFILE_JIT_COMPILATION)
                mono_profiler_method_jit (method);
        if (MONO_PROBE_METHOD_COMPILE_BEGIN_ENABLED ())
@@ -4441,8 +4441,7 @@ mini_method_compile (MonoMethod *method, guint32 opts, MonoDomain *domain, gbool
                return cfg;
        }
 
-       mono_jit_stats.basic_blocks += cfg->num_bblocks;
-       mono_jit_stats.max_basic_blocks = MAX (cfg->num_bblocks, mono_jit_stats.max_basic_blocks);
+       cfg->stat_basic_blocks += cfg->num_bblocks;
 
        if (COMPILE_LLVM (cfg)) {
                MonoInst *ins;
@@ -5247,6 +5246,21 @@ mono_jit_compile_method_inner (MonoMethod *method, MonoDomain *target_domain, in
 
        prof_options = cfg->prof_options;
 
+       /*
+        * Update global stats while holding a lock, instead of doing many
+        * InterlockedIncrement operations during JITting.
+        */
+       mono_jit_stats.allocate_var += cfg->stat_allocate_var;
+       mono_jit_stats.locals_stack_size += cfg->stat_locals_stack_size;
+       mono_jit_stats.basic_blocks += cfg->stat_basic_blocks;
+       mono_jit_stats.max_basic_blocks = MAX (cfg->stat_basic_blocks, mono_jit_stats.max_basic_blocks);
+       mono_jit_stats.cil_code_size += cfg->stat_cil_code_size;
+       mono_jit_stats.regvars += cfg->stat_n_regvars;
+       mono_jit_stats.inlineable_methods += cfg->stat_inlineable_methods;
+       mono_jit_stats.inlined_methods += cfg->stat_inlined_methods;
+       mono_jit_stats.cas_demand_generation += cfg->stat_cas_demand_generation;
+       mono_jit_stats.code_reallocs += cfg->stat_code_reallocs;
+
        mono_destroy_compile (cfg);
 
 #ifndef DISABLE_JIT
@@ -6051,9 +6065,21 @@ register_jit_stats (void)
 {
        mono_counters_register ("Compiled methods", MONO_COUNTER_JIT | MONO_COUNTER_WORD, &mono_jit_stats.methods_compiled);
        mono_counters_register ("Methods from AOT", MONO_COUNTER_JIT | MONO_COUNTER_WORD, &mono_jit_stats.methods_aot);
-       mono_counters_register ("Methods JITted using LLVM", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.methods_with_llvm);   
        mono_counters_register ("Methods JITted using mono JIT", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.methods_without_llvm);
+       mono_counters_register ("Methods JITted using LLVM", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.methods_with_llvm);   
        mono_counters_register ("Total time spent JITting (sec)", MONO_COUNTER_JIT | MONO_COUNTER_DOUBLE, &mono_jit_stats.jit_time);
+       mono_counters_register ("Basic blocks", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.basic_blocks);
+       mono_counters_register ("Max basic blocks", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.max_basic_blocks);
+       mono_counters_register ("Allocated vars", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.allocate_var);
+       mono_counters_register ("Code reallocs", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.code_reallocs);
+       mono_counters_register ("Allocated code size", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.allocated_code_size);
+       mono_counters_register ("Inlineable methods", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.inlineable_methods);
+       mono_counters_register ("Inlined methods", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.inlined_methods);
+       mono_counters_register ("Regvars", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.regvars);
+       mono_counters_register ("Locals stack size", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.locals_stack_size);
+       mono_counters_register ("Method cache lookups", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.methods_lookups);
+       mono_counters_register ("Compiled CIL code size", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.cil_code_size);
+       mono_counters_register ("Native code size", MONO_COUNTER_JIT | MONO_COUNTER_INT, &mono_jit_stats.native_code_size);
 }
 
 static void runtime_invoke_info_free (gpointer value);
@@ -6551,22 +6577,10 @@ print_jit_stats (void)
 {
        if (mono_jit_stats.enabled) {
                g_print ("Mono Jit statistics\n");
-               g_print ("Methods cache lookup:   %ld\n", mono_jit_stats.methods_lookups);
-               g_print ("Basic blocks:           %ld\n", mono_jit_stats.basic_blocks);
-               g_print ("Max basic blocks:       %ld\n", mono_jit_stats.max_basic_blocks);
-               g_print ("Allocated vars:         %ld\n", mono_jit_stats.allocate_var);
-               g_print ("Compiled CIL code size: %ld\n", mono_jit_stats.cil_code_size);
-               g_print ("Native code size:       %ld\n", mono_jit_stats.native_code_size);
                g_print ("Max code size ratio:    %.2f (%s)\n", mono_jit_stats.max_code_size_ratio/100.0,
                                 mono_jit_stats.max_ratio_method);
                g_print ("Biggest method:         %ld (%s)\n", mono_jit_stats.biggest_method_size,
                                 mono_jit_stats.biggest_method);
-               g_print ("Code reallocs:          %ld\n", mono_jit_stats.code_reallocs);
-               g_print ("Allocated code size:    %ld\n", mono_jit_stats.allocated_code_size);
-               g_print ("Inlineable methods:     %ld\n", mono_jit_stats.inlineable_methods);
-               g_print ("Inlined methods:        %ld\n", mono_jit_stats.inlined_methods);
-               g_print ("Regvars:                %ld\n", mono_jit_stats.regvars);
-               g_print ("Locals stack size:      %ld\n", mono_jit_stats.locals_stack_size);
 
                g_print ("\nCreated object count:   %ld\n", mono_stats.new_object_count);
                g_print ("Delegates created:      %ld\n", mono_stats.delegate_creations);

diff --git a/mono/mini/mini.h b/mono/mini/mini.h
index c2326b18d17fd246fb6a0f13e02a164b237bc552..18c7bda31ad57a1326bdc233687e31456ee750b8 100644 (file)
--- a/mono/mini/mini.h
+++ b/mono/mini/mini.h
@@ -1355,6 +1355,17 @@ typedef struct {
         */
        guint8 *gc_map;
        guint32 gc_map_size;
+
+       /* Stats */
+       int stat_allocate_var;
+       int stat_locals_stack_size;
+       int stat_basic_blocks;
+       int stat_cil_code_size;
+       int stat_n_regvars;
+       int stat_inlineable_methods;
+       int stat_inlined_methods;
+       int stat_cas_demand_generation;
+       int stat_code_reallocs;
 } MonoCompile;
 
 typedef enum {
@@ -1370,30 +1381,30 @@ typedef enum {
 } MonoCompileFlags;
 
 typedef struct {
-       gulong methods_compiled;
-       gulong methods_aot;
-       gulong methods_lookups;
-       gulong allocate_var;
-       gulong cil_code_size;
-       gulong native_code_size;
-       gulong code_reallocs;
-       gulong max_code_size_ratio;
-       gulong biggest_method_size;
-       gulong allocated_code_size;
-       gulong inlineable_methods;
-       gulong inlined_methods;
-       gulong basic_blocks;
-       gulong max_basic_blocks;
-       gulong locals_stack_size;
-       gulong regvars;
-       gulong cas_declsec_check;
-       gulong cas_linkdemand_icall;
-       gulong cas_linkdemand_pinvoke;
-       gulong cas_linkdemand_aptc;
-       gulong cas_linkdemand;
-       gulong cas_demand_generation;
-       gulong generic_virtual_invocations;
-    int methods_with_llvm;
+       gint32 methods_compiled;
+       gint32 methods_aot;
+       gint32 methods_lookups;
+       gint32 allocate_var;
+       gint32 cil_code_size;
+       gint32 native_code_size;
+       gint32 code_reallocs;
+       gint32 max_code_size_ratio;
+       gint32 biggest_method_size;
+       gint32 allocated_code_size;
+       gint32 inlineable_methods;
+       gint32 inlined_methods;
+       gint32 basic_blocks;
+       gint32 max_basic_blocks;
+       gint32 locals_stack_size;
+       gint32 regvars;
+       gint32 cas_declsec_check;
+       gint32 cas_linkdemand_icall;
+       gint32 cas_linkdemand_pinvoke;
+       gint32 cas_linkdemand_aptc;
+       gint32 cas_linkdemand;
+       gint32 cas_demand_generation;
+       gint32 generic_virtual_invocations;
+       int methods_with_llvm;
        int methods_without_llvm;
        char *max_ratio_method;
        char *biggest_method;

diff --git a/mono/mini/tramp-alpha.c b/mono/mini/tramp-alpha.c
index 186d9bc08cbe791bed96028e04dcf2857ba3f0af..cab03d65ec5f8a8af8a17cf9e0edfff7e320d826 100644 (file)
--- a/mono/mini/tramp-alpha.c
+++ b/mono/mini/tramp-alpha.c
@@ -485,8 +485,6 @@ mono_arch_create_specific_trampoline (gpointer arg1,
        g_debug("mono_arch_create_specific_trampoline: Target: %p, Arg1: %p",
         real_code, arg1);
   
-  mono_jit_stats.method_trampolines++;
-  
   if (code_len)
     *code_len = size;
   

diff --git a/mono/mini/tramp-hppa.c b/mono/mini/tramp-hppa.c
index 595bbc0416624c40a6f89562d1483772ea304761..3054e8c7c61ebf16da24aa8704cd15814dc7198b 100644 (file)
--- a/mono/mini/tramp-hppa.c
+++ b/mono/mini/tramp-hppa.c
@@ -349,8 +349,6 @@ mono_arch_create_class_init_trampoline (MonoVTable *vtable)
        /* Sanity check */
        g_assert ((buf - code) <= METHOD_TRAMPOLINE_SIZE);
 
-       mono_jit_stats.method_trampolines++;
-
        return code;
 }
 
@@ -378,8 +376,6 @@ create_specific_tramp (MonoMethod *method, guint8* tramp, MonoDomain *domain)
        ji->code_start = code;
        ji->code_size = buf - code;
 
-       mono_jit_stats.method_trampolines++;
-
        return ji;
 }