 	auto common_launch_config = make_linear_launch_config(device, num_elements);
 	auto buffer_size = num_elements * sizeof(element_t);
 
-	auto work_can_start = cuda::event::create(device);
-
-	for(size_t r = 0; r < num_repetitions; r++) {
-		std::cout
-			<< "Preparing another run of " << num_kernels << " kernels in parallel (run "
-			<< r+1 << " of " << num_repetitions << ')' << std::endl;
+	std::cout
+		<< "Running " << num_kernels << " sequences of HtoD-kernel-DtoH, in parallel" << std::endl;
 		// Unfortunately, we need to use indices here - unless we
 		// had access to a zip iterator (e.g. boost::zip_iterator)
-		for(size_t k = 0; k < num_kernels; k++) {
-			auto& stream = streams[k];
-			auto& buffer_set = buffers[k];
-			stream.enqueue.wait(work_can_start.id());
-			std::cout << "Enqueueing actual work on stream " << k+1 << " of " << num_kernels << std::endl;
-			stream.enqueue.copy(buffer_set.device_lhs.get(), buffer_set.host_lhs.get(), buffer_size);
-			stream.enqueue.copy(buffer_set.device_rhs.get(), buffer_set.host_rhs.get(), buffer_size);
-			stream.enqueue.kernel_launch(
-				add<element_t>,
-				common_launch_config,
-				buffer_set.device_lhs.get(),
-				buffer_set.device_rhs.get(),
-				buffer_set.device_result.get(),
-				num_elements);
-			stream.enqueue.copy(buffer_set.host_result.get(), buffer_set.device_result.get(), buffer_size);
-			stream.enqueue.callback(
-				[k, r](cuda::stream::id_t stream_id, cuda::status_t status) {
-					std::cout
-						<< "Stream " << k+1 << " of " << num_kernels << " has concluded all work "
-						<< "for run " << r+1 << " of " << num_repetitions << std::endl;
-				}
-			);
-		}
-		cuda::outstanding_error::ensure_none();
-		usleep(25000);
+	for(size_t k = 0; k < num_kernels; k++) {
+		auto& stream = streams[k];
+		auto& buffer_set = buffers[k];
+		stream.enqueue.copy(buffer_set.device_lhs.get(), buffer_set.host_lhs.get(), buffer_size);
+		stream.enqueue.copy(buffer_set.device_rhs.get(), buffer_set.host_rhs.get(), buffer_size);
+		stream.enqueue.kernel_launch(
+			add<element_t>,
+			common_launch_config,
+			buffer_set.device_lhs.get(),
+			buffer_set.device_rhs.get(),
+			buffer_set.device_result.get(),
+			num_elements);
+		stream.enqueue.copy(buffer_set.host_result.get(), buffer_set.device_result.get(), buffer_size);
+		stream.enqueue.callback(
+			[k](cuda::stream::id_t stream_id, cuda::status_t status) {
+				std::cout
+					<< "Stream " << k+1 << " of " << num_kernels << " has concluded all work. " << std::endl;
+			}
+		);
+	}
+	usleep(50000);
+	for(auto& stream : streams) { stream.synchronize(); }
+	cuda::outstanding_error::ensure_none();
 
-		// We expect the streams to schedule _no_work_ until we tell them to. But were
-		// they busy while we slept?
-
-		auto num_streams_with_remaining_work =
-			std::count_if(std::begin(streams), std::end(streams),
-				[](const cuda::stream_t<>& stream) { return stream.has_work_remaining(); }
-			);
-		if (num_streams_with_remaining_work != num_kernels) {
-			std::stringstream ss;
-			std::cout
-				<< "Some streams (" << num_kernels - num_streams_with_remaining_work
-				<< " of " << num_kernels << ") have concluded their work before the "
-				<< "event allowing any work to commence has fired; that should not "
-				<< "have happened." << std::endl;
-
-			std::cout << "\nFAILURE" << std::endl;
-			exit(EXIT_FAILURE);
-		}
-
-		work_can_start.fire();
-
-		std::cout << "Synchronizing all streams after having allowing them to start working." << std::endl;
-		for(auto& stream : streams) { stream.synchronize(); }
-	}
-
-
-	// TODO: Check for correctness here
+	// TODO: Consider checking for correctness here
 
 	std::cout << "\nSUCCESS" << std::endl;
 }

}

struct buffer_set_t {
	std::unique_ptr<element_t[]> host_lhs;
	std::unique_ptr<element_t[]> host_rhs;
	std::unique_ptr<element_t[]> host_result;
	cuda::memory::device::unique_ptr<element_t[]> device_lhs;
	cuda::memory::device::unique_ptr<element_t[]> device_rhs;
	cuda::memory::device::unique_ptr<element_t[]> device_result;
};

std::vector<buffer_set_t> generate_buffers(const cuda::device_t<>  device)
{
	// TODO: This should be an std::array, but generating
	// it is a bit tricky and I don't want to burden the example

		[&]() {
			return buffer_set_t {
				// Sticking to C++11 here...
				cuda::memory::host::make_unique<element_t[]>(num_elements),
				cuda::memory::host::make_unique<element_t[]>(num_elements),
				cuda::memory::host::make_unique<element_t[]>(num_elements),
				cuda::memory::device::make_unique<element_t[]>(device.id(), num_elements),
				cuda::memory::device::make_unique<element_t[]>(device.id(), num_elements),
				cuda::memory::device::make_unique<element_t[]>(device.id(), num_elements)
