Mercurial > hg > graal-compiler

comparison src/share/vm/c1/c1_Compiler.cpp @ 13086:096c224171c4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/
author Doug Simon <doug.simon@oracle.com>
date Wed, 20 Nov 2013 00:10:38 +0100
parents 836a62f43af9 469216acdb28
children d8041d695d19
comparison
equal deleted inserted replaced
12782:92b7ec34ddfa 13086:096c224171c4
40 #include "prims/nativeLookup.hpp" 40 #include "prims/nativeLookup.hpp"
41 #include "runtime/arguments.hpp" 41 #include "runtime/arguments.hpp"
42 #include "runtime/interfaceSupport.hpp" 42 #include "runtime/interfaceSupport.hpp"
43 #include "runtime/sharedRuntime.hpp" 43 #include "runtime/sharedRuntime.hpp"
44 44
45 volatile int Compiler::_runtimes = uninitialized;
46 45
47 Compiler::Compiler() : AbstractCompiler(c1) { 46 Compiler::Compiler() : AbstractCompiler(c1) {
48 } 47 }
49 48
50 49 void Compiler::init_c1_runtime() {
51 Compiler::~Compiler() {
52 Unimplemented();
53 }
54
55
56 void Compiler::initialize_all() {
57 BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob(); 50 BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob();
58 Arena* arena = new (mtCompiler) Arena(); 51 Arena* arena = new (mtCompiler) Arena();
59 Runtime1::initialize(buffer_blob); 52 Runtime1::initialize(buffer_blob);
60 FrameMap::initialize(); 53 FrameMap::initialize();
61 // initialize data structures 54 // initialize data structures
62 ValueType::initialize(arena); 55 ValueType::initialize(arena);
63 // Instruction::initialize();
64 // BlockBegin::initialize();
65 GraphBuilder::initialize(); 56 GraphBuilder::initialize();
66 // note: to use more than one instance of LinearScan at a time this function call has to 57 // note: to use more than one instance of LinearScan at a time this function call has to
67 // be moved somewhere outside of this constructor: 58 // be moved somewhere outside of this constructor:
68 Interval::initialize(arena); 59 Interval::initialize(arena);
69 } 60 }
70 61
71 62
72 void Compiler::initialize() { 63 void Compiler::initialize() {
73 if (_runtimes != initialized) { 64 // Buffer blob must be allocated per C1 compiler thread at startup
74 initialize_runtimes( initialize_all, &_runtimes); 65 BufferBlob* buffer_blob = init_buffer_blob();
66
67 if (should_perform_init()) {
68 if (buffer_blob == NULL) {
69 // When we come here we are in state 'initializing'; entire C1 compilation
70 // can be shut down.
71 set_state(failed);
72 } else {
73 init_c1_runtime();
74 set_state(initialized);
75 }
75 } 76 }
76 mark_initialized();
77 } 77 }
78 78
79 79 BufferBlob* Compiler::init_buffer_blob() {
80 BufferBlob* Compiler::get_buffer_blob(ciEnv* env) {
81 // Allocate buffer blob once at startup since allocation for each 80 // Allocate buffer blob once at startup since allocation for each
82 // compilation seems to be too expensive (at least on Intel win32). 81 // compilation seems to be too expensive (at least on Intel win32).
83 BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob(); 82 assert (CompilerThread::current()->get_buffer_blob() == NULL, "Should initialize only once");
84 if (buffer_blob != NULL) {
85 return buffer_blob;
86 }
87 83
88 // setup CodeBuffer. Preallocate a BufferBlob of size 84 // setup CodeBuffer. Preallocate a BufferBlob of size
89 // NMethodSizeLimit plus some extra space for constants. 85 // NMethodSizeLimit plus some extra space for constants.
90 int code_buffer_size = Compilation::desired_max_code_buffer_size() + 86 int code_buffer_size = Compilation::desired_max_code_buffer_size() +
91 Compilation::desired_max_constant_size(); 87 Compilation::desired_max_constant_size();
92 88
93 buffer_blob = BufferBlob::create("Compiler1 temporary CodeBuffer", 89 BufferBlob* buffer_blob = BufferBlob::create("C1 temporary CodeBuffer", code_buffer_size);
94 code_buffer_size); 90 if (buffer_blob != NULL) {
95 if (buffer_blob == NULL) {
96 CompileBroker::handle_full_code_cache();
97 env->record_failure("CodeCache is full");
98 } else {
99 CompilerThread::current()->set_buffer_blob(buffer_blob); 91 CompilerThread::current()->set_buffer_blob(buffer_blob);
100 } 92 }
101 93
102 return buffer_blob; 94 return buffer_blob;
103 } 95 }
104 96
105 97
106 void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci) { 98 void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci) {
107 BufferBlob* buffer_blob = Compiler::get_buffer_blob(env); 99 BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob();
108 if (buffer_blob == NULL) { 100 assert(buffer_blob != NULL, "Must exist");
109 return;
110 }
111
112 if (!is_initialized()) {
113 initialize();
114 }
115
116 // invoke compilation 101 // invoke compilation
117 { 102 {
118 // We are nested here because we need for the destructor 103 // We are nested here because we need for the destructor
119 // of Compilation to occur before we release the any 104 // of Compilation to occur before we release the any
120 // competing compiler thread 105 // competing compiler thread