Hi Mark,

Can you describe why the  flush calls are required, are both required?
Blits are immediate operations at the lowest level (unless IMX53 uses a drawlist), but not immediate at the Pg level.
What context are you PgXXXXX "render draws" targeted at, and what is your current context, is it oscontext?

I would suggest:

PgFlushCx(oscontext);

And eliminate the second PgFlush call and replace it with a PgWaitHWIdle().

Now, if that is all working, then I would suggest using a locking mutex, and two back buffers instead of one (only if 
you are re-rasterizing the entire scene).

I am also thinking a lot of these operations may be falling back to software libffb ... have you brought up this issue 
via a support channel?
What display bpp are you using, 32-bits?  Are your offscreen contexts the same bpp as the display?  (very important)

Regards,
-Derek

-----Original Message-----
From: Mark Anderson [mailto:community-noreply@qnx.com] 
Sent: June-21-12 1:08 PM
To: photon-graphics
Subject: Very slow graphics rendering

We are seeing some very slow widget rendering times, and are in need of some means of speeding things up.

In general, our situation is this:
We have some background tasks rendering moving waveforms via line draws.  When we display a dialog (over the waveforms),
 we are seeing such a large amount of time taken to draw the dialog, that the background waveform tasks are held off too
 long.
The dialogs consist of a background image and multiple button images and text drawn within the dialog.

With smaller dialogs (e.g. 120x240 background image and two or three button images in the 75x55 range) the rendering 
time is short enough.
It's when we display much larger dialogs that the overall time is too long.  Currently the larger dialog we are seeing 
the problems with is 487x634, and contains about 20 buttons, most of which also have text drawn on them using a PtLabel 
widget.
After we return from the Photon event callback that makes all of the realize calls for the widgets, the Photon server 
time to render all of these buttons is about 250ms.

Some additional context:
Our systems consists of multiple C++ classes, loosely mapped to various Photon widgets.  The images that represent 
buttons are not nested within Photon widgets, but rather nested within a list maintained in our Dialog class.
We are currently using offscreen pre-rendered images and blitting them onto the screen in the Draw() method of dialogs, 
buttons, etc.  This has improved the time needed to display the dialog, (versus just allowing the default Photon 
PtImageArea widget to draw the bitmaps) but the time is still rather long.

Our hardware is:
   1280x800 display
   Freescale iMX53 evaluation board


This is the Draw() method for our raw widget:

void Image::Draw( PtWidget_t *widget, PhTile_t *damage ) {
   Image *image = NULL;

	// Find the Image object from its widget member.
   for( uint32_t x = 0; x < m_image_list.size(); x++ )
   {
      if( m_image_list[x]->Widget_get() == widget )
      {
         image = m_image_list[x];
         break;
      }
   }

	// Did we find the Image object?
   if( image == NULL )
   {
      //TODO raise error
      return;
   }

   if( image->m_image != IMG_NULL )
   {
		// Does this Image object have an offscreen context that we pre-rendered the bitmap into?
		PdOffscreenContext_t *oscontext = IMG::GetOSContext( image->m_image );

		// This is required, otherwise the blitting does not work properly.
		PgFlush();
		
		PhRect_t src;
		src.ul.x = src.ul.y = 0;
		src.lr.x = oscontext->dim.w - 1;
		src.lr.y = oscontext->dim.h - 1;
		
		PgChromaOn();

		// Set the chroma operation to copy every pixel in the source to
		// the destination, except the color 0x0000FF00 (bright green)
		PgSetChroma( 0x0000FF00, Pg_CHROMA_SRC_MATCH | Pg_CHROMA_NODRAW );

		PgContextBlit( oscontext, &src, PhDCGetCurrent(), PtCalcCanvas(widget,NULL)...