1 /*
  2  * Copyright (c) 1999, 2023, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #ifndef SHARE_COMPILER_ABSTRACTCOMPILER_HPP
 26 #define SHARE_COMPILER_ABSTRACTCOMPILER_HPP
 27 
 28 #include "ci/compilerInterface.hpp"
 29 #include "compiler/compilerDefinitions.hpp"
 30 #include "compiler/compilerDirectives.hpp"
 31 
 32 typedef void (*initializer)(void);
 33 
 34 // Per-compiler statistics
 35 class CompilerStatistics {
 36   friend class VMStructs;
 37 
 38   class Data {
 39     friend class VMStructs;
 40   public:
 41     elapsedTimer _time;  // time spent compiling
 42     uint _bytes;         // number of bytecodes compiled, including inlined bytecodes
 43     uint _count;         // number of compilations
 44     Data() : _bytes(0), _count(0) {}
 45     void update(elapsedTimer time, int bytes) {
 46       _time.add(time);
 47       _bytes += bytes;
 48       _count++;
 49     }
 50     void reset() {
 51       _time.reset();
 52     }
 53   };
 54 
 55  public:
 56   Data _standard;  // stats for non-OSR compilations
 57   Data _osr;       // stats for OSR compilations
 58   uint _nmethods_size; //
 59   uint _nmethods_code_size;
 60 
 61   double total_time() { return _standard._time.seconds() + _osr._time.seconds(); }
 62 
 63   double bytes_per_second() {
 64     uint bytes = _standard._bytes + _osr._bytes;
 65     if (bytes == 0) {
 66       return 0.0;
 67     }
 68     double seconds = total_time();
 69     return seconds == 0.0 ? 0.0 : (bytes / seconds);
 70   }
 71 
 72   CompilerStatistics() : _nmethods_size(0), _nmethods_code_size(0) {}
 73 };
 74 
 75 class AbstractCompiler : public CHeapObj<mtCompiler> {
 76  private:
 77   volatile int _num_compiler_threads;
 78 
 79  protected:
 80   volatile int _compiler_state;
 81   // Used for tracking global state of compiler runtime initialization
 82   enum { uninitialized, initializing, initialized, failed, shut_down };
 83 
 84   // This method returns true for the first compiler thread that reaches that methods.
 85   // This thread will initialize the compiler runtime.
 86   bool should_perform_init();
 87 
 88  private:
 89   const CompilerType _type;
 90 
 91   CompilerStatistics _stats;
 92 
 93  public:
 94   AbstractCompiler(CompilerType type) : _num_compiler_threads(0), _compiler_state(uninitialized), _type(type) {}
 95 
 96   // This function determines the compiler thread that will perform the
 97   // shutdown of the corresponding compiler runtime.
 98   bool should_perform_shutdown();
 99 
100   // Name of this compiler
101   virtual const char* name() = 0;
102 
103   // Determine if the current compiler provides an intrinsic
104   // for method 'method'. An intrinsic is available if:
105   //  - the intrinsic is enabled (by using the appropriate command-line flag,
106   //    the command-line compile ommand, or a compiler directive)
107   //  - the platform on which the VM is running supports the intrinsic
108   //    (i.e., the platform provides the instructions necessary for the compiler
109   //    to generate the intrinsic code).
110   //
111   // The directive provides the compilation context and includes pre-evaluated values
112   // dependent on VM flags, compile commands, and compiler directives.
113   //
114   // Usually, the compilation context is the caller of the method 'method'.
115   // The only case when for a non-recursive method 'method' the compilation context
116   // is not the caller of the 'method' (but it is the method itself) is
117   // java.lang.ref.Reference::get.
118   // For java.lang.ref.Reference::get, the intrinsic version is used
119   // instead of the compiled version so that the value in the referent
120   // field can be registered by the G1 pre-barrier code. The intrinsified
121   // version of Reference::get also adds a memory barrier to prevent
122   // commoning reads from the referent field across safepoint since GC
123   // can change the referent field's value. See Compile::Compile()
124   // in src/share/vm/opto/compile.cpp or
125   // GraphBuilder::GraphBuilder() in src/share/vm/c1/c1_GraphBuilder.cpp
126   // for more details.
127 
128   bool is_intrinsic_available(const methodHandle& method, DirectiveSet* directive) {
129     vmIntrinsics::ID id = method->intrinsic_id();
130     assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
131     return is_intrinsic_supported(method) &&
132            vmIntrinsics::is_intrinsic_available(id) &&
133            !directive->is_intrinsic_disabled(id);
134   }
135 
136   // Determines if an intrinsic is supported by the compiler, that is,
137   // the compiler provides the instructions necessary to generate
138   // the intrinsic code for method 'method'.
139   //
140   // The 'is_intrinsic_supported' method is an allow-list, that is,
141   // by default no intrinsics are supported by a compiler except
142   // the ones listed in the method. Overriding methods should conform
143   // to this behavior.
144   virtual bool is_intrinsic_supported(const methodHandle& method) {
145     return false;
146   }
147 
148   // Compiler type queries.
149   bool is_c1() const                     { return _type == compiler_c1; }
150   bool is_c2() const                     { return _type == compiler_c2; }
151   bool is_jvmci() const                  { return _type == compiler_jvmci; }
152   CompilerType type() const              { return _type; }
153 
154   // Compiler threads are hidden by default.
155   virtual bool is_hidden_from_external_view() const { return true; }
156 
157   // Customization
158   virtual void initialize () = 0;
159 
160   void set_num_compiler_threads(int num) { _num_compiler_threads = num;  }
161   int num_compiler_threads()             { return _num_compiler_threads; }
162 
163   // Get/set state of compiler objects
164   bool is_initialized()           { return _compiler_state == initialized; }
165   bool is_failed     ()           { return _compiler_state == failed;}
166   void set_state     (int state);
167   void set_shut_down ()           { set_state(shut_down); }
168   // Compilation entry point for methods
169   virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci, bool install_code, DirectiveSet* directive) {
170     ShouldNotReachHere();
171   }
172 
173   // Notifies this compiler that the current thread (`current`) is about to stop.
174   // The current thread currently holds the CompileThread_lock.
175   virtual void stopping_compiler_thread(CompilerThread* current) {
176     // Do nothing
177   }
178 
179   // Notifies this compiler that queue is empty just prior to waiting on
180   // MethodCompileQueue_lock which is held by the current thread (`thread`).
181   virtual void on_empty_queue(CompileQueue* queue, CompilerThread* thread) {
182     // Do nothing
183   }
184 
185   // Print compilation timers and statistics
186   virtual void print_timers() {
187     ShouldNotReachHere();
188   }
189 
190   CompilerStatistics* stats() { return &_stats; }
191 };
192 
193 #endif // SHARE_COMPILER_ABSTRACTCOMPILER_HPP