/**
* Prepares a work group for execution and launches it.
*/
static void tta_opencl_wg_launch(kernel_exec_cmd* cmd) {
void* args[MAX_KERNEL_ARGS];
kernel_metadata *kernel = (kernel_metadata*)cmd->kernel;
int num_groups_x = cmd->num_groups[0];
int i, first_gid_x, last_gid_x;
cmd->status = POCL_KST_RUNNING;
/* single thread version: execute all work groups in
a single trampoline call as fast as possible.
Do not create any threads. */
for (int i = 0; i < kernel->num_args + kernel->num_locals; ++i) {
#ifdef DEBUG_TTA_DEVICE
lwpr_print_str("tta: processing arg ");
lwpr_print_int(i);
lwpr_print_str(" value: ");
lwpr_print_int(cmd->args[i]);
lwpr_newline();
#endif
args[i] = (void*)cmd->args[i];
}
#ifdef DEBUG_TTA_DEVICE
lwpr_print_str("tta: ------------------- starting kernel\n");
#endif
tta_opencl_wg_execute(cmd, args, 0, num_groups_x - 1);
#ifdef DEBUG_TTA_DEVICE
lwpr_print_str("\ntta: ------------------- kernel finished\n");
#endif
cmd->status = POCL_KST_FINISHED;
}
int main() {
volatile unsigned int timestamp;
/* Clear RTC and timestamp */
_TCE_RTC(0, timestamp);
timestamp = 0;
lwpr_print_str("Hello World!\n");
_TCE_RTC(1, timestamp);
lwpr_print_str("Printing Hello World took ");
lwpr_print_int(timestamp);
lwpr_print_str(" ms.\n");
return 0;
}
int main() {
void *state = &&state0;
while (1) {
goto *state;
state1:
state = &&state2;
statex = 1;
lwpr_print_str("s1 ");
continue;
state0:
state = &&state1;
statex = 0;
lwpr_print_str("s0 ");
continue;
}
state2:
lwpr_print_str("exiting");
return 0;
}
/**
* Executes the work groups of the kernel command.
*/
static void tta_opencl_wg_execute(
kernel_exec_cmd* cmd,
void** args,
int first_gidx, int last_gidx) {
kernel_metadata *kernel = (kernel_metadata*)cmd->kernel;
const int num_groups_x = cmd->num_groups[0];
const int num_groups_y = (cmd->work_dim >= 2) ? (cmd->num_groups[1]) : 1;
const int num_groups_z = (cmd->work_dim == 3) ? (cmd->num_groups[2]) : 1;
struct pocl_context context;
context.work_dim = cmd->work_dim;
context.num_groups[0] = cmd->num_groups[0];
context.num_groups[1] = cmd->num_groups[1];
context.num_groups[2] = cmd->num_groups[2];
context.global_offset[0] = cmd->global_offset[0];
context.global_offset[1] = cmd->global_offset[1];
context.global_offset[2] = cmd->global_offset[2];
for (unsigned gid_x = first_gidx; gid_x <= last_gidx; gid_x++) {
for (unsigned gid_y = 0; gid_y < num_groups_y; gid_y++) {
for (unsigned gid_z = 0; gid_z < num_groups_z; gid_z++) {
context.group_id[0] = gid_x;
context.group_id[1] = gid_y;
context.group_id[2] = gid_z;
#ifdef DEBUG_TTA_DEVICE
lwpr_print_str("tta: ------------------- launching WG ");
lwpr_print_int(gid_x); lwpr_print_str("-");
lwpr_print_int(gid_y); lwpr_print_str("-");
lwpr_print_int(gid_z); lwpr_print_str(" @ ");
lwpr_print_int((unsigned)kernel->work_group_func);
lwpr_newline();
#endif
kernel->work_group_func (args, &context);
}
}
}
}
int main() {
kernel_metadata *next_kernel;
int work_dim = 1;
size_t local_work_sizes[3] = {1, 0, 0};
size_t global_work_sizes[3] = {2, 0, 0};
#ifdef DEBUG_TTA_DEVICE
lwpr_print_str("tta: Hello from a TTA device\n");
lwpr_print_str("tta: initializing the command objects\n");
#endif
#if _STANDALONE_MODE == 1
initialize_kernel_launch();
kernel_exec_cmd *next_command = &kernel_command;
#else
kernel_exec_cmd *next_command = kernel_command_ptr;
#endif
do {
#ifdef DEBUG_TTA_DEVICE
lwpr_print_str("tta: waiting for commands\n");
#endif
while (next_command->status != POCL_KST_READY)
;
next_kernel = (kernel_metadata*)(next_command->kernel);
#ifdef DEBUG_TTA_DEVICE
lwpr_print_str("tta: got a command to execute: ");
lwpr_print_str(" with ");
lwpr_print_int(next_command->work_dim);
lwpr_print_str(" dimensions. num_groups ");
lwpr_print_int(next_command->num_groups[0]);
lwpr_print_str("-"),
lwpr_print_int(next_command->num_groups[1]);
lwpr_print_str("-"),
lwpr_print_int(next_command->num_groups[2]);
lwpr_print_str(" dimensions. global offset ");
lwpr_print_int(next_command->global_offset[0]);
lwpr_print_str("-"),
lwpr_print_int(next_command->global_offset[1]);
lwpr_print_str("-"),
lwpr_print_int(next_command->global_offset[2]);
lwpr_newline();
#endif
tta_opencl_wg_launch(next_command);
/* In case this is the host-device setup (not the standalone mode),
wait forever for commands from the host. Otherwise, execute the
only command from the standalone binary and quit. */
} while (1 && !_STANDALONE_MODE);
return 0;
}
