text: 
  template<DeviceType TYPE>
  void run( Device* device, int minSize = 512, int maxSize = 64*1024 )//, int increment = 512 )
  {
  	ADLASSERT( TYPE == device->m_type );
  
  	Stopwatch sw( device );
  
  //	RadixSort<TYPE>::Data* data0 = RadixSort<TYPE>::allocate( device, maxSize, RadixSortBase::SORT_SIMPLE );
  	RadixSort<TYPE>::Data* data0 = RadixSort<TYPE>::allocate( device, maxSize, RadixSortBase::SORT_STANDARD );
  	RadixSort<TYPE>::Data* data1 = RadixSort<TYPE>::allocate( device, maxSize, RadixSortBase::SORT_STANDARD );
  	RadixSort<TYPE>::Data* data2 = RadixSort<TYPE>::allocate( device, maxSize, RadixSortBase::SORT_ADVANCED );
  
  	Buffer<SortData> buf0( device, maxSize );
  	Buffer<SortData> buf1( device, maxSize );
  	Buffer<SortData> buf2( device, maxSize );
  
  	SortData* input = new SortData[ maxSize ];
  
  //	for(int iter = minSize; iter<=maxSize; iter+=increment)
  	for(int iter = minSize; iter<=maxSize; iter*=2)
  	{
  		int size = NEXTMULTIPLEOF( iter, 512 );
  
  		for(int i=0; i<size; i++) input[i] = SortData( getRandom(0,0xff), i );
  
  		buf0.write( input, size );
  		buf1.write( input, size );
  		buf2.write( input, size );
  		DeviceUtils::waitForCompletion( device );
  
  
  		sw.start();
  
  		RadixSort<TYPE>::execute( data0, buf0, size );
  
  		sw.split();
  
  		RadixSort<TYPE>::execute( data1, buf1, size );
  
  		sw.split();
  
  		RadixSort<TYPE>::execute( data2, buf2, size );
  
  		sw.stop();
  
  
  		float t[3];
  		sw.getMs( t, 3 );
  //		printf("	%d	%3.2f	%3.2f	%3.2f\n", size, t[0], t[1], t[2]);
  		printf("	%d	%3.2f	%3.2f\n", size, t[1], t[2]);
  	}
  
  	RadixSort<TYPE>::deallocate( data0 );
  	RadixSort<TYPE>::deallocate( data1 );
  	RadixSort<TYPE>::deallocate( data2 );
  
  	delete [] input;
  }
  
  template<DeviceType TYPE>
  void run32( Device* device, int size )
  {
  	//Cayman: 4194.30Keys:    373.05MKeys/s
  	//Cypress: 4194.30Keys:    315.13MKeys/s
  	ADLASSERT( TYPE == device->m_type );
  
  	Stopwatch sw( device );
  
  	RadixSort32<TYPE>::Data* data = RadixSort32<TYPE>::allocate( device, size );
  	Copy<TYPE>::Data* copyData = Copy<TYPE>::allocate( device );
  
  	Buffer<u32> inputMaster( device, size );
  	Buffer<u32> input( device, size );
  	Buffer<u32> output( device, size );
  	{
  		u32* host = new u32[size];
  		for(int i=0; i<size; i++) host[i] = getRandom(0u, 0xffffffffu);
  		inputMaster.write( host, size );
  		DeviceUtils::waitForCompletion( device );
  		delete [] host;
  	}
  
  	int nIter = 100;
  	sw.start();
  	for(int iter=0; iter<nIter; iter++)
  	{
  //		Copy<TYPE>::execute( copyData, (Buffer<float>&)input, (Buffer<float>&)inputMaster, size );
  //		RadixSort32<TYPE>::execute( data, input, size );
  		RadixSort32<TYPE>::execute( data, input, output, size );
  	}
  	sw.stop();
  
  	{
  		float tInS = sw.getMs()/1000.f/(float)nIter;
  		float mKeysPerS = size/1000.f/1000.f/tInS;
  		printf("%3.2fMKeys:	%3.2fMKeys/s\n", size/1000.f, mKeysPerS);
  	}
  
  	RadixSort32<TYPE>::deallocate( data );
  	Copy<TYPE>::deallocate( copyData );
  }
  
  template<DeviceType TYPE>
  void radixSortBenchmark()
  {
  
  	Device* device;
  	{
  		DeviceUtils::Config cfg;
  		device = DeviceUtils::allocate( TYPE, cfg );
  	}
  
  	run32<TYPE>( device, 256*1024*8*2 );
  //	run32<TYPE>( device, 256*20*6 );
  
  //	run<TYPE>( device, 512, 1024*128*4 );
  
  	DeviceUtils::deallocate( device );
  
  }
  