public static final int get2FoldUnrolled(int n)
   {
      return n < 0
         ? 0xFFFFFFFF
         : n > 0x00010000
            ? n > 0x01000000
            ? n > 0x10000000
            ? n > 0x40000000
            ? 0xFFFFFFFF
            : (n > 0x20000000) ? 0x40000000 : 0x20000000
            : n > 0x04000000 ? (n > 0x08000000) ? 0x10000000 : 0x08000000 : (n > 0x02000000) ? 0x04000000 : 0x02000000
            : n > 0x00100000
               ? n > 0x00400000
               ? (n > 0x00800000) ? 0x01000000 : 0x00800000
               : (n > 0x00200000) ? 0x00400000 : 0x00200000
               : n > 0x00040000
                  ? (n > 0x00080000) ? 0x00100000 : 0x00080000
                  : (n > 0x00020000) ? 0x00040000 : 0x00020000
            : n > 0x00000100 ? n > 0x00001000
               ? n > 0x00004000
               ? (n > 0x00008000) ? 0x00010000 : 0x00008000
               : (n > 0x00002000) ? 0x00004000 : 0x00002000
               : n > 0x00000400
                  ? (n > 0x00000800) ? 0x00001000 : 0x00000800
                  : (n > 0x00000200) ? 0x00000400 : 0x00000200 : n > 0x00000010 ? n > 0x00000040 ?
               (n >
                0x00000080)
                  ?
                  0x00000100
                  :
                     0x00000080 :
               (n >
                0x00000020)
                  ?
                  0x00000040
                  :
                     0x00000020 :
               n >
               0x00000004
                  ?
                  (n >
                   0x00000008)
                     ?
                     0x00000010
                     :
                        0x00000008
                  :
                     (n >
                      0x00000002)
                        ?
                        0x00000004
                        :
                           n;

   }

import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.nio.FloatBuffer;
import java.nio.ByteBuffer;


public class UnsafeDemo
{
   private static final int SIZE = 10000000;
   private static final int LOOPS = 50;


   public static void main(String[] args) throws Exception
   {
      Unsafe unsafe = getUnsafe();
      System.out.println("Unsafe = " + unsafe);
      System.out.println("  addressSize() = " + unsafe.addressSize());
      System.out.println("  pageSize() = " + unsafe.pageSize());
      System.out.println("  pageSize() = " + unsafe.pageSize());
      int cap = SIZE;//10m
      int ps = unsafe.pageSize();
      long base = unsafe.allocateMemory(cap + ps);
      long pointer;
      unsafe.setMemory(base, cap + ps, (byte) 0);
      if (base % ps != 0)
      {
         // Round up to page boundary
         pointer = base + ps - (base & (ps - 1));
      }
      else
      {
         pointer = base;
      }
      for (int i = 0; i < 5; i++)
      {
         benchArray();
         benchUnsafe(unsafe, pointer);
         benchBuffer();
         benchDirectBuffer();
         System.out.println("-------");
      }
      unsafe.freeMemory(pointer);
   }

   private static void benchDirectBuffer()
   {
      ByteBuffer fb = ByteBuffer.allocateDirect(SIZE);
      //unsafe benchmark
      int INTS = SIZE / 4;
      float[] dummy = new float[INTS];
      for (int i = 0; i < INTS; i++)
      {
         fb.putFloat(i,(float) (Math.random() * 1000));
      }
      long time = System.nanoTime();
      float x = 0;
      for (int i = 0; i < INTS; i++)
      {
         x += fb.getFloat(i);
      }
      System.out.println("Directbytebuffer2float time: " + (System.nanoTime() - time) / 1000000.0d + " ms");
      System.out.println("x array= " + x);
   }

   private static void benchUnsafe(final Unsafe unsafe, long pointer)
   {
      //unsafe benchmark
      int INTS = SIZE / 4;
      long absAdr = pointer-4;
      for (int i = 0; i < INTS; i++)
      {
         unsafe.putFloat(absAdr+=4, (float) (Math.random() * 1000));
      }
      long time = System.nanoTime();
      int x = 0;
      absAdr = pointer-4;
      for (int i = 0; i < INTS; i++)
      {
         x += unsafe.getFloat(absAdr+=4);
      }
      System.out.println("unsafe time " + (System.nanoTime() - time) / 1000000.0d + " ms");
      System.out.println("x unsafe= " + x);
   }

   private static void benchArray()
   {
      //unsafe benchmark
      int INTS = SIZE / 4;
      float[] dummy = new float[INTS];
      for (int i = 0; i < INTS; i++)
      {
         dummy[i] = (float) (Math.random() * 1000);
      }
      long time = System.nanoTime();
      float x = 0;
      for (int i = 0; i < INTS; i++)
      {
         x += dummy[i];
      }
      System.out.println("Array time: " + (System.nanoTime() - time) / 1000000.0d + " ms");
      System.out.println("x array= " + x);
   }

