@MappedType(sizeof = 12)
public class MappedVec3 extends MappedObject
{
   public float x;

   public float y;

   public float z; // you can hardcode this field's byte-offset using: @MappedField(offset=8)

   public float length()
   {
      return (float) Math.sqrt(x*x + y*y + z*z); // natural field access
   }

   @Override
   public String toString()
   {
      return "[" + x + "," + y + "," + z + "]";
   }
}

public class TestMappedObject
{
   public static void main(String[] args)
   {
      MappedObjectTransformer.register(MappedVec3.class);

      // we 'fork' the current application. the forked version will have transformed classes
      if (MappedObjectClassLoader.fork(TestMappedObject.class, args))
      {
         // if this is the version of the classloader without transformed classes, stop right here
         return;
      }

      // business as usual

      ByteBuffer bb = ByteBuffer.allocateDirect(4096);
      bb.order(ByteOrder.nativeOrder());
      MappedVec3 vecs = MappedVec3.map(bb);

      // naturally we start at mapping 0
      vecs.x = 1.30f;
      vecs.y = 2.50f;
      vecs.z = 3.60f;

      vecs.view = 1; // go to mapping at index 1
      vecs.x = 0.13f;
      vecs.y = 0.25f;
      vecs.z = 0.36f;

      float x0 = bb.getFloat(0 << 2);
      float y0 = bb.getFloat(1 << 2);
      float z0 = bb.getFloat(2 << 2);

      float x1 = bb.getFloat(3 << 2);
      float y1 = bb.getFloat(4 << 2);
      float z1 = bb.getFloat(5 << 2);
   }
}

struct Sphere
{
   float x, y, z, r;

   bool intersects(Sphere that)
   {
      float xd = this->x - that->x;
      float yd = this->y - that->y;
      float zd = this->z - that->z;
      float d2 = (xd * xd) + (yd * yd) + (zd * zd);
      float r = this->r + that->r;
      return d2 <= r * r;
   }
}

   @MappedType(stride = 16)
   public abstract class Sphere // or interface...
   {
      // sliding window
      public abstract void map(int element);

      // getters (with annotations)
      public abstract @MappedField(offset = 0,  type = float.class) float x();
      public abstract @MappedField(offset = 4,  type = float.class) float y();
      public abstract @MappedField(offset = 8,  type = float.class) float z();
      public abstract @MappedField(offset = 12, type = float.class) float r();

      // setters
      public abstract void x(float x);
      public abstract void y(float y);
      public abstract void z(float z);
      public abstract void r(float r);

      public boolean intersects(Sphere that)
      {
         float xd = this.x() - that.x();
         float yd = this.y() - that.y();
         float zd = this.z() - that.z();
         float d2 = (xd * xd) + (yd * yd) + (zd * zd);
         float r = this.r() + that.r();
         return d2 <= r * r;
      }
}

      MappedObjectProvider<Sphere> provider = new MappedObjectProvider<Sphere>(Sphere.class);

      int sphereCount = 128;
      ByteBuffer data1 = ByteBuffer.allocate(      provider.sizeof() * sphereCount);
      ByteBuffer data2 = ByteBuffer.allocateDirect(provider.sizeof() * sphereCount);
      byte[]     data3 = new byte[                 provider.sizeof() * sphereCount];
      
      Sphere sA = provider.newMappedObject(data1, 0, sphereCount); // datasource, base, elementCount
      Sphere sB = provider.newMappedObject(data2, 0, sphereCount);
      Sphere sC = provider.newMappedObject(data3, 0, sphereCount);

      sA.map(5);  // slide the MappedObject to element 5 (offset = base+5*stride)
      sB.map(13); // slide the MappedObject to element 13

      // sA.x = sB.x;
      sA.x(sB.x());

package eden;

import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.util.Arrays;

import sun.misc.Unsafe;

public class MappedObject
{
   private static final long nanoTimeOverhead;
   static
   {
      nanoTimeOverhead = measureNanoTimeOverhead();
      System.out.println("Java version: " + System.getProperty("java.version"));
      System.out.println("JavaVM version: " + System.getProperty("java.vm.version"));
      System.out.println("nanoTimeOverhead: " + nanoTimeOverhead + "ns");
   }

   private static Unsafe grabUnsafeInstanceFromBuffer()
   {
      try
      {
         ByteBuffer dummy = ByteBuffer.allocateDirect(1);
         Field unsafeField = dummy.getClass().getDeclaredField("unsafe");
         unsafeField.setAccessible(true);
         return (Unsafe) unsafeField.get(dummy);
      }
      catch (Throwable t)
      {
         throw new Error(t);
      }
   }

