Disabled external gits

cs440-acg/ext/tbb/examples/parallel_reduce/primes/main.cpp

@@ -0,0 +1,106 @@
+/*
+    Copyright (c) 2005-2020 Intel Corporation
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#include "primes.h"
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <cctype>
+#include <utility>
+#include <iostream>
+#include <sstream>
+#include "tbb/tick_count.h"
+
+#include "../../common/utility/utility.h"
+
+struct RunOptions{
+    //! NumberType of threads to use.
+    utility::thread_number_range threads;
+    //whether to suppress additional output
+    bool silentFlag;
+    //
+    NumberType n;
+    //! Grain size parameter
+    NumberType grainSize;
+    // number of time to repeat calculation
+    NumberType repeatNumber;
+
+    RunOptions(utility::thread_number_range threads_, NumberType grainSize_, NumberType n_, bool silentFlag_, NumberType repeatNumber_)
+        : threads(threads_), silentFlag(silentFlag_), n(n_), grainSize(grainSize_), repeatNumber(repeatNumber_)
+    {}
+};
+
+//! Parse the command line.
+static RunOptions ParseCommandLine( int argc, const char* argv[] ) {
+    utility::thread_number_range threads( utility::get_default_num_threads, 0, utility::get_default_num_threads() );
+    NumberType grainSize = 1000;
+    bool silent = false;
+    NumberType number = 100000000;
+    NumberType repeatNumber = 1;
+
+    utility::parse_cli_arguments(argc,argv,
+        utility::cli_argument_pack()
+            //"-h" option for displaying help is present implicitly
+            .positional_arg(threads,"n-of-threads",utility::thread_number_range_desc)
+            .positional_arg(number,"number","upper bound of range to search primes in, must be a positive integer")
+            .positional_arg(grainSize,"grain-size","must be a positive integer")
+            .positional_arg(repeatNumber,"n-of-repeats","repeat the calculation this number of times, must be a positive integer")
+            .arg(silent,"silent","no output except elapsed time")
+    );
+
+    RunOptions options(threads,grainSize, number, silent, repeatNumber);
+    return options;
+}
+
+int main( int argc, const char* argv[] ) {
+    tbb::tick_count mainBeginMark = tbb::tick_count::now();
+    RunOptions options =ParseCommandLine(argc,argv);
+
+    // Try different numbers of threads
+    for( int p=options.threads.first; p<=options.threads.last; p=options.threads.step(p) ) {
+        for (NumberType i=0; i<options.repeatNumber;++i){
+            tbb::tick_count iterationBeginMark = tbb::tick_count::now();
+            NumberType count = 0;
+            NumberType n = options.n;
+            if( p==0 ) {
+                #if __TBB_MIC_OFFLOAD
+                #pragma offload target(mic) in(n) out(count)
+                #endif // __TBB_MIC_OFFLOAD
+                count = SerialCountPrimes(n);
+            } else {
+                NumberType grainSize = options.grainSize;
+                #if __TBB_MIC_OFFLOAD
+                #pragma offload target(mic) in(n, p, grainSize) out(count)
+                #endif // __TBB_MIC_OFFLOAD
+                count = ParallelCountPrimes(n, p, grainSize);
+            }
+            tbb::tick_count iterationEndMark = tbb::tick_count::now();
+            if (!options.silentFlag){
+                std::cout
+                        <<"#primes from [2.." <<options.n<<"] = " << count
+                        <<" ("<<(iterationEndMark-iterationBeginMark).seconds()<< " sec with "
+                ;
+                if( 0 != p )
+                    std::cout<<p<<"-way parallelism";
+                else
+                    std::cout<<"serial code";
+                std::cout<<")\n" ;
+            }
+        }
+    }
+    utility::report_elapsed_time((tbb::tick_count::now()-mainBeginMark).seconds());
+    return 0;
+}