[Java] 认识Java中的Stub与StubQueue

static StubQueue* _code;

// InterpreterCodeSize是在平台相关
// 的templateInterpreter_x86.hpp中
// 定义的，64位下是256 * 1024
int code_size = InterpreterCodeSize;
_code = new StubQueue(
        new InterpreterCodeletInterface, 
        code_size, 
        NULL,
        "Interpreter");

class Stub VALUE_OBJ_CLASS_SPEC { ... };

class InterpreterCodelet: public Stub {
private:
int        _size;     // the size in bytes
const char*    _description;  // a description of the codelet, for debugging & printing
Bytecodes::Code  _bytecode;   // associated bytecode if any
public:
// Code info
address code_begin() const  {
   return (address)this + round_to(sizeof(InterpreterCodelet), CodeEntryAlignment);
}
address code_end() const {
   return (address)this + size();
}
int size() const {
   return _size;
}
// ...
int code_size() const { 
   return code_end() - code_begin();  
}
// ...
};

class StubQueue: public CHeapObj<mtCode> {
private:
StubInterface* _stub_interface;   // the interface prototype
address    _stub_buffer;    // where all stubs are stored
int      _buffer_size;     // the buffer size in bytes
int      _buffer_limit;    // the (byte) index of the actual buffer limit (_buffer_limit <= _buffer_size)
int      _queue_begin;     // the (byte) index of the first queue entry (word-aligned)
int      _queue_end;     // the (byte) index of the first entry after the queue (word-aligned)
int      _number_of_stubs;   // the number of buffered stubs

bool is_contiguous() const {
  return _queue_begin <= _queue_end;
}
int index_of(Stub* s) const {
  int i = (address)s - _stub_buffer;
  return i;
}
Stub* stub_at(int i) const {
  return (Stub*)(_stub_buffer + i);
}
Stub* current_stub() const {
  return stub_at(_queue_end);
}
// ...
}

StubQueue::StubQueue(
StubInterface* stub_interface,  // InterpreterCodeletInterface对象
int      buffer_size,   // 256*1024
Mutex*     lock,
const char*  name) : _mutex(lock)
{
intptr_t   size = round_to(buffer_size, 2*BytesPerWord); // BytesPerWord的值为8
BufferBlob*  blob = BufferBlob::create(name, size); // 在StubQueue中创建BufferBlob对象
_stub_interface  = stub_interface;
_buffer_size   = blob->content_size();
_buffer_limit  = blob->content_size();
_stub_buffer   = blob->content_begin();
_queue_begin   = 0;
_queue_end     = 0;
_number_of_stubs = 0;
}

BufferBlob* BufferBlob::create(const char* name, int buffer_size) {
// ...
BufferBlob*  blob = NULL;
unsigned int   size = sizeof(BufferBlob);
// align the size to CodeEntryAlignment
size = align_code_offset(size);
size += round_to(buffer_size, oopSize); // oopSize是一个指针的宽度，在64位上就是8
{
   MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
   blob = new (size) BufferBlob(name, size);
}
return blob;
}

void* BufferBlob::operator new(size_t s, unsigned size, bool is_critical) throw() {
void* p = CodeCache::allocate(size, is_critical);
return p;
}