diff a/src/hotspot/share/memory/metaspace/metaspaceArena.hpp b/src/hotspot/share/memory/metaspace/metaspaceArena.hpp
--- a/src/hotspot/share/memory/metaspace/metaspaceArena.hpp
+++ b/src/hotspot/share/memory/metaspace/metaspaceArena.hpp
@@ -27,23 +27,25 @@
 #define SHARE_MEMORY_METASPACE_METASPACEARENA_HPP
 
 #include "memory/allocation.hpp"
 #include "memory/metaspace.hpp"
 #include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/metablock.hpp"
 #include "memory/metaspace/metachunkList.hpp"
 
 class outputStream;
 class Mutex;
 
 namespace metaspace {
 
 class ArenaGrowthPolicy;
+struct ArenaStats;
+class MetaspaceContext;
 class ChunkManager;
-class Metachunk;
 class FreeBlocks;
+class Metachunk;
 
-struct ArenaStats;
 
 // The MetaspaceArena is a growable metaspace memory pool belonging to a CLD;
 //  internally it consists of a list of metaspace chunks, of which the head chunk
 //  is the current chunk from which we allocate via pointer bump.
 //
@@ -72,14 +74,17 @@
 // MetaspaceArena also keeps a FreeBlocks structure to manage memory blocks which
 //  had been deallocated prematurely.
 //
 
 class MetaspaceArena : public CHeapObj<mtClass> {
+  friend class MetaspaceArenaTestFriend;
 
   // Please note that access to a metaspace arena may be shared
   // between threads and needs to be synchronized in CLMS.
 
+  const size_t _allocation_alignment_words;
+
   // Reference to the chunk manager to allocate chunks from.
   ChunkManager* const _chunk_manager;
 
   // Reference to the growth policy to use.
   const ArenaGrowthPolicy* const _growth_policy;
@@ -124,14 +129,14 @@
 
   ChunkManager* chunk_manager() const           { return _chunk_manager; }
 
   // free block list
   FreeBlocks* fbl() const                       { return _fbl; }
-  void add_allocation_to_fbl(MetaWord* p, size_t word_size);
+  void add_allocation_to_fbl(MetaBlock bl);
 
-  // Given a chunk, add its remaining free committed space to the free block list.
-  void salvage_chunk(Metachunk* c);
+  // Given a chunk, return the committed remainder of this chunk.
+  MetaBlock salvage_chunk(Metachunk* c);
 
   // Allocate a new chunk from the underlying chunk manager able to hold at least
   // requested word size.
   Metachunk* allocate_new_chunk(size_t requested_word_size);
 
@@ -142,36 +147,35 @@
   //  requested_word_size additional words.
   //
   // On success, true is returned, false otherwise.
   bool attempt_enlarge_current_chunk(size_t requested_word_size);
 
-  // Returns true if the area indicated by pointer and size have actually been allocated
-  // from this arena.
-  DEBUG_ONLY(bool is_valid_area(MetaWord* p, size_t word_size) const;)
-
   // Allocate from the arena proper, once dictionary allocations and fencing are sorted out.
-  MetaWord* allocate_inner(size_t word_size);
+  MetaBlock allocate_inner(size_t word_size, MetaBlock& wastage);
 
 public:
 
-  MetaspaceArena(ChunkManager* chunk_manager, const ArenaGrowthPolicy* growth_policy,
-                 SizeAtomicCounter* total_used_words_counter,
+  MetaspaceArena(MetaspaceContext* context,
+                 const ArenaGrowthPolicy* growth_policy,
+                 size_t allocation_alignment_words,
                  const char* name);
 
   ~MetaspaceArena();
 
+  size_t allocation_alignment_words() const { return _allocation_alignment_words; }
+  size_t allocation_alignment_bytes() const { return allocation_alignment_words() * BytesPerWord; }
+
   // Allocate memory from Metaspace.
-  // 1) Attempt to allocate from the dictionary of deallocated blocks.
-  // 2) Attempt to allocate from the current chunk.
-  // 3) Attempt to enlarge the current chunk in place if it is too small.
-  // 4) Attempt to get a new chunk and allocate from that chunk.
-  // At any point, if we hit a commit limit, we return null.
-  MetaWord* allocate(size_t word_size);
+  // On success, returns non-empty block of the specified word size, and
+  // possibly a wastage block that is the result of alignment operations.
+  // On failure, returns an empty block. Failure may happen if we hit a
+  // commit limit.
+  MetaBlock allocate(size_t word_size, MetaBlock& wastage);
 
   // Prematurely returns a metaspace allocation to the _block_freelists because it is not
   // needed anymore.
-  void deallocate(MetaWord* p, size_t word_size);
+  void deallocate(MetaBlock bl);
 
   // Update statistics. This walks all in-use chunks.
   void add_to_statistics(ArenaStats* out) const;
 
   // Convenience method to get the most important usage statistics.
@@ -181,10 +185,12 @@
   DEBUG_ONLY(void verify() const;)
   DEBUG_ONLY(void verify_allocation_guards() const;)
 
   void print_on(outputStream* st) const;
 
+  // Returns true if the given block is contained in this arena
+  DEBUG_ONLY(bool contains(MetaBlock bl) const;)
 };
 
 } // namespace metaspace
 
 #endif // SHARE_MEMORY_METASPACE_METASPACEARENA_HPP