   public static void main(String[] args)
   {
      Unsafe unsafe = grabUnsafeInstanceFromBuffer();

      //

      int vectors = 4 * 1024; // small, to keep it in cache
      int floats = vectors * 4;
      int bytes = floats * 4;

      //

      int runs = 256;

      for (int i = 0; i < 16; i++)
      {
         System.out.println();

         runFloatObjectBenchmark(vectors, floats, bytes, runs);
         runFloatBufferBenchmark(vectors, floats, bytes, runs);
         runFloatArrayBenchmark(vectors, floats, bytes, runs);
         runFloatPointerBenchmark(unsafe, vectors, floats, bytes, runs);
      }
   }

   static class FloatVector
   {
      public float x, y, z, w;
   }

   private static final String formatNanos(long nanos)
   {
      if (nanos > 10 * 1000000000L)
         return (nanos / 1000000000L) + "s";
      if (nanos > 10 * 1000000L)
         return (nanos / 1000000L) + "ms";
      if (nanos > 10 * 1000L)
         return (nanos / 1000L) + "us";
      return nanos + "ns";
   }

   private static final void printResults(String prefix, long[] durations)
   {
      System.out.println(prefix + ".best:   " + formatNanos(durations[(int) (durations.length * 0.00f)]));
      System.out.println(prefix + ".good:   " + formatNanos(durations[(int) (durations.length * 0.05f)]));
      System.out.println(prefix + ".median: " + formatNanos(durations[(int) (durations.length * 0.50f)]));
      System.out.println(prefix + ".bad:    " + formatNanos(durations[(int) (durations.length * 0.95f) - 1]));
      System.out.println(prefix + ".worst:  " + formatNanos(durations[(int) (durations.length * 1.00f) - 1]));
   }

   private static final void runFloatObjectBenchmark(int vectors, int floats, int bytes, int runs)
   {
      FloatVector[] a = new FloatVector[vectors];
      FloatVector[] b = new FloatVector[vectors];
      FloatVector[] dst = new FloatVector[vectors];

      // allocate the objects sequentially, per array
      for (int i = 0; i < vectors; i++)
         a[i] = new FloatVector();
      for (int i = 0; i < vectors; i++)
         b[i] = new FloatVector();
      for (int i = 0; i < vectors; i++)
         dst[i] = new FloatVector();

      long[] durations = new long[runs];
      for (int i = 0; i < durations.length; i++)
      {
         long t0 = System.nanoTime();
         testFloatObjectMulPerformance(a, b, dst, vectors);
         long t1 = System.nanoTime();
         long took = (t1 - t0) - 2 * nanoTimeOverhead;
         durations[i] = took;
      }

      Arrays.sort(durations);
      printResults("Vector", durations);
   }

   private static final void runFloatArrayBenchmark(int vectors, int floats, int bytes, int runs)
   {
      float[] a = new float[floats];
      float[] b = new float[floats];
      float[] dst = new float[floats];

      long[] durations = new long[runs];
      for (int i = 0; i < durations.length; i++)
      {
         long t0 = System.nanoTime();
         testFloatArrayMulPerformance(a, b, dst, vectors);
         long t1 = System.nanoTime();
         long took = (t1 - t0) - 2 * nanoTimeOverhead;
         durations[i] = took;
      }

      Arrays.sort(durations);
      printResults("float[]", durations);
   }

   private static final void runFloatBufferBenchmark(int vectors, int floats, int bytes, int runs)
   {
      FloatBuffer a = ByteBuffer.allocateDirect(bytes).order(ByteOrder.nativeOrder()).asFloatBuffer();
      FloatBuffer b = ByteBuffer.allocateDirect(bytes).order(ByteOrder.nativeOrder()).asFloatBuffer();
      FloatBuffer dst = ByteBuffer.allocateDirect(bytes).order(ByteOrder.nativeOrder()).asFloatBuffer();

      long[] durations = new long[runs];
      for (int i = 0; i < durations.length; i++)
      {
         long t0 = System.nanoTime();
         testFloatBufferMulPerformance(a, b, dst, vectors);
         long t1 = System.nanoTime();
         long took = (t1 - t0) - 2 * nanoTimeOverhead;
         durations[i] = took;
      }

      Arrays.sort(durations);
      printResults("FloatBuffer", durations);
   }

   private static final void runFloatPointerBenchmark(Unsafe unsafe, int vectors, int floats, int bytes, int runs)
   {
      long a = malloc_aligned(unsafe, bytes, 4 * 4);
      long b = malloc_aligned(unsafe, bytes, 4 * 4);
      long dst = malloc_aligned(unsafe, bytes, 4 * 4);

      long[] durations = new long[runs];
      for (int i = 0; i < durations.length; i++)
      {
         long t0 = System.nanoTime();
         testFloatPointerMulPerformance(unsafe, a, b, dst, vectors);
         long t1 = System.nanoTime();
         long took = (t1 - t0) - 2 * nanoTimeOverhead;
         durations[i] = took;
      }

      Arrays.sort(durations);
      printResults("float*", durations);
   }

