Method execute_device

src/device/host/host_function.cpp:1052–1166

}

void host_function::execute_device(const host_function_entry& func_entry,
								 const uint32_t& cpu_count,
								 const uint3& group_dim,
								 const uint3& local_dim,
								 const uint32_t& work_dim,
								 const std::vector<const void*>& vptr_args) const {
	// #work-groups
	const auto group_count = group_dim.x * group_dim.y * group_dim.z;
	// #work-items per group
	const uint32_t local_size = local_dim.x * local_dim.y * local_dim.z;
	// group ticketing system, each worker thread will grab a new group id, once it's done with one group
	std::atomic<uint32_t> group_idx { 0 };
	
	// start worker threads
#if defined(FLOOR_HOST_FUNCTION_ENABLE_TIMING)
	const auto time_start = floor_timer::start();
#endif
	std::atomic<bool> success { true };
	std::vector<std::unique_ptr<std::thread>> worker_threads(cpu_count);
	for (uint32_t cpu_idx = 0; cpu_idx < cpu_count; ++cpu_idx) {
		worker_threads[cpu_idx] = std::make_unique<std::thread>([this, &success, cpu_idx, &func_entry, &vptr_args,
													   &group_idx, group_count, group_dim,
													   local_size, local_dim, work_dim] {
			// set CPU affinity for this thread to a particular CPU to prevent this thread from being constantly moved/scheduled
			// on different CPUs (starting at index 1, with 0 representing no affinity)
			set_thread_affinity(cpu_idx + 1);
			
			// retrieve the instance for this CPU + reset/init it
			auto instance = func_entry.program->get_instance(cpu_idx);
			if (!instance) {
				log_error("no instance for CPU #$ (for $)", cpu_idx, function_name);
				success = false;
				return;
			}
			instance->reset(local_dim * group_dim, local_dim, group_dim, work_dim);
			
			auto& exec_ctx = device_exec_context;
			exec_ctx.ids = &instance->ids;
			exec_ctx.linear_local_work_size = local_size;
			auto& ids = instance->ids;
			
			// get and set the function for this instance
			const auto& func_info = *func_entry.info;
			const auto func_iter = instance->functions.find(func_info.name);
			if (func_iter == instance->functions.end()) {
				log_error("failed to find function \"$\" for CPU #$", function_name, cpu_idx);
				success = false;
				return;
			}
			exec_ctx.func = make_callable_host_function(func_iter->second, vptr_args);
			if (!exec_ctx.func) {
				log_error("failed to create function \"$\" for CPU #$", function_name, cpu_idx);
				success = false;
				return;
			}
			
			// init contexts (aka fibers)
			floor_fiber_context main_ctx;