test_conformance/events/test_callbacks.cpp - platform/external/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 event_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->event_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];
     for (int i = 0; i < EVENT_CALLBACK_TYPE_TOTAL; i++)
     {
         user_data[i].event_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 event_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->event_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];
	for (int i = 0; i < EVENT_CALLBACK_TYPE_TOTAL; i++)
	{
	user_data[i].event_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;
	}