Function build_archive

compute/universal_binary.cpp:658–911

	}
	
	static bool build_archive(const string& src_input,
							  const bool is_file_input,
							  const string& dst_archive_file_name,
							  const llvm_toolchain::compile_options& options,
							  const vector<target>& targets_in,
							  const bool use_precompiled_header) {
		// make sure we can open the output file before we start doing anything else
		file_io archive(dst_archive_file_name, file_io::OPEN_TYPE::WRITE_BINARY);
		if (!archive.is_open()) {
			log_error("can't write archive to $", dst_archive_file_name);
			return false;
		}
		
		// ensure targets are unique
		unordered_set<target> unique_targets_in;
		unique_targets_in.reserve(targets_in.size());
		for (const auto& target : targets_in) {
			unique_targets_in.emplace(target);
		}
		
		// create a thread pool of #logical-cpus threads that build all targets
		const auto target_count = unique_targets_in.size();
		const auto compile_job_count = uint32_t(min(size_t(core::get_hw_thread_count()), target_count));
		
		// enqueue + sanitize targets
		safe_mutex targets_lock;
		vector<target_v2> targets;
		deque<pair<size_t, target>> remaining_targets;
		auto unique_target_iter = unique_targets_in.begin();
		for (size_t i = 0; i < target_count; ++i, ++unique_target_iter) {
			auto target = *unique_target_iter;
			switch (target.common.type) {
				case COMPUTE_TYPE::NONE:
					log_error("invalid target type");
					return false;
				case COMPUTE_TYPE::OPENCL:
					target.opencl._unused = 0;
					break;
				case COMPUTE_TYPE::CUDA:
					target.cuda._unused = 0;
					break;
				case COMPUTE_TYPE::METAL:
					target.metal._unused = 0;
					break;
				case COMPUTE_TYPE::HOST:
					target.host._unused = 0;
					break;
				case COMPUTE_TYPE::VULKAN:
					target.vulkan._unused = 0;
					break;
			}
			
			targets.emplace_back(target);
			remaining_targets.emplace_back(i, target);
		}
		
		safe_mutex prog_data_lock;
		vector<unique_ptr<llvm_toolchain::program_data>> targets_prog_data(target_count);