Re: [Starpu-devel] Task re-execution with StarPU

[Mawussi Zounon <mawussi.zounon@manchester.ac.uk>]

Hi Samuel,
Thanks for the quick reply.
My question is not accurate but you make it to understand my problem,
with a good example. I will read more about the tags and see how
to exploit them. Once again thanks, the response is very helpful.

Best regards,
--Mawussi



________________________________________
From: Samuel Thibault [samuel.thibault@inria.fr]
Sent: Wednesday, August 02, 2017 5:59 PM
To: Mawussi Zounon
Cc: starpu-devel@lists.gforge.inria.fr; Olivier Aumage
Subject: Re: Task re-execution with StarPU

Hello,

Mawussi Zounon, on mer. 02 août 2017 13:04:31 +0000, wrote:
> During the execution, halfway in the DAG, a task may be corrupted,
> i.e., produce invalid result for some reasons.

>  1. With StarPU how can a node traverse backward a part of the DAG?

It can not, StarPU does not keep a record of completed tasks, that
wouldn't scale. It's up to the application to go back in its submission
loops.

Okay.

>  2. Is it possible for a node to insert subtasks during the computation?

A node can submit whatever tasks it wants during the execution :)
 One thing which is not simple, however, is inserting at task *within* an
already-submitted DAG. Appending tasks is not a problem, but stuffing
tasks in the middle of a string of tasks modifying a piece of data, for
instance, can not be done trivially. For this, one has to use StarPU
tags, which act as a rendez-vous points. This is also needed because
whatever tasks you submit will depend on the last submitted tasks which
have touched the data, which are probably much later in your DAG, which
is not what you want: you want to get the task to start immediately, to
replace the bogus task. So you need to use tags to detach that part of
the DAG, and be able to plug your tasks in there, independently from the
rest of the DAG.

I guess (I don't have enough details on your exact use case to be sure)
a way would be something like this:

A->Bperhapsbogus->C

where C uses a tagC which depends on a tagCorrect. If Bperhapsbogus
computed rightly, you release tagCorrect. Otherwise, you submit another
task Bperhapsbogus with sequential_consistency set to 0 (to avoid
getting appended after the DAG), and perhaps that one will release
tagCorrect, otherwise submit yet another, etc.

Concerning having to go back in the DAG, as I said you have to do it in
the application, basically up to the first read-only dependency. You may
might want to introduce a tasks whose only purpose is to make a copy of
the input to a data which will be written to by B, so you have a copy
from which to restart if B gets bogus.

>  3. How to inform the neighbouring nodes on the new subtasks?

I don't think you want to go that way.  The principle of StarPU
distributed on MPI is that there is no exchange of information on the
DAG, to make things simple and scalable.

And I don't think you actually need to inform the neighbouring nodes
about the new subtasks, you can just introduce an intermediate cl==NULL
task which thus does nothing but provide the well-known synchronization
point between the MPI nodes.

> Please fill free to send me any useful references or links.

Well, to my knowledge you are the first one trying to do things like
this :)

(about tags, there is of course the StarPU manual, and examples in the
tree).

Samuel