1 /*
2     Copyright (c) 2005-2021 Intel Corporation
3 
4     Licensed under the Apache License, Version 2.0 (the "License");
5     you may not use this file except in compliance with the License.
6     You may obtain a copy of the License at
7 
8         http://www.apache.org/licenses/LICENSE-2.0
9 
10     Unless required by applicable law or agreed to in writing, software
11     distributed under the License is distributed on an "AS IS" BASIS,
12     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13     See the License for the specific language governing permissions and
14     limitations under the License.
15 */
16 
17 // Support for GUI display for Polygon overlay demo
18 
19 #define VIDEO_WINMAIN_ARGS
20 #include <iostream>
21 
22 #include "oneapi/tbb/tick_count.h"
23 
24 #include "common/utility/get_default_num_threads.hpp"
25 
26 #include "polyover.hpp"
27 #include "polymain.hpp"
28 #include "pover_video.hpp"
29 #ifndef _WIN32
30 #include <sys/time.h>
31 #include <unistd.h>
32 
33 void rt_sleep(int msec) {
34     usleep(msec * 1000);
35 }
36 
37 #else //_WIN32
38 
39 #undef OLDUNIXTIME
40 #undef STDTIME
41 
42 #include <windows.h>
43 
44 void rt_sleep(int msec) {
45     Sleep(msec);
46 }
47 
48 #endif /*  _WIN32  */
49 
50 bool g_next_frame() {
51     if (++n_next_frame_calls >= frame_skips) { // the data race here is benign
52         n_next_frame_calls = 0;
53         return gVideo->next_frame();
54     }
55     return gVideo->running;
56 }
57 
58 bool g_last_frame() {
59     if (n_next_frame_calls)
60         return gVideo->next_frame();
61     return gVideo->running;
62 }
63 
64 bool initializeVideo(int argc, char *argv[]) {
65     //pover_video *l_video = new pover_video();
66     //gVideo = l_video;
67     gVideo->init_console(); // don't check return code.
68     gVideo->title = g_windowTitle;
69     g_useGraphics = gVideo->init_window(g_xwinsize, g_ywinsize);
70     return true;
71 }
72 
73 void pover_video::on_process() {
74     oneapi::tbb::tick_count t0, t1;
75     double naiveParallelTime, domainSplitParallelTime;
76     // create map1  These could be done in parallel, if the pseudorandom number generator were re-seeded.
77     GenerateMap(
78         &gPolymap1, gMapXSize, gMapYSize, gNPolygons, /*red*/ 255, /*green*/ 0, /*blue*/ 127);
79     // create map2
80     GenerateMap(
81         &gPolymap2, gMapXSize, gMapYSize, gNPolygons, /*red*/ 0, /*green*/ 255, /*blue*/ 127);
82     //
83     // Draw source maps
84     gDrawXOffset = map1XLoc;
85     gDrawYOffset = map1YLoc;
86     for (int i = 0; i < int(gPolymap1->size()); i++) {
87         (*gPolymap1)[i].drawPoly();
88     }
89     gDrawXOffset = map2XLoc;
90     gDrawYOffset = map2YLoc;
91     for (int i = 0; i < int(gPolymap2->size()); i++) {
92         (*gPolymap2)[i].drawPoly();
93     }
94     gDoDraw = true;
95 
96     // run serial map generation
97     gDrawXOffset = maprXLoc;
98     gDrawYOffset = maprYLoc;
99     {
100         RPolygon *xp =
101             new RPolygon(0, 0, gMapXSize - 1, gMapYSize - 1, 0, 0, 0); // Clear the output space
102         delete xp;
103         t0 = oneapi::tbb::tick_count::now();
104         SerialOverlayMaps(&gResultMap, gPolymap1, gPolymap2);
105         t1 = oneapi::tbb::tick_count::now();
106         std::cout << "Serial overlay took " << (t1 - t0).seconds() * 1000 << " msec"
107                   << "\n";
108         gSerialTime = (t1 - t0).seconds() * 1000;
109 #if _DEBUG
110         CheckPolygonMap(gResultMap);
111         // keep the map for comparison purposes.
112 #else
113         delete gResultMap;
114 #endif
115         if (gCsvFile.is_open()) {
116             gCsvFile << "Serial Time," << gSerialTime << "\n";
117             gCsvFile << "Threads,";
118             if (gThreadsLow == THREADS_UNSET || gThreadsLow == utility::get_default_num_threads()) {
119                 gCsvFile << "Threads,Automatic";
120             }
121             else {
122                 for (int i = gThreadsLow; i <= gThreadsHigh; i++) {
123                     gCsvFile << i;
124                     if (i < gThreadsHigh)
125                         gCsvFile << ",";
126                 }
127             }
128             gCsvFile << "\n";
129         }
130         if (gIsGraphicalVersion)
131             rt_sleep(2000);
132     }
133     // run naive parallel map generation
134     {
135         Polygon_map_t *resultMap;
136         if (gCsvFile.is_open()) {
137             gCsvFile << "Naive Time";
138         }
139         NaiveParallelOverlay(resultMap, *gPolymap1, *gPolymap2);
140         delete resultMap;
141         if (gIsGraphicalVersion)
142             rt_sleep(2000);
143     }
144     // run split map generation
145     {
146         Polygon_map_t *resultMap;
147         if (gCsvFile.is_open()) {
148             gCsvFile << "Split Time";
149         }
150         SplitParallelOverlay(&resultMap, gPolymap1, gPolymap2);
151         delete resultMap;
152         if (gIsGraphicalVersion)
153             rt_sleep(2000);
154     }
155     // split, accumulating into concurrent vector
156     {
157         concurrent_Polygon_map_t *cresultMap;
158         if (gCsvFile.is_open()) {
159             gCsvFile << "Split CV time";
160         }
161         SplitParallelOverlayCV(&cresultMap, gPolymap1, gPolymap2);
162         delete cresultMap;
163         if (gIsGraphicalVersion)
164             rt_sleep(2000);
165     }
166     // split, accumulating into ETS
167     {
168         ETS_Polygon_map_t *cresultMap;
169         if (gCsvFile.is_open()) {
170             gCsvFile << "Split ETS time";
171         }
172         SplitParallelOverlayETS(&cresultMap, gPolymap1, gPolymap2);
173         delete cresultMap;
174         if (gIsGraphicalVersion)
175             rt_sleep(2000);
176     }
177     if (gIsGraphicalVersion)
178         rt_sleep(8000);
179     delete gPolymap1;
180     delete gPolymap2;
181 #if _DEBUG
182     delete gResultMap;
183 #endif
184 }
185