Passage d'une fonction aléatoire en paramétre d'une autre fonction.

Version imprimable

13/03/2014, 10h10
nifulol

Passage d'une fonction aléatoire en paramétre d'une autre fonction.

Bonjour.

Je ne sais pas si le titre est très explicite.
Je souhaite donc crée une fonction/template qui prend en paramétre une fonction ou un bout de code que l'on pourra mettre en paramétre comme la fonction : tbb::parallel_for
(lien vers son code source : https://github.com/xman/tbb/blob/mas...parallel_for.h )
je comprends comment fonctionne cette fonction mais je ne comprends pas comment elle lance la fonction mit en paramétre.
Car je souhaite entourer cette fonction de code. Dans le but de rendre générique la fonction et de l'utilisé ou je le souhaite.

J'espère avoir était clair.

Sinon, si tu as un compilateur c++11, tu peux tout simplement utiliser std::function

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#include <iostream>
#include <functional>
 
int f(std::function<int(int,int)> g, int arg1, int arg2)
{
   return arg1 + g(arg1, arg2);
}
 
int f2(int a, int b)
{
  return a*b;
}
 
int main()
{
   int x = 3, y = 2;
   std::cerr << f(f2, x, y);
   return 0;
}

Oui je suis sur c++11.

Mais en faite ce que je souhaite c'est mettre un bout de code en paramètre qu'il va exécuté comme une fonction quand je lui dirai.
Et surtout je ne connais pas les paramètres donc en gros c'est un bloc de code inconnu que je souhaite exécuté plus tard.

Voilà le genre de truc que je veux faire.

Code:

1
2
3
4
5
6
7
8
9
10
#include <iostream>
 
template<typename Fonction>
 
void benchMarking(Fonction f)
{
    std::cout<<"l'avant"<<std::endl;
    f();
    std::cout<<"l'après"<<std::endl;
}

Code:

1
2
3
4
5
6
benchMarking({
                for (int idx_frame = 0; idx_frame<TotalNumberOfColorFrames;idx_frame++)
                    {
                        kernel<<<NSamplesLine_NLateral/160,160>>>(NSamplesLine_NLateral,EnsembleLengthOut,digital_gain_color,TotalNumberOfColorFrames,idx_frame,dev_m_pWall_filter_coeff,dev_IQPostRejection,dev_WFIQ);
                        cudaDeviceSynchronize();	    
                    }});

c'est cuda derrière mais je m'en fiche un peu car le but de pouvoir mettre n'importe quoi car comme j'ai parlé tous à l'heure la fonction parallel_for fait ça:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
                tbb::parallel_for(int(0), NSamplesLine_NLateral, [&](int ij)
                {
                    for (int k2 = 0; k2 < EnsembleLengthOut; ++k2)
                    {
                        const int IndexWFI = index_offset + 2*(ij + k2 * NSamplesLine_NLateral);
                        float WFI = 0.f;
                        float WFQ = 0.f;
                        const float* p_current_wall_filter_coeff = m_pWall_filter_coeff + k2;
                        for (int k1 = 0; k1 < EnsembleLengthOut; ++k1)
                        {
                            const int IndexI = index_offset + 2*(ij + k1 * NSamplesLine_NLateral);
                            const float CurrentI = digital_gain_color * IQPostRejection[IndexI];
                            const float CurrentQ = digital_gain_color * IQPostRejection[IndexI + 1];
                            WFI += *p_current_wall_filter_coeff * CurrentI;
                            WFQ += *p_current_wall_filter_coeff * CurrentQ;
                            p_current_wall_filter_coeff += EnsembleLengthOut;
                        }
                        WFIQ[IndexWFI]     = WFI;
                        WFIQ[IndexWFI + 1] = WFQ;*
                    }
                });

Et on voit que il prends en crochet le code qu'il met dans sa fonction et qu'il va le parallélisé. C'est juste un exemple je ne souhaite pas dupliqué ceci.
Moi je souhaite faire ça benchMarking([&](int ij){code});

Voilà j'espère avoir était assez clair, oodini je teste ce que tu as mis.

Citation:

Envoyé par nifulol

Mais en faite ce que je souhaite c'est mettre un bout de code en paramétre qu'il va executé comme une fonction quand je lui dirai.
Et surtout je ne connais pas les paramétres donc en gros c'est un bloc de code inconnu que je souhaite exécuté plus tard.

Si tu ne connais pas les paramètres, ça veut surtout dire que c’est une fonction sans paramètre. Sinon, tu ne sauras pas comment l’appeler.

C’est exactement à ça que sert std::function.

Pour reprendre l’exemple de tout à l’heure :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 int f(std::function<void()> f) { // faire un truc f(); // faire un autre truc } int main() { int i = 2, j =3, k=4; f([i,j,k]() { std::cout << i << j << k; }); // affichera 234 quand appelé return 0; }

13/03/2014, 14h27
jblecanard

Citation:

Envoyé par nifulol

Et on voit que il prends en crochet le code qu'il met dans sa fonction.

Pour être précis, il s'agit d'une expression lambda. Ce n'est pas du code mis entre crochets, c'est bien une fonction.
13/03/2014, 14h57
nifulol

Citation:

Envoyé par jblecanard

Pour être précis, il s'agit d'une expression lambda. Ce n'est pas du code mis entre crochets, c'est bien une fonction.

Oui mais je veux faire la même chose, et c'est aussi du code mit entre crochet car je fais la même chose avec le parrallel for ça marche avec ma fonction cela ne fonctionne pas.

Citation:

Envoyé par white_tentacle

Si tu ne connais pas les paramètres, ça veut surtout dire que c’est une fonction sans paramètre. Sinon, tu ne sauras pas comment l’appeler.

C’est exactement à ça que sert std::function.

Pour reprendre l’exemple de tout à l’heure :

Effectivement je connais pas les paramétres mais il y en a. Dans la fonction parrallel_for il va récupérer les valeurs avant la fonction qui correspond les remplis et après lance. En gros je pose ma fonction sur du code que je voudrais sélectionner. Et tous les variables sont remplie et je n'ai rien à faire. Si vous voulez de quoi je veux parler.

Je vous remercie tous. Vous m'avez bien aidé pour tous ceux qui auraient la même envie je vais donner mon fichier de test.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    benchMarking([=](int thread){
         for(int idx_frame = 0; idx_frame<TotalNumberOfColorFrames;idx_frame++)
          {
                for (int ij=0; ij<NSamplesLine_NLateral; ij++)
                {
                    for (int k2=0; k2<EnsembleLengthOut; k2++)
                    {
                        int IndexWFI = idx_frame * 2 * NSamplesLine_NLateral * EnsembleLengthOut + 2*(ij + k2*NSamplesLine_NLateral);
                        int IndexWFQ = IndexWFI+1;
                        float WFI = 0;
                        float WFQ = 0;
                        for (int k1=0; k1<EnsembleLengthOut; k1++)
                        {
                            int IndexI = idx_frame * 2 * NSamplesLine_NLateral * EnsembleLengthOut + 2*(ij + k1*NSamplesLine_NLateral);
                            int IndexQ = IndexI+1;
                            int IndexMatrixWallFilter = k2+k1*EnsembleLengthOut;
                            float CurrentI = digital_gain_color*IQPostRejection[IndexI];
                            float CurrentQ = digital_gain_color*IQPostRejection[IndexQ];
                            WFI = WFI + *m_pWall_filter_coeff[IndexMatrixWallFilter] * CurrentI;
                            WFQ = WFQ + *m_pWall_filter_coeff[IndexMatrixWallFilter] * CurrentQ;
                        }
                        WFIQ[IndexWFI] = WFI;
                        WFIQ[IndexWFQ] = WFQ;
                    }
                }
                }
                std::cout<<thread<<std::endl;
            });

Code:

1
2
3
4
5
6
7
void benchMarking(std::function<void(int)> f)
{
    std::cout<<"l'avant"<<std::endl;
    int thread=20;
    f(thread);
    std::cout<<"l'après"<<std::endl;
}

l'avant
20
l'après

Mon calcul se fait très bien. Ce qui me manquait c'était le = ou & car les paramètres changent toujours mais je dois tous les fournir. Merci encore.