How come full screen exclusive mode is so slow?

Question

Hi. I am currently working on customer facing point-of-sale application. This application has a lot of animation going on and so needs quite speedy graphics performance. When I first investigated this it looked like I could do it in pure Java 2D which would be a lot easier than resorting to DirectX or OpenGL and mixing languages.
Unfortunately as the app has moved closer to functional complete the graphics performance appears to have deteriorated to the point where it is unusable. So I have gone back to the beginning and written a test program to identify the problem .
The tests I have done indicate that full screen exclusive mode runs about ten times slower than windowed mode. Which is mind boggling. Normally - say in DirectX - you would expect a full screen exclusive version of a games/graphics app to run a little bit quicker than a windowed version since it doesn't have to mess around with clip regions and moving vram pointers.
My test program creates a 32 bit image and blits it to the screen a variable number of times in both windowed and full screen mode. Edited results look like this:
iter wndw fscrn performance
     10 16.0 298.0 1862% slower
     20 47.0 610.0 1297% slower
     30 94.0 923.0 981% slower
     40 141.0 1205.0 854% slower
     50 157.0 1486.0 946% slower
     60 204.0 1877.0 920% slower
     70 234.0 2127.0 908% slower
     80 266.0 2425.0 911% slower
     90 297.0 2722.0 916% slower
     100 344.0 3253.0 945% slower
The results are substantially the same with the openGL hint turned on (although I don't have that option on the release hardware). I am assuming that the images end up as managed since they are created through BufferedImage and the system is running under 1.5.
Is there a way to get the full screen version running as fast as the windowed version?
Here's the test prog:
import java.awt.*;
import java.awt.image.*;
import java.awt.event.*;
import javax.swing.JFrame;
public class BlittingTest extends JFrame {
     BufferedImage     blankImage;
     BufferedImage     testImage;
     boolean               fullscreen;
     int                    frameNum;
     public BlittingTest( boolean fullscreen ) throws HeadlessException {
          super();
          // window setup. Escape to exit!
          addKeyListener ( new KeyAdapter() {
               public void keyPressed( KeyEvent ke ) {
                    if (ke.getKeyCode() == KeyEvent.VK_ESCAPE ) {
                         System.exit(0);
          this.fullscreen=fullscreen;
          if ( fullscreen ) {
               setUndecorated ( true );
          } else {
               setTitle( "BlittingTest - <esc> to exit)");
               setSize( 800, 600 );
          setVisible(true);
          setIgnoreRepaint(true);
          // strategy setup
          if ( fullscreen ) {
               GraphicsDevice gdev =
                    GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
               DisplayMode newDisplayMode = new DisplayMode (800, 600, 32,
                                             DisplayMode.REFRESH_RATE_UNKNOWN);
               DisplayMode oldDisplayMode = gdev.getDisplayMode();               
               gdev.setFullScreenWindow(this);
               gdev.setDisplayMode(newDisplayMode);
               createBufferStrategy(2);
          // create assets
          testImage = new BufferedImage ( 50, 50, BufferedImage.TYPE_INT_ARGB );
          Graphics2D g = testImage.createGraphics();
          for ( int i = 0; i < 50; i ++ ) {
               g.setColor( new Color ( 0, (50 - i) * 3, 0, i * 3 ));
               g.drawLine( i, 0, i, 49 );
          g.dispose();
          blankImage = new BufferedImage ( 50, 50, BufferedImage.TYPE_INT_ARGB );
          g = blankImage.createGraphics();
          g.setColor ( Color.WHITE );
          g.fillRect( 0, 0, 50, 50 );
          g.dispose();
          frameNum = -1;
     public void init() {
          // blank both screen buffers
          for ( int i = 0; i < 2; i++ ) {
               Graphics g2 = getBufferStrategy().getDrawGraphics();
               g2.setColor ( Color.WHITE );
               g2.fillRect( 0, 0, 800, 600 );
               g2.dispose();
               getBufferStrategy().show();
     public long testFrame ( int numBlits ) {
          int          x, y;
          long     timeIn, timeOut;
          frameNum++;
          Graphics g = getBufferStrategy().getDrawGraphics();
          g.drawImage( testImage, 0, 0, null );
          // blank previous draw
          if ( fullscreen ) {
               if ( frameNum > 1 ) {
                    x = frameNum - 2;
                    y = frameNum - 2;
                    g.drawImage ( blankImage, x, y, null);
          } else {
               if ( frameNum > 0 ) {
                    x = frameNum - 1;
                    y = frameNum - 1;
                    g.drawImage ( blankImage, x, y, null);                    
          x = (int) frameNum;
          y = (int) frameNum;
          timeIn = System.currentTimeMillis();
          for ( int i = 0; i < numBlits; i++ ) {
               g.drawImage ( blankImage, x, y, null);
               g.drawImage ( testImage, x, y, null);
          timeOut = System.currentTimeMillis();
          g.dispose();
          getBufferStrategy().show();
          return     timeOut - timeIn;
     public static void main(String[] args) {
          boolean error = false;
          BlittingTest window = null;
          double []     windowedTest = new double [101];
          double []     fullscreenTest = new double [101];
          window = new BlittingTest ( false );     
          window.init();
          for ( int f = 1; f <= 100; f++ ) {
               windowedTest[f] = window.testFrame( f * 10 );
          window.setVisible(false);
          window.dispose();
          window = new BlittingTest ( true );     
          window.init();
          for ( int f = 1; f <= 100; f++ ) {
               fullscreenTest[f] = window.testFrame( f * 10 );
          window.setVisible(false);
          window.dispose();
          for ( int f = 10; f <= 100; f++ ) {
               System.out.println ( "\t" + f + "\t" + windowedTest[f] +
                         "\t" + fullscreenTest[f] +
                         "\t" + (int) ( (fullscreenTest[f]/windowedTest[f])*100.0) + "% slower");
}

Answer 1

Well I could do...
The problem is that I am compositing multiple layers of alpha transparent images. If I just render straight to the screen I get nasty flicker where I see glimpses of the background before the top layer(s) get rendered. So I would have to render to an offscreen buffer and then blit the assembled image into the screen. Even then there will be some tearing as you can never sync to the screen refresh in windowed mode.
And the thing is - there ought to be a 'proper' solution, g*dd*mm*t. Surely the core team didn't put together a solution that is ten times slower than it should be and then say 'What the heck, we'll release it anyway'.
I mean, if you can't believe in Sun engineering what can you believe in?