bonjour tout le monde
Je travaille actuellement sur une petit programme qui a pour but de vérifier si des points se trouvent à l'extérieur ou à l'intérieur de polygones (je dois tester plusieurs milliers de points sur plusieurs milliers de polygones ).
Pour accélérer le calcul je voudrais utiliser plusieurs threads pour traiter plusieurs points simultanément
j'ai donc fait des test sur un bout de code ou je découpe l'exécution d'une fonction suivant le nombre de threads choisi

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include <iostream>
#include <vector>
#include <thread>
#include <chrono>
#include <utility>
 
std::vector <std::pair<int, int>> Pair(const std::vector<int>& arr, int start, int end)
{
    std::pair<int, int > paire;
    std::vector <std::pair<int, int>> Vec_paire;
    for (int i = start; i < end; ++i)
    {
        paire = { arr[i], arr[i] + 1 };
        //std::cout << pair.first << ", " << pair.second << std::endl;
        Vec_paire.emplace_back(paire);
    }
 
    return Vec_paire;
}
 
int main()
{
	const int num_threads = 2;
	const int array_size = 1000;
	std::vector<int> arr(array_size);
 
    // initilisation vector arr avec des valeurs de 0 à array_size-1
    for (int i = 0; i < array_size; ++i)
    {
        arr[i] = i;
    }
 
    // création  vector de threads
    std::vector<std::thread> threads;
 
    // division de vect arr en parts égale en fonction du nombre de theards choisi
    int parts_size = array_size / num_threads;
    std::vector <std::vector<std::pair<int, int>>> results(parts_size);
 
    auto start1 = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < num_threads; ++i)
    {
        int start = i * parts_size;
        int end = (i + 1) * parts_size;
        threads.emplace_back([&arr, start, end, &results, i]()
            { results[i] = Pair(arr, start, end); });
    }
    // attendre fin d'exécution des threads 
    for (auto& thread : threads)
    {
        thread.join();
    }
    auto end1 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> float_ms1 = end1 - start1;
    std::cout << "temps " << float_ms1.count() << " ms " << std::endl;
 
    // affichage des valeurs 
    for (int i = 0; i < results.size(); i++)
    {
 
        for (int j = 0; j < results[i].size(); j++)
            std::cout << results[i][j].first << ", " << results[i][j].second << std::endl;
    }
 
 
    return 0;
}
Pourriez vous le dire si je procède de la bonne façon et me donner quelques conseils
et comment gérer les cas ou le nombre de points ( array_size ) ne se divise pas par le nombre de threads ?
merci d'avance