Re: [Starpu-devel] Dépendances dynamiques

[Adrien Roussel <adrien.roussel@itwm.fraunhofer.de>]

Bonjour,

  Désolé de déranger à nouveau, mais j'essaye de me faire la main sur 
une réduction toute simple, sauf que j'ai des problèmes de data race.
J'essaye de faire une réduction d'un vecteur m_x, de taille m_size dans 
une variable m_res.
J'ai suivi les exemples donnés dans la doc StarPU, mais pourtant j'ai 
l'impression que les dépendances ne sont pas prises en compte.
Dans un premier temps, dans le constructeur je donne dépendances en 
entrée dans un tableau de "struct starpu_data_descr" nommé "x_descr".
Que je passerais ensuite en argument lors de l'insertion de la tâche, en 
plus de la variable d'accumulation.

Est-ce que par tout hasard j'aurais négligé quelque chose lors du 
développement ?

Merci d'avance.

Voici ma classe :

    template<typename ValueType>
      class StarPU_reduction : public StarPUBlas
      {
          typedef StarPUBlas BaseType;
        public:

          StarPU_reduction (int _dom, ValueType* _x,
                  ValueType* _res, int _size)
              : m_res (_res), BaseType (_dom), m_x(_x), m_size(_size)
          {
#ifdef USE_STARPU
             // Registration of the data
             m_x_handle = (starpu_data_handle_t*) 
malloc(sizeof(starpu_data_handle_t) * m_size);
             x_descr = (starpu_data_descr*) 
malloc(sizeof(starpu_data_descr) * m_size);
             for(int i = 0; i < m_size; ++i)
             {
                starpu_variable_data_register(&m_x_handle[i], 
STARPU_MAIN_RAM, (uintptr_t)&m_x[i], sizeof(m_x[i]));
                x_descr[i] = {};
                x_descr[i].handle = m_x_handle[i];
                x_descr[i].mode = STARPU_R;
             }
             starpu_variable_data_register(&m_res_handle, 
STARPU_MAIN_RAM, (uintptr_t)m_res, sizeof(m_res[0]));

             // Configuration of the codelet
             cl = {};
             cl.cpu_funcs[0] = cpu_reduction;
             cl.nbuffers = STARPU_VARIABLE_NBUFFERS;
#endif
          }

          void
          exec ()
          {
#ifdef USE_STARPU
            int ret = starpu_task_insert(&cl, STARPU_W, m_res_handle, 
STARPU_DATA_MODE_ARRAY, x_descr, m_size, 0);
#else
            cpu_reduction( m_x, m_res, m_size);
#endif
          }

          void print()
          {
            std::cout << "PART: " << m_dom_id << "\tREDUCTION" << 
std::endl;
          }

        private:
          ValueType* m_x;
          ValueType* m_res;
          int m_size;
#ifdef USE_STARPU
          struct vec_size_t params;
          struct starpu_codelet cl;
          struct starpu_task *task;

          struct starpu_data_descr* x_descr;
          starpu_data_handle_t* m_x_handle;

          starpu_data_handle_t m_res_handle;
#endif
      };


On 06/12/2018 09:46 AM, Samuel Thibault wrote:
> Adrien Roussel, le mar. 12 juin 2018 09:38:31 +0200, a ecrit:
> > Sauf que, j'ai l'impression que StarPU libère la mémoire de ma tache après
> > son exécution.
> Oui, c'est le champ destroy, que tu peux mettre à 0 pour éviter qu'il le
> fasse.
>
> Samuel

--
|---------------------------------------------------------|
| Dr. Adrien Roussel
| Competence Center High Performance Computing
| Fraunhofer Institut ITWM
| Tel.   : +49 631 31600-4984
| E-Mail : adrien.roussel@itwm.fraunhofer.de
| Web    : https://adrien-roussel.eu
| Address: Fraunhofer-Platz 1
|          D-67663 Kaiserslautern
|---------------------------------------------------------|