consider the time to transfer data from the gpus to the RAM too when resizing

include/starpu_perfmodel.h

@@ -171,6 +171,9 @@ void starpu_bus_print_affinity(FILE *f);
 
 double starpu_get_bandwidth_RAM_CUDA(unsigned cudadev);
 double starpu_get_latency_RAM_CUDA(unsigned cudadev);
+double starpu_get_bandwidth_CUDA_RAM(unsigned cudadev);
+double starpu_get_latency_CUDA_RAM(unsigned cudadev);
+
 
 #ifdef __cplusplus
 }

include/starpu_sched_ctx.h

@@ -82,6 +82,8 @@ unsigned starpu_sched_ctx_get_nshared_workers(unsigned sched_ctx_id, unsigned sc
 
 unsigned starpu_sched_ctx_contains_worker(int workerid, unsigned sched_ctx_id);
 
+unsigned starpu_sched_ctx_contains_type_of_worker(enum starpu_worker_archtype arch, unsigned sched_ctx_id);
+
 unsigned starpu_sched_ctx_overlapping_ctxs_on_worker(int workerid);
 
 unsigned starpu_sched_ctx_is_ctxs_turn(int workerid, unsigned sched_ctx_id);

sc_hypervisor/src/policies_utils/policy_tools.c

@@ -440,19 +440,31 @@ void sc_hypervisor_get_tasks_times(int nw, int nt, double times[nw][nt], int *wo
                                 times[w][t] = (length / 1000.);
 
 				double transfer_time = 0.0;
+				unsigned worker_in_ctx = starpu_sched_ctx_contains_worker(worker, tp->sched_ctx_id);
 				enum starpu_worker_archtype arch = starpu_worker_get_type(worker);
-				if(arch == STARPU_CUDA_WORKER)
+				if(!worker_in_ctx && !size_ctxs)
 				{
-					unsigned worker_in_ctx = starpu_sched_ctx_contains_worker(worker, tp->sched_ctx_id);
-					if(!worker_in_ctx && !size_ctxs)
+					if(arch == STARPU_CUDA_WORKER)
 					{
 						double transfer_velocity = starpu_get_bandwidth_RAM_CUDA(worker);
 						transfer_time +=  (tp->data_size / transfer_velocity) / 1000. ;
+						double latency = starpu_get_latency_RAM_CUDA(worker);
+						transfer_time += latency/1000.;
+						
+						
+					}
+					else if(arch == STARPU_CPU_WORKER)
+					{
+						if(!starpu_sched_ctx_contains_type_of_worker(arch, tp->sched_ctx_id))
+						{
+							double transfer_velocity = starpu_get_bandwidth_CUDA_RAM(worker);
+							transfer_time += (tp->data_size / transfer_velocity) / 1000. ;
+							double latency = starpu_get_latency_CUDA_RAM(worker);
+							transfer_time += latency / 1000.;
+						}
 					}
-					double latency = starpu_get_latency_RAM_CUDA(worker);
-					transfer_time += latency/1000.;
-
 				}
+
 //				printf("%d/%d %s x %d time = %lf transfer_time = %lf\n", w, tp->sched_ctx_id, tp->cl->model->symbol, tp->n, times[w][t], transfer_time);
 				times[w][t] += transfer_time;
 			}

src/core/perfmodel/perfmodel_bus.c

@@ -1381,12 +1381,22 @@ static void write_bus_bandwidth_file_content(void)
 
 double starpu_get_bandwidth_RAM_CUDA(unsigned cudadev)
 {
-	return bandwidth_matrix[0][cudadev+1];
+	return bandwidth_matrix[STARPU_MAIN_RAM][cudadev+1];
 }
 
 double starpu_get_latency_RAM_CUDA(unsigned cudadev)
 {
-	return latency_matrix[0][cudadev+1];
+	return latency_matrix[STARPU_MAIN_RAM][cudadev+1];
+}
+
+double starpu_get_bandwidth_CUDA_RAM(unsigned cudadev)
+{
+	return bandwidth_matrix[1][STARPU_MAIN_RAM];
+}
+
+double starpu_get_latency_CUDA_RAM(unsigned cudadev)
+{
+	return latency_matrix[1][STARPU_MAIN_RAM];
 }
 
 void starpu_bus_print_bandwidth(FILE *f)

src/core/sched_ctx.c

@@ -995,6 +995,26 @@ unsigned starpu_sched_ctx_contains_worker(int workerid, unsigned sched_ctx_id)
 	return 0;
 }
 
+unsigned starpu_sched_ctx_contains_type_of_worker(enum starpu_worker_archtype arch, unsigned sched_ctx_id)
+{
+	struct starpu_worker_collection *workers = starpu_sched_ctx_get_worker_collection(sched_ctx_id);
+	int worker;
+
+	struct starpu_sched_ctx_iterator it;
+	if(workers->init_iterator)
+		workers->init_iterator(workers, &it);
+
+	while(workers->has_next(workers, &it))
+	{
+		worker = workers->get_next(workers, &it);
+		enum starpu_worker_archtype curr_arch = starpu_worker_get_type(worker);
+		if(curr_arch == arch)
+			return 1;
+	}
+	return 0;
+
+}
+
 unsigned _starpu_worker_belongs_to_a_sched_ctx(int workerid, unsigned sched_ctx_id)
 {
 	struct _starpu_machine_config *config = (struct _starpu_machine_config *)_starpu_get_machine_config();