jdk8-mips64-public/hotspot: comparison src/share/vm/compiler/compileBroker.hpp

-:f353275af40e
+:d5d065957597
 /*
-* Copyright (c) 1999, 2006, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 bool         _is_success;
 bool         _is_blocking;
 int          _comp_level;
 int          _num_inlined_bytecodes;
 nmethodLocker* _code_handle;  // holder of eventual result
-CompileTask* _next;
+CompileTask* _next, *_prev;
 // Fields used for logging why the compilation was initiated:
 jlong        _time_queued;  // in units of os::elapsed_counter()
 jobject      _hot_method;   // which method actually triggered this task
 int          _hot_count;    // information about its invocation counter
 const char*  _comment;      // more info about the task
+void print_compilation(outputStream *st, methodOop method, char* method_name);
 public:
 CompileTask() {
 _lock = new Monitor(Mutex::nonleaf+2, "CompileTaskLock");
 }
 int          num_inlined_bytecodes() const     { return _num_inlined_bytecodes; }
 void         set_num_inlined_bytecodes(int n)  { _num_inlined_bytecodes = n; }
 CompileTask* next() const                      { return _next; }
 void         set_next(CompileTask* next)       { _next = next; }
+CompileTask* prev() const                      { return _prev; }
+void         set_prev(CompileTask* prev)       { _prev = prev; }
 void         print();
 void         print_line();
 void         print_line_on_error(outputStream* st, char* buf, int buflen);
 void         log_task(xmlStream* log);
 void         log_task_queued();
 void         log_task_start(CompileLog* log);
 void         log_task_done(CompileLog* log);
 };
 // CompilerCounters
 //
 // Per Compiler Performance Counters.
 int compile_type()                       { return _compile_type; }
 PerfCounter* time_counter()              { return _perf_time; }
 PerfCounter* compile_counter()           { return _perf_compiles; }
 };
 // CompileQueue
 //
 // A list of CompileTasks.
 class CompileQueue : public CHeapObj {
 Monitor*    _lock;
 CompileTask* _first;
 CompileTask* _last;
+int _size;
 public:
 CompileQueue(const char* name, Monitor* lock) {
 _name = name;
 _lock = lock;
 _first = NULL;
 _last = NULL;
+_size = 0;
 }
 const char*  name() const                      { return _name; }
 Monitor*     lock() const                      { return _lock; }
 void         add(CompileTask* task);
+void         remove(CompileTask* task);
+CompileTask* first()                           { return _first; }
+CompileTask* last()                            { return _last;  }
 CompileTask* get();
 bool         is_empty() const                  { return _first == NULL; }
+int          size()     const                  { return _size;          }
 void         print();
+};
+// CompileTaskWrapper
+//
+// Assign this task to the current thread.  Deallocate the task
+// when the compilation is complete.
+class CompileTaskWrapper : StackObj {
+public:
+CompileTaskWrapper(CompileTask* task);
+~CompileTaskWrapper();
 };
 // Compilation
 //
 static int  _last_compile_type;
 static int  _last_compile_level;
 static char _last_method_compiled[name_buffer_length];
-static CompileQueue* _method_queue;
+static CompileQueue* _c2_method_queue;
+static CompileQueue* _c1_method_queue;
 static CompileTask* _task_free_list;
 static GrowableArray<CompilerThread*>* _method_threads;
 // performance counters
 static int _sum_osr_bytes_compiled;
 static int _sum_standard_bytes_compiled;
 static int _sum_nmethod_size;
 static int _sum_nmethod_code_size;
-static int compiler_count() {
-return CICompilerCountPerCPU
-// Example: if CICompilerCountPerCPU is true, then we get
-// max(log2(8)-1,1) = 2 compiler threads on an 8-way machine.
-// May help big-app startup time.
-? (MAX2(log2_intptr(os::active_processor_count())-1,1))
-: CICompilerCount;
-}
 static CompilerThread* make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, TRAPS);
-static void init_compiler_threads(int compiler_count);
+static void init_compiler_threads(int c1_compiler_count, int c2_compiler_count);
 static bool compilation_is_complete  (methodHandle method, int osr_bci, int comp_level);
-static bool compilation_is_in_queue  (methodHandle method, int osr_bci);
 static bool compilation_is_prohibited(methodHandle method, int osr_bci, int comp_level);
 static uint assign_compile_id        (methodHandle method, int osr_bci);
 static bool is_compile_blocking      (methodHandle method, int osr_bci);
 static void preload_classes          (methodHandle method, TRAPS);
 int comp_level,
 methodHandle hot_method,
 int hot_count,
 const char* comment,
 TRAPS);
+static CompileQueue* compile_queue(int comp_level) {
+if (is_c2_compile(comp_level)) return _c2_method_queue;
+if (is_c1_compile(comp_level)) return _c1_method_queue;
+return NULL;
+}
 public:
 enum {
 // The entry bci used for non-OSR compilations.
 standard_entry_bci = InvocationEntryBci
 };
-static AbstractCompiler* compiler(int level ) {
+static AbstractCompiler* compiler(int comp_level) {
-if (level == CompLevel_fast_compile) return _compilers[0];
+if (is_c2_compile(comp_level)) return _compilers[1]; // C2
-assert(level == CompLevel_highest_tier, "what level?");
+if (is_c1_compile(comp_level)) return _compilers[0]; // C1
-return _compilers[1];
+return NULL;
 }
+static bool compilation_is_in_queue(methodHandle method, int osr_bci);
+static int queue_size(int comp_level) {
+CompileQueue *q = compile_queue(comp_level);
+return q != NULL ? q->size() : 0;
+}
 static void compilation_init();
 static void init_compiler_thread_log();
-static nmethod* compile_method(methodHandle method, int osr_bci,
+static nmethod* compile_method(methodHandle method,
-methodHandle hot_method, int hot_count,
+int osr_bci,
+int comp_level,
+methodHandle hot_method,
+int hot_count,
 const char* comment, TRAPS);
 static void compiler_thread_loop();
 static uint get_compilation_id() { return _compilation_id; }

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/compiler/compileBroker.hpp

src/share/vm/compiler/compileBroker.hpp