   private static void benchBuffer()
   {
      FloatBuffer fb = FloatBuffer.allocate(SIZE/4);
      //unsafe benchmark
      int INTS = SIZE / 4;
      float[] dummy = new float[INTS];
      for (int i = 0; i < INTS; i++)
      {
         fb.put(i,(float) (Math.random() * 1000));
      }
      long time = System.nanoTime();
      float x = 0;
      for (int i = 0; i < INTS; i++)
      {
         x += fb.get(i);
      }
      System.out.println("Floatbuffer time: " + (System.nanoTime() - time) / 1000000.0d + " ms");
      System.out.println("x array= " + x);
   }


   public static Unsafe getUnsafe() throws Exception
   {
      Unsafe unsafe = null;

      try
      {
         Class uc = Unsafe.class;
         Field[] fields = uc.getDeclaredFields();
         for (int i = 0; i < fields.length; i++)
         {
            if (fields[i].getName().equals("theUnsafe"))
            {
               fields[i].setAccessible(true);
               unsafe = (Unsafe) fields[i].get(uc);
               break;
            }
         }
      }
      catch (Exception ignore)
      {
      }

      return unsafe;
   }
}

res.append(line + " ");

for (int i = lengthOfList;--i>=0;)
{
   doStuff();
}

try  {
while (true)
{
   doStuff(i++);
}
} catch ()

/* Copyright Hamster Development 2006 */
package src;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.DisplayMode;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.Window;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * Developed with pleasure :)
 *
 * @author HamsterofDeath
 */
public class SpinBench extends JFrame
{
// ------------------------------ FIELDS ------------------------------

  public static SpinBench instance;
  private JPanel jpMain;

  private String title;

// --------------------------- CONSTRUCTORS ---------------------------

  /**
   * Standard-konstruktor
   */
  public SpinBench(Image img)
  {
    super();
    instance = this;
    this.title = "Spinbench";
    setResizable(false);
    buildGUI();
    addListener();
    pack();
    center();

    Window w = new Window(this);
    getGraphicsConfiguration().getDevice().setFullScreenWindow(w);
    getGraphicsConfiguration().getDevice().setDisplayMode(new DisplayMode(1600, 1200, 32, 60));
    Image buffered = getImg();
    Graphics2D graphics;
    List<Graphics2D> g2d = new ArrayList<Graphics2D>();
    for (int i = 1; i < 31; i++)
    {
      for (int i2 = 1; i2 < 31; i2++)
      {
        Graphics2D g2 = (Graphics2D) buffered.getGraphics();
        g2.translate(i * 50, i2 * 50);
        g2.scale(0.1, 0.1);
        g2d.add(g2);
        //g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        //g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
      }
    }
    graphics = (Graphics2D) buffered.getGraphics();
    graphics.setColor(Color.black);
    while (true)
    {
      long startTime = System.nanoTime();
      int frames = 0;
      while (frames++ < 100)
      {
        graphics.fillRect(0, 0, 1600, 1200);
        for (Graphics2D graphics2D : g2d)
        {
          graphics2D.rotate(0.1 * Math.random());
          graphics2D.drawImage(img, 0, 0, null);
        }
        //aufs panel
        w.getGraphics().drawImage(buffered, 0, 0, null);
      }
      long elapsed = System.nanoTime() - startTime;
      double nsPerDraw = elapsed / (float) frames;
      System.out.println(nsPerDraw + " ns per frame = " + 1.0 / (nsPerDraw / 1000000000.0) + " fps");
    }
  }

  private Image getImg()
  {
    //  return new BufferedImage(1600, 1200, BufferedImage.TYPE_INT_ARGB);
    return this.createVolatileImage(1600, 1200);
  }

  /**
   * Gui aufbauen
   */
  protected void buildGUI()
  {
    setTitle(title);
    getContentPane().setLayout(new BorderLayout(6, 6));
    jpMain = new JPanel();
    getContentPane().add(jpMain, BorderLayout.CENTER);
    jpMain.setBorder(new EmptyBorder(6, 6, 6, 6));
    jpMain.setLayout(new BorderLayout(6, 6));

    jpMain.setPreferredSize(new Dimension(640, 480));
  }

  /**
   * Listener registrieren
   */
  protected void addListener()
  {
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }

  private void center()
  {
    Toolkit tk = Toolkit.getDefaultToolkit();
    setLocation((int) (tk.getScreenSize().getWidth() / 2 - getWidth() / 2),
                (int) (tk.getScreenSize().getHeight() / 2 - getHeight() / 2));
    setVisible(true);
  }

// --------------------------- main() method ---------------------------

  public static void main(String[] args)
    throws IOException
  {
    Image image = ImageIO.read(new File("resource/hamster.jpg"));
    new SpinBench(image);
  }
}