   private static final long measureNanoTimeOverhead()
   {
      long nanoTimeOverhead = Long.MAX_VALUE;
      for (int k = 0; k < 64; k++)
      {
         for (int i = 0; i < 1024; i++)
            System.nanoTime();

         long runNanoTimeOverhead = Long.MAX_VALUE;
         for (int i = 0; i < 64; i++)
         {
            long currentOverhead = -(System.nanoTime() - System.nanoTime());
            if (currentOverhead < runNanoTimeOverhead)
               runNanoTimeOverhead = currentOverhead;
         }

         if (runNanoTimeOverhead < nanoTimeOverhead)
            nanoTimeOverhead = runNanoTimeOverhead;
      }
      return nanoTimeOverhead;
   }

   private static long malloc_aligned(Unsafe unsafe, long bytes, long align)
   {
      long base = unsafe.allocateMemory(bytes + align);
      long pntr = base + (align - (base % align));
      return pntr;
   }

   private static void testFloatObjectMulPerformance(FloatVector[] a, FloatVector[] b, FloatVector[] dst, int vectorCount)
   {
      for (int i = 0; i < vectorCount; i++)
      {
         int p = i;
         dst[p].x = a[p].x * b[p].x;
         dst[p].y = a[p].y * b[p].y;
         dst[p].z = a[p].z * b[p].z;
      }
   }

   private static void testFloatArrayMulPerformance(float[] a, float[] b, float[] dst, int vectorCount)
   {
      for (int i = 0; i < vectorCount; i++)
      {
         int p = i << 2;
         dst[p + 0] = a[p + 0] * b[p + 0];
         dst[p + 1] = a[p + 1] * b[p + 1];
         dst[p + 2] = a[p + 2] * b[p + 2];
      }
   }

   private static void testFloatBufferMulPerformance(FloatBuffer a, FloatBuffer b, FloatBuffer dst, int vectorCount)
   {
      for (int i = 0; i < vectorCount; i++)
      {
         int p = i << 2;
         dst.put(p + 0, a.get(p + 0) * b.get(p + 0));
         dst.put(p + 1, a.get(p + 1) * b.get(p + 1));
         dst.put(p + 2, a.get(p + 2) * b.get(p + 2));
      }
   }

   private static void testFloatPointerMulPerformance(Unsafe unsafe, long a, long b, long dst, int vectorCount)
   {
      for (int i = 0; i < vectorCount; i++)
      {
         int p = i << 4;

         unsafe.putFloat(dst + (p + 0), unsafe.getFloat(a + (p + 0)) * unsafe.getFloat(b + (p + 0))); // long + (int + int)
         unsafe.putFloat(dst + (p + 4), unsafe.getFloat(a + (p + 4)) * unsafe.getFloat(b + (p + 4)));
         unsafe.putFloat(dst + (p + 8), unsafe.getFloat(a + (p + 8)) * unsafe.getFloat(b + (p + 8)));
      }
   }

   private static void testFloatPointerMulPerformance_slower(Unsafe unsafe, long a, long b, long dst, int vectorCount)
   {
      for (int i = 0; i < vectorCount; i++)
      {
         int p = i << 4;
         long ap = p + a;
         long bp = p + b;
         long dstp = p + dst;

         unsafe.putFloat(dstp + 0, unsafe.getFloat(ap + 0) * unsafe.getFloat(bp + 0));
         unsafe.putFloat(dstp + 4, unsafe.getFloat(ap + 4) * unsafe.getFloat(bp + 4));
         unsafe.putFloat(dstp + 8, unsafe.getFloat(ap + 8) * unsafe.getFloat(bp + 8));
      }
   }
}

Java version: 1.6.0_20
JavaVM version: 16.3-b01
nanoTimeOverhead: 698ns

... [snip] ...

Vector.best:   26us
Vector.good:   26us
Vector.median: 27us
Vector.bad:    28us
Vector.worst:  52us

FloatBuffer.best:   20us
FloatBuffer.good:   20us
FloatBuffer.median: 20us
FloatBuffer.bad:    21us
FloatBuffer.worst:  112us

float[].best:   35us
float[].good:   35us
float[].median: 36us
float[].bad:    38us
float[].worst:  157us

float*.best:   17us
float*.good:   17us
float*.median: 18us
float*.bad:    19us
float*.worst:  95us

MappedVec2 vec2s = MappedVec2.map(ByteBuffer)

public static void main(String[] args)
{
    if(MappedInstanceTransformer.fork(MyApp.class, args))
    {
         MappedInstanceTransformer.register(MappedVec2.class);
         MappedInstanceTransformer.register(MappedVec3.class);
         MappedInstanceTransformer.register(MappedVec4.class);
         return;
    }

    // your code

    ByteBuffer bb = ByteBuffer.allocateDirect(MappedVec2.sizeof * n);
    MappedVec2 vec2s = MappedVec2.map(bb);
}