test_conformance/events/test_callbacks.cpp - external/github.com/KhronosGroup/OpenCL-CTS - Git at Google

 //
 // Copyright (c) 2017 The Khronos Group Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
 #include "testBase.h"
 #include "action_classes.h"
 #include "harness/conversions.h"
 #include "harness/ThreadPool.h"

 #if !defined (_MSC_VER)
 #include <unistd.h>
 #endif // !_MSC_VER

 extern const char *IGetStatusString( cl_int status );

 #define PRINT_OPS 0

 // Yes, this is somewhat nasty, in that we're relying on the CPU (the real CPU, not the OpenCL device)
 // to be atomic w.r.t. boolean values. Although if it isn't, we'll just miss the check on this bool
 // until the next time around, so it's not that big of a deal. Ideally, we'd be using a semaphore with
 // a trywait on it, but then that introduces the fun issue of what to do on Win32, etc. This way is
 // far more portable, and worst case of failure is a slightly longer test run.
 static bool sCallbackTriggered = false;


 #define EVENT_CALLBACK_TYPE_TOTAL 3
 static bool sCallbackTriggered_flag[ EVENT_CALLBACK_TYPE_TOTAL ] ={ false,false, false };
 cl_int event_callback_types[EVENT_CALLBACK_TYPE_TOTAL] ={ CL_SUBMITTED, CL_RUNNING, CL_COMPLETE};

 // Our callback function
 /*void CL_CALLBACK single_event_callback_function( cl_event event, cl_int commandStatus, void * userData )
 {
      int i=*static_cast<int *>(userData);
     log_info( "\tEvent callback  %d   triggered\n",  i);
     sCallbackTriggered_flag [ i ] = true;
 }*/

 /*   use struct as call back para */
 typedef struct { cl_int enevt_type; int index; } CALL_BACK_USER_DATA;

 void CL_CALLBACK single_event_callback_function_flags( cl_event event, cl_int commandStatus, void * userData )
 {
    // int i=*static_cast<int *>(userData);
     CALL_BACK_USER_DATA *pdata= static_cast<CALL_BACK_USER_DATA *>(userData);

     log_info( "\tEvent callback  %d  of type %d triggered\n",  pdata->index, pdata->enevt_type);
     sCallbackTriggered_flag [pdata->index ] = true;
 }

 int test_callback_event_single( cl_device_id device, cl_context context, cl_command_queue queue, Action *actionToTest )
 {
     // Note: we don't use the waiting feature here. We just want to verify that we get a callback called
     // when the given event finishes

     cl_int error = actionToTest->Setup( device, context, queue );
     test_error( error, "Unable to set up test action" );

     // Set up a user event, which we use as a gate for the second event
     clEventWrapper gateEvent = clCreateUserEvent( context, &error );
     test_error( error, "Unable to set up user gate event" );

     // Set up the execution of the action with its actual event
     clEventWrapper actualEvent;
     error = actionToTest->Execute( queue, 1, &gateEvent, &actualEvent );
     test_error( error, "Unable to set up action execution" );

     // Set up the callback on the actual event

   /*  use struct as call back para */
   CALL_BACK_USER_DATA user_data[EVENT_CALLBACK_TYPE_TOTAL];
   int index [EVENT_CALLBACK_TYPE_TOTAL]={ 0,1,2};
   for( int i=0;i< EVENT_CALLBACK_TYPE_TOTAL; i++)
   {
        user_data[i].enevt_type=event_callback_types[i];
        user_data[i].index =i;
        error = clSetEventCallback( actualEvent, event_callback_types[i], single_event_callback_function_flags, user_data+i );

   }

     // Now release the user event, which will allow our actual action to run
     error = clSetUserEventStatus( gateEvent, CL_COMPLETE );
     test_error( error, "Unable to trigger gate event" );

     // Now we wait for completion. Note that we can actually wait on the event itself, at least at first
     error = clWaitForEvents( 1, &actualEvent );
     test_error( error, "Unable to wait for actual test event" );

     // Note: we can check our callback now, and it MIGHT have been triggered, but that's not guaranteed
     if( sCallbackTriggered )
     {
         // We're all good, so return success
         return 0;
     }

     // The callback has not yet been called, but that doesn't mean it won't be. So wait for it
     log_info( "\tWaiting for callback..." );
     fflush( stdout );
     for( int i = 0; i < 10 * 10; i++ )
     {
         usleep( 100000 );    // 1/10th second

     int cc=0;
     for( int k=0;k< EVENT_CALLBACK_TYPE_TOTAL;k++)
         if (sCallbackTriggered_flag[k]) {
             cc++;
         }

         if  (cc== EVENT_CALLBACK_TYPE_TOTAL  )
         {
             log_info( "\n" );
             return 0;
         }
         log_info( "." );
         fflush( stdout );
     }

     // If we got here, we never got the callback
     log_error( "\nCallback not called within 10 seconds! (assuming failure)\n" );
     return -1;
 }

 #define TEST_ACTION( name ) \
 {    \
     name##Action action;    \
     log_info( "-- Testing " #name "...\n" );    \
     if( ( error = test_callback_event_single( deviceID, context, queue, &action ) ) != CL_SUCCESS )    \
         retVal++;            \
     clFinish( queue ); \
 }

 int test_callbacks( cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements )
 {
     cl_int error;
     int retVal = 0;

     log_info( "\n" );

     TEST_ACTION( NDRangeKernel )

     TEST_ACTION( ReadBuffer )
     TEST_ACTION( WriteBuffer )
     TEST_ACTION( MapBuffer )
     TEST_ACTION( UnmapBuffer )

     if( checkForImageSupport( deviceID ) == CL_IMAGE_FORMAT_NOT_SUPPORTED )
     {
         log_info( "\nNote: device does not support images. Skipping remainder of callback tests...\n" );
     }
     else
     {
         TEST_ACTION( ReadImage2D )
         TEST_ACTION( WriteImage2D )
         TEST_ACTION( CopyImage2Dto2D )
         TEST_ACTION( Copy2DImageToBuffer )
         TEST_ACTION( CopyBufferTo2DImage )
         TEST_ACTION( MapImage )

         if( checkFor3DImageSupport( deviceID ) == CL_IMAGE_FORMAT_NOT_SUPPORTED )
             log_info( "\nNote: device does not support 3D images. Skipping remainder of waitlist tests...\n" );
         else
         {
             TEST_ACTION( ReadImage3D )
             TEST_ACTION( WriteImage3D )
             TEST_ACTION( CopyImage2Dto3D )
             TEST_ACTION( CopyImage3Dto2D )
             TEST_ACTION( CopyImage3Dto3D )
             TEST_ACTION( Copy3DImageToBuffer )
             TEST_ACTION( CopyBufferTo3DImage )
         }
     }

     return retVal;
 }

 #define  SIMUTANEOUS_ACTION_TOTAL  18
 static bool sSimultaneousFlags[ 54 ];// for 18 actions with 3 callback status
 static volatile int sSimultaneousCount;

 Action * actions[ 19 ] = { 0 };

 // Callback for the simultaneous tests
 void CL_CALLBACK simultaneous_event_callback_function( cl_event event, cl_int commandStatus, void * userData )
 {
     int eventIndex = (int)(size_t)userData;
   int actionIndex = eventIndex/EVENT_CALLBACK_TYPE_TOTAL;
   int statusIndex = eventIndex%EVENT_CALLBACK_TYPE_TOTAL;
     log_info( "\tEvent callback triggered for action %s callback type %s \n", actions[actionIndex]->GetName(), IGetStatusString(statusIndex) );
     sSimultaneousFlags[ actionIndex ] = true;
     ThreadPool_AtomicAdd(&sSimultaneousCount,1);
 }

 int test_callbacks_simultaneous( cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements )
 {
     cl_int error;

     // Unlike the singles test, in this one, we run a bunch of events all at once, to verify that
     // the callbacks do get called once-and-only-once for each event, even if the run out of order or
     // are dependent on each other

     // First, the list of actions to run
     int actionCount = 0, index = 0;

     actions[ index++ ] = new NDRangeKernelAction();
     actions[ index++ ] = new ReadBufferAction();
     actions[ index++ ] = new WriteBufferAction();
     actions[ index++ ] = new MapBufferAction();
     actions[ index++ ] = new UnmapBufferAction();

     if( checkForImageSupport( deviceID ) != CL_IMAGE_FORMAT_NOT_SUPPORTED )
     {
         actions[ index++ ] = new ReadImage2DAction();
         actions[ index++ ] = new WriteImage2DAction();
         actions[ index++ ] = new CopyImage2Dto2DAction();
         actions[ index++ ] = new Copy2DImageToBufferAction();
         actions[ index++ ] = new CopyBufferTo2DImageAction();
         actions[ index++ ] = new MapImageAction();

         if( checkFor3DImageSupport( deviceID ) != CL_IMAGE_FORMAT_NOT_SUPPORTED )
         {
             actions[ index++ ] = new ReadImage3DAction();
             actions[ index++ ] = new WriteImage3DAction();
             actions[ index++ ] = new CopyImage2Dto3DAction();
             actions[ index++ ] = new CopyImage3Dto2DAction();
             actions[ index++ ] = new CopyImage3Dto3DAction();
             actions[ index++ ] = new Copy3DImageToBufferAction();
             actions[ index++ ] = new CopyBufferTo3DImageAction();
         }
     }
     actionCount = index;
     actions[ index++ ] = NULL;

     // Now set them all up
     log_info( "\tSetting up test events...\n" );
     for( index = 0; actions[ index ] != NULL; index++ )
     {
         error = actions[ index ]->Setup( deviceID, context, queue );
         test_error( error, "Unable to set up test action" );
         sSimultaneousFlags[ index ] = false;
     }
     sSimultaneousCount = 0;

     // Set up the user event to start them all
     clEventWrapper gateEvent = clCreateUserEvent( context, &error );
     test_error( error, "Unable to set up user gate event" );

     // Start executing, all tied to the gate event
     //clEventWrapper actionEvents[ 18 ];// current actionCount is 18
     clEventWrapper *actionEvents= new clEventWrapper[actionCount];
     if (actionEvents == NULL)
     {
         log_error(" memory error in test_callbacks_simultaneous  \n");
       for (size_t i=0;i<(sizeof(actions)/sizeof(actions[0]));++i)
         if (actions[i]) delete actions[i];
         return  -1;
     }

     RandomSeed seed( gRandomSeed );
     for( index = 0; actions[ index ] != NULL; index++ )
     {
         // Randomly choose to wait on the gate, or wait on the previous event
         cl_event * eventPtr = &gateEvent;
         if( ( index > 0 ) && ( random_in_range( 0, 255, seed ) & 1 ) )
             eventPtr = &actionEvents[ index - 1 ];

         error = actions[ index ]->Execute( queue, 1, eventPtr, &actionEvents[ index ] );
         test_error( error, "Unable to execute test action" );


     for( int k=0; k< EVENT_CALLBACK_TYPE_TOTAL; k++)
     {
        error = clSetEventCallback( actionEvents[index], event_callback_types[k], simultaneous_event_callback_function, (void *)(size_t)(index*EVENT_CALLBACK_TYPE_TOTAL+k ) );
        test_error( error, "Unable to set event callback function" );

     }
     }

   int total_callbacks= actionCount * EVENT_CALLBACK_TYPE_TOTAL;

     // Now release the user event, which will allow our actual action to run
     error = clSetUserEventStatus( gateEvent, CL_COMPLETE );
     test_error( error, "Unable to trigger gate event" );

     // Wait on the actual action events now
     log_info( "\tWaiting for test completions...\n" );
     error = clWaitForEvents( actionCount, &actionEvents[ 0 ] );
     test_error( error, "Unable to wait for actual test events" );

     // Note: we can check our callback now, and it MIGHT have been triggered, but that's not guaranteed
   int last_count = 0;
     if( ((last_count = sSimultaneousCount)) == total_callbacks)
     {
         // We're all good, so return success
         log_info( "\t%d of %d callbacks received\n", sSimultaneousCount, total_callbacks );

         if (actionEvents) delete [] actionEvents;
     for (size_t i=0;i<(sizeof(actions)/sizeof(actions[0]));++i)
       if (actions[i]) delete actions[i];
         return 0;
     }

     // We haven't gotten (all) of the callbacks, so wait for them
     log_info( "\tWe've only received %d of the %d callbacks we expected; waiting for more...\n", last_count, total_callbacks );

     for( int i = 0; i < 10 * 10; i++ )
     {
         usleep( 100000 );    // 1/10th second
         if( ((last_count = sSimultaneousCount)) == total_callbacks )
         {
       // All of the callbacks were executed
       if (actionEvents) delete [] actionEvents;
       for (size_t i=0;i<(sizeof(actions)/sizeof(actions[0]));++i)
         if (actions[i]) delete actions[i];
         return 0;
         }
     }

     // If we got here, some of the callbacks did not occur in time
     log_error( "\nError: We only ever received %d of our %d callbacks!\n", last_count, total_callbacks );
     log_error( "Events that did not receive callbacks:\n" );
     for( index = 0; actions[ index ] != NULL; index++ )
     {
         if( !sSimultaneousFlags[ index ] )
             log_error( "\t%s\n", actions[ index ]->GetName() );
     }

   if (actionEvents) delete [] actionEvents;
     return -1;

 }
	//
	// Copyright (c) 2017 The Khronos Group Inc.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	//
	#include "testBase.h"
	#include "action_classes.h"
	#include "harness/conversions.h"
	#include "harness/ThreadPool.h"

	#if !defined (_MSC_VER)
	#include <unistd.h>
	#endif // !_MSC_VER

	extern const char *IGetStatusString( cl_int status );

	#define PRINT_OPS 0

	// Yes, this is somewhat nasty, in that we're relying on the CPU (the real CPU, not the OpenCL device)
	// to be atomic w.r.t. boolean values. Although if it isn't, we'll just miss the check on this bool
	// until the next time around, so it's not that big of a deal. Ideally, we'd be using a semaphore with
	// a trywait on it, but then that introduces the fun issue of what to do on Win32, etc. This way is
	// far more portable, and worst case of failure is a slightly longer test run.
	static bool sCallbackTriggered = false;


	#define EVENT_CALLBACK_TYPE_TOTAL 3
	static bool sCallbackTriggered_flag[ EVENT_CALLBACK_TYPE_TOTAL ] ={ false,false, false };
	cl_int event_callback_types[EVENT_CALLBACK_TYPE_TOTAL] ={ CL_SUBMITTED, CL_RUNNING, CL_COMPLETE};

	// Our callback function
	/void CL_CALLBACK single_event_callback_function( cl_event event, cl_int commandStatus, void userData )
	{
	int i=static_cast<int >(userData);
	log_info( "\tEvent callback %d triggered\n", i);
	sCallbackTriggered_flag [ i ] = true;
	}*/

	/* use struct as call back para */
	typedef struct { cl_int enevt_type; int index; } CALL_BACK_USER_DATA;

	void CL_CALLBACK single_event_callback_function_flags( cl_event event, cl_int commandStatus, void * userData )
	{
	// int i=static_cast<int >(userData);
	CALL_BACK_USER_DATA pdata= static_cast<CALL_BACK_USER_DATA >(userData);

	log_info( "\tEvent callback %d of type %d triggered\n", pdata->index, pdata->enevt_type);
	sCallbackTriggered_flag [pdata->index ] = true;
	}

	int test_callback_event_single( cl_device_id device, cl_context context, cl_command_queue queue, Action *actionToTest )
	{
	// Note: we don't use the waiting feature here. We just want to verify that we get a callback called
	// when the given event finishes

	cl_int error = actionToTest->Setup( device, context, queue );
	test_error( error, "Unable to set up test action" );

	// Set up a user event, which we use as a gate for the second event
	clEventWrapper gateEvent = clCreateUserEvent( context, &error );
	test_error( error, "Unable to set up user gate event" );

	// Set up the execution of the action with its actual event
	clEventWrapper actualEvent;
	error = actionToTest->Execute( queue, 1, &gateEvent, &actualEvent );
	test_error( error, "Unable to set up action execution" );

	// Set up the callback on the actual event

	/* use struct as call back para */
	CALL_BACK_USER_DATA user_data[EVENT_CALLBACK_TYPE_TOTAL];
	int index [EVENT_CALLBACK_TYPE_TOTAL]={ 0,1,2};
	for( int i=0;i< EVENT_CALLBACK_TYPE_TOTAL; i++)
	{
	user_data[i].enevt_type=event_callback_types[i];
	user_data[i].index =i;
	error = clSetEventCallback( actualEvent, event_callback_types[i], single_event_callback_function_flags, user_data+i );

	}

	// Now release the user event, which will allow our actual action to run
	error = clSetUserEventStatus( gateEvent, CL_COMPLETE );
	test_error( error, "Unable to trigger gate event" );

	// Now we wait for completion. Note that we can actually wait on the event itself, at least at first
	error = clWaitForEvents( 1, &actualEvent );
	test_error( error, "Unable to wait for actual test event" );

	// Note: we can check our callback now, and it MIGHT have been triggered, but that's not guaranteed
	if( sCallbackTriggered )
	{
	// We're all good, so return success
	return 0;
	}

	// The callback has not yet been called, but that doesn't mean it won't be. So wait for it
	log_info( "\tWaiting for callback..." );
	fflush( stdout );
	for( int i = 0; i < 10 * 10; i++ )
	{
	usleep( 100000 ); // 1/10th second

	int cc=0;
	for( int k=0;k< EVENT_CALLBACK_TYPE_TOTAL;k++)
	if (sCallbackTriggered_flag[k]) {
	cc++;
	}

	if (cc== EVENT_CALLBACK_TYPE_TOTAL )
	{
	log_info( "\n" );
	return 0;
	}
	log_info( "." );
	fflush( stdout );
	}

	// If we got here, we never got the callback
	log_error( "\nCallback not called within 10 seconds! (assuming failure)\n" );
	return -1;
	}

	#define TEST_ACTION( name ) \
	{ \
	name##Action action; \
	log_info( "-- Testing " #name "...\n" ); \
	if( ( error = test_callback_event_single( deviceID, context, queue, &action ) ) != CL_SUCCESS ) \
	retVal++; \
	clFinish( queue ); \
	}

	int test_callbacks( cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements )
	{
	cl_int error;
	int retVal = 0;

	log_info( "\n" );

	TEST_ACTION( NDRangeKernel )

	TEST_ACTION( ReadBuffer )
	TEST_ACTION( WriteBuffer )
	TEST_ACTION( MapBuffer )
	TEST_ACTION( UnmapBuffer )

	if( checkForImageSupport( deviceID ) == CL_IMAGE_FORMAT_NOT_SUPPORTED )
	{
	log_info( "\nNote: device does not support images. Skipping remainder of callback tests...\n" );
	}
	else
	{
	TEST_ACTION( ReadImage2D )
	TEST_ACTION( WriteImage2D )
	TEST_ACTION( CopyImage2Dto2D )
	TEST_ACTION( Copy2DImageToBuffer )
	TEST_ACTION( CopyBufferTo2DImage )
	TEST_ACTION( MapImage )

	if( checkFor3DImageSupport( deviceID ) == CL_IMAGE_FORMAT_NOT_SUPPORTED )
	log_info( "\nNote: device does not support 3D images. Skipping remainder of waitlist tests...\n" );
	else
	{
	TEST_ACTION( ReadImage3D )
	TEST_ACTION( WriteImage3D )
	TEST_ACTION( CopyImage2Dto3D )
	TEST_ACTION( CopyImage3Dto2D )
	TEST_ACTION( CopyImage3Dto3D )
	TEST_ACTION( Copy3DImageToBuffer )
	TEST_ACTION( CopyBufferTo3DImage )
	}
	}

	return retVal;
	}

	#define SIMUTANEOUS_ACTION_TOTAL 18
	static bool sSimultaneousFlags[ 54 ];// for 18 actions with 3 callback status
	static volatile int sSimultaneousCount;

	Action * actions[ 19 ] = { 0 };

	// Callback for the simultaneous tests
	void CL_CALLBACK simultaneous_event_callback_function( cl_event event, cl_int commandStatus, void * userData )
	{
	int eventIndex = (int)(size_t)userData;
	int actionIndex = eventIndex/EVENT_CALLBACK_TYPE_TOTAL;
	int statusIndex = eventIndex%EVENT_CALLBACK_TYPE_TOTAL;
	log_info( "\tEvent callback triggered for action %s callback type %s \n", actions[actionIndex]->GetName(), IGetStatusString(statusIndex) );
	sSimultaneousFlags[ actionIndex ] = true;
	ThreadPool_AtomicAdd(&sSimultaneousCount,1);
	}

	int test_callbacks_simultaneous( cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements )
	{
	cl_int error;

	// Unlike the singles test, in this one, we run a bunch of events all at once, to verify that
	// the callbacks do get called once-and-only-once for each event, even if the run out of order or
	// are dependent on each other

	// First, the list of actions to run
	int actionCount = 0, index = 0;

	actions[ index++ ] = new NDRangeKernelAction();
	actions[ index++ ] = new ReadBufferAction();
	actions[ index++ ] = new WriteBufferAction();
	actions[ index++ ] = new MapBufferAction();
	actions[ index++ ] = new UnmapBufferAction();

	if( checkForImageSupport( deviceID ) != CL_IMAGE_FORMAT_NOT_SUPPORTED )
	{
	actions[ index++ ] = new ReadImage2DAction();
	actions[ index++ ] = new WriteImage2DAction();
	actions[ index++ ] = new CopyImage2Dto2DAction();
	actions[ index++ ] = new Copy2DImageToBufferAction();
	actions[ index++ ] = new CopyBufferTo2DImageAction();
	actions[ index++ ] = new MapImageAction();

	if( checkFor3DImageSupport( deviceID ) != CL_IMAGE_FORMAT_NOT_SUPPORTED )
	{
	actions[ index++ ] = new ReadImage3DAction();
	actions[ index++ ] = new WriteImage3DAction();
	actions[ index++ ] = new CopyImage2Dto3DAction();
	actions[ index++ ] = new CopyImage3Dto2DAction();
	actions[ index++ ] = new CopyImage3Dto3DAction();
	actions[ index++ ] = new Copy3DImageToBufferAction();
	actions[ index++ ] = new CopyBufferTo3DImageAction();
	}
	}
	actionCount = index;
	actions[ index++ ] = NULL;

	// Now set them all up
	log_info( "\tSetting up test events...\n" );
	for( index = 0; actions[ index ] != NULL; index++ )
	{
	error = actions[ index ]->Setup( deviceID, context, queue );
	test_error( error, "Unable to set up test action" );
	sSimultaneousFlags[ index ] = false;
	}
	sSimultaneousCount = 0;

	// Set up the user event to start them all
	clEventWrapper gateEvent = clCreateUserEvent( context, &error );
	test_error( error, "Unable to set up user gate event" );

	// Start executing, all tied to the gate event
	//clEventWrapper actionEvents[ 18 ];// current actionCount is 18
	clEventWrapper *actionEvents= new clEventWrapper[actionCount];
	if (actionEvents == NULL)
	{
	log_error(" memory error in test_callbacks_simultaneous \n");
	for (size_t i=0;i<(sizeof(actions)/sizeof(actions[0]));++i)
	if (actions[i]) delete actions[i];
	return -1;
	}

	RandomSeed seed( gRandomSeed );
	for( index = 0; actions[ index ] != NULL; index++ )
	{
	// Randomly choose to wait on the gate, or wait on the previous event
	cl_event * eventPtr = &gateEvent;
	if( ( index > 0 ) && ( random_in_range( 0, 255, seed ) & 1 ) )
	eventPtr = &actionEvents[ index - 1 ];

	error = actions[ index ]->Execute( queue, 1, eventPtr, &actionEvents[ index ] );
	test_error( error, "Unable to execute test action" );


	for( int k=0; k< EVENT_CALLBACK_TYPE_TOTAL; k++)
	{
	error = clSetEventCallback( actionEvents[index], event_callback_types[k], simultaneous_event_callback_function, (void )(size_t)(indexEVENT_CALLBACK_TYPE_TOTAL+k ) );
	test_error( error, "Unable to set event callback function" );

	}
	}

	int total_callbacks= actionCount * EVENT_CALLBACK_TYPE_TOTAL;

	// Now release the user event, which will allow our actual action to run
	error = clSetUserEventStatus( gateEvent, CL_COMPLETE );
	test_error( error, "Unable to trigger gate event" );

	// Wait on the actual action events now
	log_info( "\tWaiting for test completions...\n" );
	error = clWaitForEvents( actionCount, &actionEvents[ 0 ] );
	test_error( error, "Unable to wait for actual test events" );

	// Note: we can check our callback now, and it MIGHT have been triggered, but that's not guaranteed
	int last_count = 0;
	if( ((last_count = sSimultaneousCount)) == total_callbacks)
	{
	// We're all good, so return success
	log_info( "\t%d of %d callbacks received\n", sSimultaneousCount, total_callbacks );

	if (actionEvents) delete [] actionEvents;
	for (size_t i=0;i<(sizeof(actions)/sizeof(actions[0]));++i)
	if (actions[i]) delete actions[i];
	return 0;
	}

	// We haven't gotten (all) of the callbacks, so wait for them
	log_info( "\tWe've only received %d of the %d callbacks we expected; waiting for more...\n", last_count, total_callbacks );

	for( int i = 0; i < 10 * 10; i++ )
	{
	usleep( 100000 ); // 1/10th second
	if( ((last_count = sSimultaneousCount)) == total_callbacks )
	{
	// All of the callbacks were executed
	if (actionEvents) delete [] actionEvents;
	for (size_t i=0;i<(sizeof(actions)/sizeof(actions[0]));++i)
	if (actions[i]) delete actions[i];
	return 0;
	}
	}

	// If we got here, some of the callbacks did not occur in time
	log_error( "\nError: We only ever received %d of our %d callbacks!\n", last_count, total_callbacks );
	log_error( "Events that did not receive callbacks:\n" );
	for( index = 0; actions[ index ] != NULL; index++ )
	{
	if( !sSimultaneousFlags[ index ] )
	log_error( "\t%s\n", actions[ index ]->GetName() );
	}

	if (actionEvents) delete [] actionEvents;
	return -1;

	}